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