void taskmain(int argc, char *argv[]) { LOG_FILE = stderr; glob_t profile_glob; int rc = 0; int i = 0; Action *action = NULL; tst_t *targets = NULL; bstring pid_file = NULL; check(argc == 3, "USAGE: procer <profile_dir> <procer_pid_file>"); pid_file = bfromcstr(argv[2]); rc = Unixy_remove_dead_pidfile(pid_file); check(rc == 0, "Failed to remove %s, procer is probably already running.", bdata(pid_file)); rc = Unixy_daemonize(); check(rc == 0, "Couldn't daemonize, that's not good."); rc = chdir(argv[1]); check(rc == 0, "Couldn't change to %s profile dir.", argv[1]); rc = Unixy_pid_file(pid_file); check(rc == 0, "Failed to make the PID file: %s", bdata(pid_file)); FILE *log = fopen("error.log", "a+"); check(log, "Couldn't open error.log"); setbuf(log, NULL); LOG_FILE = log; bstring dir_glob = bformat("%s/[A-Za-z0-9]*", argv[1]); check(dir_glob, "Couldn't make the directory glob."); rc = glob(bdata(dir_glob), GLOB_ERR | GLOB_ONLYDIR, NULL, &profile_glob); check(rc == 0, "Failed to find directories in the profiles."); debug("Loading %zu actions.", profile_glob.gl_pathc); for(i = 0; i < profile_glob.gl_pathc; i++) { action = Action_create(profile_glob.gl_pathv[i]); targets = tst_insert(targets, bdata(action->name), blength(action->name), action); } // now we setup the dependencies from the settings they've got tst_traverse(targets, Action_dependency_assign, targets); tst_traverse(targets, Action_start_all, NULL); taskexit(0); error: taskexitall(1); }
int AST_walk_hash(tst_t *settings, Value *data, ast_hash_walk_cb cb) { struct ASTScanData scan = {.settings = settings, .cb = cb, .error = 0}; tst_traverse(data->as.hash, ast_hash_traverse_cb, &scan); return scan.error; } Value *AST_get(tst_t *settings, tst_t *fr, bstring name, ValueType type) { Pair *pair = tst_search(fr, bdata(name), blength(name)); check_debug(pair, "Couldn't find variable %s of type %s", bdata(name), Value_type_name(type)); Value *val = Pair_value(pair); if(Value_is(val, REF)) { val = Value_resolve(settings, val); check(val, "Couldn't find variable %s of type %s", bdata(name), Value_type_name(type)); } check(val->type == type, "Invalid type for %s, should be %s not %s", bdata(name), Value_type_name(type), Value_type_name(val->type)); return val; error: return NULL; }
static inline int Server_copy_active_handlers(Server *srv, Server *copy_from) { int i = 0; for(i = 0; i < darray_end(copy_from->handlers); i++) { Handler *from = darray_get(copy_from->handlers, i); int j = 0; for(j = 0; j < darray_end(srv->handlers); j++) { Handler *to = darray_get(srv->handlers, j); if(same_handler(from, to)) { debug("Swapping %p original for %p replacement", to, from); RouteUpdater update = {.original = to, .replacement = from}; tst_traverse(srv->hosts->routes, update_host_routes, &update); darray_set(srv->handlers, j, from); // swap them around so that the darrays stay full darray_set(copy_from->handlers, i, to); to->running = 0; break; } } } return 0; }
// returned object belongs to caller. dict_array* dict_to_array(dict *d) { dict_array *a = pdf_malloc(sizeof(dict_array)); if (!a) return a; a->cur = 0; a->items = pdf_malloc((sizeof(struct dict_item))* (d->n)); if (!a->items) return NULL; if (d && d->dict) { #if defined (HASHMAP) fprintf(stderr, "%s is not implemented", __FUNCTION__); #elif defined (TSTC) tstc_call(d->dict, 0, (tstc_f)dict_tstc_array_append, (void*)a); #else tst_print_reset(1); tst_traverse(d->dict, (tst_hook)dict_array_append, a); tst_print_reset(-1); #endif } return a; }
void MIME_destroy() { if(MIME_MAP) { tst_traverse(MIME_MAP, MIME_traverse_destroy, NULL); tst_destroy(MIME_MAP); MIME_MAP = NULL; } }
void Setting_destroy() { if(SETTINGS_MAP) { tst_traverse(SETTINGS_MAP, Setting_traverse_destroy, NULL); tst_destroy(SETTINGS_MAP); SETTINGS_MAP = NULL; } }
char *test_tst_traverse() { traverse_count = 0; tst_traverse(node, tst_traverse_test_cb, valueA); debug("traverse count is: %d", traverse_count); mu_assert(traverse_count == 4, "Didn't find 4 keys."); return NULL; }
void dict_each(dict *d, void (*call()), void *a) { if (d && d->dict) { #ifdef TSTC tstc_call(d->dict, 0, call, a); #elif defined (HASHMAP) #else tst_traverse(d->dict, call, a); #endif } }
void run_repl(Module *state, const char *in_file) { printf("EaRing. Copyright 2008 Zed A. Shaw.\n"); printf("Done compiling %s. Enter ? to get the function list.\n", in_file); char *cmd = NULL; current_module = state; repl_init(NULL); while((cmd = repl_prompt())) { if(cmd[0] == '?') { tst_traverse(state->functions, (tst_traverse_cb)query_functions, NULL); } else { run_function(state, cmd); } } }
void dict_dump(dict* d) { printf("%s", "\n"); if (d) { if (d->dict) { #ifdef TSTC tstc_print(d->dict); #elif defined (HASHMAP) #else tst_print_reset(1); tst_traverse(d->dict, dict_print_keyval, NULL); tst_print_reset(-1); #endif } } }
void dict_free(dict* d) { if (d) { if (d->dict) { #ifdef TSTC tstc_call(d->dict, 0, dict_entry_free, 0); tstc_free(d->dict); #elif defined (HASHMAP) extern void pdf_obj_delete(void *); hash_map_entry *e; hash_map_iterator *i = hash_map_front(d->dict); while (!hash_map_iterator_at_end(i)) { e = hash_map_iterator_get(i); pdf_obj_delete(e->v); pdf_free(e->v); hash_map_iterator_next(i); } hash_map_iterator_free(i); hash_map_free(d->dict); #else tst_print_reset(1); tst_traverse(d->dict, dict_free_val, NULL); tst_cleanup(d->dict); tst_print_reset(-1); #endif } if (d->stream) { pdf_free(d->stream); } pdf_free(d); } return; }
// returned object belongs to caller. // Experimental: using list as target by imitating "LISP" style. dict_list* dict_to_list(dict *d) { dict_list *l = pdf_malloc(sizeof(dict_list)); l->next = l->last = NULL; l->val.t = eLimit; if (d && d->dict) { #ifdef TSTC char buf[1024]; tstc_call(d->dict, buf, dict_list_append, l); #elif defined (HASHMAP) hash_map_iterator *i = hash_map_front(d->dict); hash_map_entry *e; while (!hash_map_iterator_at_end(i)) { e = hash_map_iterator_get(i); dict_list_append((char*)e->k, e->v, l); hash_map_iterator_next(i); } hash_map_iterator_free(i); #else tst_print_reset(1); tst_traverse(d->dict, (tst_hook)dict_list_append, l); tst_print_reset(-1); #endif } if (l->val.t == eLimit) { pdf_free(l); l = NULL; } return l; }
void AST_destroy(tst_t *settings) { tst_traverse(settings, AST_destroy_cb, NULL); tst_destroy(settings); }
static void update_host_routes(void *value, void *data) { Host *host = ((Route *)value)->data; tst_traverse(host->routes->routes, update_routes, data); }
char *cmd_help(void *self, char *argv[], int argc) { char *ret = malloc(2048); memset(ret, '\0', sizeof(2048)); tst_traverse(commands, _cmd_help_i, (void *)ret); return ret; }
void taskmain(int argc, char *argv[]) { dbg_set_log(stderr); glob_t profile_glob; int rc = 0; int i = 0; Action *action = NULL; tst_t *targets = NULL; bstring pid_file = NULL; char *procer_error_log = NULL; m2program = procer_program; check(argc == 3, "USAGE: %s <profile_dir> <procer_pid_file>", m2program); pid_file = bfromcstr(argv[2]); srand(time(NULL)); // simple randomness rc = Unixy_remove_dead_pidfile(pid_file); check(rc == 0, "Failed to remove %s, %s is probably already running.", bdata(pid_file), m2program); rc = Unixy_daemonize(1); check(rc == 0, "Couldn't daemonize, that's not good."); rc = chdir(argv[1]); check(rc == 0, "Couldn't change to %s profile dir.", argv[1]); rc = Unixy_pid_file(pid_file); check(rc == 0, "Failed to make the PID file: %s", bdata(pid_file)); if( (procer_error_log = getenv("PROCER_ERROR_LOG")) == NULL) procer_error_log = "error.log"; FILE *log = fopen(procer_error_log, "a+"); check(log, "Couldn't open error.log"); setbuf(log, NULL); dbg_set_log(log); bstring dir_glob = bformat("%s/[A-Za-z0-9]*", argv[1]); check(dir_glob, "Couldn't make the directory glob."); rc = glob(bdata(dir_glob), GLOB_ERR, NULL, &profile_glob); check(rc == 0, "Failed to find directories in the profiles."); struct stat sb; debug("Loading %zu actions.", profile_glob.gl_pathc); start_terminator(); while(RUNNING) { for(i = 0; i < profile_glob.gl_pathc; i++) { rc = lstat(profile_glob.gl_pathv[i], &sb); check(rc == 0, "Failed to stat file or directory: %s", profile_glob.gl_pathv[i]); if (sb.st_mode & S_IFDIR) { action = Action_create(profile_glob.gl_pathv[i]); targets = tst_insert(targets, bdata(action->name), blength(action->name), action); } } // now we setup the dependencies from the settings they've got tst_traverse(targets, Action_dependency_assign, targets); tst_traverse(targets, Action_start_all, NULL); while(RUNNING) { Action_sleep(1); } } log_warn("Exiting as requested from procer."); taskexit(0); error: taskexitall(1); }
int main(int argc, char *argv[]) { CORD input = NULL; const char *in_file_name = NULL; FILE *in_file = NULL; Module *state = NULL; int opt; int disassemble = 0; const char *func = "main"; int interactive = 0; int listing = 0; while((opt = getopt(argc, argv, "lhdf:i")) != -1) { switch(opt) { case 'd': disassemble = 1; break; case 'f': func = optarg; break; case 'i': interactive = 1; break; case 'l': listing = 1; break; case 'h': /// fall through! default: die(NULL, "USAGE: earing [-d | -i] [-f function] <file.asm>\n"); return 1; } } if(optind >= argc) { die(NULL, "You have to give a file. Use -h to see the usage."); return 1; } GC_INIT(); in_file_name = argv[optind]; in_file = fopen(in_file_name, "r"); if(!in_file) { die(NULL, "Failed to open the input file %s", in_file_name); } input = CORD_from_file(in_file); state = Module_create(in_file_name, 1024); Module_register_default_directives(state); if(!Module_compile(state, CORD_to_const_char_star(input), CORD_len(input))) { die(state, "Parsing failed with %d errors.\n", state->errors); return 1; } else { if(listing) { tst_traverse(state->functions, (tst_traverse_cb)query_functions, NULL); } else if(disassemble) { dis_functions(state); } else if(interactive) { // go into interactive mode with the repl run_repl(state, in_file_name); } else { // run the given function or the "main" default run_function(state, func); } } return 0; }