void tree_free(TREE_T *t) { if (t==NULL) return; tree_free(t->lt); tree_free(t->gt); free(t); }
static inline void tree_free(treap_node *node) { if (node!=NULL) { tree_free(node->left); tree_free(node->right); free(node); } }
void tree_free(NodePointer p) { if ( p->left ) { tree_free(p->left); } if ( p->right ) { tree_free(p->right); } free(p); }
/** * Deallocates a TreeNode object. */ void tree_free(TreeNode* tree) { if (tree == NULL) return; else { tree_free(tree->left); tree_free(tree->right); free(tree); } }
/* * Recursive post-order traversal to deallocate tree memory */ void tree_free (TreeNode *root) { if (!root) return; tree_free (root->left); tree_free (root->right); if (root->info) free (root->info); free (root); }
static int addrs_configure(backend_t *chain, hash_t *config){ ssize_t ret; DT_UINT32T elements_per_level = 0; DT_UINT32T read_per_calc = READ_PER_CALC_DEFAULT; addrs_userdata *data = (addrs_userdata *)chain->userdata; hash_data_copy(ret, TYPE_UINT32T, elements_per_level, config, HK(perlevel)); hash_data_copy(ret, TYPE_UINT32T, read_per_calc, config, HK(read_size)); if(elements_per_level <= 1) return -EINVAL; // "chain blocks-address variable 'per-level' invalid"); if(read_per_calc < 1) read_per_calc = READ_PER_CALC_DEFAULT; if( (data->tree = tree_alloc(chain, elements_per_level, read_per_calc)) == NULL) return error("chain blocks-address no memory"); if(tree_recalc(data->tree) != 0){ tree_free(data->tree); return error("chain blocks-address tree recalc failed"); } return 0; }
int rop_chain(unsigned char **chain, unsigned char *binary, unsigned long binary_len, struct Arg *arg) { struct Node *root; int result; root = (struct Node *)malloc(sizeof(struct Node)); if(!root) { fprintf(stderr ,"malloc failed.\n"); return -1; } struct Gadget *head; head = (struct Gadget *)malloc(sizeof(struct Gadget)); if(!head) { fprintf(stderr ,"malloc failed.\n"); return -1; } *chain = (unsigned char *)malloc(sizeof(unsigned char)); if(!*chain) { fprintf(stderr ,"malloc failed.\n"); return -1; } rop_parse_gadgets(root, binary, binary_len, arg); result = rop_chain_execve(root, head, arg); if(!result) { result = rop_chain_list_traverse(head, chain); } rop_chain_list_free(head); tree_free(root); return result; }
static void search_requirements(struct hash *hash, struct node *n, struct tree *d) { struct tree_node *t, *u; struct tree *providers; t = tree_first(n->need->root); while (t) { providers = tree_new(); get_all_providers(t->n, providers); u = tree_first(providers->root); while (u) { if (!tree_search_node(d, u->n->name)) tree_insert(d, hash_search(hash, u->n->name)); u = tree_next(u); } tree_free_all_nodes(providers); tree_free(providers); t = tree_next(t); } t = tree_first(n->provide->root); while (t) { search_requirements(hash, t->n, d); t = tree_next(t); } }
int count_providers(struct hash *hash, char *name) { int count; struct node *n; struct tree *all; count = 0; if ((n = hash_search(hash, name)) == NULL) { fprintf(stderr, "bee-dep: count_providers: cannot find \"%s\"\n", name); return -1; } if (IS_PKG(n)) { fprintf(stderr, "bee-dep: count_providers: error: \"%s\" is a package\n", name); return -1; } all = tree_new(); get_all_providers(n, all); count = tree_count(all); tree_free_all_nodes(all); tree_free(all); return count; }
int count_removable(struct hash *hash, char *remove) { struct node *n; struct tree *t; int c; if ((n = hash_search(hash, remove)) == NULL) { fprintf(stderr, "bee-dep: print_removable: cannot find \"%s\"\n", remove); return -1; } if (!IS_PKG(n)) { fprintf(stderr, "bee-dep: print_removable: \"%s\": no such package\n", remove); return -1; } t = tree_new(); search_removable(hash, n, t, remove); c = tree_count(t); tree_free(t); return c; }
int print_removable(struct hash *hash, char *remove) { struct node *n; struct tree *t; struct tree_node *e; char **dirs, **files; int cnt, dir_cnt, file_cnt, i; if ((n = hash_search(hash, remove)) == NULL) { fprintf(stderr, "bee-dep: print_removable: cannot find \"%s\"\n", remove); return 1; } if (!IS_PKG(n)) { fprintf(stderr, "bee-dep: print_removable: \"%s\": no such package\n", remove); return 1; } t = tree_new(); search_removable(hash, n, t, remove); cnt = tree_count(t); if ((dirs = calloc(cnt, sizeof(*dirs))) == NULL || (files = calloc(cnt, sizeof(*files))) == NULL) { perror("bee-dep: print_removable: calloc"); return 1; } e = tree_first(t->root); dir_cnt = file_cnt = 0; while (e) { if (IS_DIR(e->n)) dirs[dir_cnt++] = e->n->name; else files[file_cnt++] = e->n->name; e = tree_next(e); } sort_dirs(dirs, dir_cnt); for (i = 0; i < file_cnt; i++) puts(files[i]); for (i = 0; i < dir_cnt; i++) puts(dirs[i]); free(dirs); free(files); tree_free(t); return 0; }
int print_broken(struct hash *hash, char print) { int c, i; char h; struct tree_node *t; struct tree *dry; c = 0; for (i = 0; i < TBLSIZE; i++) { t = tree_first(hash->tbl[i]->root); while (t) { h = 0; if (IS_PKG(t->n)) { dry = tree_new(); print_broken_nodes(t->n, &c, &h, print, dry); tree_free(dry); } t = tree_next(t); } } return c; }
int main(void) { struct Node *restrict root; struct Node *restrict node; const int exit_status = tree_create(&root, 20u); if (exit_status == 0u) { tree_print(root); PRINT_IS_SORTED(); tree_invert(root); tree_print(root); PRINT_IS_SORTED(); printf("tree_length: %u\n", tree_length(root)); PRINT_NTH(0); PRINT_NTH(-1); PRINT_NTH(10); PRINT_NTH(19); PRINT_NTH(20); tree_free(root); } else { puts("tree_create failed"); } return exit_status; }
/* process all here-docs * * nredir->data is set to the next here-doc redirection by redir_addhere() * after processing it is set to the content of the here-doc (an narg node) * ----------------------------------------------------------------------- */ void redir_source(void) { struct parser p; stralloc delim; int r; parse_init(&p, P_HERE); stralloc_init(&delim); for(; redir_list; redir_list = &redir_list->data->nredir) { /* expand the delimiter */ stralloc_init(&delim); expand_catsa((union node *)redir_list, &delim, 0); /* when any character of the delimiter has been escaped then treat the whole here-doc as non-expanded word */ r = parse_here(&p, &delim, (redir_list->list->nargstr.flag & S_ESCAPED)); tree_free(redir_list->list); redir_list->list = parse_getarg(&p); /* free expanded delimiters */ stralloc_free(&delim); } }
int main (int argc, char *argv[]) { if (argc != 2) { usage(); exit(1); } char *infile = argv[1]; TreeNode *tree = huffman_build_tree(infile); if (tree == NULL) { printf("Could not build the tree!"); usage(); exit(1); } EncodeTable *etab = table_build(tree); if (etab == NULL) { printf("Could not build the table!"); usage(); exit(1); } table_print(etab); table_free(etab); tree_free(tree); return 0; }
/* Returns non-zero on error. */ static int reset_dircache(status_t *stats) { tree_free(stats->dirsize_cache); stats->dirsize_cache = tree_create(0, 0); return stats->dirsize_cache == NULL_TREE; }
int db_close(struct nessdb *db) { tree_free(db->tree); xfree(db); return 1; }
void iexpr_free(struct node *np) { unsigned idx = iexpr_hash(np) % IEXPRSZ; struct iexpr *cp; struct iexpr *prevcp = NULL; /* search cache */ for (cp = Cache[idx]; cp != NULL; cp = cp->next) { if (iexpr_cmp(cp->np, np) == 0) { /* found it */ cp->count--; if (cp->count == 0) { tree_free(cp->np); if (prevcp == NULL) Cache[idx] = cp->next; else prevcp->next = cp->next; FREE(cp); } return; } prevcp = cp; } }
int main() { FILE * out; out = fopen("errors.txt","w"); int i = 1; Lex * test = create_Lex("count(1,1);"); Node * past = get_first(test); Branch * tree; while (past != NULL) { printf("%d token is %d with value %s\n", i, get_token(past), get_value(past)); past = get_next(past); i++; } tree = create_tree(test, out); fclose(out); if (tree == NULL) { printf("Unable to create tree.\n"); } destroy_Lex(test); tree_print(tree); translate(tree, "out.c"); tree_free(tree); _CrtDumpMemoryLeaks(); return 0; }
static void* save_state_cmd (int argc, char **argv, void *data) { Node *pos = (Node *) data; Node *i; Node *j; if (savedtree != NULL) { tree_free (savedtree); } savedtree = node_new (); i = node_root (pos); j = savedtree; do { j = savedtree = tree_duplicate (i, j); i = node_down (i); j = node_insert_down (j); } while (i != NULL); j = node_remove (j); { int no; no = node_no (pos); savedtree = node_root (savedtree); while (--no) savedtree = node_recurse (savedtree); } return pos; }
/* * iexpr -- find instanced expr in cache, or add it if necessary */ struct node * iexpr(struct node *np) { unsigned idx = iexpr_hash(np) % IEXPRSZ; struct iexpr *bucketp = Cache[idx]; struct iexpr *cp; /* search cache */ for (cp = bucketp; cp != NULL; cp = cp->next) if (iexpr_cmp(cp->np, np) == 0) { /* found it */ tree_free(np); cp->count++; return (cp->np); } /* allocate new cache entry */ cp = MALLOC(sizeof (*cp)); cp->np = np; cp->next = bucketp; cp->count = 1; Cache[idx] = cp; stats_counter_bump(Niexpr); return (np); }
void auto_test_flow() { FILE *files[4]; int i; int n[11] = {0, 5000, 10000, 15000, 20000, 25000, 30000, 35000, 40000, 45000, 50000}; double results[3]; test_set set[TESTS]; for(i = 0; i < 4; i++) { char buffer[10]; sprintf(buffer, "tests/results_%d.txt",i+1); files[i] = fopen(buffer, "w+"); if(files[i]==NULL) { fprintf(stderr, "Error opening test [%d] file", i); return; } } for (i = 0; i < 11; i++) {//for each n fprintf(stdout, "------------------------\nTESTING FOR N=%d\n", n[i]); fprintf(stdout, "Creating structures...\n"); auto_test_create(n[i], results, set); fprintf(files[0], "%d %f %f %f\n", n[i], results[0], results[1], results[2]); //fprintf(stdout, "Calculating trees' height...\n"); //fprintf(files[1], "%d %d %d\n", n[i], tree_height(set[0].bst), tree_height(set[0].avl)); fprintf(stdout, "Inserting test...\n"); auto_test_insert(n[i], results, set); fprintf(files[2], "%d %f %f %f\n", n[i], results[0], results[1], results[2]); fprintf(stdout, "Removing test...\n"); auto_test_remove(n[i], results, set); fprintf(files[3], "%d %f %f %f\n", n[i], results[0], results[1], results[2]); fprintf(stdout, "Done!\n------------------------\n\n"); } for (i = 0; i < 4; i++) { fclose(files[i]); } for (i = 0; i < TESTS; ++i) { list_free(set[i].list); tree_free(set[i].bst); tree_free(set[i].avl); } }
/** * Deallocates an Decoder object. Returns -1 if there is an error. */ int decoder_free(Decoder *decoder) { assert(decoder != NULL); int status = 0; status = bits_io_close(decoder->bfile); tree_free(decoder->tree); fclose(decoder->outfp); free(decoder); return status; }
END_TEST START_TEST(test_tree_free) { TreeNode *t = tree_new(); ck_assert_msg(t != NULL, "Tree node should not be NULL."); tree_free(t); }
// Frees the map void map_free(map m) { pthread_mutex_lock(m->mutex); pthread_mutex_t * mutex = m->mutex; tree_free(m->t); free(m); pthread_mutex_unlock(mutex); pthread_mutex_destroy(mutex); free(mutex); }
int main(int argc, char *argv[]) { int total; int n, i, t0, t1, t2, t3; node_t root; if (argc < 2) { printf("Arguments not sufficient, use default values\n"); } else { G_MAX_DEPTH = atoi(argv[1]); if (argc >= 3) G_ITERATION = atoi(argv[2]); if (argc >= 4) G_TRACEITER = atoi(argv[3]); else G_TRACEITER = 0.8 * G_ITERATION; } total = (pow(N_CHILD, G_MAX_DEPTH + 1) - 1) / (N_CHILD - 1); G_NODES_ARR = xmalloc(sizeof(node_t) * total); memset(G_NODES_ARR, 0x0, sizeof(node_t) * total); printf("Depth: %d, Iter: %d (mtrace the %dth), Nodes: %d\n", G_MAX_DEPTH, G_ITERATION, G_TRACEITER, total); root.dep = 0; root.off = 0; root.idx = 0; root.nchild = 0; for (G_ITER = 0; G_ITER < G_ITERATION; G_ITER++) { t0 = curr_time_micro(); if (G_ITER == G_TRACEITER) mtrace(); tree_build(&root); if (G_ITER == G_TRACEITER) muntrace(); t1 = curr_time_micro(); /* for (i = 0; i < total; i++) { node_t *p = G_NODES_ARR + i; printf("%d: %d %d %d %d\n", i, p->dep, p->off, p->idx, p->nchild); } */ n = 0; tree_traversal(&root, &n); if (n != total) printf("Tree check failed! (%d vs. %d)\n", total, n); t2 = curr_time_micro(); tree_free(); t3 = curr_time_micro(); printf("[%02d] Build: %d Traversal: %d Free: %d\n", G_ITER, t1-t0, t2-t1, t3-t2); } return 0; }
END_TEST START_TEST(test_tree_size) { TreeNode *t = tree_new(); t->left = tree_new(); t->right = tree_new(); ck_assert_int_eq(tree_size(t), 3); tree_free(t); }
static int addrs_destroy(backend_t *chain){ addrs_userdata *data = (addrs_userdata *)chain->userdata; tree_free(data->tree); free(chain->userdata); chain->userdata = NULL; return 0; }
static int copy_cmd (int argc,char **argv, void *data) { Node *pos = (Node *) data; if (clipboard != NULL) { tree_free (clipboard); } clipboard = node_new (); clipboard = tree_duplicate (pos, clipboard); return (int) pos; }
void keyValue(char a[][30] ,int n) { int i; TREE_T *root=tree_new("m for root"); TREE_T *backup=tree_load(); for(i=0;i<n;i++) { char *p=a[i]; int value; char name[MAXN+1]; TREE_T *t; switch(p[0]) { case 'S': sscanf(p,"SET %s %d",&name,&value); t=tree_get(root,name); t->value=value; break; case 'G': sscanf(p,"GET %s",&name); t=tree_has(root,name); if (!t) t=tree_get(backup,name); printf("%d\n",t->value); break; case 'R': tree_free(root); root=tree_new("m for root"); break; case 'C': tree_commit(backup,root); root=tree_new("m for root"); break; default: assert(0); } } tree_free(root); tree_save(backup); }