void compile_iter_loop(compiler_wrapper *cw, ast_node *root) { ast_loop_node *node = (ast_loop_node *)root; compile(cw, node->onloop); append_op(cw, LI_MAKE_ITER, node->lineno); int tagOut = next_if_tag(cw); int tagLoop = next_if_tag(cw); int start = (int)cw->rops.count; append_op(cw, LI_NEXT_ITER_OR_JUMP, node->lineno); append_op(cw, tagOut, node->lineno); append_op(cw, -1, node->lineno); append_op(cw, -1, node->lineno); append_op(cw, -1, node->lineno); append_var_info(cw, ((ast_value_node *)(node->init))->value.s, 0, node->lineno); append_op(cw, LI_POP, node->lineno); if(node->condition) { append_op(cw, LI_ITER_INDEX, node->lineno); append_var_info(cw, ((ast_value_node *)(node->condition))->value.s, 0, node->lineno); append_op(cw, LI_POP, node->lineno); } lky_object *wrapLoop = lobjb_build_int(tagLoop); lky_object *wrapOut = lobjb_build_int(tagOut); pool_add(&ast_memory_pool, wrapLoop); pool_add(&ast_memory_pool, wrapOut); arr_append(&cw->loop_start_stack, wrapLoop); arr_append(&cw->loop_end_stack, wrapOut); compile_compound(cw, node->payload->next); arr_remove(&cw->loop_start_stack, NULL, cw->loop_start_stack.count - 1); arr_remove(&cw->loop_end_stack, NULL, cw->loop_end_stack.count - 1); append_op(cw, tagLoop, node->lineno); append_op(cw, LI_JUMP, node->lineno); // Add the jump to the start location unsigned char buf[4]; int_to_byte_array(buf, start); append_op(cw, buf[0], node->lineno); append_op(cw, buf[1], node->lineno); append_op(cw, buf[2], node->lineno); append_op(cw, buf[3], node->lineno); append_op(cw, tagOut, node->lineno); append_op(cw, LI_POP, node->lineno); cw->save_val = 1; }
/*! ** Parse the command line arguments and fill @a dg accordingly. ** ** @param[out] dg The main data structure to be filled. ** @param[in] argc The arguments count. ** @param[in] argv The arguments array. */ void dgopts(depgraph_t *dg, int argc, char **argv) { int opt_idx; int c; int stop_loop = 0; while (!stop_loop && -1 != (c = getopt_long(argc, argv, dgoptstring, dglongopts, &opt_idx))) { switch (c) { case 'h': print_help(help, ERROR_NO); break; case 'o': dg->out = pool_add(strdup(optarg)); break; case 'r': dg->root = pool_add(strdup(optarg)); break; case 't': dg->outfunc = which_output(optarg); break; case 'u': print_help(usage, ERROR_NO); break; case 'v': dg->verbose = 1; break; case 'V': print_help(version, ERROR_NO); break; case '?': print_help(help, ERROR_CMD); break; default: exit(ERROR_CMD); break; } } if (optind >= argc) { print_help(usage, ERROR_CMD); } dg->atom = pool_add(strdup(argv[optind])); if (NULL == dg->outfunc) dg->outfunc = output_txt; }
EagleComplexType *ett_copy(EagleComplexType *type) { EagleComplexType *output = malloc(ty_size_of_type(type)); pool_add(&type_mempool, output); memcpy(output, type, ty_size_of_type(type)); if(output->type == ETFunction) { EagleFunctionType *ft = (EagleFunctionType *)output; ft->params = malloc(ft->pct * sizeof(EagleComplexType *)); pool_add(&type_mempool, ft->params); } return output; }
int main(void) { pool p; pthread_t t1, t2; size_t i; if( (p = pool_new(NELEM)) == NULL) return 77; /* Add some items to the pool */ for(i = 0; i < NELEM; i++) { void* dummy = (void*)(i + 1); pool_add(p, dummy); } /* Start the threads */ pthread_create(&t1, NULL, tfn, p); pthread_create(&t2, NULL, tfn, p); /* Wait for the threads to finish */ pthread_join(t1, NULL); pthread_join(t2, NULL); pool_free(p, NULL); return 0; }
EagleComplexType *ett_interface_type(char *name) { EagleComplexType *et = hst_get(&type_named_table, name, NULL, NULL); if(et) return et; EagleInterfaceType *ett = malloc(sizeof(EagleInterfaceType)); ett->names = arr_create(3); arr_append(&ett->names, name); ett->type = ETInterface; pool_add(&list_mempool, &ett->names); pool_add(&type_mempool, ett); return (EagleComplexType *)ett; }
EagleComplexType *ett_function_type(EagleComplexType *retVal, EagleComplexType **params, int pct) { EagleFunctionType *ett = malloc(sizeof(EagleFunctionType)); ett->type = ETFunction; ett->retType = retVal; ett->params = malloc(sizeof(EagleComplexType *) * pct); memcpy(ett->params, params, sizeof(EagleComplexType *) * pct); ett->pct = pct; ett->variadic = 0; ett->closure = NO_CLOSURE; ett->gen = 0; pool_add(&type_mempool, ett); pool_add(&type_mempool, ett->params); return (EagleComplexType *)ett; }
// Helper function to add an instruction/tag to // the running operations list. This should be // the only function that appends to that list. void append_op(compiler_wrapper *cw, long ins, long lineno) { lky_object *obj = lobjb_build_int(ins); lky_object *idx = lobjb_build_int(lineno); pool_add(&ast_memory_pool, obj); arr_append(&cw->rops, obj); arr_append(&cw->rindices, idx); }
void correct_bases(bwa_seq_t *seqs, bwa_seq_t *ori_read, alignarray *aligns, const int tid) { pool *p = NULL; int j = 0, cursor = 0, i = 0, index = 0, has_hit = 0; alg *a = NULL; bwa_seq_t *s = NULL; int *counter = NULL; //p_query("ORI", ori_read); p = new_pool(); ori_read->cursor = 0; for (i = 0; i < aligns->len; i++) { a = g_ptr_array_index(aligns, i); index = a->r_id; s = &seqs[index]; if (s->is_in_c_pool > 0 && s->is_in_c_pool != tid) continue; if (s->status == USED || strcmp(s->name, ori_read->name) == 0) continue; s->rev_com = a->rev_comp; if (s->rev_com) s->cursor = s->len - ori_read->len - a->pos; else s->cursor = a->pos; if (s->is_in_c_pool == 0) pool_add(p, s, tid); } if (p->n >= 4) { //p_pool(__func__, p, NULL); counter = (int*) calloc(5, sizeof(int)); for (j = 0; j < ori_read->len; j++) { reset_c(counter, NULL); has_hit = 0; for (i = 0; i < p->n; i++) { s = g_ptr_array_index(p->reads, i); cursor = s->cursor + j; if (cursor >= 0 || cursor < s->len) { has_hit = 1; if (s->rev_com) { counter[s->rseq[cursor]]++; } else { counter[s->seq[cursor]]++; } } } //show_debug_msg(__func__, "Correcting %d: %d:%d:%d:%d\n", j, counter[0], // counter[1], counter[2], counter[3]); if (has_hit) { ori_read->seq[j] = get_pure_most(counter); ori_read->rseq[ori_read->len - 1 - j] = 3 - ori_read->seq[j]; } } free(counter); } free_pool(p); //p_query("AFT", ori_read); }
EagleComplexType *ett_gen_type(EagleComplexType *ytype) { EagleGenType *ett = malloc(sizeof(EagleGenType)); ett->type = ETGenerator; ett->ytype = ytype; pool_add(&type_mempool, ett); return (EagleComplexType *)ett; }
VarBundle *vs_put(VarScopeStack *vs, char *ident, LLVMValueRef val, EagleComplexType *type, int lineno) { VarBundle *vb = vs_create(ident, NULL, type, val, lineno); VarScope *s = vs->scope; hst_put(&s->table, ident, vb, NULL, NULL); pool_add(&vs->pool, vb); return vb; }
EagleComplexType *ett_class_type(char *name) { EagleComplexType *et = hst_get(&type_named_table, name, NULL, NULL); if(et) return et; EagleStructType *ett = malloc(sizeof(EagleStructType)); ett->type = ETClass; ett->types = arr_create(10); ett->names = arr_create(10); ett->name = name; hst_put(&type_named_table, name, ett, NULL, NULL); pool_add(&type_mempool, ett); pool_add(&list_mempool, &ett->types); pool_add(&list_mempool, &ett->names); return (EagleComplexType *)ett; }
int balanceador_AgregaURL (char *URL){ int PoolstructOptimo = PoolstructMasVacia (); struct Poolstruct *ps; ps = listaPools_getPoolstruct(PoolstructOptimo); pool_add(ps, URL); printf("(B)***** %s en el pool del hilo %d \n", URL, PoolstructOptimo); int x = 3; }
EagleComplexType *ett_array_type(EagleComplexType *of, int ct) { EagleArrayType *ett = malloc(sizeof(EagleArrayType)); ett->type = ETArray; ett->of = of; ett->ct = ct; pool_add(&type_mempool, ett); return (EagleComplexType *)ett; }
EagleComplexType *ett_pointer_type(EagleComplexType *to) { EaglePointerType *ett = malloc(sizeof(EaglePointerType)); ett->type = ETPointer; ett->to = to; ett->counted = 0; ett->weak = 0; ett->closed = 0; pool_add(&type_mempool, ett); return (EagleComplexType *)ett; }
int main(){ srand(time(NULL)); struct thread_pool *pool = pool_init(4); int i; int num[10]; for(i = 0; i < 10; ++i) num[i] = i; for(i = 0; i < 10; ++i){ pool_add(pool, handle, num+i); } sleep(5); pool_destroy(pool); return 0; }
EagleComplexType *ett_generic_type(char *ident) { EagleComplexType *ty = hst_get(&generic_ident_table, ident, NULL, NULL); if(ty) return ty; ty = calloc(ty_type_max_size(), 1); ty->type = ETGeneric; ((EagleGenericType *)ty)->ident = ident; hst_put(&generic_ident_table, ident, ty, NULL, NULL); pool_add(&type_mempool, ty); return ty; }
VarBundle *vs_put_in_module(VarScopeStack *vs, char *ident, char *module, LLVMValueRef val, EagleComplexType *type) { VarBundle *vb = vs_create(ident, module, type, val, -1); Hashtable *mod = hst_get(&vs->modules, module, NULL, NULL); if(!mod) { mod = malloc(sizeof(Hashtable)); *mod = hst_create(); mod->duplicate_keys = 1; hst_put(&vs->modules, module, mod, NULL, NULL); } hst_put(mod, ident, vb, NULL, NULL); pool_add(&vs->pool, vb); return vb; }
EagleComplexType *ett_enum_type(char *name) { EagleComplexType *et = hst_get(&enum_named_table, name, NULL, NULL); if(et) return et; char *anam = hst_retrieve_duped_key(&enum_table, name); if(!anam) die(__LINE__, "Internal compiler error: no such enum %s", name); EagleEnumType *en = malloc(sizeof(*en)); en->type = ETEnum; en->name = anam; pool_add(&type_mempool, en); hst_put(&enum_named_table, name, en, NULL, NULL); return (EagleComplexType *)en; }
NPError My_NPN_PostURLNotify(NPP instance, const char* url, const char* target, uint32_t len, const char* buf, NPBool file, void* notifyData){ fprintf(stderr, "%s-%d: %s\n", __func__, __LINE__, url); if(target) return NPERR_NO_ERROR; url_data *data = malloc(sizeof(url_data)); data->httpType = CURL_HTTP_POST; data->instance = instance; data->url = strdup(url); data->notifyData = notifyData; data->postData = (char*)malloc(len); memcpy(data->postData, buf, len); pool_add(g_FRManager.pool, url_worker, data); return NPERR_NO_ERROR; }
void queue_get(queue_t *q, msg_t *msg) { msg_list_t *first; assert(q); assert(msg); pthread_mutex_lock(&q->mutex); while (q->msg_nr == 0) pthread_cond_wait(&q->cond, &q->mutex); first = q->first; q->first = first->next; q->msg_nr--; msg->data = first->msg.data; msg->type = first->msg.type; msg->len = first->msg.len; pool_add(q, first); pthread_mutex_unlock(&q->mutex); return; }
static void server_read_callback(struct bufferevent *bev, void *ctx) { struct range_stream *cs = (struct range_stream *) ctx; struct io *io = cs->io; debug_print(0, "read_cb bev=%p", bev); while (!range_stream_empty(cs)) { int log_size; struct Log *log = range_stream_get(cs, &log_size); if (log == NULL) { break; } char *data = log_get_data((struct Log *) log); debug_print(0, "%d %d %s", log->protocol, log->logsize, data); switch (log_data_protocol(log)) { case LOGPOOL_EVENT_READ: debug_print(1, "R %d %d, '%s'", log->klen, log->vlen, data); pool_add((struct Procedure*) log, bev, io->pool); break; case LOGPOOL_EVENT_WRITE: #if LOGPOOL_DEBUG >= 1 log_dump(stderr, "W ", (struct Log *) log, "\n", 0); #endif pool_exec((struct Log *) log, log_size, io->pool); break; case LOGPOOL_EVENT_QUIT: debug_print(1, "Q %d, %d\n", log->klen, log->vlen); pool_delete_connection(io->pool, bev); bufferevent_free(bev); goto L_exit; case LOGPOOL_EVENT_NULL: default: /*TODO*/abort(); break; } } L_exit:; return; }
char * pool_memdup(pool_t *pool, const char *str, int len) { char *p=0, *q=0; int err=-1; do { assertb(str); p = (char*)malloc(len); assertb(p); memcpy(p, str, len); q = (char*)pool_add(pool, p, 0, 0); err = 0; } while(0); if( err ) { if( q ) { pool_free(pool, q); } else if ( p ) { free(p); } p = q = 0; } return q; }
NPError My_NPN_GetURLNotify(NPP instance, const char* url, const char* target, void* notifyData){ fprintf(stderr, "%s-%d: %p, %s\n", __func__, __LINE__, target, url); if(target && !strcmp("_blank", target)){ My_NPP_URLNotify(instance, url, NPRES_DONE, notifyData); }else if(!memcmp(url, "javascript:", 11)){ NPStream stream; char buf[256]; sprintf(buf, "file:///%X.html__flashplugin_unique__", instance); stream.url = url; stream.notifyData = notifyData; stream.end = strlen(buf); My_NPP_NewStream(instance, "text/html", &stream, 0, NULL); My_NPP_WriteReady(instance, &stream); My_NPP_Write(instance, &stream, 0, stream.end, buf); My_NPP_URLNotify(instance, url, NPRES_DONE, notifyData); My_NPP_DestroyStream(instance, &stream, NPRES_DONE); }else if(!target){ url_data *data = malloc(sizeof(url_data)); data->httpType = CURL_HTTP_GET; data->instance = instance; data->url = strdup(url); data->notifyData = notifyData; data->postData = NULL; pool_add(g_FRManager.pool, url_worker, data); } return NPERR_NO_ERROR; }
void* pool_realloc(pool_t *pool, void *ptr, size_t len) { pool_remove(pool, ptr); ptr = realloc(ptr, len); return pool_add(pool, ptr, 0, 0); }
void append_var_info(compiler_wrapper *cw, char *ch, char load, int lineno) { char needs_close = cw->repl; char already_defined = 0; arraylist list = cw->used_names; int i; for(i = 0; i < list.count; i++) { name_wrapper *w = arr_get(&cw->used_names, i); if(strcmp(w->name, ch)) continue; if(w->owner != cw) { switch_to_close(w->owner, ch, w->idx); needs_close = 1; } else { needs_close = is_close(cw, w->idx); already_defined = 1; } } if(!needs_close && !already_defined && load) needs_close = 1; if(needs_close) { lky_instruction istr = load ? LI_LOAD_CLOSE : LI_SAVE_CLOSE; char *nsid = malloc(strlen(ch) + 1); strcpy(nsid, ch); int i = find_prev_name(cw, nsid); if(i < 0) { i = (int)cw->rnames.count; arr_append(&cw->rnames, nsid); } append_op(cw, istr, lineno); unsigned char buf[4]; int_to_byte_array(buf, i); append_op(cw, buf[0], lineno); append_op(cw, buf[1], lineno); append_op(cw, buf[2], lineno); append_op(cw, buf[3], lineno); return; } lky_instruction istr = load ? LI_LOAD_LOCAL : LI_SAVE_LOCAL; hm_error_t err; int idx = 0; lky_object_builtin *o = hm_get(&cw->saved_locals, ch, &err); if(err == HM_KEY_NOT_FOUND) { idx = get_next_local(cw); lky_object *obj = lobjb_build_int(idx); pool_add(&ast_memory_pool, obj); hm_put(&cw->saved_locals, ch, obj); } else idx = OBJ_NUM_UNWRAP(o); append_op(cw, istr, lineno); unsigned char buf[4]; int_to_byte_array(buf, idx); append_op(cw, buf[0], lineno); append_op(cw, buf[1], lineno); append_op(cw, buf[2], lineno); append_op(cw, buf[3], lineno); name_wrapper *wrap = malloc(sizeof(name_wrapper)); pool_add(&ast_memory_pool, wrap); wrap->idx = cw->rops.count - 5; wrap->name = ch; wrap->owner = cw; arr_append(&cw->used_names, wrap); }
void* pool_malloc(pool_t *pool, size_t len) { return pool_add(pool, calloc(len, 1), 0, 0); }
int rfc6791_add(struct ipv4_prefix *prefix) { return pool_add(pool, prefix); }
void compile_loop(compiler_wrapper *cw, ast_node *root) { ast_loop_node *node = (ast_loop_node *)root; // if(node->init && node->condition && !node->onloop) // return compile_iter_loop(cw, root); int tagOut = next_if_tag(cw); // Prepare the exit tag int tagLoop = next_if_tag(cw); // Prepare the continue tag if(node->init) // If we have a for loop, compile the init { char save = cw->save_val; cw->save_val = 0; compile(cw, node->init); if(!cw->save_val) append_op(cw, LI_POP, node->lineno); cw->save_val = save; } int start = (int)cw->rops.count; // The start location (for loop jumps) compile(cw, node->condition); // Append the tag for the unknown end location append_op(cw, LI_JUMP_FALSE, node->lineno); append_op(cw, tagOut, node->lineno); append_op(cw, -1, node->lineno); // Note that we use for bytes to represent jump locations. append_op(cw, -1, node->lineno); // This allows us to index locations beyond 255 in the append_op(cw, -1, node->lineno); // interpreter. lky_object *wrapLoop = lobjb_build_int(tagLoop); lky_object *wrapOut = lobjb_build_int(tagOut); pool_add(&ast_memory_pool, wrapLoop); pool_add(&ast_memory_pool, wrapOut); arr_append(&cw->loop_start_stack, wrapLoop); arr_append(&cw->loop_end_stack, wrapOut); compile_compound(cw, node->payload->next); arr_remove(&cw->loop_start_stack, NULL, cw->loop_start_stack.count - 1); arr_remove(&cw->loop_end_stack, NULL, cw->loop_end_stack.count - 1); append_op(cw, tagLoop, node->lineno); if(node->onloop) // If a for loop, compile the onloop. { char save = cw->save_val; cw->save_val = 0; compile(cw, node->onloop); if(!cw->save_val) append_op(cw, LI_POP, node->lineno); cw->save_val = save; } append_op(cw, LI_JUMP, node->lineno); // Add the jump to the start location unsigned char buf[4]; int_to_byte_array(buf, start); append_op(cw, buf[0], node->lineno); append_op(cw, buf[1], node->lineno); append_op(cw, buf[2], node->lineno); append_op(cw, buf[3], node->lineno); append_op(cw, tagOut, node->lineno); cw->save_val = 1; }
char* pool_strdup(pool_t *pool, const char *str) { if( !str ) return 0; return (char*)pool_add(pool, strdup(str), 0, 0); }