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);
}
