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