int Athena_ParseEngineMessage(struct Athena_MessageList *to, const char *(*read_function)(void *arg, uint32_t len), void(*free_function)(void *arg, const char *z), void *arg){ /* end is the ending position in msg, as will be passed to TurboJSON */ const char *const head = read_function(arg, 4), *msg = NULL, *end = NULL; if(!head) return -1; if(memcmp(head, "HTTP", 4)==0 || memcmp(head, "http", 4)==0){ return -3; /* Not implemented yet. */ } else if(memcmp(head, "Athe", 4)==0){ const char *const head2 = read_function(arg, 10); char c; int x = 0; if(!head2 || memcmp(head2, "na Message", 10)!=0) return -8; /* Bad Athena header. */ if(free_function){ free_function(arg, head); free_function(arg, head2); } do{ /* Burn through the rest of the line. Normally this will be a single space, to pad the first line to 16 bytes. */ const char *ch = read_function(arg, 1); if(!ch || ++x > 33) return -8; c = ch[0]; if(free_function) free_function(arg, ch); }while(c!='\n'); } return msg!=end; }
int sudoki_bi() { char ***tab; t_list *list; t_present *present; int i; if ((tab = get_all_tab()) == NULL) return (-1); i = -1; while (++i < my_tablen(tab)) { if ((present = get_present(tab[i])) == NULL || (list = get_list(tab[i])) == NULL) return (-1); filler(tab[i], list, present); if (check_valid(tab[i]) == 1) error_aff_tab(); else aff_table(tab[i]); if (i < (my_tablen(tab) - 1)) write(1, "####################\n", 21); free_function_bis(list, present); } free_function(tab); return (0); }
rpc_mempool::~rpc_mempool() { #if MEMPOOL_DEBUG SMBLogInfo("destroying rpc_mempool at %p", ASL_LEVEL_DEBUG, this); #endif std::for_each(ptrs.begin(), ptrs.end(), free_function()); }
/* * Frees data stores in priority queue using free function. */ void free_priority_queue_data( priority_queue **pq, void (*free_function)( void * ) ) { int i; for ( i = 1; i <= (*pq)->heap_size; i++ ) { free_function( (*pq)->heap_array[ i ] ); } (*pq)->heap_size = 0; }
/* * Destroy all the elements blow us in the tree * only useful as part of a complete tree destroy. */ static void rb_destroy(struct rbnode *x,void (*free_function)(void *)) { if (x!=RBNULL) { if (x->left!=RBNULL) rb_destroy(x->left,free_function); if (x->right!=RBNULL) rb_destroy(x->right,free_function); if (free_function!=NULL) free_function(x->object); rb_free(x); } }
struct task_s * run (struct task_s *task) { switch ( task->t ) { case TASK_EVAL: return eval (task->d.task_eval_v.expr, task->d.task_eval_v.cont); case TASK_APP1: { if ( task->d.task_app1_v.erator->t == FUNCTION_D ) { struct function_s *val = new_function (); struct task_s *ntask; val->t = FUNCTION_D1; init_ptr (&val->d.function_d1_v, task->d.task_app1_v.rand); ntask = invoke (task->d.task_app1_v.cont, val); free_function (val); return ntask; } else { struct continuation_s *ncont = new_continuation (); struct task_s *ntask; ncont->t = CONTINUATION_APP; init_ptr (&ncont->d.continuation_app_v.erator, task->d.task_app1_v.erator); init_ptr (&ncont->d.continuation_app_v.cont, task->d.task_app1_v.cont); ntask = eval (task->d.task_app1_v.rand, ncont); free_continuation (ncont); return ntask; } } case TASK_APP: return apply (task->d.task_app_v.erator, task->d.task_app_v.erand, task->d.task_app_v.cont); case TASK_INVOKE: return invoke (task->d.task_invoke_v.cont, task->d.task_invoke_v.val); case TASK_FINAL: /* Should not happen */; } fprintf (stderr, "INTERNAL ERROR: run() surprised!\n"); return NULL; }
void bas_release_object(Object* object) { object->ref_count --; if (object->ref_count == 0) { if (object->type == kTypeArray) free_array((Array*)object); else if (object->type == kTypeFunction) free_function((Function*)object); else if (object->type == kTypeString) free_string((String*)object); else { ASSERT(0); // object destructor not implemented! } } mem_free(object); }
void operator()(T* object) { if (object) { free_function(object); } }
int main() { printf("%d\n", free_function(36)); return 0; }
struct expression_s * parse (FILE *input) { int ch; do { ch = getc (input); if ( ch == '#' ) while ( ch != '\n' && ch != EOF ) ch = getc (input); } while ( ch == ' ' || ch == '\n' || ch == '\r' || ch == '\t' ); if ( ch == '`' ) { struct expression_s *rator = parse (input); struct expression_s *rand = parse (input); struct expression_s *expr = new_expression (); expr->t = EXPRESSION_APPLICATION; init_ptr (&expr->d.expression_application_v.rator, rator); init_ptr (&expr->d.expression_application_v.rand, rand); #if 0 /* Harmless but not necessary */ free_expression (rator); free_expression (rand); #endif return expr; } else if ( ch == 'i' || ch == 'I' ) { struct function_s *fun = new_function (); struct expression_s *expr = new_expression (); fun->t = FUNCTION_I; expr->t = EXPRESSION_FUNCTION; init_ptr (&expr->d.expression_function_v, fun); #if 0 /* Harmless but not necessary */ free_function (fun); #endif return expr; } else if ( ch == 'k' || ch == 'K' ) { struct function_s *fun = new_function (); struct expression_s *expr = new_expression (); fun->t = FUNCTION_K; expr->t = EXPRESSION_FUNCTION; init_ptr (&expr->d.expression_function_v, fun); #if 0 /* Harmless but not necessary */ free_function (fun); #endif return expr; } else if ( ch == 's' || ch == 'S' ) { struct function_s *fun = new_function (); struct expression_s *expr = new_expression (); fun->t = FUNCTION_S; expr->t = EXPRESSION_FUNCTION; init_ptr (&expr->d.expression_function_v, fun); #if 0 /* Harmless but not necessary */ free_function (fun); #endif return expr; } else if ( ch == 'v' || ch == 'V' ) { struct function_s *fun = new_function (); struct expression_s *expr = new_expression (); fun->t = FUNCTION_V; expr->t = EXPRESSION_FUNCTION; init_ptr (&expr->d.expression_function_v, fun); #if 0 /* Harmless but not necessary */ free_function (fun); #endif return expr; } else if ( ch == 'd' || ch == 'D' ) { struct function_s *fun = new_function (); struct expression_s *expr = new_expression (); fun->t = FUNCTION_D; expr->t = EXPRESSION_FUNCTION; init_ptr (&expr->d.expression_function_v, fun); #if 0 /* Harmless but not necessary */ free_function (fun); #endif return expr; } else if ( ch == 'e' || ch == 'E' ) { struct function_s *fun = new_function (); struct expression_s *expr = new_expression (); fun->t = FUNCTION_E; expr->t = EXPRESSION_FUNCTION; init_ptr (&expr->d.expression_function_v, fun); #if 0 /* Harmless but not necessary */ free_function (fun); #endif return expr; } else if ( ch == 'p' || ch == 'P' ) { struct function_s *fun = new_function (); struct expression_s *expr = new_expression (); fun->t = FUNCTION_P; expr->t = EXPRESSION_FUNCTION; init_ptr (&expr->d.expression_function_v, fun); #if 0 /* Harmless but not necessary */ free_function (fun); #endif return expr; } else if ( ch == 'f' || ch == 'F' ) { struct function_s *fun = new_function (); struct expression_s *expr = new_expression (); fun->t = FUNCTION_F; expr->t = EXPRESSION_FUNCTION; init_ptr (&expr->d.expression_function_v, fun); #if 0 /* Harmless but not necessary */ free_function (fun); #endif return expr; } else if ( ch == 'r' ) { struct function_s *fun = new_function (); struct expression_s *expr = new_expression (); fun->t = FUNCTION_DOT; fun->d.function_dot_v = '\n'; expr->t = EXPRESSION_FUNCTION; init_ptr (&expr->d.expression_function_v, fun); #if 0 /* Harmless but not necessary */ free_function (fun); #endif return expr; } else if ( ch == '.' ) { struct function_s *fun = new_function (); struct expression_s *expr = new_expression (); int ch2; fun->t = FUNCTION_DOT; ch2 = getc (input); if ( ch2 == EOF ) goto ueof; fun->d.function_dot_v = ch2; expr->t = EXPRESSION_FUNCTION; init_ptr (&expr->d.expression_function_v, fun); #if 0 /* Harmless but not necessary */ free_function (fun); #endif return expr; } else if ( ch == '@' ) { struct function_s *fun = new_function (); struct expression_s *expr = new_expression (); fun->t = FUNCTION_AT; expr->t = EXPRESSION_FUNCTION; init_ptr (&expr->d.expression_function_v, fun); #if 0 /* Harmless but not necessary */ free_function (fun); #endif return expr; } else if ( ch == '?' ) { struct function_s *fun = new_function (); struct expression_s *expr = new_expression (); int ch2; fun->t = FUNCTION_QUES; ch2 = getc (input); if ( ch2 == EOF ) goto ueof; fun->d.function_ques_v = ch2; expr->t = EXPRESSION_FUNCTION; init_ptr (&expr->d.expression_function_v, fun); #if 0 /* Harmless but not necessary */ free_function (fun); #endif return expr; } else if ( ch == '|' ) { struct function_s *fun = new_function (); struct expression_s *expr = new_expression (); fun->t = FUNCTION_PIPE; expr->t = EXPRESSION_FUNCTION; init_ptr (&expr->d.expression_function_v, fun); #if 0 /* Harmless but not necessary */ free_function (fun); #endif return expr; } else if ( ch == EOF ) { ueof: fprintf (stderr, "Unexpected end of file\n"); exit (1); } else { fprintf (stderr, "Character not recognized: %c\n", ch); exit (1); } return NULL; }
struct task_s * apply (struct function_s *rator, struct function_s *rand, struct continuation_s *cont) { switch ( rator->t ) { case FUNCTION_I: return invoke (cont, rand); case FUNCTION_DOT: putchar (rator->d.function_dot_v); return invoke (cont, rand); case FUNCTION_K1: return invoke (cont, rator->d.function_k1_v); case FUNCTION_K: { struct function_s *val = new_function (); struct task_s *task; val->t = FUNCTION_K1; init_ptr (&val->d.function_k1_v, rand); task = invoke (cont, val); free_function (val); return task; } case FUNCTION_S2: { struct expression_s *e_x = new_expression (); struct expression_s *e_y = new_expression (); struct expression_s *e_z = new_expression (); struct expression_s *e1 = new_expression (); struct expression_s *e2 = new_expression (); struct expression_s *e = new_expression (); struct task_s *task = new_task (); e_x->t = EXPRESSION_FUNCTION; init_ptr (&e_x->d.expression_function_v, rator->d.function_s2_v.x); e_y->t = EXPRESSION_FUNCTION; init_ptr (&e_y->d.expression_function_v, rator->d.function_s2_v.y); e_z->t = EXPRESSION_FUNCTION; init_ptr (&e_z->d.expression_function_v, rand); e1->t = EXPRESSION_APPLICATION; init_ptr (&e1->d.expression_application_v.rator, e_x); init_ptr (&e1->d.expression_application_v.rand, e_z); e2->t = EXPRESSION_APPLICATION; init_ptr (&e2->d.expression_application_v.rator, e_y); init_ptr (&e2->d.expression_application_v.rand, e_z); e->t = EXPRESSION_APPLICATION; init_ptr (&e->d.expression_application_v.rator, e1); init_ptr (&e->d.expression_application_v.rand, e2); task->t = TASK_EVAL; init_ptr (&task->d.task_eval_v.expr, e); init_ptr (&task->d.task_eval_v.cont, cont); #if 0 /* Harmless but not necessary */ free_expression (e_x); free_expression (e_y); free_expression (e_z); free_expression (e1); free_expression (e2); free_expression (e); #endif return task; } case FUNCTION_S1: { struct function_s *val = new_function (); struct task_s *task; val->t = FUNCTION_S2; init_ptr (&val->d.function_s2_v.x, rator->d.function_s1_v); init_ptr (&val->d.function_s2_v.y, rand); task = invoke (cont, val); free_function (val); return task; } case FUNCTION_S: { struct function_s *val = new_function (); struct task_s *task; val->t = FUNCTION_S1; init_ptr (&val->d.function_s1_v, rand); task = invoke (cont, val); free_function (val); return task; } case FUNCTION_V: return invoke (cont, rator); case FUNCTION_D1: { struct continuation_s *ncont = new_continuation (); struct task_s *task = new_task (); ncont->t = CONTINUATION_DEL; init_ptr (&ncont->d.continuation_del_v.erand, rand); init_ptr (&ncont->d.continuation_del_v.cont, cont); task->t = TASK_EVAL; init_ptr (&task->d.task_eval_v.expr, rator->d.function_d1_v); init_ptr (&task->d.task_eval_v.cont, ncont); #if 0 /* Harmless but not necessary */ free_continuation (ncont); #endif return task; } case FUNCTION_D: { struct expression_s *promise = new_expression (); struct function_s *val = new_function (); struct task_s *task; promise->t = EXPRESSION_FUNCTION; init_ptr (&promise->d.expression_function_v, rand); val->t = FUNCTION_D1; init_ptr (&val->d.function_d1_v, promise); task = invoke (cont, val); free_continuation (cont); free_function (val); return task; } case FUNCTION_CONT: return invoke (rator->d.function_cont_v, rand); case FUNCTION_DCONT: { struct function_s *val = new_function (); struct task_s *task = new_task (); struct continuation_s *ncont = new_continuation (); push_cont (cont); val->t = FUNCTION_CONT; init_ptr (&val->d.function_cont_v, rator->d.function_cont_v); task->t = TASK_APP; ncont->t = CONTINUATION_ABORT; init_ptr (&task->d.task_app_v.erator, val); init_ptr (&task->d.task_app_v.erand, rand); init_ptr (&task->d.task_app_v.cont, ncont); return task; } case FUNCTION_P: { struct function_s *val = new_function (); struct task_s *task = new_task (); struct continuation_s *ncont = new_continuation (); push_cont (cont); val->t = FUNCTION_I; task->t = TASK_APP; ncont->t = CONTINUATION_ABORT; init_ptr (&task->d.task_app_v.erator, rand); init_ptr (&task->d.task_app_v.erand, val); init_ptr (&task->d.task_app_v.cont, ncont); return task; } case FUNCTION_F: { struct function_s *val = new_function (); struct task_s *task = new_task (); struct continuation_s *ncont = new_continuation (); val->t = FUNCTION_DCONT; init_ptr (&val->d.function_cont_v, cont); task->t = TASK_APP; ncont->t = CONTINUATION_ABORT; init_ptr (&task->d.task_app_v.erator, rand); init_ptr (&task->d.task_app_v.erand, val); init_ptr (&task->d.task_app_v.cont, ncont); return task; } case FUNCTION_E: { struct task_s *task = new_task (); task->t = TASK_FINAL; return task; } case FUNCTION_AT: { struct function_s *val = new_function (); struct task_s *task = new_task (); current_ch = getchar (); val->t = (current_ch != EOF ? FUNCTION_I : FUNCTION_V); task->t = TASK_APP; init_ptr (&task->d.task_app_v.erator, rand); init_ptr (&task->d.task_app_v.erand, val); init_ptr (&task->d.task_app_v.cont, cont); #if 0 /* Harmless but not necessary */ free_function (val); #endif return task; } case FUNCTION_QUES: { struct function_s *val = new_function (); struct task_s *task = new_task (); val->t = (current_ch == rator->d.function_ques_v ? FUNCTION_I : FUNCTION_V); task->t = TASK_APP; init_ptr (&task->d.task_app_v.erator, rand); init_ptr (&task->d.task_app_v.erand, val); init_ptr (&task->d.task_app_v.cont, cont); #if 0 /* Harmless but not necessary */ free_function (val); #endif return task; } case FUNCTION_PIPE: { struct function_s *val = new_function (); struct task_s *task = new_task (); if ( current_ch != EOF ) { val->t = FUNCTION_DOT; val->d.function_dot_v = current_ch; } else val->t = FUNCTION_V; task->t = TASK_APP; init_ptr (&task->d.task_app_v.erator, rand); init_ptr (&task->d.task_app_v.erand, val); init_ptr (&task->d.task_app_v.cont, cont); #if 0 /* Harmless but not necessary */ free_function (val); #endif return task; } } fprintf (stderr, "INTERNAL ERROR: apply() surprised!\n"); return NULL; }
void release_function (struct function_s *fun) { fun->refcnt --; free_function (fun); }