void index_file(char * file, struct hash_table * table) { /* get a reverse hash table of the terms in the file */ FILE * file_fd; struct Parser * parser; char * word; file_fd = fopen(file, "r"); parser = parser_new(file_fd); if (file_fd == NULL) { fprintf(stderr, "couldn't get handler for %s\n", file); free_hash_table(table); } while ( (word = parser_next_word(parser)) ) { strtolower(word); struct hash_node * tmp = hash_table_get(table, word); if(tmp) { hash_node_add_occurrence(tmp, file); } else { struct hash_node * node = new_hash_node(word); node->appears_in = new_file_node(file); hash_table_store(table, word, node); } free(word); } parser_destroy(parser); }
static int emit_anf(void) { AST* tree = NULL; Parser* ctx = parser_new(NULL, stdin); while(NULL != (tree = toplevel(ctx))) pprint_tree(stdout, normalize(tree), 0); return 0; }
static struct parser *init_parse_prefs(void) { struct parser *p = parser_new(); parser_setpriv(p, mem_zalloc(sizeof(struct prefs_data))); parser_reg(p, "% str file", parse_prefs_load); parser_reg(p, "? str expr", parse_prefs_expr); parser_reg(p, "K sym tval sym sval int attr int char", parse_prefs_k); parser_reg(p, "R uint idx int attr int char", parse_prefs_r); parser_reg(p, "F uint idx sym lighting int attr int char", parse_prefs_f); parser_reg(p, "GF sym type sym direction uint attr uint char", parse_prefs_gf); parser_reg(p, "L uint idx int attr int char", parse_prefs_l); parser_reg(p, "E sym tval int attr", parse_prefs_e); parser_reg(p, "Q sym idx sym n ?sym sval ?sym flag", parse_prefs_q); /* XXX should be split into two kinds of line */ parser_reg(p, "B uint idx str text", parse_prefs_b); /* XXX idx should be {tval,sval} pair! */ parser_reg(p, "A str act", parse_prefs_a); parser_reg(p, "C int mode str key", parse_prefs_c); parser_reg(p, "M int type sym attr", parse_prefs_m); parser_reg(p, "V uint idx int k int r int g int b", parse_prefs_v); parser_reg(p, "W int window uint flag uint value", parse_prefs_w); parser_reg(p, "X str option", parse_prefs_x); parser_reg(p, "Y str option", parse_prefs_y); return p; }
/* Driver Modes *****************************************************************************/ static int emit_tokens(void) { Tok* token = NULL; Parser* ctx = parser_new(NULL, stdin); while(NULL != (token = gettoken(ctx))) pprint_token(stdout, token, true); return 0; }
static int emit_csource(void) { AST* tree = NULL; Parser* ctx = parser_new(NULL, stdin); while(NULL != (tree = normalize(toplevel(ctx)))) codegen(stdout, tree); return 0; }
int config_load_file(FILE *config_file, struct Config *dest) { char *rdbuf = malloc(CONFIG_CHUNK_SIZE); int ret = -1; xmpp_ctx_t *ctx = xmpp_ctx_new(NULL, NULL); parser_t *parser = parser_new(ctx, NULL, NULL, config_parse_stanza, dest); size_t read_bytes; do { read_bytes = fread(rdbuf, 1, CONFIG_CHUNK_SIZE, config_file); if (!parser_feed(parser, rdbuf, read_bytes)) { ret = 2; goto __cleanup__; } } while (read_bytes == CONFIG_CHUNK_SIZE); if (errno != 0) { ret = 1; } else { ret = 0; } __cleanup__: free(rdbuf); parser_free(parser); xmpp_ctx_free(ctx); return ret; }
struct parser *init_parse_v(void) { struct parser *p = parser_new(); parser_setpriv(p, NULL); parser_reg(p, "N uint index str name", parse_v_n); parser_reg(p, "X uint type int rating uint height uint width uint min_lev uint max_lev", parse_v_x); parser_reg(p, "D str text", parse_v_d); return p; }
int setup_tests(void **state) { struct parser *p = parser_new(); if (!p) return 1; *state = p; return 0; }
static struct parser *init_parse_room(void) { struct parser *p = parser_new(); parser_setpriv(p, NULL); parser_reg(p, "V sym version", ignored); parser_reg(p, "N uint index str name", parse_room_n); parser_reg(p, "X uint type int rating uint height uint width uint doors uint tval", parse_room_x); parser_reg(p, "D str text", parse_room_d); return p; }
struct parser *init_parse_quest(void) { struct parser *p = parser_new(); parser_setpriv(p, NULL); parser_reg(p, "name str name", parse_quest_name); parser_reg(p, "level uint level", parse_quest_level); parser_reg(p, "race str race", parse_quest_race); parser_reg(p, "number uint number", parse_quest_number); return p; }
static int lyajl_new_parser (lua_State *L) { int r = luaL_ref(L, LUA_REGISTRYINDEX); luvit_parser_t *parser = parser_new(L); parser->ref = malloc(sizeof(luv_ref_t)); parser->ref->L = L; parser->ref->r = r; parser->handle = yajl_alloc(&lyajl_callbacks, NULL, (void*)parser->ref); luaL_getmetatable(L, JSON_PARSER_HANDLE); lua_setmetatable(L, -2); return 1; }
static struct parser *init_parse_profile(void) { struct parser *p = parser_new(); parser_setpriv(p, NULL); parser_reg(p, "name str name", parse_profile_name); parser_reg(p, "params int block int rooms int unusual int rarity", parse_profile_params); parser_reg(p, "tunnel int rnd int chg int con int pen int jct", parse_profile_tunnel); parser_reg(p, "streamer int den int rng int mag int mc int qua int qc", parse_profile_streamer); parser_reg(p, "room sym name int height int width int level int pit int rarity int cutoff", parse_profile_room); parser_reg(p, "cutoff int cutoff", parse_profile_cutoff); return p; }
/* cppparser_new */ CppParser * cppparser_new(Cpp * cpp, CppParser * parent, char const * filename, int filters) { /* FIXME factor code */ CppParser * cp; if((cp = object_new(sizeof(*cp))) == NULL) return NULL; cp->cpp = cpp; cp->parent = parent; cp->parser = parser_new(filename); cp->filters = filters; cp->inject = NULL; cp->inject_first = 0; cp->newlines_last = 0; cp->newlines_last_cnt = 0; cp->trigraphs_last = 0; cp->trigraphs_last_cnt = 0; cp->directive_newline = 1; cp->directive_control = 0; cp->queue_ready = 0; cp->queue_code = CPP_CODE_NULL; cp->queue_string = NULL; cp->subparser = NULL; if(cp->parser == NULL) { cppparser_delete(cp); return NULL; } parser_add_filter(cp->parser, _cpp_filter_inject, cp); parser_add_filter(cp->parser, _cpp_filter_newlines, cp); if(cp->filters & CPP_FILTER_TRIGRAPH) parser_add_filter(cp->parser, _cpp_filter_trigraphs, cp); parser_add_callback(cp->parser, _cpp_callback_inject, cp); parser_add_callback(cp->parser, _cpp_callback_dequeue, cp); if(cp->filters & CPP_FILTER_WHITESPACE) parser_add_callback(cp->parser, _cpp_callback_whitespace, cp); else { parser_add_callback(cp->parser, _cpp_callback_newline, cp); parser_add_callback(cp->parser, _cpp_callback_otherspace, cp); } parser_add_callback(cp->parser, _cpp_callback_comment, cp); parser_add_callback(cp->parser, _cpp_callback_header, cp); parser_add_callback(cp->parser, _cpp_callback_control, cp); parser_add_callback(cp->parser, _cpp_callback_comma, cp); parser_add_callback(cp->parser, _cpp_callback_operator, cp); parser_add_callback(cp->parser, _cpp_callback_quote, cp); parser_add_callback(cp->parser, _cpp_callback_directive, cp); parser_add_callback(cp->parser, _cpp_callback_word, cp); parser_add_callback(cp->parser, _cpp_callback_unknown, cp); return cp; }
static struct parser *init_parse_grafmode(void) { struct parser *p = parser_new(); parser_setpriv(p, NULL); parser_reg(p, "V sym version", ignored); parser_reg(p, "N uint index str menuname", parse_graf_n); parser_reg(p, "I uint wid uint hgt str filename", parse_graf_i); parser_reg(p, "P str prefname", parse_graf_p); parser_reg(p, "X uint alpha uint row uint max", parse_graf_x); return p; }
/* main: */ gint main ( gint argc, gchar **argv ) { Parser *parser; FILE *infile = NULL;; gboolean close_infile; AST *ast; Dumper *dumper; gint a; gchar *srcdir = "."; gchar *incsubdir = ""; /* CL_DEBUG("hello!"); */ /* command line */ for (a = 1; a < argc; a++) { if (!strcmp(argv[a], "-s")) { a++; ASSERT(a < argc); srcdir = argv[a]; } else if (!strcmp(argv[a], "-u")) { a++; ASSERT(a < argc); incsubdir = argv[a]; } else { ASSERT(!infile); if (!(infile = fopen(argv[a], "r"))) CL_ERROR("could not open '%s' : %s", argv[a], strerror(errno)); close_infile = TRUE; } } if (!infile) { infile = stdin; close_infile = FALSE; } /* parse */ parser = parser_new(); if (!(ast = parser_parse(parser, infile))) CL_ERROR("parse error"); if (close_infile) fclose(infile); /* dump */ dumper = dumper_new(srcdir, incsubdir); dumper_dump(dumper, ast); dumper_write(dumper); return 0; }
struct parser *init_parse_vault(void) { struct parser *p = parser_new(); parser_setpriv(p, NULL); parser_reg(p, "name str name", parse_vault_name); parser_reg(p, "type str type", parse_vault_type); parser_reg(p, "rating int rating", parse_vault_rating); parser_reg(p, "rows uint height", parse_vault_rows); parser_reg(p, "columns uint width", parse_vault_columns); parser_reg(p, "min-depth uint min_lev", parse_vault_min_depth); parser_reg(p, "max-depth uint max_lev", parse_vault_max_depth); parser_reg(p, "D str text", parse_vault_d); return p; }
static struct parser *init_parse_room(void) { struct parser *p = parser_new(); parser_setpriv(p, NULL); parser_reg(p, "name str name", parse_room_name); parser_reg(p, "type uint type", parse_room_type); parser_reg(p, "rating int rating", parse_room_rating); parser_reg(p, "rows uint height", parse_room_height); parser_reg(p, "columns uint width", parse_room_width); parser_reg(p, "doors uint doors", parse_room_doors); parser_reg(p, "tval sym tval", parse_room_tval); parser_reg(p, "D str text", parse_room_d); return p; }
struct parser *init_parse_rb(void) { struct parser *p = parser_new(); parser_setpriv(p, NULL); parser_reg(p, "V sym version", ignored); parser_reg(p, "N str name", parse_rb_n); parser_reg(p, "G char glyph", parse_rb_g); parser_reg(p, "M uint pain", parse_rb_m); parser_reg(p, "F ?str flags", parse_rb_f); parser_reg(p, "S ?str spells", parse_rb_s); parser_reg(p, "D str desc", parse_rb_d); return p; }
struct parser *init_parse_stores(void) { struct parser *p = parser_new(); parser_setpriv(p, NULL); parser_reg(p, "store uint index str name", parse_store); parser_reg(p, "owner uint purse str name", parse_owner); parser_reg(p, "slots uint min uint max", parse_slots); parser_reg(p, "turnover uint turnover", parse_turnover); parser_reg(p, "normal sym tval sym sval", parse_normal); parser_reg(p, "always sym tval sym sval", parse_always); parser_reg(p, "buy str base", parse_buy); parser_reg(p, "buy-flag sym flag str base", parse_buy_flag); return p; }
struct parser *init_parse_summon(void) { struct parser *p = parser_new(); parser_setpriv(p, NULL); parser_reg(p, "name str name", parse_summon_name); parser_reg(p, "msgt sym type", parse_summon_message_type); parser_reg(p, "uniques int allowed", parse_summon_unique); parser_reg(p, "base sym base", parse_summon_base); parser_reg(p, "race-flag sym flag", parse_summon_race_flag); parser_reg(p, "fallback str fallback", parse_summon_fallback); parser_reg(p, "desc str desc", parse_summon_desc); return p; }
struct parser *init_parse_r(void) { struct parser *p = parser_new(); parser_setpriv(p, NULL); parser_reg(p, "V sym version", ignored); parser_reg(p, "N uint index str name", parse_r_n); parser_reg(p, "T sym base", parse_r_t); parser_reg(p, "G char glyph", parse_r_g); parser_reg(p, "C sym color", parse_r_c); parser_reg(p, "I int speed int hp int aaf int ac int sleep", parse_r_i); parser_reg(p, "W int level int rarity int power int mexp", parse_r_w); parser_reg(p, "B sym method ?sym effect ?rand damage", parse_r_b); parser_reg(p, "F ?str flags", parse_r_f); parser_reg(p, "D str desc", parse_r_d); parser_reg(p, "S str spells", parse_r_s); parser_reg(p, "drop sym tval sym sval uint chance uint min uint max", parse_r_drop); parser_reg(p, "drop-artifact str name", parse_r_drop_artifact); parser_reg(p, "mimic sym tval sym sval", parse_r_mimic); return p; }
static struct parser *init_parse_prefs(bool user) { struct parser *p = parser_new(); struct prefs_data *pd = mem_zalloc(sizeof *pd); int i; parser_setpriv(p, pd); pd->user = user; for (i = 0; i < ANGBAND_TERM_MAX; i++) { pd->loaded_window_flag[i] = FALSE; } parser_reg(p, "% str file", parse_prefs_load); parser_reg(p, "? str expr", parse_prefs_expr); parser_reg(p, "K sym tval sym sval int attr int char", parse_prefs_k); parser_reg(p, "R uint idx int attr int char", parse_prefs_r); parser_reg(p, "F uint idx sym lighting int attr int char", parse_prefs_f); parser_reg(p, "N uint idx int attr int char", parse_prefs_n); parser_reg(p, "GF sym type sym direction uint attr uint char", parse_prefs_gf); parser_reg(p, "L uint idx int attr int char", parse_prefs_l); parser_reg(p, "E sym tval int attr", parse_prefs_e); parser_reg(p, "Q sym idx sym n ?sym sval ?sym flag", parse_prefs_q); /* XXX should be split into two kinds of line */ parser_reg(p, "B uint idx str text", parse_prefs_b); /* XXX idx should be {tval,sval} pair! */ parser_reg(p, "A str act", parse_prefs_a); parser_reg(p, "C int mode str key", parse_prefs_c); parser_reg(p, "M sym type sym attr", parse_prefs_m); parser_reg(p, "V uint idx int k int r int g int b", parse_prefs_v); parser_reg(p, "W int window uint flag uint value", parse_prefs_w); parser_reg(p, "X str option", parse_prefs_x); parser_reg(p, "Y str option", parse_prefs_y); return p; }
void master_run(Master* master) { MAGIC_ASSERT(master); guint slaveSeed = (guint)random_nextInt(master->random); Slave* slave = slave_new(master, master->config, slaveSeed); /* hook in our logging system. stack variable used to avoid errors * during cleanup below. */ GLogLevelFlags configuredLogLevel = configuration_getLogLevel(master->config); g_log_set_default_handler(logging_handleLog, &(configuredLogLevel)); GDateTime* dt_now = g_date_time_new_now_local(); gchar* dt_format = g_date_time_format(dt_now, "%F %H:%M:%S"); message("Shadow v%s initialized at %s using GLib v%u.%u.%u", SHADOW_VERSION, dt_format, (guint)GLIB_MAJOR_VERSION, (guint)GLIB_MINOR_VERSION, (guint)GLIB_MICRO_VERSION); g_date_time_unref(dt_now); g_free(dt_format); /* store parsed actions from each user-configured simulation script */ GQueue* actions = g_queue_new(); Parser* xmlParser = parser_new(); /* parse built-in examples, or input files */ gboolean success = TRUE; if(master->config->runFileExample) { GString* file = example_getFileExampleContents(); success = parser_parseContents(xmlParser, file->str, file->len, actions); g_string_free(file, TRUE); } else { /* parse all given input XML files */ while(success && g_queue_get_length(master->config->inputXMLFilenames) > 0) { GString* filename = g_queue_pop_head(master->config->inputXMLFilenames); success = parser_parseFile(xmlParser, filename, actions); } } parser_free(xmlParser); /* if there was an error parsing, bounce out */ if(success) { message("successfully parsed Shadow XML input!"); } else { g_queue_free(actions); error("error parsing Shadow XML input!"); } /* * loop through actions that were created from parsing. this will create * all the nodes, networks, applications, etc., and add an application * start event for each node to bootstrap the simulation. Note that the * plug-in libraries themselves are not loaded until a worker needs it, * since each worker will need its own private version. */ while(g_queue_get_length(actions) > 0) { Action* a = g_queue_pop_head(actions); runnable_run(a); runnable_free(a); } g_queue_free(actions); /* start running */ gint nWorkers = configuration_getNWorkerThreads(master->config); debug("starting %i-threaded engine (main + %i workers)", (nWorkers + 1), nWorkers); /* simulation mode depends on configured number of workers */ if(nWorkers > 0) { /* multi threaded, manage the other workers */ master->executeWindowStart = 0; SimulationTime jump = master_getMinTimeJump(master); master->executeWindowEnd = jump; master->nextMinJumpTime = jump; slave_runParallel(slave); } else { /* single threaded, we are the only worker */ master->executeWindowStart = 0; master->executeWindowEnd = G_MAXUINT64; slave_runSerial(slave); } debug("engine finished, cleaning up..."); slave_free(slave); }
/** Create a new Strophe connection object. * * @param ctx a Strophe context object * * @return a Strophe connection object or NULL on an error * * @ingroup Connections */ xmpp_conn_t *xmpp_conn_new(xmpp_ctx_t * const ctx) { xmpp_conn_t *conn = NULL; xmpp_connlist_t *tail, *item; if (ctx == NULL) return NULL; conn = xmpp_alloc(ctx, sizeof(xmpp_conn_t)); if (conn != NULL) { conn->ctx = ctx; conn->type = XMPP_UNKNOWN; conn->state = XMPP_STATE_DISCONNECTED; conn->sock = -1; conn->tls = NULL; conn->timeout_stamp = 0; conn->error = 0; conn->stream_error = NULL; /* default send parameters */ conn->blocking_send = 0; conn->send_queue_max = DEFAULT_SEND_QUEUE_MAX; conn->send_queue_len = 0; conn->send_queue_head = NULL; conn->send_queue_tail = NULL; /* default timeouts */ conn->connect_timeout = CONNECT_TIMEOUT; conn->lang = xmpp_strdup(conn->ctx, "en"); if (!conn->lang) { xmpp_free(conn->ctx, conn); return NULL; } conn->domain = NULL; conn->jid = NULL; conn->pass = NULL; conn->stream_id = NULL; conn->bound_jid = NULL; conn->tls_support = 0; conn->tls_disabled = 0; conn->tls_failed = 0; conn->sasl_support = 0; conn->secured = 0; conn->bind_required = 0; conn->session_required = 0; conn->parser = parser_new(conn->ctx, _handle_stream_start, _handle_stream_end, _handle_stream_stanza, conn); conn->reset_parser = 0; conn_prepare_reset(conn, auth_handle_open); conn->authenticated = 0; conn->conn_handler = NULL; conn->userdata = NULL; conn->timed_handlers = NULL; /* we own (and will free) the hash values */ conn->id_handlers = hash_new(conn->ctx, 32, NULL); conn->handlers = NULL; /* give the caller a reference to connection */ conn->ref = 1; /* add connection to ctx->connlist */ tail = conn->ctx->connlist; while (tail && tail->next) tail = tail->next; item = xmpp_alloc(conn->ctx, sizeof(xmpp_connlist_t)); if (!item) { xmpp_error(conn->ctx, "xmpp", "failed to allocate memory"); xmpp_free(conn->ctx, conn->lang); parser_free(conn->parser); xmpp_free(conn->ctx, conn); conn = NULL; } else { item->conn = conn; item->next = NULL; if (tail) tail->next = item; else conn->ctx->connlist = item; } } return conn; }
/** Create a new Strophe connection object. * * @param ctx a Strophe context object * * @return a Strophe connection object or NULL on an error * * @ingroup Connections */ xmpp_conn_t *xmpp_conn_new(xmpp_ctx_t * const ctx) { xmpp_conn_t *conn; list_t *item; if (!ctx) return NULL; conn = xmpp_alloc(ctx, sizeof(xmpp_conn_t)); if (!conn) return NULL; conn->ctx = ctx; conn->type = XMPP_UNKNOWN; conn->state = XMPP_STATE_DISCONNECTED; conn->sock = -1; conn->tls = NULL; conn->timeout_stamp = 0; conn->error = 0; conn->stream_error = NULL; /* default send parameters */ conn->blocking_send = 0; conn->send_queue_max = DEFAULT_SEND_QUEUE_MAX; conn->send_queue = list_init(ctx); if (!conn->send_queue) goto out_free_conn; /* default timeouts */ conn->connect_timeout = CONNECT_TIMEOUT; conn->lang = xmpp_strdup(ctx, "en"); if (!conn->lang) goto out_free_send_queue; conn->domain = NULL; conn->jid = NULL; conn->pass = NULL; conn->stream_id = NULL; conn->bound_jid = NULL; conn->tls_support = 0; conn->tls_disabled = 0; conn->tls_failed = 0; conn->sasl_support = 0; conn->secured = 0; conn->bind_required = 0; conn->session_required = 0; conn->parser = parser_new(ctx, _handle_stream_start, _handle_stream_end, _handle_stream_stanza, conn); if (!conn->parser) goto out_free_lang; conn->reset_parser = 0; conn_prepare_reset(conn, auth_handle_open); conn->authenticated = 0; conn->conn_handler = NULL; conn->userdata = NULL; /* we own (and will free) the hash values */ conn->id_handlers = hash_new(ctx, 32, NULL); conn->timed_handlers = list_init(ctx); if (!conn->timed_handlers) goto out_free_parser; conn->handlers = list_init(ctx); if (!conn->handlers) goto out_free_timed_handlers; /* give the caller a reference to connection */ conn->ref = 1; /* add connection to ctx->connlist */ item = list_init_item(ctx); if (!item) goto out_free_handlers; else { item->data = (void *)conn; list_push(ctx->connlist, item); } return conn; out_free_handlers: list_destroy(conn->handlers); out_free_timed_handlers: list_destroy(conn->timed_handlers); out_free_parser: parser_free(conn->parser); out_free_lang: xmpp_free(ctx, conn->lang); out_free_send_queue: list_destroy(conn->send_queue); out_free_conn: xmpp_free(ctx, conn); return NULL; }