void iterate_node_2(node_t *node) { int action; action = get_action_2(node); switch (action) { case 0: node->link_0->value = node->value; case 1: connect_nodes(node, node->link_0, node->link_1); /* swap_nodes(node->link_0, node->link_1); */ swap_nodes(node, node->link_1); break; case 2: node->link_1->value = node->value; case 3: connect_nodes(node, node->link_1, node->link_0); /* swap_nodes(node->link_1, node->link_0); */ swap_nodes(node, node->link_0); break; case 4: node->link_0->value = inverted_value(node); break; case 5: node->link_0->value = inverted_value(node); swap_nodes(node, node->link_1); break; case 6: node->link_1->value = inverted_value(node); break; case 7: node->link_1->value = inverted_value(node); swap_nodes(node, node->link_0); break; } /* node->value = 0; node->value = 1; invert_value(node); connect_nodes(node, node->link_0, node->link_1); swap_values(node, node->link_0); swap_values(node, node->link_1); node->link_0->value = node->value; node->link_0->value = 0; node->link_0->value = 1; node->link_0->value = inverted_value(node); node->link_1->value = node->value; node->link_1->value = 0; node->link_1->value = 1; node->link_1->value = inverted_value(node); swap_nodes(node, node->link_0); swap_nodes(node, node->link_1); */ }
/* Deletes a node from a binary search tree * Three cases to consider - node has 0,i 1, or two kids * First two are trivial and can be done in constant time * Third one requires that you replace the node being deleted * with its in order successor * which is (in this case) just the minimum (leftmost node) in right subtree * Time complexity O(h) in worst case - same as above * Returns 0 on success, and -1 on error */ int delete_node_bst(struct b_node* to_delete) { if(to_delete == NULL) { //Nonexisting node - this really depends on the semantics of 'error' //Some could argue that the job was already done here, and this is a success //But no nodes were actually deleted, and this is an invalid input return -1; } if(to_delete->left == NULL && to_delete->right == NULL) { //This is a leaf node - can be deleted really easily //First clear reference in parent if(swap_nodes(to_delete, NULL) < 0) { //Error occured while swapping return -1; } free(to_delete); return 0; } //Now we need to consider the two separate cases where the node //has only 1 child if(to_delete->left && to_delete->right == NULL) { //only has left child if(swap_nodes(to_delete, to_delete->left) < 0) { return -1; } free(to_delete); return 0; } if(to_delete->right && to_delete->left == NULL) { //only has right child if(swap_nodes(to_delete, to_delete->right) < 0) { return -1; } free(to_delete); return 0; } //Has ro have two kids, so we get the successor, swap those nodes, then //delete that node //we know the successor can't have two kids - otherwise its //left child would be smaller struct b_node* successor = find_min(to_delete->right); if(swap_nodes(to_delete, successor) < 0) { return -1; } return delete_node_bst(to_delete); //The successor node now occupies to_deletes original //position in the tree }
int List_bubble_sort(List *list, List_compare cmp) { int n = List_count(list); check(n >= 0, "List contains no elements"); debug("List contains %d elements", n); int sorted = 0; /* repeat until sorted */ for ( ; n > 0 && !sorted ; n--) { sorted = 1; LIST_FOREACH(list, first, next, cur) { check(cur, "List contains a NULL Node."); ListNode *next = Node_next(cur); /* if this pair is out of order */ if ( next && cmp(Node_value(cur), Node_value(next)) > 0) { debug("%s is greater than %s", (char *)Node_value(cur), (char *)Node_value(next)); swap_nodes(cur, next); sorted = 0; } else if (! next) { debug("The list is over."); } else { debug("%s is less than %s", (char *)Node_value(cur), (char *)Node_value(next)); } } debug("We have %d rounds to go, and list is%ssorted", n, sorted ? " " : " not "); debug("We will%sgo to the next cycle.", (n > 0 && !sorted) ? " " : " not "); }
void RBTREE_REMOVE_NODE(struct RBTREE_TYPENAME* target, struct RBTREE_NODE* N) { DEBUG_RBTREE("rbtree_remove_node: "RBTREE_KEY_PRNF"\n", RBTREE_KEY_PRNA(N->key)); valgrind_assert(target->size >= 1); DEBUG_RBTREE("before:\n"); // RBTREE_PRINT(target); if (target->size == 1) { valgrind_assert(target->root == N); target->root = 0; goto end; } // If N has two children, we use replacement R: in-order successor { struct RBTREE_NODE* R = NULL; if (N->right != NULL && N->left != NULL) R = rbtree_leftmost_loop(N->right); if (R != NULL) swap_nodes(target, N, R); delete_one_child(target, N); DEBUG_RBTREE("after:\n"); // RBTREE_PRINT(target); } end: target->size--; }
void circulate_leaves(monitor_t *m, desktop_t *d, circulate_dir_t dir) { if (d == NULL || d->root == NULL || is_leaf(d->root)) return; node_t *par = d->focus->parent; bool focus_first_child = is_first_child(d->focus); if (dir == CIRCULATE_FORWARD) for (node_t *s = second_extrema(d->root), *f = prev_leaf(s); f != NULL; s = prev_leaf(f), f = prev_leaf(s)) swap_nodes(f, s); else for (node_t *f = first_extrema(d->root), *s = next_leaf(f); s != NULL; f = next_leaf(s), s = next_leaf(f)) swap_nodes(f, s); if (focus_first_child) focus_node(m, d, par->first_child, true); else focus_node(m, d, par->second_child, true); }
static bs_tree_node_t* delete_node(bs_tree_t* tree, bs_tree_node_t* node, void* key) { int cmp = tree->compare(node->key, key); if(cmp < 0) { if(node->left) delete_node(tree, node->left, key); else return NULL; } else if(cmp > 0) { if(node->right) delete_node(tree, node->right, key); else return NULL; } else { if(node->left && node->right) { bs_tree_node_t* successor = find_min(node->right); swap_nodes(successor, node); replace_node_in_parent(tree, successor, successor->right); return successor; } else if(node->left) replace_node_in_parent(tree, node, node->left); else if(node->right) replace_node_in_parent(tree, node, node->right); else replace_node_in_parent(tree, node, NULL); return node; } }
void IntervalMap::remove(pcNode*node, int interval) { // Ein Blatt //TODO: FIX BUG if (!node->left && !node->right) { *get_parent_ptr(node, interval) = 0; delete node; } // Nur ein Kind else if (node->left && !node->right) { *get_parent_ptr(node, interval) = node->left; node->left->parent = node->parent; delete node; } else if (!node->left && node->right) { *get_parent_ptr(node, interval) = node->right; node->right->parent = node->parent; delete node; } // Zwei Kinder else { std::cout << "swap" << std::endl; pcNode*other = get_prev_node(node); std::cout << other->y << std::endl; swap_nodes(node, other, interval); std::cout << "after swap" << std::endl; // Löschen des Knoten durch Benutzen von einer // der beiden anderen Methoden remove(node, interval); } }
/* * Sift a node up to the highest position it can hold according to the * comparator. */ static void sift_up(binaryheap *heap, int node_off) { while (node_off != 0) { int cmp; int parent_off; /* * If this node is smaller than its parent, the heap condition is * satisfied, and we're done. */ parent_off = parent_offset(node_off); cmp = heap->bh_compare(heap->bh_nodes[node_off], heap->bh_nodes[parent_off], heap->bh_arg); if (cmp <= 0) break; /* * Otherwise, swap the node and its parent and go on to check the * node's new parent. */ swap_nodes(heap, node_off, parent_off); node_off = parent_off; } }
InteractionState::Captor& InteractionState::Captor::operator=(Captor& other) { swap_nodes(other); other.unlink(); return *this; }
// This will sort the list from most hits to least void slist_sort_by_hits(slist *l) { register snode* cur, *prev; if (l->cnt <= 1) return; prev = cur = l->head; while (cur && cur->next) { /* If the next node is bigger */ if (cur->hits < cur->next->hits) { if (cur == l->head) { // Update the actual list head l->head = cur->next; prev = NULL; } swap_nodes(prev, cur, cur->next); // start over prev = cur = l->head; continue; } prev = cur; cur = cur->next; } // End with cur pointing at first record l->cur = l->head; }
void fix_bst(node * root){ if (root == NULL) return; node * n1 = NULL, *n2 = NULL, **k = (node **)malloc(sizeof(node)); k[0] = NULL; inorder_prev(root, k, &n1, &n2); swap_nodes(n1, n2); }
//! <b>Requires</b>: node1 and node2 can't be header nodes //! of two trees. //! //! <b>Effects</b>: Swaps two nodes. After the function node1 will be inserted //! in the position node2 before the function. node2 will be inserted in the //! position node1 had before the function. //! //! <b>Complexity</b>: Logarithmic. //! //! <b>Throws</b>: Nothing. //! //! <b>Note</b>: This function will break container ordering invariants if //! node1 and node2 are not equivalent according to the ordering rules. //! //!Experimental function static void swap_nodes(node_ptr node1, node_ptr node2) { if(node1 == node2) return; node_ptr header1(tree_algorithms::get_header(node1)), header2(tree_algorithms::get_header(node2)); swap_nodes(node1, header1, node2, header2); }
int main(void){ int i = 0; UZOL * tmp = NULL; pridaj(&tmp, 1, 5); printf("pred: "); print(tmp); eraseMax(&tmp); for(i = 0; i < 5; i++){ swap_nodes(&tmp,9 - i, 0 + i); swap_nodes(&tmp,19 - i, 10 + i); } printf("po: "); print(tmp); return 0; }
/* * 从 i 开始与父节点比较, 如果当前节点的 priority 大于 父节点, 交换父节点, 从父节点开始继续, 直到找到父节点的 priority 大于当前节点. */ static bool float_up(struct heap *heap, size_t i) { bool moved = false; size_t parent; for (; i > 1; i = parent) { parent = heap_parent__(i); if (heap->array[parent]->priority >= heap->array[i]->priority) { break; } swap_nodes(heap, parent, i); moved = true; } return moved; }
/* * Sift a node down from its current position to satisfy the heap * property. */ static void sift_down(binaryheap *heap, int node_off) { while (true) { int left_off = left_offset(node_off); int right_off = right_offset(node_off); int swap_off = 0; /* Is the left child larger than the parent? */ if (left_off < heap->bh_size && heap->bh_compare(heap->bh_nodes[node_off], heap->bh_nodes[left_off], heap->bh_arg) < 0) swap_off = left_off; /* Is the right child larger than the parent? */ if (right_off < heap->bh_size && heap->bh_compare(heap->bh_nodes[node_off], heap->bh_nodes[right_off], heap->bh_arg) < 0) { /* swap with the larger child */ if (!swap_off || heap->bh_compare(heap->bh_nodes[left_off], heap->bh_nodes[right_off], heap->bh_arg) < 0) swap_off = right_off; } /* * If we didn't find anything to swap, the heap condition is * satisfied, and we're done. */ if (!swap_off) break; /* * Otherwise, swap the node with the child that violates the heap * property; then go on to check its children. */ swap_nodes(heap, swap_off, node_off); node_off = swap_off; } }
/** Preconditions: * N has at most one non-null child * Tree size is 2 or more */ static inline void delete_one_child(struct RBTREE_TYPENAME* target, struct RBTREE_NODE* N) { valgrind_assert(target->size >= 2); valgrind_assert(N->right == NULL || N->left == NULL); struct RBTREE_NODE* P = N->parent; struct RBTREE_NODE* C = (N->right == NULL) ? N->left : N->right; if (C == NULL) { if (N->color == RED) { replace(P, N, NULL); return; } } if (C != NULL) { swap_nodes(target, N, C); struct RBTREE_NODE* t = N; N = C; C = t; } if (N->color == BLACK) { if (C != NULL && C->color == RED) { // unlink child replace(N, C, NULL); } else { delete_case1(target, P, N); replace(P, N, C); } } else // N RED { replace(N, C, NULL); } }
/* Use a disgustingly simplistic bubble sort to put our lists in order */ void index_sort(PkgNodePtr top) { PkgNodePtr p, q; /* Sort everything at the top level */ for (p = top->kids; p; p = p->next) { for (q = top->kids; q; q = q->next) { if (q->next && strcmp(q->name, q->next->name) > 0) swap_nodes(q, q->next); } } /* Now sub-sort everything n levels down */ for (p = top->kids; p; p = p->next) { if (p->kids) index_sort(p); } }
void fix_bst(struct node* root){ if (root != NULL){ struct node** swaplist = (struct node**)malloc(sizeof(struct node*) * 2); swaplist[0] = NULL; swaplist[1] = NULL; int index = 0; inorder_check(root, swaplist,&index); if (swaplist[1] == NULL){ if (swaplist[0]->left != NULL && swaplist[0]->data < swaplist[0]->left->data) swaplist[1] = swaplist[0]->left; else if (swaplist[0]->right != NULL && swaplist[0]->data > swaplist[0]->right->data) swaplist[1] = swaplist[0]->right; else swaplist[1] = root; } swap_nodes(swaplist[0], swaplist[1]); } return; }
/* * binaryheap_remove_first * * Removes the first (root, topmost) node in the heap and returns a * pointer to it after rebalancing the heap. The caller must ensure * that this routine is not used on an empty heap. O(log n) worst * case. */ Datum binaryheap_remove_first(binaryheap *heap) { Assert(!binaryheap_empty(heap) && heap->bh_has_heap_property); if (heap->bh_size == 1) { heap->bh_size--; return heap->bh_nodes[0]; } /* * Swap the root and last nodes, decrease the size of the heap (i.e. * remove the former root node) and sift the new root node down to its * correct position. */ swap_nodes(heap, 0, heap->bh_size - 1); heap->bh_size--; sift_down(heap, 0); return heap->bh_nodes[heap->bh_size]; }
/* * 从 i 开始直到遇到子节点比当前节点 priority 小 或 i 是叶子节点 */ static void float_down(struct heap *heap, size_t i) { while (!heap_is_leaf__(heap, i)) { size_t left = heap_left__(i); size_t right = heap_right__(i); size_t max = i; if (heap->array[left]->priority > heap->array[max]->priority) { max = left; } if (right <= heap->n && heap->array[right]->priority > heap->array[max]->priority) { max = right; } if (max == i) { break; } swap_nodes(heap, max, i); i = max; } }
/* * opt0 - delete useless expressions and combine constants. * * opt0 will delete expressions such as x + 0, x - 0, x * 0, * x * 1, 0 / x, x / 1, x mod 0, etc from the tree pointed to * by node and combine obvious constant operations. It cannot * combine name and label constants but will combine icon type * nodes. */ void opt0(ENODE **node) { ENODE *ep; __int64 val, sc; ep = *node; if( ep == NULL ) return; switch( (*node)->nodetype ) { case en_b_ref: case en_c_ref: case en_h_ref: case en_w_ref: /* optimize unary node */ case en_ub_ref: case en_uc_ref: case en_uh_ref: case en_uw_ref: /* optimize unary node */ case en_flt_ref: case en_dbl_ref: case en_cbc: case en_cbh: case en_cbw: case en_cch: case en_ccw: case en_chw: case en_ainc: case en_adec: case en_not: case en_compl: opt0( &((*node)->p[0])); return; case en_uminus: opt0( &(ep->p[0])); if( ep->p[0]->nodetype == en_icon ) { ep->nodetype = en_icon; ep->i = -ep->p[0]->i; } return; case en_add: case en_sub: opt0(&(ep->p[0])); opt0(&(ep->p[1])); if( ep->p[0]->nodetype == en_icon ) { if( ep->p[1]->nodetype == en_icon ) { dooper(node); return; } if( ep->p[0]->i == 0 ) { if( ep->nodetype == en_sub ) { ep->p[0] = ep->p[1]; ep->nodetype = en_uminus; } else *node = ep->p[1]; return; } } else if( ep->p[1]->nodetype == en_icon ) { if( ep->p[1]->i == 0 ) { *node = ep->p[0]; return; } } return; case en_mul: case en_mulu: opt0(&(ep->p[0])); opt0(&(ep->p[1])); if( ep->p[0]->nodetype == en_icon ) { if( ep->p[1]->nodetype == en_icon ) { dooper(node); return; } val = ep->p[0]->i; if( val == 0 ) { *node = ep->p[0]; return; } if( val == 1 ) { *node = ep->p[1]; return; } sc = pwrof2(val); if( sc != -1 ) { swap_nodes(ep); ep->p[1]->i = sc; ep->nodetype = en_shl; } } else if( ep->p[1]->nodetype == en_icon ) { val = ep->p[1]->i; if( val == 0 ) { *node = ep->p[1]; return; } if( val == 1 ) { *node = ep->p[0]; return; } sc = pwrof2(val); if( sc != -1 ) { ep->p[1]->i = sc; ep->nodetype = en_shl; } } break; case en_div: case en_udiv: opt0(&(ep->p[0])); opt0(&(ep->p[1])); if( ep->p[0]->nodetype == en_icon ) { if( ep->p[1]->nodetype == en_icon ) { dooper(node); return; } if( ep->p[0]->i == 0 ) { /* 0/x */ *node = ep->p[0]; return; } } else if( ep->p[1]->nodetype == en_icon ) { val = ep->p[1]->i; if( val == 1 ) { /* x/1 */ *node = ep->p[0]; return; } sc = pwrof2(val); if( sc != -1 ) { ep->p[1]->i = sc; ep->nodetype = en_shr; } } break; case en_mod: opt0(&(ep->p[0])); opt0(&(ep->p[1])); if( ep->p[1]->nodetype == en_icon ) { if( ep->p[0]->nodetype == en_icon ) { dooper(node); return; } sc = pwrof2(ep->p[1]->i); if( sc != -1 ) { ep->p[1]->i = mod_mask(sc); ep->nodetype = en_and; } } break; case en_and: case en_or: case en_xor: case en_shr: case en_shru: case en_shl: opt0(&(ep->p[0])); opt0(&(ep->p[1])); if( ep->p[0]->nodetype == en_icon && ep->p[1]->nodetype == en_icon ) dooper(node); break; case en_land: case en_lor: case en_ult: case en_ule: case en_ugt: case en_uge: case en_lt: case en_le: case en_gt: case en_ge: case en_eq: case en_ne: case en_asand: case en_asor: case en_asadd: case en_assub: case en_asmul: case en_asdiv: case en_asmod: case en_asrsh: case en_aslsh: case en_cond: case en_fcall: case en_void: case en_assign: opt0(&(ep->p[0])); opt0(&(ep->p[1])); break; } }
void track_pointer(int root_x, int root_y) { if (frozen_pointer->action == ACTION_NONE) return; int16_t delta_x, delta_y, x = 0, y = 0, w = 1, h = 1; uint16_t width, height; pointer_action_t pac = frozen_pointer->action; monitor_t *m = frozen_pointer->monitor; desktop_t *d = frozen_pointer->desktop; node_t *n = frozen_pointer->node; client_t *c = frozen_pointer->client; xcb_window_t win = frozen_pointer->window; xcb_rectangle_t rect = frozen_pointer->rectangle; node_t *vertical_fence = frozen_pointer->vertical_fence; node_t *horizontal_fence = frozen_pointer->horizontal_fence; delta_x = root_x - frozen_pointer->position.x; delta_y = root_y - frozen_pointer->position.y; switch (pac) { case ACTION_MOVE: if (frozen_pointer->is_tiled) { xcb_window_t pwin = XCB_NONE; query_pointer(&pwin, NULL); if (pwin == win) return; coordinates_t loc; bool is_managed = (pwin == XCB_NONE ? false : locate_window(pwin, &loc)); if (is_managed && is_tiled(loc.node->client) && loc.monitor == m) { swap_nodes(m, d, n, m, d, loc.node); arrange(m, d); } else { if (is_managed && loc.monitor == m) { return; } else if (!is_managed) { xcb_point_t pt = (xcb_point_t) {root_x, root_y}; monitor_t *pmon = monitor_from_point(pt); if (pmon == NULL || pmon == m) { return; } else { loc.monitor = pmon; loc.desktop = pmon->desk; } } bool focused = (n == mon->desk->focus); transfer_node(m, d, n, loc.monitor, loc.desktop, loc.desktop->focus); if (focused) focus_node(loc.monitor, loc.desktop, n); frozen_pointer->monitor = loc.monitor; frozen_pointer->desktop = loc.desktop; } } else { x = rect.x + delta_x; y = rect.y + delta_y; window_move(win, x, y); c->floating_rectangle.x = x; c->floating_rectangle.y = y; xcb_point_t pt = (xcb_point_t) {root_x, root_y}; monitor_t *pmon = monitor_from_point(pt); if (pmon == NULL || pmon == m) return; bool focused = (n == mon->desk->focus); transfer_node(m, d, n, pmon, pmon->desk, pmon->desk->focus); if (focused) focus_node(pmon, pmon->desk, n); frozen_pointer->monitor = pmon; frozen_pointer->desktop = pmon->desk; } break; case ACTION_RESIZE_SIDE: case ACTION_RESIZE_CORNER: if (frozen_pointer->is_tiled) { if (vertical_fence != NULL) { double sr = frozen_pointer->vertical_ratio + (double) delta_x / vertical_fence->rectangle.width; sr = MAX(0, sr); sr = MIN(1, sr); vertical_fence->split_ratio = sr; } if (horizontal_fence != NULL) { double sr = frozen_pointer->horizontal_ratio + (double) delta_y / horizontal_fence->rectangle.height; sr = MAX(0, sr); sr = MIN(1, sr); horizontal_fence->split_ratio = sr; } arrange(mon, mon->desk); } else { if (pac == ACTION_RESIZE_SIDE) { switch (frozen_pointer->side) { case SIDE_TOP: x = rect.x; y = rect.y + delta_y; w = rect.width; h = rect.height - delta_y; break; case SIDE_RIGHT: x = rect.x; y = rect.y; w = rect.width + delta_x; h = rect.height; break; case SIDE_BOTTOM: x = rect.x; y = rect.y; w = rect.width; h = rect.height + delta_y; break; case SIDE_LEFT: x = rect.x + delta_x; y = rect.y; w = rect.width - delta_x; h = rect.height; break; } width = MAX(1, w); height = MAX(1, h); window_move_resize(win, x, y, width, height); c->floating_rectangle = (xcb_rectangle_t) {x, y, width, height}; window_draw_border(n, d->focus == n, mon == m); } else if (pac == ACTION_RESIZE_CORNER) { switch (frozen_pointer->corner) { case CORNER_TOP_LEFT: x = rect.x + delta_x; y = rect.y + delta_y; w = rect.width - delta_x; h = rect.height - delta_y; break; case CORNER_TOP_RIGHT: x = rect.x; y = rect.y + delta_y; w = rect.width + delta_x; h = rect.height - delta_y; break; case CORNER_BOTTOM_LEFT: x = rect.x + delta_x; y = rect.y; w = rect.width - delta_x; h = rect.height + delta_y; break; case CORNER_BOTTOM_RIGHT: x = rect.x; y = rect.y; w = rect.width + delta_x; h = rect.height + delta_y; break; } width = MAX(1, w); height = MAX(1, h); window_move_resize(win, x, y, width, height); c->floating_rectangle = (xcb_rectangle_t) {x, y, width, height}; window_draw_border(n, d->focus == n, mon == m); } } break; case ACTION_FOCUS: case ACTION_NONE: break; } }
/* * opt0 - delete useless expressions and combine constants. * * opt0 will delete expressions such as x + 0, x - 0, x * 0, * x * 1, 0 / x, x / 1, x mod 0, etc from the tree pointed to * by node and combine obvious constant operations. It cannot * combine name and label constants but will combine icon type * nodes. */ static void opt0(ENODE **node) { ENODE *ep; int64_t val, sc; ep = *node; if( ep == (ENODE *)NULL ) return; switch( (*node)->nodetype ) { case en_b_ref: case en_c_ref: case en_h_ref: case en_w_ref: /* optimize unary node */ case en_ub_ref: case en_uc_ref: case en_uh_ref: case en_uw_ref: /* optimize unary node */ case en_flt_ref: case en_dbl_ref: case en_cubw: case en_cucw: case en_cuhw: case en_cubu: case en_cucu: case en_cuhu: case en_cbu: case en_ccu: case en_chu: case en_cbc: case en_cbh: case en_cbw: case en_cch: case en_ccw: case en_chw: case en_ainc: case en_adec: opt0( &((*node)->p[0])); return; case en_compl: opt0( &(ep->p[0])); if( ep->p[0]->nodetype == en_icon ) { ep->nodetype = en_icon; ep->i = ~ep->p[0]->i; } return; case en_not: opt0( &(ep->p[0])); if( ep->p[0]->nodetype == en_icon ) { ep->nodetype = en_icon; ep->i = !ep->p[0]->i; } return; case en_uminus: opt0( &(ep->p[0])); if( ep->p[0]->nodetype == en_icon ) { ep->nodetype = en_icon; ep->i = -ep->p[0]->i; } return; case en_tempref: opt0( &(ep->p[0])); if( ep->p[0] && ep->p[0]->nodetype == en_icon ) { ep->nodetype = en_icon; ep->i = ep->p[0]->i; } return; case en_tempfpref: opt0( &(ep->p[0])); if( ep->p[0] && ep->p[0]->nodetype == en_fcon ) { ep->nodetype = en_fcon; ep->f = ep->p[0]->f; } return; case en_add: case en_sub: opt0(&(ep->p[0])); opt0(&(ep->p[1])); if( ep->p[0]->nodetype == en_icon ) { if( ep->p[1]->nodetype == en_icon ) { dooper(node); return; } if( ep->p[0]->i == 0 ) { if( ep->nodetype == en_sub ) { ep->p[0] = ep->p[1]; ep->nodetype = en_uminus; } else *node = ep->p[1]; return; } } else if( ep->p[1]->nodetype == en_icon ) { if( ep->p[1]->i == 0 ) { *node = ep->p[0]; return; } } return; case en_mul: case en_mulu: opt0(&(ep->p[0])); opt0(&(ep->p[1])); if( ep->p[0]->nodetype == en_icon ) { if( ep->p[1]->nodetype == en_icon ) { dooper(node); return; } val = ep->p[0]->i; if( val == 0 ) { *node = ep->p[0]; return; } if( val == 1 ) { *node = ep->p[1]; return; } sc = pwrof2(val); if( sc != -1 ) { swap_nodes(ep); ep->p[1]->i = sc; ep->nodetype = en_shl; } } else if( ep->p[1]->nodetype == en_icon ) { val = ep->p[1]->i; if( val == 0 ) { *node = ep->p[1]; return; } if( val == 1 ) { *node = ep->p[0]; return; } sc = pwrof2(val); if( sc != -1 ) { ep->p[1]->i = sc; ep->nodetype = en_shl; } } break; case en_div: case en_udiv: opt0(&(ep->p[0])); opt0(&(ep->p[1])); if( ep->p[0]->nodetype == en_icon ) { if( ep->p[1]->nodetype == en_icon ) { dooper(node); return; } if( ep->p[0]->i == 0 ) { /* 0/x */ *node = ep->p[0]; return; } } else if( ep->p[1]->nodetype == en_icon ) { val = ep->p[1]->i; if( val == 1 ) { /* x/1 */ *node = ep->p[0]; return; } sc = pwrof2(val); if( sc != -1 ) { ep->p[1]->i = sc; if ((*node)->nodetype == en_udiv) ep->nodetype = en_shru; else ep->nodetype = ep->p[0]->isUnsigned ? en_shru : en_shr; } } break; case en_mod: opt0(&(ep->p[0])); opt0(&(ep->p[1])); if( ep->p[1]->nodetype == en_icon ) { if( ep->p[0]->nodetype == en_icon ) { dooper(node); return; } sc = pwrof2(ep->p[1]->i); if( sc != -1 ) { ep->p[1]->i = mod_mask(sc); ep->nodetype = en_and; } } break; case en_and: case en_or: case en_xor: case en_shr: case en_shru: case en_asr: case en_shl: case en_shlu: opt0(&(ep->p[0])); opt0(&(ep->p[1])); if( ep->p[0]->nodetype == en_icon && ep->p[1]->nodetype == en_icon ) dooper(node); break; case en_land: opt0(&(ep->p[0])); opt0(&(ep->p[1])); if (ep->p[0]->nodetype==en_icon && ep->p[1]->nodetype==en_icon) { dooper(node); break; } break; case en_lor: opt0(&(ep->p[0])); opt0(&(ep->p[1])); if (ep->p[0]->nodetype==en_icon && ep->p[1]->nodetype==en_icon) { dooper(node); break; } break; case en_ult: case en_ule: case en_ugt: case en_uge: case en_lt: case en_le: case en_gt: case en_ge: case en_eq: case en_ne: opt0(&(ep->p[0])); opt0(&(ep->p[1])); if (ep->p[0]->nodetype==en_icon && ep->p[1]->nodetype==en_icon) dooper(node); break; case en_feq: case en_fne: case en_flt: case en_fle: case en_fgt: case en_fge: opt0(&(ep->p[0])); opt0(&(ep->p[1])); break; case en_cond: opt0(&(ep->p[0])); opt0(&(ep->p[1]->p[0])); opt0(&(ep->p[1]->p[1])); if ((ep->p[0]->nodetype==en_icon||ep->p[0]->nodetype==en_cnacon) && (ep->p[1]->p[0]->nodetype==en_icon || ep->p[1]->p[0]->nodetype==en_cnacon) && (ep->p[1]->p[1]->nodetype==en_icon || ep->p[1]->p[1]->nodetype==en_cnacon)) dooper(node); break; case en_chk: opt0(&(ep->p[0])); opt0(&(ep->p[1])); opt0(&(ep->p[2])); break; case en_asand: case en_asor: case en_asadd: case en_assub: case en_asmul: case en_asdiv: case en_asmod: case en_asrsh: case en_aslsh: case en_fcall: case en_void: opt0(&(ep->p[0])); opt0(&(ep->p[1])); break; case en_assign: opt0(&(ep->p[0])); opt0(&(ep->p[1])); break; } }
int main(){ List *list = (List*)0; int opt; int val; int k1,k2; do{ //loop printf("Select an operation:\n"); printf("1) Create a list\t2) Insert at front\n3) Insert at end\t4) Delete first"); printf("\n5) Delete last\t\t6) Display list\n7) Delete list\t\t8) Swap nodes\n9) Exit\n> "); scanf("%d",&opt); FLUSH_STDIN(); switch (opt){ case 1: //Create list if((create_list(list) == -1)) fprintf(stderr,"\nError: List already created\n"); else fprintf(stdout,"\nList successfully created\n"); break; case 2: //Insert front printf("Enter a value(integer) to insert: "); scanf("%d",&val); list = insert_front(list,val); err_check(); break; case 3: //Insert end printf("Enter a value(integer) to insert: "); scanf("%d",&val); list = insert_end(list,val); err_check(); break; case 4: //Delete first list = delete_front(list); err_check(); break; case 5: //Delete last list = delete_end(list); err_check(); break; case 6: //Display list if(display_list(list) <= 0) fprintf(stderr,"\nError: List is empty or not created. Cannot display.\n"); break; case 7: //Delete the whole list list = delete_list(list); if(list_err == LIST_DELETED) fprintf(stderr,"\nThe list has already been deleted or not even created.\n"); else printf("\nList delete successfully.\n"); break; case 8: //Swap printf("Enter key values of two nodes to be swapped: "); scanf("%d %d",&k1,&k2); list = swap_nodes(list,k1,k2); err_check(); break; case 9: //Exit break; default: //Invalid option fprintf(stderr,"\nError: Invalid option\n"); }//switch }while(opt != 9); return 0; }
bool move_client(coordinates_t *loc, int dx, int dy) { node_t *n = loc->node; if (n == NULL || n->client == NULL) { return false; } monitor_t *pm = NULL; if (IS_TILED(n->client)) { if (!grabbing) { return false; } xcb_window_t pwin = XCB_NONE; query_pointer(&pwin, NULL); if (pwin == n->id) { return false; } coordinates_t dst; bool is_managed = (pwin != XCB_NONE && locate_window(pwin, &dst)); if (is_managed && dst.monitor == loc->monitor && IS_TILED(dst.node->client)) { swap_nodes(loc->monitor, loc->desktop, n, loc->monitor, loc->desktop, dst.node); return true; } else { if (is_managed && dst.monitor == loc->monitor) { return false; } else { xcb_point_t pt = {0, 0}; query_pointer(NULL, &pt); pm = monitor_from_point(pt); } } } else { client_t *c = n->client; xcb_rectangle_t rect = c->floating_rectangle; int16_t x = rect.x + dx; int16_t y = rect.y + dy; if (focus_follows_pointer) { listen_enter_notify(loc->desktop->root, false); } window_move(n->id, x, y); if (focus_follows_pointer) { listen_enter_notify(loc->desktop->root, true); } c->floating_rectangle.x = x; c->floating_rectangle.y = y; if (!grabbing) { put_status(SBSC_MASK_NODE_GEOMETRY, "node_geometry 0x%08X 0x%08X 0x%08X %ux%u+%i+%i\n", loc->monitor->id, loc->desktop->id, loc->node->id, rect.width, rect.height, x, y); } pm = monitor_from_client(c); } if (pm == NULL || pm == loc->monitor) { return true; } bool focused = (n == mon->desk->focus); transfer_node(loc->monitor, loc->desktop, n, pm, pm->desk, pm->desk->focus); loc->monitor = pm; loc->desktop = pm->desk; if (focused) { focus_node(pm, pm->desk, n); } return true; }
/* * opt0 - delete useless expressions and combine constants. * * opt0 will delete expressions such as x + 0, x - 0, x * 0, * x * 1, 0 / x, x / 1, x mod 0, etc from the tree pointed to * by node and combine obvious constant operations. It cannot * combine name and label constants but will combine icon type * nodes. */ static void opt0(ENODE **node) { ENODE *ep; int sc; int64_t val; ep = *node; if( ep == (ENODE *)NULL ) return; switch( (*node)->nodetype ) { case en_vector_ref: case en_ref32: case en_ref32u: case en_b_ref: case en_c_ref: case en_h_ref: case en_w_ref: /* optimize unary node */ case en_ub_ref: case en_uc_ref: case en_uh_ref: case en_uw_ref: /* optimize unary node */ case en_flt_ref: case en_dbl_ref: case en_quad_ref: case en_wp_ref: case en_hp_ref: case en_ccwp: case en_cucwp: opt0(&((*node)->p[0])); return; case en_cubw: case en_cucw: case en_cuhw: case en_cubu: case en_cucu: case en_cuhu: case en_cbu: case en_ccu: case en_chu: case en_cbc: case en_cbh: case en_cbw: case en_cch: case en_ccw: case en_chw: opt0( &(ep->p[0])); if (ep->p[0]->nodetype == en_icon) { ep->nodetype = en_icon; ep->i = ep->p[0]->i; } return; case en_sxb: case en_sxc: case en_sxh: case en_zxb: case en_zxc: case en_zxh: case en_abs: opt0( &(ep->p[0])); if( ep->p[0]->nodetype == en_icon ) dooper(*node); return; case en_compl: opt0( &(ep->p[0])); if( ep->p[0]->nodetype == en_icon ) { ep->nodetype = en_icon; ep->i = ~ep->p[0]->i; } return; case en_not: opt0( &(ep->p[0])); if( ep->p[0]->nodetype == en_icon ) { ep->nodetype = en_icon; ep->i = !ep->p[0]->i; } return; case en_uminus: opt0( &(ep->p[0])); if( ep->p[0]->nodetype == en_icon ) { ep->nodetype = en_icon; ep->i = -ep->p[0]->i; } return; case en_tempref: opt0( &(ep->p[0])); if( ep->p[0] && ep->p[0]->nodetype == en_icon ) { ep->nodetype = en_icon; ep->i = ep->p[0]->i; } else if (ep->constflag) { ep->nodetype = en_icon; } return; case en_tempfpref: opt0( &(ep->p[0])); if( ep->p[0] && ep->p[0]->nodetype == en_fcon ) { ep->nodetype = en_fcon; ep->f = ep->p[0]->f; Float128::Assign(&ep->f128,&ep->p[0]->f128); } return; case en_vadd: case en_vsub: case en_add: case en_sub: opt0(&(ep->p[0])); opt0(&(ep->p[1])); if(ep->p[0]->nodetype == en_icon) { if(ep->p[1]->nodetype == en_icon) { dooper(*node); return; } if( ep->p[0]->i == 0 ) { if( ep->nodetype == en_sub ) { ep->p[0] = ep->p[1]; ep->nodetype = en_uminus; } else *node = ep->p[1]; return; } // Place the constant node second in the add to allow // use of immediate mode instructions. if (ep->nodetype==en_add) swap_nodes(ep); } // Add or subtract of zero gets eliminated. else if( ep->p[1]->nodetype == en_icon ) { if( ep->p[1]->i == 0 ) { *node = ep->p[0]; return; } } return; case en_ptrdif: opt0(&(ep->p[0])); opt0(&(ep->p[1])); opt0(&(ep->p[4])); if (ep->p[0]->nodetype == en_icon) { if (ep->p[1]->nodetype == en_icon && ep->p[4]->nodetype == en_icon) { dooper(*node); return; } } break; case en_i2d: opt0(&(ep->p[0])); if (ep->p[0]->nodetype == en_icon) { dooper(*node); return; } break; case en_d2i: opt0(&(ep->p[0])); if (ep->p[0]->nodetype == en_fcon) { ep->i = (long)ep->p[0]->f; ep->nodetype = en_icon; return; } break; case en_fadd: case en_fsub: opt0(&(ep->p[0])); opt0(&(ep->p[1])); if (ep->p[0]->nodetype == en_fcon) { if (ep->p[1]->nodetype == en_fcon) { dooper(*node); return; } } break; case en_fmul: opt0(&(ep->p[0])); opt0(&(ep->p[1])); if (ep->p[0]->nodetype == en_fcon) { if (ep->p[1]->nodetype == en_fcon) { dooper(*node); return; } //else if (ep->p[1]->nodetype == en_icon) { // ep->nodetype = en_fcon; // ep->f = ep->p[0]->f * ep->p[1]->i; // return; //} } //else if (ep->p[0]->nodetype == en_icon) { // if (ep->p[1]->nodetype == en_fcon) { // ep->nodetype = en_fcon; // ep->f = ep->p[0]->i * ep->p[1]->f; // return; // } //} break; case en_fdiv: opt0(&(ep->p[0])); opt0(&(ep->p[1])); if (ep->p[0]->nodetype == en_fcon) { if (ep->p[1]->nodetype == en_fcon) { dooper(*node); return; } //else if (ep->p[1]->nodetype == en_icon) { // ep->nodetype = en_fcon; // ep->f = ep->p[0]->f / ep->p[1]->i; // return; //} } break; case en_isnullptr: opt0(&(ep->p[0])); if (ep->p[0]->nodetype == en_icon) dooper(*node); return; case en_mulf: opt0(&(ep->p[0])); opt0(&(ep->p[1])); if (ep->p[0]->nodetype == en_icon && ep->p[1]->nodetype == en_icon) dooper(*node); return; case en_vmul: case en_vmuls: case en_mul: case en_mulu: opt0(&(ep->p[0])); opt0(&(ep->p[1])); if( ep->p[0]->nodetype == en_icon ) { if( ep->p[1]->nodetype == en_icon ) { dooper(*node); return; } if (ep->p[1]->nodetype == en_fcon) { ep->nodetype = en_icon; ep->i = ep->p[0]->i * ep->p[1]->f; return; } val = ep->p[0]->i; if( val == 0 ) { *node = ep->p[0]; return; } if( val == 1 ) { *node = ep->p[1]; return; } sc = pwrof2(val); if( sc != -1 ) { swap_nodes(ep); ep->p[1]->i = sc; ep->nodetype = en_shl; return; } // Place constant as oper2 swap_nodes(ep); } else if( ep->p[1]->nodetype == en_icon ) { val = ep->p[1]->i; if( val == 0 ) { *node = ep->p[1]; return; } if( val == 1 ) { *node = ep->p[0]; return; } sc = pwrof2(val); if( sc != -1 ) { ep->p[1]->i = sc; ep->nodetype = en_shl; return; } } break; case en_div: case en_udiv: opt0(&(ep->p[0])); opt0(&(ep->p[1])); if( ep->p[0]->nodetype == en_icon ) { if( ep->p[1]->nodetype == en_icon ) { dooper(*node); return; } if( ep->p[0]->i == 0 ) { /* 0/x */ *node = ep->p[0]; return; } } else if( ep->p[1]->nodetype == en_icon ) { val = ep->p[1]->i; if( val == 1 ) { /* x/1 */ *node = ep->p[0]; return; } sc = pwrof2(val); if( sc != -1 ) { ep->p[1]->i = sc; if ((*node)->nodetype == en_udiv) ep->nodetype = en_shru; else ep->nodetype = ep->p[0]->isUnsigned ? en_shru : en_shr; } } break; case en_mod: opt0(&(ep->p[0])); opt0(&(ep->p[1])); if( ep->p[1]->nodetype == en_icon ) { if( ep->p[0]->nodetype == en_icon ) { dooper(*node); return; } sc = pwrof2(ep->p[1]->i); if( sc != -1 ) { ep->p[1]->i = mod_mask(sc); ep->nodetype = en_and; } } break; case en_and: case en_or: case en_xor: opt0(&(ep->p[0])); opt0(&(ep->p[1])); if (ep->p[0]->nodetype == en_icon && ep->p[1]->nodetype == en_icon) dooper(*node); else if (ep->p[0]->nodetype == en_icon) swap_nodes(ep); break; case en_shr: case en_shru: case en_asr: case en_asl: case en_shl: case en_shlu: opt0(&(ep->p[0])); opt0(&(ep->p[1])); if( ep->p[0]->nodetype == en_icon && ep->p[1]->nodetype == en_icon ) dooper(*node); // Shift by zero.... else if( ep->p[1]->nodetype == en_icon ) { if( ep->p[1]->i == 0 ) { *node = ep->p[0]; return; } } break; case en_land_safe: case en_land: opt0(&(ep->p[0])); opt0(&(ep->p[1])); if (ep->p[0]->nodetype==en_icon && ep->p[1]->nodetype==en_icon) dooper(*node); break; case en_lor_safe: case en_lor: opt0(&(ep->p[0])); opt0(&(ep->p[1])); if (ep->p[0]->nodetype==en_icon && ep->p[1]->nodetype==en_icon) dooper(*node); break; case en_ult: case en_ule: case en_ugt: case en_uge: case en_lt: case en_le: case en_gt: case en_ge: case en_eq: case en_ne: opt0(&(ep->p[0])); opt0(&(ep->p[1])); if (ep->p[0]->nodetype==en_icon && ep->p[1]->nodetype==en_icon) dooper(*node); break; case en_feq: case en_fne: case en_flt: case en_fle: case en_fgt: case en_fge: opt0(&(ep->p[0])); opt0(&(ep->p[1])); if (ep->p[0]->nodetype == en_fcon && ep->p[1]->nodetype == en_fcon) dooper(*node); break; case en_veq: case en_vne: case en_vlt: case en_vle: case en_vgt: case en_vge: opt0(&(ep->p[0])); opt0(&(ep->p[1])); break; case en_safe_cond: case en_cond: opt0(&(ep->p[0])); opt0(&(ep->p[1]->p[0])); opt0(&(ep->p[1]->p[1])); if ((ep->p[0]->nodetype==en_icon||ep->p[0]->nodetype==en_cnacon) && (ep->p[1]->p[0]->nodetype==en_icon || ep->p[1]->p[0]->nodetype==en_cnacon) && (ep->p[1]->p[1]->nodetype==en_icon || ep->p[1]->p[1]->nodetype==en_cnacon)) dooper(*node); break; case en_chk: opt0(&(ep->p[0])); opt0(&(ep->p[1])); opt0(&(ep->p[2])); break; case en_asand: case en_asor: case en_asadd: case en_assub: case en_asmul: case en_asdiv: case en_asmod: case en_asrsh: case en_aslsh: case en_fcall: opt0(&(ep->p[0])); opt0(&(ep->p[1])); break; case en_assign: opt0(&(ep->p[0])); opt0(&(ep->p[1])); break; // en_tempref comes from typecasting case en_void: opt0(&(ep->p[0])); opt0(&(ep->p[1])); if (ep->p[0]->nodetype == en_tempref) { (*node)->nodetype = ep->p[1]->nodetype; *node = ep->p[1]; } break; case en_addrof: opt0(&(ep->p[0])); break; case en_list: for (ep = ep->p[2]; ep; ep = ep->p[2]) opt0(&(ep->p[0])); break; } }
void iterate_node_3(node_t *node) { int action; action = get_action_3(node); switch (action) { case 0: node->link_1->value = node->value; case 9: connect_nodes(node, node->link_0, node->link_1); swap_nodes(node, node->link_2); break; case 1: node->link_2->value = node->value; case 10: connect_nodes(node, node->link_1, node->link_2); swap_nodes(node, node->link_0); break; case 2: node->link_0->value = node->value; case 11: connect_nodes(node, node->link_2, node->link_0); swap_nodes(node, node->link_1); break; case 3: disconnect_nodes(node, node->link_0); case 12: swap_nodes(node, node->link_0); break; case 4: disconnect_nodes(node, node->link_1); case 13: swap_nodes(node, node->link_1); break; case 5: disconnect_nodes(node, node->link_2); case 14: swap_nodes(node, node->link_2); break; case 6: case 15: swap_values(node, node->link_0); break; case 7: swap_values(node, node->link_1); break; case 8: swap_values(node, node->link_2); break; } /* node->value = 0; node->value = 1; invert_value(node); disconnect_nodes(node, node->link_0); disconnect_nodes(node, node->link_1); disconnect_nodes(node, node->link_2); connect_nodes(node, node->link_0, node->link_1); connect_nodes(node, node->link_1, node->link_2); connect_nodes(node, node->link_2, node->link_0); swap_values(node, node->link_0); swap_values(node, node->link_1); swap_values(node, node->link_2); node->link_0->value = node->value; node->link_0->value = 0; node->link_0->value = 1; node->link_0->value = inverted_value(node); node->link_1->value = node->value; node->link_1->value = 0; node->link_1->value = 1; node->link_1->value = inverted_value(node); node->link_2->value = node->value; node->link_2->value = 0; node->link_2->value = 1; node->link_2->value = inverted_value(node); swap_nodes(node, node->link_0); swap_nodes(node, node->link_1); swap_nodes(node, node->link_2); */ }