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;
}
