connection_engine::connection_engine(class handler &h, const connection_options& opts) {
connection_ = proton::connection(take_ownership(pn_connection()).get());
pn_ptr<pn_transport_t> transport = take_ownership(pn_transport());
pn_ptr<pn_collector_t> collector = take_ownership(pn_collector());
if (!connection_ || !transport || !collector)
throw proton::error("engine create");
int err = pn_transport_bind(transport.get(), connection_.pn_object());
if (err)
throw error(msg() << "transport bind:" << pn_code(err));
pn_connection_collect(connection_.pn_object(), collector.get());
ctx_ = &connection_engine_context::get(connection_); // Creates context
ctx_->engine_handler = &h;
ctx_->transport = transport.release();
ctx_->collector = collector.release();
opts.apply(connection_);
// Provide defaults for connection_id and link_prefix if not set.
std::string cid = connection_.container_id();
if (cid.empty()) {
cid = make_id();
pn_connection_set_container(connection_.pn_object(), cid.c_str());
}
id_generator &link_gen = connection_context::get(connection_).link_gen;
if (link_gen.prefix().empty()) {
link_gen.prefix(make_id()+"/");
}
}
int
main(void)
{
gwy_type_init();
printf(file_prologue, generated, id, id, title, title);
const gchar* const *names = gwy_fit_func_list_builtins();
guint nfuncs = g_strv_length((gchar**)names);
GwyFitFunc **fitfuncs = g_new(GwyFitFunc*, nfuncs);
for (guint i = 0; i < nfuncs; i++) {
fitfuncs[i] = gwy_fit_func_new(names[i]);
g_assert(GWY_IS_FIT_FUNC(fitfuncs[i]));
}
qsort(fitfuncs, nfuncs, sizeof(GwyFitFunc*), compare);
GString *str = g_string_new(NULL);
const gchar *processing_group = "NONE";
for (guint i = 0; i < nfuncs; i++) {
GwyFitFunc *fitfunc = fitfuncs[i];
const gchar *name = gwy_fit_func_get_name(fitfunc);
const gchar *group = gwy_fit_func_get_group(fitfunc);
if (!gwy_strequal(group, processing_group)) {
if (!gwy_strequal(processing_group, "NONE"))
printf(group_epilogue);
g_string_assign(str, group);
make_id(str);
printf(group_prologue, id, str->str, group, group);
processing_group = group;
}
g_string_assign(str, name);
make_id(str);
printf(function_prologue, id, str->str, name);
g_string_assign(str, gwy_fit_func_formula(fitfunc));
convert_pango_to_docbook(str);
make_math(str);
printf("<entry>%s</entry>\n", str->str);
guint n = gwy_fit_func_n_params(fitfunc);
printf("<entry>");
for (guint j = 0; j < n; j++) {
g_string_assign(str, gwy_fit_func_param_name(fitfunc, j));
convert_pango_to_docbook(str);
make_math(str);
printf("%s %s", j ? "," : "", str->str);
}
printf("</entry>\n");
printf(function_epilogue);
g_object_unref(fitfunc);
}
if (!gwy_strequal(processing_group, "NONE"))
printf(group_epilogue);
printf(file_epilogue);
return 0;
}
int
main(void)
{
gwy_type_init();
printf(file_prologue, generated, id, id, title, title);
const gchar* const *names = gwy_grain_value_list_builtins();
guint nvalues = g_strv_length((gchar**)names);
GwyGrainValue **grainvalues = g_new(GwyGrainValue*, nvalues);
for (guint i = 0; i < nvalues; i++) {
grainvalues[i] = gwy_grain_value_new(names[i]);
g_assert(GWY_IS_GRAIN_VALUE(grainvalues[i]));
}
qsort(grainvalues, nvalues, sizeof(GwyGrainValue*), compare);
GString *str = g_string_new(NULL);
const gchar *processing_group = "NONE";
for (guint i = 0; i < nvalues; i++) {
GwyGrainValue *grainvalue = grainvalues[i];
const gchar *name = gwy_grain_value_get_name(grainvalue);
const gchar *group = gwy_grain_value_get_group(grainvalue);
if (!gwy_strequal(group, processing_group)) {
if (!gwy_strequal(processing_group, "NONE"))
printf(group_epilogue);
g_string_assign(str, group);
make_id(str);
printf(group_prologue, id, str->str, group, group);
processing_group = group;
}
g_string_assign(str, name);
make_id(str);
printf(value_prologue, id, str->str, name);
g_string_assign(str, gwy_grain_value_get_symbol(grainvalue));
convert_pango_to_docbook(str);
make_math(str);
printf("<entry>%s</entry>\n", str->str);
printf("<entry><code>%s</code></entry>",
gwy_grain_value_get_ident(grainvalue));
g_string_assign(str, "");
if (gwy_grain_value_needs_same_units(grainvalue))
append_separated(str, "needs same lateral and value units");
if (gwy_grain_value_is_angle(grainvalue))
append_separated(str, "represents angle in radians");
printf("<entry>%s</entry>\n", str->str);
printf(value_epilogue);
g_object_unref(grainvalue);
}
if (!gwy_strequal(processing_group, "NONE"))
printf(group_epilogue);
printf(file_epilogue);
return 0;
}
DrawRectDrawOp(const Rect& rect_, const Color& color_)
: DrawOp(DRAWRECT_DRAWOP),
rect(rect_),
color(color_)
{
id = make_id(type, rect.left, rect.top);
}
/**
Setup Kademlia.
Must be called after MPI_Init() and whoami().
*/
void
KDA_Init(int alpha_in, int k_in)
{
NOTE_F;
KDA_Data(alpha_in, k_in);
MPIRPC_Node node;
node.comm = MPI_COMM_NULL;
node.rank = 0;
id = make_id(debug_rank);
self = KDA_Neighbor_create_id(id, node);
NOTE_XI("SELF: ", id, id);
port[0] = '\0';
clients = list_create();
MPIRPC_Register("info", handle_info);
// MPIRPC_Register("neighbor", handle_neighbor);
MPIRPC_Register("ping", handle_ping);
MPIRPC_Register("join", handle_join);
MPIRPC_Register("find_node", handle_find_node);
MPIRPC_Register("query_id", handle_query_id);
MPIRPC_Register("query_id_k", handle_query_id_k);
MPIRPC_Register("store", handle_store);
MPIRPC_Register("retrieve", handle_retrieve);
MPIRPC_Register("shutdown", handle_shutdown);
KDA_Init_conn();
}
void mergeItemName (UnitData* item)
{
char const* id = make_id (item->getID ());
char* name = strip_item (item->getStringData ("Name"));
if (!strcmp (name, "Ultimate Orb"))
int asdf = 0;
int len = (int) strlen (name);
if (len >= 7 && !strnicmp (name + len - 7, "Level ", 6))
{
name[len - 7] = name[len - 1];
name[len - 6] = 0;
}
if (len >= 4 && name[len - 1] == ')' && (name[len - 3] == '(' || name[len - 4] == '('))
{
if (name[len - 4] == '(')
len -= 5;
else
len -= 4;
name[len] = 0;
}
int pos = sgetValue (idir, name) - 1;
if (pos >= 0 && getValue (dir, id) == 0)
{
dir = addString (dir, id, 1);
char const* abils = item->getData ("abilList");
if ((abils[0] == 0 || abils[0] == '_') && stricmp (item->getData ("class"), "Campaign"))
pos = items[pos].realid;
items[pos].ids[items[pos].numIds] = item->getID ();
items[pos].numIds++;
}
}
/*
Erstmal Vektor von DT-Links aufbauen, dann über alle DT-Blöcke gehen und die
Daten in 1000er-Blöcken nach oGroup.data[i] kopieren.
*/
void data_group::read_DL(rawfile* file, link pos) const {
// int nExtra = 0;
// int dt_first = 0;
std::vector<link> dt_extra;
link next = pos;
while (next) {
file->seek(next);
block_header dl = prase_block_header(file, make_id('D', 'L'));
std::vector<link> dl_links;
file->read_to_container(dl_links, dl.link_count);
dt_extra.insert(dt_extra.end(), dl_links.begin() + 1, dl_links.end());
/*
// Wird nicht benötigt
dl_flags = fread_uint8(fp, 1);
reserved = fread_uint8(fp, 3);
dl_count = fread_uint32(fp, 1);
if (dl_flags & 1) {
dl_equal_length = fread_uint64(fp, 1);
} else {
dl_offset = fread_uint64(fp, dl_count);
}*/
next = dl_links[0];
}
data_.get() = get_recs(file, dt_extra);
}
SurfaceDrawOp(const Vector2i& pos_,
const FramebufferSurface& surface_,
const Rect& rect_) :
DrawOp(SURFACE_DRAWOP),
pos(pos_),
surface(surface_),
rect(rect_)
{
id = make_id(type, pos.x, pos.y);
}
void file::prase_basic_hdblock() {
// prase HDBLOCK
handle_->seek(64, rawfile::seek_orgin::begin);
// read header
block_header header = prase_block_header(handle_.get(), make_id('H', 'D'));
// read links
handle_->read_to_container(links_, header.link_count);
}
static C_RESULT add_device(device_t* device, const int32_t id_wanted)
{
int32_t id = make_id(device);
if( id_wanted == GAMEPAD_ID && id == id_wanted)
{
PRINT("Input device %s found\n", device->name);
strncpy(gamepad.name, device->handlers, MAX_NAME_LENGTH);
return C_OK;
}
return C_FAIL;
}
int propagate_link( int state , Config_set *A , Config_set *B )
{
STATE *shift_state;
Config_set *C_ptr , *ptr;
TOKEN *T_ptr , *first;
TOKEN *dot;
TOKEN *L2;
TOKEN *L1;
int i;
if( B == NULL )
return 0;
L1 = A->lookahead;
dot = A->dot;
L2 = B->lookahead;
if ( add_set( L2 , L1 ) == FALSE )
return 0;
if( B->dot == NULL )
return 0;
i = parser_table[state][make_id(B->dot->string)-1].go_to;
//printf("%d %s -> %d\n",state , B->dot->string , i );
//view_state(state);
// if ( i == 105 )
// printf("hit\n");
// shift state
for( shift_state = state_start ; i != shift_state->statenum ; shift_state = shift_state->next );
for( C_ptr = shift_state->config_set ; C_ptr != NULL && B->rule != C_ptr->rule ; C_ptr = C_ptr->set_next );
propagate_link( i , B , C_ptr );
//comput lookahead by closue 0
for( C_ptr = shift_state->config_set ; C_ptr != NULL && C_ptr->set_next != NULL ; C_ptr = C_ptr->set_next )
{
for( ptr = shift_state->config_set ; ptr != NULL ; ptr = ptr->set_next )
{
if ( C_ptr->dot == NULL )
continue;
if ( strcmp( C_ptr->dot->string , ptr->rule->lhs ) == 0 )
propagate( shift_state->statenum , C_ptr , ptr );
}
}
return 0;
}
std::vector<std::string> data_group::get_recs(rawfile* file, std::vector<link> dt_links) const {
std::vector<std::string> data;
for (std::size_t i = 0; i < dt_links.size(); i++) {
file->seek(dt_links[i]);
block_header dt = prase_block_header(file, make_id('D', 'T'));
uint64_t ndt_Bytes = dt.length - 24;
// uint64_t ndt_Rec = ndt_Bytes / (get_data_bytes() + get_inval_bytes());
data.push_back(std::string());
file->read_to_container(data.back(), ndt_Bytes);
}
return data;
}
void maze_generator_kruskal_private::generate_edges()
{
edges_sets.clear();
for (unsigned int x = 0; x < size_x ; x++)
for (unsigned int y = 0; y < size_y ; y++)
{
unsigned int edge_id;
//get all left walls
if (x < size_x - 1)
{
edge_id = make_id(x, y) + (make_id(x + 1, y) << locations_id_mask);
edges_sets.push_back(edge_id);
}
if (y < size_y - 1)
{
edge_id = make_id(x, y) + (make_id(x, y + 1) << locations_id_mask);
edges_sets.push_back(edge_id);
}
}
srand((unsigned int)time(NULL));
std::random_shuffle(edges_sets.begin(), edges_sets.end());
}
data_group::data_group(std::shared_ptr<rawfile>& file, uint64_t l) :
block(file, l), links_(), channel_groups_(), rec_id_size_()
{
file->seek(l);
block_header header = prase_block_header(file.get(), make_id('D', 'G'));
file->read_to_container(links_, header.link_count);
file->read(rec_id_size_);
if (rec_id_size_ != 0) {
throw std::invalid_argument("unsorted MDF4 files not supported");
}
prase_channel_groups();
}
void
prepare_utmp (struct utmp *utmp, char *tty,
const char *username, const char *hostname)
{
char *ttyx = clean_ttyname (tty);
memset(utmp, 0, sizeof(*utmp));
utmp->ut_time = time(NULL);
strncpy(utmp->ut_line, ttyx, sizeof(utmp->ut_line));
strncpy(utmp->ut_name, username, sizeof(utmp->ut_name));
# ifdef HAVE_STRUCT_UTMP_UT_USER
strncpy(utmp->ut_user, username, sizeof(utmp->ut_user));
# endif
# ifdef HAVE_STRUCT_UTMP_UT_ADDR
if (hostname[0]) {
struct hostent *he;
if ((he = gethostbyname(hostname)))
memcpy(&utmp->ut_addr, he->h_addr_list[0],
sizeof(utmp->ut_addr));
}
# endif
# ifdef HAVE_STRUCT_UTMP_UT_HOST
shrink_hostname (hostname, utmp->ut_host, sizeof(utmp->ut_host));
# endif
# ifdef HAVE_STRUCT_UTMP_UT_TYPE
utmp->ut_type = USER_PROCESS;
# endif
# ifdef HAVE_STRUCT_UTMP_UT_PID
utmp->ut_pid = getpid();
# endif
# ifdef HAVE_STRUCT_UTMP_UT_ID
strncpy(utmp->ut_id, make_id(ttyx), sizeof(utmp->ut_id));
# endif
}
static void
utmpx_update(struct utmpx *ut, char *line, const char *user, const char *host)
{
struct timeval tmp;
char *clean_tty = clean_ttyname(line);
strncpy(ut->ut_line, clean_tty, sizeof(ut->ut_line));
#ifdef HAVE_STRUCT_UTMPX_UT_ID
strncpy(ut->ut_id, make_id(clean_tty), sizeof(ut->ut_id));
#endif
strncpy(ut->ut_user, user, sizeof(ut->ut_user));
shrink_hostname (host, ut->ut_host, sizeof(ut->ut_host));
#ifdef HAVE_STRUCT_UTMPX_UT_SYSLEN
ut->ut_syslen = strlen(host) + 1;
if (ut->ut_syslen > sizeof(ut->ut_host))
ut->ut_syslen = sizeof(ut->ut_host);
#endif
ut->ut_type = USER_PROCESS;
gettimeofday (&tmp, 0);
ut->ut_tv.tv_sec = tmp.tv_sec;
ut->ut_tv.tv_usec = tmp.tv_usec;
pututxline(ut);
#ifdef WTMPX_FILE
updwtmpx(WTMPX_FILE, ut);
#elif defined(WTMP_FILE)
{ /* XXX should be removed, just drop wtmp support */
struct utmp utmp;
int fd;
prepare_utmp (&utmp, line, user, host);
if ((fd = open(_PATH_WTMP, O_WRONLY|O_APPEND, 0)) >= 0) {
write(fd, &utmp, sizeof(struct utmp));
close(fd);
}
}
#endif
}
int propagate( int state , Config_set *A , Config_set *B )
{
STATE *shift_state;
Config_set *C_ptr , *ptr;
TOKEN *T_ptr , *first;
TOKEN *dot;
TOKEN *L2;
TOKEN *L1;
int i;
L1 = A->lookahead;
dot = A->dot;
L2 = B->lookahead;
//First(£^L)
for( T_ptr = dot->next ; T_ptr != NULL ; T_ptr = T_ptr->next )
{
first = search_token( first_set_start , T_ptr->string );
if (first == NULL )
continue;
if ( search_set(first,"£f") == TRUE )
{
add_set(L2,first);
delete_set( &(L2->set) , "£f" );
continue;
}
else
{
if ( add_set(L2,first) == FALSE )
return 0;
break;
}
}
//First(£^L) , £^ is lambda
if(T_ptr == NULL)
{
add_set( L2 , L1 );
}
//printf("%d\n", parser_table[state][make_id(dot->string)].go_to );
if( B->dot == NULL )
return 0;
i = parser_table[state][make_id(B->dot->string)-1].go_to;
//printf("%d %s -> %d\n",state , B->dot->string , i );
//view_state(state);
if( i == state )
return 0;
// shift state
for( shift_state = state_start ; i != shift_state->statenum ; shift_state = shift_state->next );
for( C_ptr = shift_state->config_set ; C_ptr != NULL && B->rule != C_ptr->rule ; C_ptr = C_ptr->set_next );
{
// if ( i == 105 )
// printf("hit\n");
propagate_link( i , B , C_ptr );
}
//comput lookahead by closue 0
C_ptr = shift_state->config_set;
for( C_ptr = shift_state->config_set ; C_ptr != NULL && C_ptr->set_next != NULL ; C_ptr = C_ptr->set_next )
{
for( ptr = shift_state->config_set ; ptr != NULL ; ptr = ptr->set_next )
{
if ( C_ptr->dot == NULL )
continue;
if ( strcmp( C_ptr->dot->string , ptr->rule->lhs ) == 0 )
{
propagate( shift_state->statenum , C_ptr , ptr );
}
}
}
return 0;
}
bool saveDotaData (char const* dest)
{
MPQFILE file = MPQOpenFile (((CDotAReplayApp*) ::AfxGetApp ())->res, dest, MPQFILE_REWRITE);
if (file)
{
static int hsub[256];
static int isub[512];
memset (hsub, 0, sizeof hsub);
memset (isub, 0, sizeof isub);
int mxh = bk_numHeroes;
for (int i = 1; i < numHeroes; i++)
{
bool found = false;
for (int j = 1; j < bk_numHeroes && !found; j++)
{
if (samename (heroes[i].name, bk_heroes[j].name))
{
hsub[j] = i;
found = true;
}
}
if (!found)
hsub[mxh++] = i;
}
int mxi = bk_numItems;
for (int i = 1; i < numItems; i++)
{
bool found = false;
for (int j = 1; j < bk_numItems && !found; j++)
{
if (items[i].type/2 == bk_items[j].type/2 && samename (items[i].name, bk_items[j].name))
{
isub[j] = i;
found = true;
}
}
if (!found)
isub[mxi++] = i;
}
MPQFilePuts (file, "[HERO]\r\n");
for (int m = 0; m < mxh; m++)
{
int i = hsub[m];
DotaHero* hero = &heroes[i];
MPQFilePuts (file, mprintf ("\"%s\",\"%s\",%d,\"%s\",%d,%d", hero->name, hero->oname, hero->tavern,
hero->imgTag, hero->slot, hero->point));
for (int j = 0; j < 5; j++)
MPQFilePuts (file, mprintf (",%s", make_id (hero->abils[j])));
for (int j = 0; j < hero->numIds; j++)
MPQFilePuts (file, mprintf (",%s", make_id (hero->ids[j])));
MPQFilePuts (file, "\r\n");
}
MPQFilePuts (file, "[ITEM]\r\n");
for (int m = 0; m < mxi; m++)
{
int i = isub[m];
DotaItem* item = getItem (i);
MPQFilePuts (file, mprintf ("\"%s\",%d,\"%s\"", item->name, item->cost, item->imgTag));
for (int j = 0; j < item->numIds; j++)
MPQFilePuts (file, mprintf (",%s", make_id (item->ids[j])));
MPQFilePuts (file, "\r\n");
}
MPQFilePuts (file, "[ABILITY]\r\n");
for (int i = 1; i < numAbilities; i++)
{
DotaAbility* abil = getAbility (i);
MPQFilePuts (file, mprintf ("\"%s\",%d,\"%s\"", abil->name, abil->slot, abil->imgTag));
for (int j = 0; j < abil->numIds; j++)
MPQFilePuts (file, mprintf (",%s", make_id (abil->ids[j])));
MPQFilePuts (file, "\r\n");
}
MPQFilePuts (file, "[RECIPE]\r\n");
for (int i = 0; i < numRecipes; i++)
{
DotaRecipe* recipe = getRecipe (i);
MPQFilePuts (file, make_id (recipe->result));
for (int j = 0; j < recipe->numsrc; j++)
MPQFilePuts (file, mprintf (",%s,%d", make_id (recipe->srcid[j]), recipe->srccount[j]));
MPQFilePuts (file, "\r\n");
}
MPQCloseFile (file);
}
else
return false;
MPQFlushListfile (((CDotAReplayApp*) ::AfxGetApp ())->res);
return true;
}
connection_engine::container::container(const std::string& s) : id_(make_id(s)) {}
void
start_login(const char *host, int autologin, char *name)
{
struct arg_val argv;
char *user;
int save_errno;
#ifdef ENCRYPTION
encrypt_output = NULL;
decrypt_input = NULL;
#endif
#ifdef HAVE_UTMPX_H
{
int pid = getpid();
struct utmpx utmpx;
struct timeval tv;
char *clean_tty;
/*
* Create utmp entry for child
*/
clean_tty = clean_ttyname(line);
memset(&utmpx, 0, sizeof(utmpx));
strncpy(utmpx.ut_user, ".telnet", sizeof(utmpx.ut_user));
strncpy(utmpx.ut_line, clean_tty, sizeof(utmpx.ut_line));
#ifdef HAVE_STRUCT_UTMP_UT_ID
strncpy(utmpx.ut_id, make_id(clean_tty), sizeof(utmpx.ut_id));
#endif
utmpx.ut_pid = pid;
utmpx.ut_type = LOGIN_PROCESS;
gettimeofday (&tv, NULL);
utmpx.ut_tv.tv_sec = tv.tv_sec;
utmpx.ut_tv.tv_usec = tv.tv_usec;
if (pututxline(&utmpx) == NULL)
fatal(net, "pututxline failed");
}
#endif
scrub_env();
/*
* -h : pass on name of host.
* WARNING: -h is accepted by login if and only if
* getuid() == 0.
* -p : don't clobber the environment (so terminal type stays set).
*
* -f : force this login, he has already been authenticated
*/
/* init argv structure */
argv.size=0;
argv.argc=0;
argv.argv=malloc(0); /*so we can call realloc later */
addarg(&argv, "login");
addarg(&argv, "-h");
addarg(&argv, host);
addarg(&argv, "-p");
if(name && name[0])
user = name;
else
user = getenv("USER");
#ifdef AUTHENTICATION
if (auth_level < 0 || autologin != AUTH_VALID) {
if(!no_warn) {
printf("User not authenticated. ");
if (require_otp)
printf("Using one-time password\r\n");
else
printf("Using plaintext username and password\r\n");
}
if (require_otp) {
addarg(&argv, "-a");
addarg(&argv, "otp");
}
if(log_unauth)
syslog(LOG_INFO, "unauthenticated access from %s (%s)",
host, user ? user : "******");
}
if (auth_level >= 0 && autologin == AUTH_VALID)
addarg(&argv, "-f");
#endif
if(user){
addarg(&argv, "--");
addarg(&argv, strdup(user));
}
if (getenv("USER")) {
/*
* Assume that login will set the USER variable
* correctly. For SysV systems, this means that
* USER will no longer be set, just LOGNAME by
* login. (The problem is that if the auto-login
* fails, and the user then specifies a different
* account name, he can get logged in with both
* LOGNAME and USER in his environment, but the
* USER value will be wrong.
*/
unsetenv("USER");
}
closelog();
/*
* This sleep(1) is in here so that telnetd can
* finish up with the tty. There's a race condition
* the login banner message gets lost...
*/
sleep(1);
execv(new_login, argv.argv);
save_errno = errno;
syslog(LOG_ERR, "%s: %m", new_login);
fatalperror_errno(net, new_login, save_errno);
/*NOTREACHED*/
}
int main(int argc, char ** argv)
{
int nwritten;
struct timeval last_time,this_time;
strcpy(hcand_ip, "127.0.0.1");
strcpy(device, "can0");
// Optionen parsen:
if (parse_options(argc,argv) != 0)
exit (1);
openlog("hcanhid",LOG_CONS | LOG_NDELAY | LOG_PERROR | LOG_PID,
LOG_LOCAL7);
if( (sock_inet = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0) {
perror("Error while opening socket");
return(-1);
}
struct sockaddr_in sin;
memset(&sin, 0, sizeof(sin));
sin.sin_family = AF_INET;
sin.sin_addr.s_addr = inet_addr(hcand_ip);
sin.sin_port = htons(3600);
if( (sock_can = socket(PF_CAN, SOCK_RAW, CAN_RAW)) < 0) {
perror("Error while opening socket");
return(-2);
}
struct sockaddr_can can_addr;
struct can_frame CanFrame;
struct ifreq can_ifr;
strcpy(can_ifr.ifr_name, device);
ioctl(sock_can, SIOCGIFINDEX, &can_ifr);
can_addr.can_family = AF_CAN;
can_addr.can_ifindex = can_ifr.ifr_ifindex;
if(debug) printf("%s at index %d\n", device, can_ifr.ifr_ifindex);
if(bind(sock_can, (struct sockaddr *)&can_addr, sizeof(can_addr)) < 0) {
perror("Error in socket bind");
return(-3);
}
canBuffer[0].can_id = make_id(35, 35, 1, 0) | CAN_EFF_FLAG;
canBuffer[0].can_dlc = 2;
canBuffer[0].data[0] = 0x11;
canBuffer[0].data[1] = 0x22;
nwritten = write(sock_can, &canBuffer[0], sizeof(struct can_frame));
if(debug) printf("Wrote %d bytes\n", nwritten);
if (nwritten != sizeof(struct can_frame)) {
syslog(LOG_ERR,"could not send complete CAN packet !");
exit(-4);
}
hcanBuffer[0].id = make_id(0, 0, 0, 0);
hcanBuffer[0].size = 0;
nwritten = sendto(sock_inet, &hcanBuffer[0], sizeof(struct hcan_frame), 0,
(struct sockaddr *) &sin, sizeof(sin));
if(debug) printf("Wrote %d bytes\n", nwritten);
if (nwritten != sizeof(struct hcan_frame)) {
syslog(LOG_ERR,"could not send complete UDP packet !");
exit(-5);
}
// Durchsatz zaehlen
packet_sent = 0;
last_time = get_time();
fd_set recv_fdset;
fd_set send_fdset;
int max_fd;
int nread;
struct timeval timeout;
max_fd = sock_inet;
if(sock_can > max_fd)
max_fd = sock_can;
while (1) {
int ret;
timeout.tv_sec = 0;
timeout.tv_usec = 500000;
FD_ZERO(&recv_fdset);
FD_ZERO(&send_fdset);
FD_SET(sock_inet, &recv_fdset);
FD_SET(sock_can, &recv_fdset);
if(hcanBufferWPtr != hcanBufferRPtr)
FD_SET(sock_inet, &send_fdset);
if(canBufferWPtr != canBufferRPtr)
FD_SET(sock_can, &send_fdset);
ret = select (max_fd + 1, &recv_fdset, &send_fdset, NULL, &timeout);
if(ret > 0) {// no timeout
if (FD_ISSET(sock_inet, &recv_fdset)) {
// read a frame from inet;
nread = recv(sock_inet, &HcanFrame, sizeof(HcanFrame), MSG_WAITALL);
if (nread != sizeof(HcanFrame)) {
syslog(LOG_ERR, "could not read full packet from server, dropping...");
exit(1);
}
else {
if(debug) printf("received udpframe: %lu %d\n", HcanFrame.id, HcanFrame.size);
if(((canBufferWPtr+1)&(BUFFERSIZE-1)) == canBufferRPtr) {
printf("no buffer left\n");
} else {
canBuffer[canBufferWPtr].can_id = HcanFrame.id | CAN_EFF_FLAG;
canBuffer[canBufferWPtr].can_dlc = HcanFrame.size;
memcpy(canBuffer[canBufferWPtr].data, HcanFrame.data, HcanFrame.size);
canBufferWPtr++;
canBufferWPtr &= BUFFERSIZE-1;
}
}
}
if (FD_ISSET(sock_can, &recv_fdset)) {
// read a frame from can;
nread = recv(sock_can, &CanFrame, sizeof(struct can_frame), MSG_WAITALL);
if (nread != sizeof(struct can_frame)) {
syslog(LOG_ERR, "could not read full packet from can, dropping...");
exit(1);
}
else {
if(debug) printf("received can frame: %lu %d\n", CanFrame.can_id, CanFrame.can_dlc);
if(((hcanBufferWPtr+1)&(BUFFERSIZE-1)) == hcanBufferRPtr) {
printf("no buffer left\n");
} else {
hcanBuffer[hcanBufferWPtr].id = CanFrame.can_id & CAN_EFF_MASK;
hcanBuffer[hcanBufferWPtr].size = CanFrame.can_dlc;
memcpy(hcanBuffer[hcanBufferWPtr].data, CanFrame.data, CanFrame.can_dlc);
hcanBufferWPtr++;
hcanBufferWPtr &= BUFFERSIZE-1;
}
}
}
if ((canBufferWPtr != canBufferRPtr) && FD_ISSET(sock_can, &send_fdset)) {
nwritten = write(sock_can, &canBuffer[canBufferRPtr], sizeof(struct can_frame));
if(debug) printf("send can frame\n");
if (nwritten != sizeof(struct can_frame))
syslog(LOG_ERR,"could not send complete CAN packet !");
canBufferRPtr++;
canBufferRPtr &= BUFFERSIZE-1;
}
if ((hcanBufferWPtr != hcanBufferRPtr) && FD_ISSET(sock_inet, &send_fdset)) {
nwritten = sendto(sock_inet, &hcanBuffer[hcanBufferRPtr], sizeof(struct hcan_frame), 0,
(struct sockaddr *) &sin, sizeof(sin));
if(debug) printf("send hcan frame\n");
if (nwritten != sizeof(struct hcan_frame))
syslog(LOG_ERR,"could not send complete UDP packet !");
hcanBufferRPtr++;
hcanBufferRPtr &= BUFFERSIZE-1;
}
}
}
return 0;
}
void configure( const memory_grammar& /*grammar*/, const std::string& schema )
{
configure();
XERCES_CPP_NAMESPACE::MemBufInputSource source( reinterpret_cast< const XMLByte* >( schema.c_str() ), schema.size(), make_id().c_str() );
XERCES_CPP_NAMESPACE::Wrapper4InputSource input( &source, false );
#if XERCES_VERSION_MAJOR == 3
if( ! parser_.loadGrammar( &input, XERCES_CPP_NAMESPACE::Grammar::SchemaGrammarType, true ) )
#else
if( ! parser_.loadGrammar( input, XERCES_CPP_NAMESPACE::Grammar::SchemaGrammarType, true ) )
#endif // XERCES_VERSION_MAJOR
throw exception( "Failed to load memory grammar" );
}
int run_parser( TTreeView *TreeView1 , char *file_name )
{
Config_set *config_ptr;
GRAMMAR *G_ptr;
STATE *state_ptr;
TOKEN *T_ptr , *T_tmp;
FILE *input ,*out;
char grammar_rule[1024];
char *ptr , *ptr_string;
char *ptr_lhs , *ptr_rhs;
SET *S_ptr;
int i , j;
int rule_num;
strncpy( lambda , "£f" , strlen("£f")+1 );
G_start = NULL;
G_end = NULL;
terminal_start = NULL;
terminal_end = NULL;
nonterminal_start = NULL;
nonterminal_end = NULL;
first_set_start = NULL;
first_set_end = NULL;
follow_set_start = NULL;
follow_set_end = NULL;
predict_set_start = NULL;
predict_set_end = NULL;
config_start = NULL;
config_end = NULL;
state_start = NULL;
state_end = NULL;
state_num = 0;
//scanner();
input = fopen( file_name ,"r");
scan = fopen("out.txt","r");
if ( input == NULL )
{
Application->MessageBoxA("grammar file error","error",0);
return 0;
}
// out = fopen("table.csv","w");
for ( i = 0 ; fgets( grammar_rule , 1024 , input ) ; )
{
ptr = grammar_rule;
// remove \n
ptr = strstr(grammar_rule , "\n");
if(ptr != NULL)
*ptr = '\0';
// remove rule num
ptr = strstr( grammar_rule , "." );
// get left handside
ptr_lhs = ptr + 2;
ptr = strstr( grammar_rule , " " );
*ptr = '\0';
insert_token( &nonterminal_start , &nonterminal_end , ptr_lhs ); // make nonterminal table
insert_token( &first_set_start , &first_set_end , ptr_lhs ); // make first set table with nonterminal
insert_token( &follow_set_start , &follow_set_end , ptr_lhs ); // make follow set table
insert_token( &predict_set_start , &predict_set_end , ptr_lhs ); // make predict set table
// get right handside
ptr = strstr( ++ptr , "¡÷" );
do
{
ptr = strstr( ++ptr , " " );
while(isspace(*ptr))
ptr++;
ptr_rhs = ptr;
ptr = strstr( ptr_rhs , "|" );
if ( ptr != NULL && *(ptr+1) != '|' )
{
for ( j = 1 ; isspace(*(ptr-j)) ; j++ )
*(ptr-j) = '\0';
}
insert_grammar( ++i , ptr_lhs , ptr_rhs );
} while ( ptr != NULL && *(ptr+1) != '|' );
}
// remove nonterminal in termainal table
T_ptr = nonterminal_start;
i = 0;
while ( T_ptr != NULL )
{
T_tmp = search_token( terminal_start , T_ptr->string );
delete_token( &terminal_start , T_tmp );
T_ptr = T_ptr->next;
i++;
}
num_of_nonterm = i;
for ( T_ptr = terminal_start , i =0 ; T_ptr != NULL ; T_ptr = T_ptr->next , i++ )
{
insert_token( &first_set_start , &first_set_end , T_ptr->string ); // make first set table
}
num_of_term = ++i;
fill_frist_set();
fill_follow_set();
i = 0;
view = fopen("state.txt","w");
//view = stdout;
out = fopen("go_to_table.csv","w");
build_CFSM();
// build goto table
parser_table = (PARSER**) malloc( sizeof(PARSER) * state_num );
for( i = 0 ; i < state_num ; i++ )
{
parser_table[i] = (PARSER*) malloc( sizeof(PARSER) * ( num_of_term + num_of_nonterm ));
for( j = 0 ; j < num_of_term + num_of_nonterm ; j++ )
{
parser_table[i][j].go_to = go_to_state(i,j+1);
if( j+1 != make_id("$") )
parser_table[i][j].action = SHIFT;
else
parser_table[i][j].action = ACCEPT;
if( parser_table[i][j].go_to == 0 )
parser_table[i][j].action = ERROR;
}
}
// comput lalr lookahead
build_LALR_lookahead();
fprintf(out,"\t,");
for( j = 0 ; j < num_of_term + num_of_nonterm ; j++ )
{
if( j+1 != make_id(",") )
fprintf(out," %s,",idtostr(j+1));
else
fprintf(out," ' ,");
}
fprintf( out ,"\n");
// build action table
for( i = 0 , state_ptr = state_start ; i < state_num ; i++ , state_ptr = state_ptr->next )
{
fprintf(out,"state%d,",i);
for( j = 0 ; j < num_of_term + num_of_nonterm ; j++ )
{
for( config_ptr = state_ptr->config_set ; config_ptr != NULL ; config_ptr = config_ptr->set_next )
{
if( config_ptr->dot == NULL && search_set( config_ptr->lookahead , idtostr(j+1) ) == TRUE )
{
if(parser_table[i][j].go_to == 0)
{
//printf("hit\n");
parser_table[i][j].go_to = config_ptr->rule->rule;
parser_table[i][j].action = REDUCE;
}
//fprintf(out,"R%02d,",parser_table[i][j].go_to);
}
}
if(parser_table[i][j].go_to > 0)
{
if( parser_table[i][j].action == SHIFT )
fprintf( out , "S%02d,",parser_table[i][j].go_to);
else
fprintf( out , "R%02d,",parser_table[i][j].go_to);
}
else
fprintf( out , ",");
}
fprintf( out ,"\n");
}
fclose(out);
//printf( "%d\n", go_to_state(4,5) );
for ( i = 0 ; i < state_num ; i++ )
{
view_state(i);
fprintf(view,"\n");
//getch();
//system("cls");
}
shift_reduce_driver( TreeView1 );
free_token(&terminal_start);
free_token(&nonterminal_start);
free_grammar();
free_state(&state_start);
//free_config(&config_start);
//system("pause");
return 0;
}
void shift_reduce_driver( TTreeView *TreeView1 )
{
char string[64];
SET *scan_ptr;
int reduce_rule;
TTreeNode *root , *parent , *son;
// clean old tree
TreeView1->Items->Clear();
// get scanner token
do
{
fscanf( scan , "%s" , string );
insert_predict( &scan_start , &scan_end , string );
} while ( strcmp(string,"$") != 0 );
scan_ptr = scan_start;
// push the start state , S ,
// onto an empty parse stack
root = (TreeView1)->Items->Add( NULL , state_start->config_set->rule->lhs );
push_stack( state_start->statenum , root );
//son = TreeView1->Items->Add( NULL , "1" );
//parent = TreeView1->Items->AddChild( root , "2" );
//son->MoveTo( parent , naAddChild );
//view_stack();
while(TRUE)
{
switch(parser_table[stack_top->index][make_id(scan_ptr->string)-1].action)
{
case ERROR:
//system("pause");
//printf("error\n");
Application->MessageBoxA("syntax error","error",0);
return;
case ACCEPT:
pop_stack(1 , son );
son->MoveTo( root , naAddChildFirst );
printf("%s\n",state_start->config_set->rule->lhs);
//view_stack();
printf("pares sucess!\n");
return;
case SHIFT:
son = TreeView1->Items->Add( NULL , scan_ptr->string );
push_stack( parser_table[stack_top->index][make_id(scan_ptr->string)-1].go_to , son );
printf("%s\n",scan_ptr->string , son );
//view_stack();
scan_ptr = scan_ptr->next;
break;
case REDUCE:
reduce_rule = parser_table[stack_top->index][make_id(scan_ptr->string)-1].go_to;
son = TreeView1->Items->Add( NULL , idtogram(reduce_rule)->lhs );
pop_stack( count_rhs_num( reduce_rule ) , son );
push_stack( parser_table[stack_top->index][make_id( idtogram(reduce_rule)->lhs )-1].go_to , son );
printf("%s\n",idtogram(reduce_rule)->lhs);
//view_stack();
break;
}
}
}
