void handle_remap(PARSER_STATE *ps) { NODE *tok; int remap_values; ps->ignore_semicolon=0; tok=get_token(ps); if (tok->type!=nt_keyword) parse_error(ps,"remap direction must be a keyword"); else if (strcmp(tok->cp,"values")==0) remap_values=1; else if (strcmp(tok->cp,"vals")==0) remap_values=1; else if (strcmp(tok->cp,"keys")==0) remap_values=0; else parse_error(ps,"unknown remap direction %s",tok->cp); node_delete(tok); tok=get_token(ps); if ((tok->type!=nt_keyword) || (strcmp(tok->cp,"{")!=0)) parse_error(ps,"remap must be given a context"); node_delete(tok); handle_opening_brace(ps); context_stack->generator=remap_values?gen_value_remap:gen_key_remap; arrow_map_delete(&(context_stack->am)); arrow_map_new(&(context_stack->am)); }
void handle_default(PARSER_STATE *ps) { NODE *tok; if (context_stack->default_value!=NULL) { node_delete(context_stack->default_value); context_stack->default_value=NULL; } ps->ignore_semicolon=0; tok=get_token(ps); if (tok->type!=nt_keyword) { context_stack->default_policy=dp_value; context_stack->default_value=tok; tok->refs++; } else if (strcmp(tok->cp,"any")==0) context_stack->default_policy=dp_any; else if (strcmp(tok->cp,"fail")==0) context_stack->default_policy=dp_fail; else if (strcmp(tok->cp,"null")==0) context_stack->default_policy=dp_null; else parse_error(ps,"unknown default policy keyword %s",tok->cp); node_delete(tok); ps->ignore_semicolon=1; }
void node_delete(node_t *n) { if (!is_nil(n->left)) node_delete(n->left); if (!is_nil(n->right)) node_delete(n->right); free(n); }
sval_t seq_delete(intset_t* set, skey_t key) { node_t* curr = set->head; node_t* ppred = NULL; node_t* pred = NULL; while (likely(curr != NULL && !curr->leaf)) { ppred = pred; pred = curr; skey_t curr_key = curr->key; if (key < curr_key) { curr = (node_t*) curr->left; } else { curr = (node_t*) curr->right; } } node_t* other; if (curr && curr->key == key) { if (pred->left == curr) { pred->left = NULL; other = (node_t*) pred->right; } else { pred->right = NULL; other = (node_t*) pred->left; } if (ppred != NULL && other == NULL) { if (ppred->left == pred) { ppred->left = NULL; } else { ppred->right = NULL; } node_delete(pred); } node_delete(curr); return curr->val; } return 0; }
void node_delete(NODE* node) { if (!node) return; symbol_delete(node->symbol); if (node->left) node_delete(node->left); if (node->right) node_delete(node->right); free(node); }
void tree_delete(tree_t *tree) { if (!is_nil(tree->root)) node_delete(tree->root); free(tree); }
gboolean node_try_delete(node_t* node) { g_assert (node); FN_W ("%s 0x%p %s\n", __func__, node, NODE_NAME(node)); /* Try clean children */ if (node_children_num (node) > 0) { g_hash_table_foreach_remove(node->children, children_remove_cb, NULL); } if (!NODE_NEED_MONITOR(node)) { /* Clean some flags. */ /* NODE_CLE_FLAG(node, NODE_FLAG_HAS_SNAPSHOT | NODE_FLAG_STAT_DONE); */ node->flag = 0; /* Now we handle the state. */ if (NODE_HAS_STATE(node, NODE_STATE_ASSOCIATED)) { port_remove(node); } /* Actually ignore the ROOT node. */ if (node->state == 0 && NODE_PARENT(node)) { children_remove(NODE_PARENT(node), node); /* Do clean instead of returning TRUE. */ node_delete (node); } /* else, we have events, clean event queue? */ } return FALSE; }
bool rbtree_delete(struct rbtree *tree, ipaddr_t IP) { struct rbtree_elem *parent, *succ, *pred, *node; if (!rbtree_search(tree, IP, &node)) { return false; } if (node->low == IP) { if (node->high == IP) { node_delete(&tree->root, node) ; } else { node->low++ ; } } else if (node->high == IP) { node->high--; } else { rbnode_t new_node; new_node = malloc(sizeof(struct rbtree_elem)) ; ASSERT(new_node); ASSERT(node->low < IP && node->high > IP) ; new_node->low=IP+1 ; new_node->high=node->high ; new_node->left=new_node->right=new_node->parent=nil ; new_node->color = _RED_ ; node->high = IP - 1; node_insert_at(&tree->root, node, new_node); } return true; }
static u8 ml_wc_nodes_create(c8 *parent_topSUB, u16 toplen, u8 qid, void *usr_cl) { struct topic_node *parent_leaf = NULL; if('\0' != parent_topSUB[0]) { parent_leaf = SUB_node_create(parent_topSUB, qid, usr_cl); if(NULL == parent_leaf) return QFL_VALUE; } /* Get the topic SUB to it's original state */ if(toplen > 1) parent_topSUB[toplen - 2] = '/'; parent_topSUB[toplen - 1] = '#'; if(NULL == SUB_node_create(parent_topSUB, qid, usr_cl)) { /* Failed to create WC topic, so delete parent as well. In this revision, 'parent_leaf' will not be a 'NULL' at this juncture, nevertheless a check (for tools) */ if(parent_leaf) node_delete(parent_leaf); return QFL_VALUE; } return qid; }
END_TEST START_TEST(test_node_delete) { node *root = node_new("d", "definition"); node *l = node_new("b", "b"); node *ll = node_new("a", "a"); node *lr = node_new("c", "c"); node_insert(root, l); node_insert(root, ll); node_insert(root, lr); // ensure correct insertions ck_assert_ptr_eq(l, root->left); ck_assert_ptr_eq(ll, root->left->left); ck_assert_ptr_eq(lr, root->left->right); ck_assert_int_eq(4, node_size(root)); ck_assert_ptr_eq(l, node_delete(root, "b")); // ensure correct reinsertion ck_assert_ptr_eq(ll, root->left); ck_assert_ptr_eq(NULL, root->right); ck_assert_ptr_eq(NULL, root->left->left); ck_assert_ptr_eq(lr, root->left->right); // node is not found in the tree anymore ck_assert_ptr_eq(NULL, node_search(root, "b")); ck_assert_int_eq(3, node_size(root)); node_free(root); }
void trie_delete(trie_tree *tree, const wchar_t *word) { assert(tree != NULL); if(tree->root == NULL) return; tree->root = node_delete(tree->root, word); }
int main(void) { //int i; RB_TREE *T; T = tree_init(); node_insert(T, 23); node_insert(T, 94); node_insert(T, 32); node_insert(T, 84); node_insert(T, 12); node_insert(T, 8); node_insert(T, 82); node_insert(T, 31); node_insert(T, 59); node_insert(T, 41); node_insert(T, 73); //for ( i = 0 ; i < 1000 ; i++ ) { // key = rand() % 1000; // node_insert(T, key); //} inorder_tree_walk(T, T->root); printf("\n"); node_delete(T, 32); node_delete(T, 8); node_delete(T, 4); printf("after delete 32, 8, 4:\n"); inorder_tree_walk(T, T->root); printf("\n"); printf("sucessor of 23 is %d\n", rbtree_successor(T, rbtree_search(T, T->root, 23))->key); printf("predecessor of 84 is %d\n", rbtree_predecessor(T, rbtree_search(T, T->root, 84))->key); printf("the maximun is %d\n", rbtree_maximum(T, T->root)->key); printf("the minimum is %d\n", rbtree_minimum(T, T->root)->key); node_destory(T, T->root); tree_destory(T); exit(0); }
u32 nodewrap_allocate(union trapped_args *args, void *pr_ctxt) { int status = 0; struct dsp_uuid node_uuid; u32 cb_data_size = 0; u32 __user *psize = (u32 __user *) args->args_node_allocate.args; u8 *pargs = NULL; struct dsp_nodeattrin proc_attr_in, *attr_in = NULL; struct node_res_object *node_res; int nodeid; void *hprocessor = ((struct process_context *)pr_ctxt)->processor; if (psize) { if (get_user(cb_data_size, psize)) status = -EPERM; cb_data_size += sizeof(u32); if (!status) { pargs = kmalloc(cb_data_size, GFP_KERNEL); if (pargs == NULL) status = -ENOMEM; } CP_FM_USR(pargs, args->args_node_allocate.args, status, cb_data_size); } CP_FM_USR(&node_uuid, args->args_node_allocate.node_id_ptr, status, 1); if (status) goto func_cont; if (args->args_node_allocate.attr_in) { CP_FM_USR(&proc_attr_in, args->args_node_allocate.attr_in, status, 1); if (!status) attr_in = &proc_attr_in; else status = -ENOMEM; } if (!status) { status = node_allocate(hprocessor, &node_uuid, (struct dsp_cbdata *)pargs, attr_in, &node_res, pr_ctxt); } if (!status) { nodeid = node_res->id + 1; CP_TO_USR(args->args_node_allocate.node, &nodeid, status, 1); if (status) { status = -EFAULT; node_delete(node_res, pr_ctxt); } } func_cont: kfree(pargs); return status; }
void node_delete(node n) { if (n) { if (n->next) node_delete(n->next); free(n); n = 0; } }
void scope_delete(SCOPE* scope) { int i; for (i = 0; i < MAX_SYMBOL_TYPES; i++) node_delete(scope->node[i]); free(scope); }
/* Modify is slightly trickier. The basic idea is we simply delete the * object and create it with the new parameters. Then we need to mark the * objects that depend on this one */ int output_pgsql_t::node_modify(osmium::Node const &node) { if (!m_options.slim) { fprintf(stderr, "Cannot apply diffs unless in slim mode\n"); util::exit_nicely(); } node_delete(node.id()); node_add(node); return 0; }
/* Delete Node */ ptr_t DeleteSuccessor(data_t *myHeap, data_t *Master2SysAlloc, int *fixedStack, int stackPtr_avl, ptr_t rootPtr, int key){ int flag_stop = 0; ptr_t nowPtr = rootPtr; struct stack_t stackOutput; int flag_stackIsUsed = 0; while(flag_stop == 0){ struct sub_t subResult = DeleteSuccessorSub(myHeap, nowPtr, key); if(subResult.feedback == FB_DONE){ flag_stop = 1; // --------- Deletion --------- node_delete(Master2SysAlloc, nowPtr); nowPtr = NULL_PTR; // --------- Balancing --------- if(flag_stackIsUsed == 0){ rootPtr = NULL_PTR; }else{ stackOutput = AVL_STACK_READ(fixedStack, stackPtr_avl); stackPtr_avl = stackOutput.hdPtr_avl; if(stackOutput.operation == GOING_LEFT){ node_set_left(myHeap, stackOutput.pointer, nowPtr); }else{ node_set_right(myHeap, stackOutput.pointer, nowPtr); } while(stackPtr_avl > 0){ nowPtr = stackOutput.pointer; ptr_t nowPtr_new = ProcessNodeDeletion(myHeap, nowPtr); stackOutput = AVL_STACK_READ(fixedStack, stackPtr_avl); stackPtr_avl = stackOutput.hdPtr_avl; if(nowPtr_new != nowPtr){ if(stackOutput.operation == GOING_LEFT){ node_set_left(myHeap, stackOutput.pointer, nowPtr_new); }else{ node_set_right(myHeap, stackOutput.pointer, nowPtr_new); } } } rootPtr = ProcessNodeDeletion(myHeap, stackOutput.pointer); } }else{ flag_stackIsUsed = 1; if(subResult.feedback == FB_LEFT){ stackOutput = AVL_STACK_WRITE(fixedStack, stackPtr_avl, nowPtr, GOING_LEFT); stackPtr_avl = stackOutput.hdPtr_avl; nowPtr = node_get_left_pointer(myHeap, nowPtr); }else{ stackOutput = AVL_STACK_WRITE(fixedStack, stackPtr_avl, nowPtr, GOING_RIGHT); stackPtr_avl = stackOutput.hdPtr_avl; nowPtr = node_get_right_pointer(myHeap, nowPtr); } } } return rootPtr; }
/* Modify is slightly trickier. The basic idea is we simply delete the * object and create it with the new parameters. Then we need to mark the * objects that depend on this one */ int output_pgsql_t::node_modify(osmid_t osm_id, double lat, double lon, const taglist_t &tags) { if( !m_options.slim ) { fprintf( stderr, "Cannot apply diffs unless in slim mode\n" ); util::exit_nicely(); } node_delete(osm_id); node_add(osm_id, lat, lon, tags); return 0; }
bool map_remove(Map *map, const void *key) { bool ret = false; map->root = node_delete(map->root, key, &ret); map->root->color = BLACK; if (ret) { --(map->size); } return ret; }
static void node_delete(struct btree_node *node, struct btree *btree) { unsigned int i, count = node->count; if (!node->depth) { if (btree->destroy) { for (i=0; i<count; i++) btree->destroy((void*)node->item[i], btree->destroy_ctx); } } else { for (i=0; i<count; i++) { node_delete(node->branch[i], btree); if (btree->destroy) btree->destroy((void*)node->item[i], btree->destroy_ctx); } node_delete(node->branch[count], btree); } free(node); }
void queue_delete(Queue *queue) { if (queue != 0) { Node *ptr = queue->top; Node *last; while (ptr != 0) { last = ptr; ptr = node_get_next(ptr); node_delete(last); } free(queue); } }
inline void page_pickSchedule() { static byte prev_index = 0; if(pre_page != PICK_SCHEDULE) { PTLS(" Page Pick Schedule"); lcd.cursor(); pre_page = PICK_SCHEDULE; node_index = node_index % (node_size()-1); prev_index = node_index + 1; } if (prev_index != node_index) { prev_index == node_index; schedule s = node_get(node_index); String t = getTimeString(s); if (mod) lcd.print(F("Mod:")); else lcd.print(F("Del: ")); lcd.print(t); lcd.setCursor(0,1); lcd.print("Targ Temp: " + (String)s.temperature); } if (button_input == PLUS_UP || button_input == PLUS_HOLD) { node_index += 1; if (node_index >= node_size()) node_index = 0; } else if (button_input == MINUS_UP || button_input == MINUS_HOLD) { node_index -= 1; if(node_index < 0) { node_index = (node_size()-1); } } else if (button_input == SET_UP) { if(mod) { switchPage(MODIFY_SCHEDULE); } else { PTLS("Node deleted"); node_delete(node_index); node_index = (node_size()-1); prev_index = node_index + 1; } } else if (button_input == MODE_UP) { switchPage(LIST_MODE); } }
//~~~~~~~~~~~~~~~~~MAIN~~~~~~~~~~~~~~~~~~~~~~~ int main(int argc, char* argv[]){ int debug = 0, flag = 1, arg, numRead = 0; char command, *stream; Line line = line_init( stdin); gen_parse_args( argc, argv, &debug); Htable htable = ht_init( ht_mod_hash); while(flag){ arg = -1; fprintf( stdout, "\ncommand: "); line_read_line( line); stream = get_line( line); sscanf( stream, " %c%n", &command, &numRead); switch( command){ case 'q': flag = 0; break; case 'i': sscanf( stream+numRead, "%d", &arg); if( arg < 0) fprintf( stderr, "MUST BE >= 0\n"); else ht_add( htable, arg, arg, debug); break; case 'd': sscanf( stream+numRead, "%d", &arg); if( arg < 0) fprintf( stderr, "MUST BE >= 0\n"); else{ int pos = ht_mod_hash( htable, arg); node_delete( &((htable->table)[pos]), arg, arg, debug); } break; case 'c': sscanf( stream+numRead, "%d", &arg); if( arg < 0) fprintf( stderr, "MUST BE >= 0\n"); else{ if( ht_exists( htable, arg, debug) ) fprintf( stdout, "The value, %d, exists!\n", arg); else fprintf( stdout, "The value, %d, does NOT exist\n", arg); } break; case 'e': ht_erase( htable); break; case 'r': sscanf( stream+numRead, "%d", &arg); if( arg >= 1) ht_resize( htable, arg, debug); else fprintf( stderr, "Error, size must be >= 1\n"); break; case 'l': ht_list( htable); break; case '\n': break; default: fprintf( stdout, "Sorry, Invalid command\n"); break; } free(stream); } line_free( line); ht_free( htable); return 0; }
u32 nodewrap_delete(union trapped_args *args, void *pr_ctxt) { u32 ret; struct node_res_object *node_res; find_node_handle(&node_res, pr_ctxt, args->args_node_delete.node); if (!node_res) return -EFAULT; ret = node_delete(node_res, pr_ctxt); return ret; }
/** * Deletes the node which points to the requested data. * * Should be safe when called in parallel with other threads that * might call the same functions. Uses fine grained locking. * * @param root root of the tree * @param comparator function used to compare nodes * @param data pointer to the data to be deleted * @return 1 if data is not found, 0 otherwise */ int node_delete_ts_fg(struct bst_node** root, comparator compare, void* data) { /* TODO: Fill-in the body of this function */ //struct bst_node** node = search(root, compare, data); struct bst_node** node = root; if (node == NULL) return -1; else { node_delete(node, compare, data); return 0; } }
static void try_node_delete(struct topic_node *node) { while(node) { if(is_node_retain(node) || is_node_willed(node) || enrolls_plugin(node) || node->cl_map[0] || node->cl_map[1] || node->cl_map[2]) break; node = node_delete(node); } }
void rbtree_delete(struct rbtree *tree, struct rbtree_elem *elem) { #if 0 struct rbtree_elem *parent, *succ, *pred, *node; //rbtree_inorder_check(tree) ; if (!(node = rbtree_find(tree, elem))) { //rbtree_inorder_check(tree) ; return false; } #endif node_delete(tree, elem) ; //rbtree_inorder_check(tree) ; }
bool rbtree_insert(struct rbtree *tree, ipaddr_t IP) { rbnode_t root, node, parent, succ, pred; root = tree->root; if (search_pred_succ(root, IP, &succ, &pred)) { return false; } if (pred != nil && pred->high == IP - 1) { if (succ != nil && succ->low == IP+1) { //log_printf("succ!=nil & pred!=nil.\n") ; ipaddr_t high = succ->high ; //inorder_check(*tree) ; node_delete(&tree->root, succ) ; //inorder_check(*tree); node = pred; pred->high = high; //if (pred->parent!=nil && pred->parent->left==pred) ASSERT(pred->high<pred->parent->low) ; //if (pred->right!=nil) ASSERT(pred->high<pred->right->low) ; } else { node = pred; pred->high = IP; } } else if (succ!=nil && succ->low==IP+1) { node = succ; succ->low=IP; } else { rbnode_t new_node; new_node = malloc(sizeof(struct rbtree_elem)); ASSERT(new_node); new_node->low = new_node->high = IP; new_node->left = new_node->right = new_node->parent = nil; new_node->color = _RED_; node = new_node; node_insert(&tree->root, new_node); } //if (node->parent!=nil && node->parent->left==node) ASSERT(node->high<node->parent->low) ; //if (node->parent!=nil && node->parent->right==node) ASSERT(node->low>node->parent->high) ; //if (node->right!=nil) ASSERT(node->high<node->right->low) ; //if (node->left!=nil) ASSERT(node->low>node->left->high) ; //inorder_check(*tree) ; return true; }
void handle_return(PARSER_STATE *ps) { NODE *tok; ps->ignore_semicolon=0; tok=get_token(ps); if (tok->type!=nt_keyword) parse_error(ps,"return policy must be a keyword"); else if (strcmp(tok->cp,"pointer")==0) context_stack->return_pointer=1; else if (strcmp(tok->cp,"value")==0) context_stack->return_pointer=0; else parse_error(ps,"unknown return policy keyword %s",tok->cp); node_delete(tok); ps->ignore_semicolon=1; }
int main (void){ LNode my_List; LNode temp; void *ptr; ptr =NULL; arr_init(ptr); my_List=llist_new(ptr); temp=my_List; while (temp!=NULL){ printf("%d\n",temp->data); temp=temp->next; } //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! node_insert(my_List,888,21); temp=my_List; while (temp!=NULL){ printf("%d\n",temp->data); temp=temp->next; } //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! node_delete(my_List,21); temp=my_List; while (temp!=NULL){ printf("%d\n",temp->data); temp=temp->next; } return 0; }