ERROR_CODE body_callback_handler_client(struct http_parser_t *http_parser, const unsigned char *data, size_t data_size) {
struct type_t *type;
decode_bencoding((unsigned char *) data, data_size, &type);
print_type(type);
free_type(type);
/* raises no error */
RAISE_NO_ERROR;
}
void free_func(struct func_t *f)
{
free(f->name);
free_statem(f->statement_list);
if (f->arguments!=NULL) {
int x;
for (x=0; x<f->num_arguments; x++) {
free_var(f->arguments[x]);
}
free(f->arguments);
}
free_type(f->ret_type);
free(f);
}
void
free_type (type_t *type)
{
if (!type)
return;
if (!type->allocated) // for statically allocated types
type->next = 0;
if (!type->freeable)
return;
switch (type->type) {
case ev_void:
case ev_string:
case ev_float:
case ev_vector:
case ev_entity:
case ev_type_count:
case ev_quat:
case ev_integer:
case ev_uinteger:
case ev_short:
break;
case ev_field:
case ev_pointer:
free_type (type->t.fldptr.type);
break;
case ev_func:
free_type (type->t.func.type);
break;
case ev_invalid:
if (type->meta == ty_array)
free_type (type->t.array.type);
break;
}
memset (type, 0, sizeof (*type));
FREE (types, type);
}
void etype::set_type(evartype _type)
{
if (type == _type) return;
free_type();
//ldebug("setting type");
type=_type;
switch(type){
case ET_INT: value = new int; break;
case ET_FLOAT: value = new float; break;
case ET_DOUBLE: value = new double; break;
case ET_CHAR: value = new char; break;
case ET_ESTR: value = new estr; break;
case ET_EARRAY: value = new estrarray; break;
// default:
// lwarn("undefined value");
}
}
void free_return_val(return_val_t ret_val) {
CAMLparam0();
CAMLlocal1(ret_type);
int i;
// Free the results
if (ret_val.results) {
for (i = 0; i < ret_val.results_len; ++i) {
if (!ret_val.results[i].is_scalar) {
free_type(ret_val.results[i].data.array.ret_type);
free(ret_val.results[i].data.array.data);
free(ret_val.results[i].data.array.shape);
free(ret_val.results[i].data.array.strides);
}
}
free(ret_val.results);
} else if (ret_val.error_msg) {
// Free the error msg
free(ret_val.error_msg);
}
CAMLreturn0;
}
etype::~etype()
{
// ldebug("destroying etype");
free_type();
}
ERROR_CODE free_type(struct type_t *type) {
/* allocats space for the current type in iteration
for the iterator and for the possible hash map element */
struct type_t *current;
struct iterator_t *iterator;
struct hash_map_element_t *element;
/* switches over the type's type in order to
execute the proper free operation */
switch(type->type) {
case INTEGER_TYPE:
/* breaks the switch */
break;
case FLOAT_TYPE:
/* breaks the switch */
break;
case STRING_TYPE:
FREE(type->value.value_string);
/* breaks the switch */
break;
case LIST_TYPE:
create_iterator_linked_list(type->value.value_list, &iterator);
while(TRUE) {
get_next_iterator(iterator, (void **) ¤t);
if(current == NULL) { break; }
free_type(current);
}
delete_iterator_linked_list(type->value.value_list, iterator);
delete_linked_list(type->value.value_list);
/* breaks the switch */
break;
case MAP_TYPE:
create_element_iterator_hash_map(type->value.value_map, &iterator);
while(TRUE) {
get_next_iterator(iterator, (void **) &element);
if(element == NULL) { break; }
free_type((struct type_t *) element->value);
}
delete_iterator_hash_map(type->value.value_map, iterator);
delete_hash_map(type->value.value_map);
/* breaks the switch */
break;
case SORT_MAP_TYPE:
create_element_iterator_sort_map(type->value.value_sort_map, &iterator);
while(TRUE) {
get_next_iterator(iterator, (void **) &element);
if(element == NULL) { break; }
free_type((struct type_t *) element->value);
}
delete_iterator_sort_map(type->value.value_sort_map, iterator);
delete_sort_map(type->value.value_sort_map);
/* breaks the switch */
break;
default:
/* breaks the switch */
break;
}
/* deltes the base type structure for the
current type, this applies to all the types */
delete_type(type);
/* raises no error */
RAISE_NO_ERROR;
}
