/* * data_delete - アイテムの削除 */ BOOL data_delete(DATA_INFO **root, DATA_INFO *del_di, const BOOL free_item) { DATA_INFO *di; if (root == NULL || *root == NULL || del_di == NULL) { return FALSE; } if (*root == del_di) { *root = del_di->next; del_di->next = NULL; if (free_item == TRUE) { data_free(del_di); } return TRUE; } for (di = *root; di != NULL; di = di->next) { if (di->next == del_di) { // 削除 di->next = del_di->next; del_di->next = NULL; if (free_item == TRUE) { data_free(del_di); } return TRUE; } if (di->child != NULL && data_delete(&di->child, del_di, free_item) == TRUE) { return TRUE; } } return FALSE; }
ssize_t data_default_write (data_t *data, fastcall_write *fargs){ // {{{ ssize_t ret; fastcall_view r_view = { { 6, ACTION_VIEW }, FORMAT(native) }; if( (ret = data_query(data, &r_view)) < 0) return ret; if(r_view.length == 0){ fargs->buffer_size = 0; data_free(&r_view.freeit); return -1; // EOF } if(fargs->buffer == NULL || fargs->offset > r_view.length){ data_free(&r_view.freeit); return -EINVAL; // invalid range } fargs->buffer_size = MIN(fargs->buffer_size, r_view.length - fargs->offset); if(fargs->buffer_size == 0){ data_free(&r_view.freeit); return -1; // EOF } memcpy(r_view.ptr + fargs->offset, fargs->buffer, fargs->buffer_size); data_free(&r_view.freeit); return 0; } // }}}
static ssize_t data_pcre_t_compare(data_t *data, fastcall_compare *fargs){ // {{{ ssize_t ret; int ovector[1 * 3]; void *data_ptr; uintmax_t data_size; data_t freeit; pcre_t *fdata = (pcre_t *)data->ptr; if(fargs->data2 == NULL) return errorn(ENOSYS); if( (ret = data_make_flat(fargs->data2, FORMAT(native), &freeit, &data_ptr, &data_size)) < 0){ data_free(&freeit); return ret; } if(pcre_exec( fdata->re, NULL, data_ptr, data_size, 0, fdata->options, ovector, (sizeof(ovector) / sizeof(ovector[0])) ) < 0){ fargs->result = 1; // not match }else{ fargs->result = 0; // match } data_free(&freeit); return 0; } // }}}
static ssize_t data_triplet_format_t_from_config(data_t *data, config_t *config) { // {{{ ssize_t ret; data_t storage; data_t slave; hash_holder_consume(ret, storage, config, HK(data)); if(ret < 0) goto error1; hash_holder_consume(ret, slave, config, HK(slave)); if(ret < 0) goto error2; if( (ret = data_triplet_format_t(data, storage, slave)) < 0) goto error3; return 0; error3: data_free(&slave); error2: data_free(&storage); error1: return ret; } // }}}
void data_remove(data_t **list, data_t *data) { data_t *n = *list; if(NULL==n) { return; } if(n==data) { *list = (data_t *)n->next; n->next = NULL; data_free(&n); return; } while(NULL!=n) { data_t *t = (data_t *)n->next; if(t==data) { n->next = (NULL==t)?NULL:t->next; if(NULL!=t) { t->next = NULL; data_free(&t); } } n = (data_t *)n->next; } }
static void data_triplet_format_t_destroy(data_t *data) { // {{{ triplet_format_t *fdata = (triplet_format_t *)data->ptr; if(fdata) { data_free(&fdata->storage); data_free(&fdata->slave); free(fdata); } } // }}}
void data_complexkey_t_destroy (data_t *data){ // {{{ complexkey_t *fdata = (complexkey_t *)data->ptr; if(fdata){ data_free(&fdata->value); data_free(&fdata->cnext); free(fdata); } data_set_void(data); } // }}}
static ssize_t data_pcre_t_enum(data_t *data, fastcall_enum *fargs){ // {{{ ssize_t ret; int ovector[1 * 3]; void *data_ptr; uintmax_t data_size; data_t freeit; data_t *deref; uintmax_t offset = 0; pcre_t *fdata = (pcre_t *)data->ptr; if(fdata->data == NULL) return errorn(ENOSYS); if( (ret = data_make_flat(fdata->data, FORMAT(native), &freeit, &data_ptr, &data_size)) < 0){ data_free(&freeit); return ret; } // deref fdata->data data_realholder(ret, fdata->data, deref); if(ret < 0){ data_free(&freeit); return ret; } while(1){ if(pcre_exec( fdata->re, NULL, data_ptr, data_size, offset, fdata->options, ovector, (sizeof(ovector) / sizeof(ovector[0])) ) < 0) goto exit; data_t d_item = DATA_HEAP_SLICET(deref, ovector[0], ovector[1] - ovector[0]); fastcall_push r_push_item = { { 3, ACTION_PUSH }, &d_item }; ret = data_query(fargs->dest, &r_push_item); data_free(&d_item); if(ret < 0) goto exit; offset = ovector[1]; } ret = 0; exit:; fastcall_push r_push_end = { { 3, ACTION_PUSH }, NULL }; data_query(fargs->dest, &r_push_end); data_free(&freeit); return ret; } // }}}
static ssize_t data_triplet_format_t_lookup(data_t *data, fastcall_crud *fargs) { // {{{ ssize_t ret; uintmax_t offset; data_t converted; data_t d_key; data_t *d_key_ptr = &d_key; data_t storage_item; triplet_format_t *fdata = (triplet_format_t *)data->ptr; // fetch value from storage data_t sl_key = DATA_SLICET(fargs->key, 1, ~0); fastcall_lookup r_lookup = { { 4, ACTION_LOOKUP }, &sl_key, &storage_item }; if( (ret = data_query(&fdata->storage, &r_lookup)) < 0) return ret; // get offset for this data if(helper_key_current(fargs->key, &d_key) < 0) { d_key_ptr = fargs->key; data_get(ret, TYPE_UINTT, offset, d_key_ptr); } else { data_get(ret, TYPE_UINTT, offset, d_key_ptr); data_free(&d_key); } if(ret < 0) return ret; data_t sl_value = DATA_SLICET(&storage_item, offset, ~0); fastcall_unpack r_unpack = { { 4, ACTION_UNPACK }, offset == 0 ? &storage_item : &sl_value, &converted, FORMAT(packed) }; if( (ret = data_query(&fdata->slave, &r_unpack)) < 0) goto exit; *fargs->value = converted; exit: data_free(&storage_item); return ret; } // }}}
/* * Releases all the nodes in the list. */ void collections_list_release(collections_listnode *start) { collections_release_data data_free = ((collections_header_data*)start->data)->data_free; collections_listnode* cur = start->next; // // travel through the rest of the // list and release all the nodes. // while (cur != start) { void * data = cur->data; if (data != NULL && data_free) { data_free(data); } list_destroy_node(start, cur); cur = start->next; } // // release the header. // free(start->data); free(start); return; }
void params_free(struct init_params *params) { if (params->bind_address != NULL) free(params->bind_address); if (params->bind_port != NULL) free(params->bind_port); if (params->proxy_address != NULL) free(params->proxy_address); if (params->destination_address != NULL) free(params->destination_address); if (params->destination_port != NULL) free(params->destination_port); if (params->packets_send != NULL) packets_free(params->packets_send); if (params->packets_receive != NULL) packets_free(params->packets_receive); if (params->connections != NULL) connections_free(params->connections); if (params->client_buffer != NULL) data_free(params->client_buffer); if (params->libnet != NULL) libnet_destroy(params->libnet); if (params->libpcap != NULL) pcap_close(params->libpcap); free(params); }
static ssize_t data_fastcall_t_free(data_t *data, fastcall_free *fargs){ // {{{ fastcall_t *fdata = (fastcall_t *)data->ptr; data_free(&fdata->d_request); data_set_void(data); return 0; } // }}}
static ssize_t data_triplet_format_single_t_lookup(data_t *data, fastcall_crud *fargs) { // {{{ ssize_t ret; data_t converted; data_t storage_item; triplet_format_t *fdata = (triplet_format_t *)data->ptr; // fetch value from storage fastcall_lookup r_lookup = { { 4, ACTION_LOOKUP }, fargs->key, &storage_item }; if( (ret = data_query(&fdata->storage, &r_lookup)) < 0) return ret; // prepare copy of template holder_copy(ret, &converted, &fdata->slave); if(ret < 0) goto exit; fastcall_convert_from r_convert = { { 5, ACTION_CONVERT_FROM }, &storage_item, FORMAT(packed) }; if( (ret = data_query(&converted, &r_convert)) < 0) goto exit; *fargs->value = converted; exit: data_free(&storage_item); return ret; } // }}}
data_t * _any_or(data_t *self, char *name, arguments_t *args) { data_t *asbool; data_t *data; int boolval; int ix; (void) name; for (ix = -1; ix < arguments_args_size(args); ix++) { data = (ix < 0) ? self : arguments_get_arg(args, ix); asbool = data_cast(data, Bool); if (!asbool) { return data_exception(ErrorSyntax, "or(): Cannot convert value '%s' of type '%s' to boolean", arguments_arg_tostring(args, ix), data_typename(arguments_get_arg(args, ix))); } boolval = data_intval(asbool); data_free(asbool); if (boolval) { return data_true(); } } return data_false(); }
static ssize_t data_complexkey_t_convert_from(data_t *data, fastcall_convert_from *fargs){ // {{{ ssize_t ret; switch(fargs->format){ case FORMAT(native):; data_t d_value; data_t d_cnext; complexkey_t *fargs_src = (complexkey_t *)fargs->src->ptr; if(data->type != fargs->src->type) return -EINVAL; holder_copy(ret, &d_value, &fargs_src->value); if(ret < 0) return ret; holder_copy(ret, &d_cnext, &fargs_src->cnext); if(ret < 0){ data_free(&d_value); return ret; } return data_complexkey_t(data, d_value, d_cnext); }; return -ENOSYS; } // }}}
static void pcre_t_destroy(pcre_t *fdata){ // {{{ if(fdata){ data_free(&fdata->freeit); pcre_free(fdata->re); free(fdata); } } // }}}
/* * data_free - アイテムの解放 */ void data_free(DATA_INFO *di) { DATA_INFO *wk_di; while (di != NULL) { wk_di = di->next; if (di->child != NULL) { data_free(di->child); } format_free_item(di); if (di->data != NULL && format_free_data(di->format_name, di->data) == FALSE) { clipboard_free_data(di->format_name, di->data); } data_menu_free_item(di); mem_free(&di->title); mem_free(&di->format_name); mem_free(&di->window_name); mem_free(&di->plugin_string); mem_free(&di); di = wk_di; } }
/* * data_item_copy - アイテムのコピーを作成 */ DATA_INFO *data_item_copy(const DATA_INFO *di, const BOOL next_copy, const BOOL move_flag, TCHAR *err_str) { DATA_INFO *new_di; if (di == NULL) { return NULL; } if ((new_di = (DATA_INFO *)mem_calloc(sizeof(DATA_INFO))) == NULL) { message_get_error(GetLastError(), err_str); return NULL; } new_di->struct_size = sizeof(DATA_INFO); new_di->type = di->type; new_di->title = alloc_copy(di->title); new_di->format_name = alloc_copy(di->format_name); new_di->format_name_hash = di->format_name_hash; new_di->format = di->format; new_di->modified.dwLowDateTime = di->modified.dwLowDateTime; new_di->modified.dwHighDateTime = di->modified.dwHighDateTime; new_di->window_name = alloc_copy(di->window_name); new_di->plugin_string = alloc_copy(di->plugin_string); new_di->plugin_param = di->plugin_param; if (move_flag == TRUE) { new_di->hkey_id = di->hkey_id; new_di->op_modifiers = di->op_modifiers; new_di->op_virtkey = di->op_virtkey; new_di->op_paste = di->op_paste; } // データのコピー if (di->data != NULL && (new_di->data = format_copy_data(di->format_name, di->data, &new_di->size)) == NULL) { new_di->data = clipboard_copy_data(di->format, di->data, &new_di->size); } // 子アイテムのコピー if (di->child != NULL && (new_di->child = data_item_copy(di->child, TRUE, move_flag, err_str)) == NULL) { data_free(new_di); return NULL; } // 次アイテムのコピー if (next_copy == TRUE && di->next != NULL && (new_di->next = data_item_copy(di->next, TRUE, move_flag, err_str)) == NULL) { data_free(new_di); return NULL; } return new_di; }
void list_free(list_t * self, void data_free(void *)) { unsigned i; assert(self); for (i = 0; data_free && i < self->length; i++) data_free(self->elements[i]); free(self->elements); free(self); }
void asf::parameter_float_image::data_alloc(src_t src_,band_t *data_,int xd_,int yd_) { data_free(); src=src_; data=data_; xd=xd_; yd=yd_; if (data==NULL && src==src_alloc) data=new band_t[size_y()*yd]; }
void __wrap_nc_session_free(struct nc_session *session, void (*data_free)(void *)) { if (data_free) { data_free(session->data); } pthread_mutex_destroy(session->ti_lock); free(session->ti_lock); free(session); }
static ssize_t try_handler(machine_t *machine, request_t *request){ // {{{ ssize_t ret; data_t freeme; request_t *try_request; try_userdata *userdata = (try_userdata *)machine->userdata; try_threaddata *threaddata = thread_data_get(&userdata->thread_data); threaddata->machine = machine; threaddata->request = request; threaddata->ret = 0; data_set_void(&freeme); if(userdata->request == 0){ try_request = request; }else{ if( (ret = get_hash(hash_data_find(request, userdata->request), &freeme, &try_request)) < 0) return ret; } request_t r_next[] = { { userdata->return_to, DATA_MACHINET(userdata->try_end) }, hash_inline(try_request), hash_end }; fastcall_query r_query = { { 3, ACTION_QUERY }, r_next }; if( (ret = data_query(&userdata->machine, &r_query)) < 0){ if(userdata->request == 0){ request_t r_pass[] = { { HK(ret), DATA_PTR_SIZET(&ret) }, hash_inline(request), hash_end }; threaddata->ret = machine_pass(machine, r_pass); }else{ request_t r_pass[] = { { HK(ret), DATA_PTR_SIZET(&ret) }, hash_inline(try_request), hash_end }; request_t r_next[] = { { HK(ret), DATA_PTR_SIZET(&ret) }, { userdata->request_out, DATA_PTR_HASHT(r_pass) }, hash_inline(request), hash_end }; threaddata->ret = machine_pass(machine, r_next); } } data_free(&freeme); return threaddata->ret; } // }}}
data_t * _file_open(char *name) { data_t *dummy = data_create(Bool, 0); array_t *args = data_array_create(1); data_t *f; array_push(args, data_create(String, "file.txt")); f = data_execute(dummy, "open", args, NULL); array_free(args); data_free(dummy); return f; }
static void testBasic (long numVar, long numRecord, long numMaxParent, long percentParent) { random_t* randomPtr = random_alloc(); puts("Starting..."); data_t* dataPtr = data_alloc(numVar, numRecord, randomPtr); assert(dataPtr); puts("Init:"); data_generate(dataPtr, 0, numMaxParent, percentParent); long v; for (v = 0; v < numVar; v++) { data_sort(dataPtr, 0, numRecord, v); long s = data_findSplit(dataPtr, 0, numRecord, v); if (s < numRecord) { assert(dataPtr->records[numVar * s + v] == 1); } if (s > 0) { assert(dataPtr->records[numVar * (s - 1) + v] == 0); } } memset(dataPtr->records, 0, dataPtr->numVar * dataPtr->numRecord); for (v = 0; v < numVar; v++) { data_sort(dataPtr, 0, numRecord, v); long s = data_findSplit(dataPtr, 0, numRecord, v); if (s < numRecord) { assert(dataPtr->records[numVar * s + v] == 1); } if (s > 0) { assert(dataPtr->records[numVar * (s - 1) + v] == 0); } assert(s == numRecord); } memset(dataPtr->records, 1, dataPtr->numVar * dataPtr->numRecord); for (v = 0; v < numVar; v++) { data_sort(dataPtr, 0, numRecord, v); long s = data_findSplit(dataPtr, 0, numRecord, v); if (s < numRecord) { assert(dataPtr->records[numVar * s + v] == 1); } if (s > 0) { assert(dataPtr->records[numVar * (s - 1) + v] == 0); } assert(s == 0); } data_free(dataPtr); }
static ssize_t data_enum_storage(data_t *storage, data_t *item_template, format_t format, data_t *dest, data_t *key) { // {{{ ssize_t ret; uintmax_t offset; data_t converted = DATA_VOID; data_t sl_storage = DATA_SLIDERT(storage, 0); do { fastcall_unpack r_unpack = { { 4, ACTION_UNPACK }, &sl_storage, &converted, format }; if( (ret = data_query(item_template, &r_unpack)) < -1) break; if(ret == -1) { ret = 0; goto error; } offset = data_slider_t_get_offset(&sl_storage); data_slider_t_set_offset(&sl_storage, r_unpack.transfered, SEEK_CUR); data_t d_offset = DATA_UINTT(offset); data_t d_complex_key_next = DATA_COMPLEXKEY_NEXTT(d_offset, *key); data_t d_complex_key_end = DATA_COMPLEXKEY_END_UINTT(offset); fastcall_create r_create = { { 4, ACTION_CREATE }, data_is_void(key) ? &d_complex_key_end : &d_complex_key_next, &converted }; ret = data_query(dest, &r_create); data_free(&converted); } while(ret >= 0); return ret; error: data_free(&converted); return ret; } // }}}
int huffman_benchmark(char *code) { data *d = huffman_encode(code); int result = data_size(d); /*char *dec = huffman_decode(d); if (strncmp(dec, code, strlen(code)) != 0) { printf("[HUFFMAN ERROR]\n"); printf("Original: %s\n", code); printf("Decoded : %s\n", dec); } free(dec);*/ data_free(d); return result; }
/**@brief Funcion que libera todo los recursos alocados en memoria de una lista. @param linklist: Punteor a la lista que quiero liberar.*/ void list_free(LinkedList* linklist){ int size = linklist->nroCollection; int i; //TODO: change this for(i=0; i < (size-1); i++){ Data* aux = NULL; list_pop(linklist, aux); data_print(aux); data_free(aux); } free(linklist->front); linklist->front = 0; }
// delete the contents of the bucket. Note, that the bucket becomes empty, but the bucket itself is // not destroyed. void bucket_destroy_contents(bucket_t *bucket) { assert(bucket); // at this point, since the bucket is being destroyed, there should be a connected transfer client. assert(bucket->transfer_client == NULL); if (bucket->data) { data_destroy(bucket->data, _mask, bucket->hashmask); data_free(bucket->data); bucket->data = NULL; } assert(bucket->data == NULL); }
void test_data() { struct Data* d = data_generate(10); data_set(0, 1, d); data_set(2, 1, d); data_set(4, 1, d); data_set(9,1,d); data_show(d); data_delete(4,d); data_show(d); data_set(3,1,d); data_show(d); data_free(d); }
int pool_free_space(PoolObject *pool){ ssize_t size_list_zero = ilist_size(&pool->list_zero); if (size_list_zero < 0) return -1; int i; iNode *inode; for (i = 0; i < size_list_zero/2; i++){ inode = ilist_remove_last(&pool->list_zero); if (inode == NULL) return -1; hash_table_remove(&pool->table, &inode->node); data_free(inode->node.value); } return 0; }