Lines Matching refs:right
52 #define right dict_right
78 * its right child C are rearranged so that the P instead becomes the left
79 * child of C. The left subtree of C is inherited as the new right subtree
87 lower = upper->right;
88 upper->right = lowleft = lower->left;
99 assert (upper == upparent->right);
100 upparent->right = lower;
109 * the same procedure, but with left and right interchanged.
117 upper->left = lowright = lower->right;
122 if (upper == upparent->right) {
123 upparent->right = lower;
129 lower->right = upper;
143 free_nodes(dict, node->right, nil);
184 * be computed recursively and compared for left and right siblings for
197 height_right = verify_redblack(nil, root->right);
205 if (root->right->color != dnode_black)
228 + verify_node_count(nil, root->right);
244 || verify_dict_has_node(nil, root->right, node);
267 new->nilnode.right = &new->nilnode;
315 dict->nilnode.right = &dict->nilnode;
344 dict->nilnode.right = &dict->nilnode;
365 dict->nilnode.right = &dict->nilnode;
381 dict->nilnode.right = &dict->nilnode;
404 if (nil->right != nil)
426 int dict_similar(const dict_t *left, const dict_t *right)
428 if (left->compare != right->compare)
431 if (left->allocnode != right->allocnode)
434 if (left->freenode != right->freenode)
437 if (left->context != right->context)
440 if (left->dupes != right->dupes)
468 root = root->right;
477 root = root->right;
503 root = root->right;
538 root = root->right;
544 root = root->right;
583 where = where->right;
591 parent->right = node;
595 node->right = nil;
606 uncle = grandpa->right;
614 if (node == parent->right) {
625 right */
670 * successor (i.e. the leftmost node in the right subtree.) By doing this,
680 if (delete->left != nil && delete->right != nil) {
691 * moving up its right child into its place.
694 child = next->right;
700 assert (nextparent->right == next);
701 nextparent->right = child;
711 next->right = delete->right;
713 next->right->parent = next;
720 assert (delparent->right == delete);
721 delparent->right = next;
726 assert (delete->left == nil || delete->right == nil);
728 child = (delete->left != nil) ? delete->left : delete->right;
735 assert (delete == delparent->right);
736 delparent->right = child;
741 delete->right = NULL;
758 sister = parent->right;
764 sister = parent->right;
768 && sister->right->color == dnode_black) {
772 if (sister->right->color == dnode_black) {
777 sister = parent->right;
781 sister->right->color = dnode_black;
786 } else { /* symmetric case: child == child->parent->right */
787 assert (child == parent->right);
797 if (sister->right->color == dnode_black
803 assert (sister->right->color == dnode_red);
804 sister->right->color = dnode_black;
877 dnode_t *nil = dict_nil(dict), *root = dict_root(dict), *right;
880 while ((right = root->right) != nil)
881 root = right;
888 * next key in the the left to right ordering. If the node has
897 if (curr->right != nil) {
898 curr = curr->right;
906 while (parent != nil && curr == parent->right) {
921 dnode_t *nil = dict_nil(dict), *parent, *right;
925 while ((right = curr->right) != nil)
926 curr = right;
989 new->right = NULL;
999 dnode->right = NULL;
1027 return (dnode->parent && dnode->left && dnode->right);
1048 load->nilnode.right = &load->nilnode;
1075 nil->right->left = newnode;
1076 nil->right = newnode;
1109 complete->right = dictnil;
1111 tree[level]->right = complete;
1121 curr->right = dictnil;
1127 tree[level]->right = complete;
1147 tree[i]->right = complete;
1154 dictnil->right = dictnil;
