int MPIDI_RMA_init(void) { int mpi_errno = MPI_SUCCESS; int i; MPIR_CHKPMEM_DECL(3); MPIR_FUNC_VERBOSE_STATE_DECL(MPID_STATE_MPIDI_RMA_INIT); MPIR_FUNC_VERBOSE_RMA_ENTER(MPID_STATE_MPIDI_RMA_INIT); MPIR_CHKPMEM_MALLOC(global_rma_op_pool_start, MPIDI_RMA_Op_t *, sizeof(MPIDI_RMA_Op_t) * MPIR_CVAR_CH3_RMA_OP_GLOBAL_POOL_SIZE, mpi_errno, "RMA op pool", MPL_MEM_RMA); for (i = 0; i < MPIR_CVAR_CH3_RMA_OP_GLOBAL_POOL_SIZE; i++) { global_rma_op_pool_start[i].pool_type = MPIDI_RMA_POOL_GLOBAL; DL_APPEND(global_rma_op_pool_head, &(global_rma_op_pool_start[i])); } MPIR_CHKPMEM_MALLOC(global_rma_target_pool_start, MPIDI_RMA_Target_t *, sizeof(MPIDI_RMA_Target_t) * MPIR_CVAR_CH3_RMA_TARGET_GLOBAL_POOL_SIZE, mpi_errno, "RMA target pool", MPL_MEM_RMA); for (i = 0; i < MPIR_CVAR_CH3_RMA_TARGET_GLOBAL_POOL_SIZE; i++) { global_rma_target_pool_start[i].pool_type = MPIDI_RMA_POOL_GLOBAL; DL_APPEND(global_rma_target_pool_head, &(global_rma_target_pool_start[i])); } fn_exit: MPIR_FUNC_VERBOSE_EXIT(MPID_STATE_MPIDI_RMA_INIT); return mpi_errno; fn_fail: MPIR_CHKPMEM_REAP(); goto fn_fail; }
void nitro_prefix_trie_add(nitro_prefix_trie_node **t, const uint8_t *rep, uint8_t length, void *ptr) { nitro_prefix_trie_node *n, *on; if (!*t) { ZALLOC(*t); if (length) { (*t)->length = length; (*t)->rep = malloc(length); memmove((*t)->rep, rep, length); } } on = n = *t; if (n->length < length && !memcmp(n->rep, rep, n->length)) { uint8_t c = rep[n->length]; nitro_prefix_trie_add(&n->subs[c], rep, length, ptr); } else { // alloc nitro_prefix_trie_mem *m; ZALLOC(m); m->ptr = ptr; if (n->length == length && !memcmp(n->rep, rep, length)) { DL_APPEND(n->members, m); } else { ZALLOC(n); n->length = length; n->rep = malloc(length); memmove(n->rep, rep, length); DL_APPEND(n->members, m); if (n->length < on->length && !memcmp(on->rep, n->rep, n->length)) { *t = n; n->subs[on->rep[length]] = on; } else if (n->length > on->length && !memcmp(on->rep, n->rep, on->length)) { *t = on; on->subs[n->rep[on->length]] = n; } else { int i; for (i = 0; i < length && on->rep[i] == n->rep[i]; i++) {} nitro_prefix_trie_node *parent; ZALLOC(parent); parent->length = i; parent->rep = malloc(parent->length); memmove(parent->rep, rep, parent->length); parent->subs[rep[parent->length]] = n; parent->subs[on->rep[parent->length]] = on; *t = parent; } } } }
void CCScheduler::priorityIn(tListEntry **ppList, SelectorProtocol *pTarget, int nPriority, bool bPaused) { tListEntry *pListElement = (tListEntry *)malloc(sizeof(*pListElement)); pListElement->target = pTarget; pListElement->priority = nPriority; pListElement->paused = bPaused; pListElement->next = pListElement->prev = NULL; // listElement->impMethod = (TICK_IMP) [target methodForSelector:updateSelector]; // empey list ? if (! *ppList) { DL_APPEND(*ppList, pListElement); } else { bool bAdded = false; for (tListEntry *pElement = *ppList; pElement; pElement = pElement->next) { if (nPriority < pElement->priority) { if (pElement == *ppList) { DL_PREPEND(*ppList, pListElement); } else { pListElement->next = pElement; pListElement->prev = pElement->prev; pElement->prev->next = pListElement; pElement->prev = pListElement; } bAdded = true; break; } } // Not added? priority has the higher value. Append it. if (! bAdded) { DL_APPEND(*ppList, pListElement); } } // update hash entry for quick access tHashUpdateEntry *pHashElement = (tHashUpdateEntry *)calloc(sizeof(*pHashElement), 1); pHashElement->target = pTarget; pTarget->selectorProtocolRetain(); pHashElement->list = ppList; pHashElement->entry = pListElement; HASH_ADD_INT(m_pHashForUpdates, target, pHashElement); }
int main() { int i; el els[10], *e, *tmp, *tmp2; for(i=0;i<10;i++) els[i].id='a'+i; /* test LL macros */ printf("LL macros\n"); LL_APPEND(head,&els[0]); LL_APPEND(head,&els[1]); LL_APPEND(head,&els[2]); LL_FOREACH(head,e) printf("%c ", e->id); printf("\n"); LL_SEARCH_SCALAR(head, e, id, 'b'); if (e) printf("search scalar found b\n"); LL_SEARCH(head, e, &els[0], eltcmp); if (e) printf("search found %c\n",e->id); LL_FOREACH_SAFE(head,e,tmp) LL_DELETE(head,e); printf("\n"); /* test DL macros */ printf("DL macros\n"); DL_APPEND(head,&els[0]); DL_APPEND(head,&els[1]); DL_APPEND(head,&els[2]); DL_FOREACH(head,e) printf("%c ", e->id); printf("\n"); DL_SEARCH_SCALAR(head, e, id, 'b'); if (e) printf("search scalar found b\n"); DL_SEARCH(head, e, &els[0], eltcmp); if (e) printf("search found %c\n",e->id); DL_FOREACH_SAFE(head,e,tmp) DL_DELETE(head,e); printf("\n"); /* test CDL macros */ printf("CDL macros\n"); CDL_PREPEND(head,&els[0]); CDL_PREPEND(head,&els[1]); CDL_PREPEND(head,&els[2]); CDL_FOREACH(head,e) printf("%c ", e->id); printf("\n"); CDL_SEARCH_SCALAR(head, e, id, 'b'); if (e) printf("search scalar found b\n"); CDL_SEARCH(head, e, &els[0], eltcmp); if (e) printf("search found %c\n",e->id); CDL_FOREACH_SAFE(head,e,tmp,tmp2) CDL_DELETE(head,e); return 0; }
void rspamd_content_type_add_param (rspamd_mempool_t *pool, struct rspamd_content_type *ct, const gchar *name_start, const gchar *name_end, const gchar *value_start, const gchar *value_end) { rspamd_ftok_t srch; struct rspamd_content_type_param *found = NULL, *nparam; g_assert (ct != NULL); srch.begin = name_start; srch.len = name_end - name_start; if (ct->attrs) { found = g_hash_table_lookup (ct->attrs, &srch); } else { ct->attrs = g_hash_table_new (rspamd_ftok_icase_hash, rspamd_ftok_icase_equal); } nparam = rspamd_mempool_alloc (pool, sizeof (*nparam)); nparam->name.begin = name_start; nparam->name.len = name_end - name_start; nparam->value.begin = value_start; nparam->value.len = value_end - value_start; if (!found) { DL_APPEND (found, nparam); g_hash_table_insert (ct->attrs, &nparam->name, nparam); } else { DL_APPEND (found, nparam); } RSPAMD_FTOK_ASSIGN (&srch, "charset"); if (rspamd_ftok_cmp (&nparam->name, &srch) == 0) { /* Adjust charset */ ct->charset.begin = nparam->value.begin; ct->charset.len = nparam->value.len; } RSPAMD_FTOK_ASSIGN (&srch, "boundary"); if (rspamd_ftok_cmp (&nparam->name, &srch) == 0) { /* Adjust boundary */ ct->boundary.begin = nparam->value.begin; ct->boundary.len = nparam->value.len; } }
void asterisk_acc_unpack_socket(char *buff, perm_node_t **key_list, asterisk_acc_table_t *asterisk_acc_table, opool_t *opool) { int i; json_object *new_obj, *jvalue; opool_item_t *item, *item2; perm_node_t *key_element, *value_element, *data_list; perm_node_t *temp, *entry; perm_node_t *temp2, *entry2; perm_node_t *data_list2; char id[10], pwd[10]; new_obj = json_tokener_parse(buff); //printf("new_obj.to_string()=%s\n", json_object_to_json_string(new_obj)); for(i = 0; i < json_object_array_length(new_obj); i++) { item = opool_get(opool); EXIT_IF_TRUE(item == NULL, "Cannot get from object pool\n"); key_element = (perm_node_t *)item->data; item2 = opool_get(opool); EXIT_IF_TRUE(item == NULL, "Cannot get from object pool\n"); value_element = (perm_node_t *)item2->data; json_object *obj = json_object_array_get_idx(new_obj, i); json_object_object_get_ex(obj, "account", &jvalue); strcpy(id, json_object_get_string(jvalue)); json_object_object_get_ex(obj, "password", &jvalue); strcpy(pwd, json_object_get_string(jvalue)); ansi_copy_str(key_element->value, id); ansi_copy_str(value_element->value, pwd); data_list = (perm_node_t *)ht_get_item(asterisk_acc_table, (void *)id); if (data_list == NULL) { DL_APPEND(*key_list, key_element); DL_APPEND(data_list, value_element); ht_add_item(asterisk_acc_table, id, data_list); } else { DL_APPEND(data_list, value_element); } } }
void pthread_scheduler_push_command (_cl_command_node *cmd) { PTHREAD_LOCK (&scheduler.wq_lock, NULL); DL_APPEND (scheduler.work_queue, cmd); pthread_cond_broadcast (&scheduler.wake_pool); PTHREAD_UNLOCK (&scheduler.wq_lock); }
void parse_gdata_stream(void *stream, R_STREAM_FILE *stream_file) { unsigned short len = 0; unsigned short leaf_type = 0; char *data = 0; SGDATAStream *data_stream = (SGDATAStream *) stream; SGlobal *global = 0; data_stream->globals_list = NULL; while (1) { stream_file_read(stream_file, 2, (char *)&len); if (len == 0) break; data = (char *) malloc(len); if (!data) return; stream_file_read(stream_file, len, data); leaf_type = *(unsigned short *) (data); if ((leaf_type == 0x110E) || (leaf_type == 0x1009)) { global = (SGlobal *) malloc(sizeof(SGlobal)); if (!global) { free (data); return; } global->leaf_type = leaf_type; parse_global(data + 2, len, global); DL_APPEND(data_stream->globals_list, global); } } }
int main(int argc, char *argv[]) { el *name, *tmp; char linebuf[BUFLEN]; FILE *file; if ( (file = fopen( "test11.dat", "r" )) == NULL ) { perror("can't open: "); exit(-1); } while (fgets(linebuf,BUFLEN,file) != NULL) { if ( (name = (el*)malloc(sizeof(el))) == NULL) exit(-1); strncpy(name->bname,linebuf,BUFLEN); DL_APPEND(head, name); } DL_SORT(head, namecmp); DL_FOREACH(head,tmp) printf("%s", tmp->bname); /* now delete the list head */ printf("deleting head %shead->prev: %s", head->bname, head->prev->bname); DL_DELETE(head,head); DL_FOREACH(head,tmp) printf("%s", tmp->bname); fclose(file); return 0; }
static void sim_fire_events(struct simulator *sim) { struct sig_hook *hooks, *h, *t; picos_t orig_target; int is_target_time; hooks = sim->hooks; sim->hooks = 0; sim->calling_hooks = 1; DL_FOREACH_SAFE(hooks, h, t) { is_target_time = (h->time && h->time <= sim->picos); if (is_target_time || (sim->any_event && bv_and_reduce(&sim->events, &h->signals))) { orig_target = h->time; if (h->cb(sim, h)) { h->time = 0; DL_DELETE(hooks, h); } else { if (h->time <= sim->picos) { /* disable times in the past */ h->time = 0; } if (h->time != orig_target) { /* reschedule if time changed */ DL_DELETE(hooks, h); DL_APPEND(sim->hooks, h); } } } }
static DWORD l_Build_AddElement( KUSB_ENUM_REGKEY_PARAMS* RegEnumParams, PKLST_DEVINFO_EL* clonedDevInfo) { PKLST_DEVINFO_HANDLE_INTERNAL clonedHandle = NULL; *clonedDevInfo = NULL; if (!l_Alloc_DevInfo(&clonedHandle, RegEnumParams->Heap)) goto Error; memcpy(&clonedHandle->DevInfoEL->Public, RegEnumParams->TempItem, sizeof(clonedHandle->DevInfoEL->Public)); // LstInfoK + 1 PoolHandle_Inc_LstInfoK(clonedHandle); clonedHandle->DevInfoEL->DevListHandle = RegEnumParams->DeviceList; clonedHandle->DevInfoEL->DevInfoHandle = clonedHandle; DL_APPEND(RegEnumParams->DeviceList->head, clonedHandle->DevInfoEL); *clonedDevInfo = clonedHandle->DevInfoEL; return ERROR_SUCCESS; Error: return GetLastError(); }
static int cras_hsp_ag_new_connection(DBusConnection *conn, struct cras_bt_profile *profile, struct cras_bt_device *device, int rfcomm_fd) { struct audio_gateway *ag; if (has_audio_gateway(device)) { syslog(LOG_ERR, "Audio gateway exists when %s connects for profile %s", cras_bt_device_name(device), profile->name); close(rfcomm_fd); return 0; } if (check_for_conflict_ag(device)) return -1; cras_bt_device_set_append_iodev_cb(device, possibly_remove_conflict_dev); ag = (struct audio_gateway *)calloc(1, sizeof(*ag)); ag->device = device; ag->conn = conn; ag->profile = cras_bt_device_profile_from_uuid(profile->uuid); ag->slc_handle = hfp_slc_create(rfcomm_fd, 1, device, NULL, cras_hfp_ag_slc_disconnected); DL_APPEND(connected_ags, ag); cras_hfp_ag_slc_initialized(ag->slc_handle); return 0; }
int main(int argc, char *argv[]) { el *name, *elt, *tmp, etmp; el *head = NULL; /* important- initialize to NULL! */ char linebuf[BUFLEN]; FILE *file; file = fopen( "test11.dat", "r" ); if (file == NULL) { perror("can't open: "); exit(-1); } while (fgets(linebuf,BUFLEN,file) != NULL) { name = (el*)malloc(sizeof(el)); if (name == NULL) exit(-1); strncpy(name->bname,linebuf,sizeof(name->bname)); DL_APPEND(head, name); } DL_SORT(head, namecmp); DL_FOREACH(head,elt) printf("%s", elt->bname); memcpy(etmp.bname, "WES\n", 5UL); DL_SEARCH(head,elt,&etmp,namecmp); if (elt != NULL) printf("found %s\n", elt->bname); /* now delete each element, use the safe iterator */ DL_FOREACH_SAFE(head,elt,tmp) { DL_DELETE(head,elt); }
int main(int argc, char *argv[]) { el *name, *elt, *tmp, etmp; int i; example_user_t *user, *users=NULL; char linebuf[BUFLEN]; FILE *file; UT_string *s; char binary[] = "\xff\xff"; if ( (file = fopen( "test11.dat", "r" )) == NULL ) { perror("can't open: "); exit(-1); } while (fgets(linebuf,BUFLEN,file) != NULL) { if ( (name = (el*)malloc(sizeof(el))) == NULL) exit(-1); strncpy(name->bname,linebuf,BUFLEN); DL_APPEND(head, name); } DL_SORT(head, namecmp); DL_FOREACH(head,elt) printf("%s", elt->bname); memcpy(&etmp.bname, "WES\n", 5); DL_SEARCH(head,elt,&etmp,namecmp); if (elt) printf("found %s\n", elt->bname); /* now delete each element, use the safe iterator */ DL_FOREACH_SAFE(head,elt,tmp) { DL_DELETE(head,elt); }
// foreign static int _uscript_func_editor_register_cmd(cmd_name, fn_callback) static int _uscript_func_editor_register_cmd(lua_State *L) { uscript_t *uscript; uhandle_t *uhandle; int rv; char *cmd_name; int fn_callback; cmd_t cmd = {0}; MLE_USCRIPT_GET(L, uscript); cmd_name = (char*)luaL_checkstring(L, 1); // strdup'd by editor_register_cmd fn_callback = luaL_checkfunction(L, 2); uhandle = calloc(1, sizeof(uhandle_t)); uhandle->uscript = uscript; uhandle->callback_ref = fn_callback; DL_APPEND(uscript->uhandles, uhandle); cmd.name = cmd_name; cmd.func = _uscript_cmd_cb; cmd.udata = (void*)uhandle; rv = editor_register_cmd(uscript->editor, &cmd); lua_createtable(L, 0, 1); luaL_pushkey(L, integer, "rv", rv); lua_pushvalue(L, -1); return 1; }
struct cras_bt_transport *cras_bt_transport_create(DBusConnection *conn, const char *object_path) { struct cras_bt_transport *transport; transport = calloc(1, sizeof(*transport)); if (transport == NULL) return NULL; transport->object_path = strdup(object_path); if (transport->object_path == NULL) { free(transport); return NULL; } transport->conn = conn; dbus_connection_ref(transport->conn); transport->fd = -1; transport->volume = -1; DL_APPEND(transports, transport); return transport; }
int main(int argc, char *argv[]) { el *name, *elt, *tmp, etmp; int i; example_user_t *user, *users=NULL; el *head = NULL; /* important- initialize to NULL! */ char linebuf[BUFLEN]; FILE *file; UT_string *s; char binary[] = "\xff\xff"; file = fopen( "test11.dat", "r" ); if (file == NULL) { perror("can't open: "); exit(-1); } while (fgets(linebuf,BUFLEN,file) != NULL) { name = (el*)malloc(sizeof(el)); if (name == NULL) { exit(-1); } strncpy(name->bname,linebuf,sizeof(name->bname)); DL_APPEND(head, name); } DL_SORT(head, namecmp); DL_FOREACH(head,elt) { printf("%s", elt->bname); }
void rspamd_worker_set_signal_handler (int signo, struct rspamd_worker *worker, struct event_base *base, void (*handler)(struct rspamd_worker_signal_handler *sigh, void *), void *handler_data) { struct rspamd_worker_signal_handler *sigh; struct rspamd_worker_signal_cb *cb; sigh = g_hash_table_lookup (worker->signal_events, GINT_TO_POINTER (signo)); if (sigh == NULL) { sigh = g_malloc0 (sizeof (*sigh)); sigh->signo = signo; sigh->worker = worker; sigh->base = base; sigh->enabled = TRUE; signal_set (&sigh->ev, signo, rspamd_worker_signal_handler, sigh); event_base_set (base, &sigh->ev); signal_add (&sigh->ev, NULL); g_hash_table_insert (worker->signal_events, GINT_TO_POINTER (signo), sigh); } cb = g_malloc0 (sizeof (*cb)); cb->handler = handler; cb->handler_data = handler_data; DL_APPEND (sigh->cb, cb); }
int main(int argc, char *argv[]) { el *id, *elt, *tmp, etmp; if ( (id = (el*)malloc(sizeof(el))) == NULL) exit(-1); id->key = 5; DL_APPEND(head,id); }
int cpw_process_add_source(cpwprocess *process, cpwsource *source) { if (source) { if (process) { DL_APPEND(process->source, source); return 0; } } return -1; }
/* Add ITEM to WQ. Currently, this just adds ITEM to the list. * * It is your task to perform any necessary operations to properly * perform synchronization. */ void wq_push(wq_t *wq, void *item) { // OUR CODE HERE pthread_mutex_lock(&wq->lock); wq_item_t *wq_item = calloc(1, sizeof(wq_item_t)); wq_item->item = item; DL_APPEND(wq->head, wq_item); pthread_cond_signal(&wq->cv); pthread_mutex_unlock(&wq->lock); }
int nextFrame_fifo(mmu *m){ pteAgent *cur; int re; cur = m->pageA; re = cur->myID; DL_DELETE(m->pageA, cur); DL_APPEND(m->pageA, cur); return m->frames[re]; }
int cpw_process_add_output(cpwprocess *process, cpwoutput *output) { if (output) { if (process) { DL_APPEND(process->output, output); return 0; } } return -1; }
void netif_add(struct netif **ifs, enum netif_type type, char *dev, char *name) { struct netif *nif = malloc(sizeof(struct netif)); fail_if(!nif, "OOM"); nif->dev = strdup(dev); nif->name = strdup(name); nif->type = type; DL_APPEND(*ifs, nif); }
void updateMMU_fifo(mmu *m, int p){ if (m->pageA == NULL){ int i; pteAgent *a; for (i=0; i<numFrames; i++){ a = iniPteAgent(i); //frame index DL_APPEND(m->pageA, a); } } return; }
/** * This function will return NULL if the qgram_t struct contains invalid values */ dl_token_t *qgram_tokenize_to_dllist(const char *str, const qgram_t *qtype) { int i; int init_len = strlen(str) + 1; char *tmp; //Mem corruption will occur otherwise... if(qtype->qgram_len < 1 || qtype->qgram_len > 3) return NULL; if(qtype->extended) { tmp = calloc((init_len + qtype->qgram_len), sizeof(char)); for(i = 0; i < (qtype->qgram_len - 1); i++) strcat(tmp, QGRAM_SP); strcat(tmp, str); for(i = 0; i < (qtype->qgram_len - 1); i++) strcat(tmp, QGRAM_EP); } else { tmp = calloc(init_len, sizeof(char)); strcpy(tmp, str); } dl_token_t *el; dl_token_t *r = NULL; int cp = 0; int len = strlen(tmp) - qtype->qgram_len + 1; char *t_ptr; while(cp < len) { t_ptr = (char *)&tmp[cp]; el = malloc(sizeof(dl_token_t)); //Allocate all chars - plus terminator... el->token = calloc((qtype->qgram_len + 1), sizeof(char)); //Copy bytes safely - strncpy should append the \0 strncpy(el->token, t_ptr, (sizeof(char) * qtype->qgram_len)); DL_APPEND(r, el); cp++; } free(tmp); return (r); }
struct ps2_async_command * ps2_send_command(struct ps2_async_command * queue, uint8_t cmd, uint8_t data, ps2_async_callback callback) { struct ps2_async_command * result = ps2_command_alloc(); if(result) { result->cmd = cmd; result->data = data; result->callback = callback; DL_APPEND(queue, result); } return result; }
void profile_save_nbload_rmaid(int proc, int rid) { if (!profiling_enabled || !(prof_groups & CAFPROF_GET)) return; rma_node_t *new_rma; if ((new_rma = malloc(sizeof(*new_rma))) == NULL) Error("malloc failed to allocate memory"); new_rma->rmaid = rid; new_rma->target = proc; DL_APPEND(saved_load_rma_list, new_rma); }
struct ircd_client* ircd_client_new(struct event_base* const evbase) { struct ircd_client* client = NULL; if ((client = calloc(1, sizeof(*client))) != NULL) { client->evbase = evbase; client->fd = -1; DL_APPEND(ircd_clients, client); } return client; }
void queue_enqueue(char *name,queue_t *queue,struct queueitem *item) { if ( queue->list == 0 && name != 0 && name[0] != 0 ) safecopy(queue->name,name,sizeof(queue->name)); if ( item == 0 ) { printf("FATAL type error: queueing empty value\n"), getchar(); return; } lock_queue(queue); DL_APPEND(queue->list,item); portable_mutex_unlock(&queue->mutex); //printf("name.(%s) append.%p list.%p\n",name,item,queue->list); }