gcc/typed-splay-tree.h

   1 /* A typesafe wrapper around libiberty's splay-tree.h.
   2    Copyright (C) 2015-2020 Free Software Foundation, Inc.
   3
   4 This file is part of GCC.
   5
   6 GCC is free software; you can redistribute it and/or modify it under
   7 the terms of the GNU General Public License as published by the Free
   8 Software Foundation; either version 3, or (at your option) any later
   9 version.
  10
  11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14 for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GCC; see the file COPYING3.  If not see
  18 <http://www.gnu.org/licenses/>.  */
  19
  20 #ifndef GCC_TYPED_SPLAY_TREE_H
  21 #define GCC_TYPED_SPLAY_TREE_H
  22
  23 /* Typesafe wrapper around libiberty's splay-tree.h.  */
  24 template <typename KEY_TYPE, typename VALUE_TYPE>
  25 class typed_splay_tree
  26 {
  27  public:
  28   typedef KEY_TYPE key_type;
  29   typedef VALUE_TYPE value_type;
  30
  31   typedef int (*compare_fn) (key_type, key_type);
  32   typedef void (*delete_key_fn) (key_type);
  33   typedef void (*delete_value_fn) (value_type);
  34   typedef int (*foreach_fn) (key_type, value_type, void *);
  35
  36   typed_splay_tree (compare_fn,
  37                     delete_key_fn,
  38                     delete_value_fn);
  39   ~typed_splay_tree ();
  40
  41   value_type lookup (key_type k);
  42   value_type predecessor (key_type k);
  43   value_type successor (key_type k);
  44   void insert (key_type k, value_type v);
  45   void remove (key_type k);
  46   value_type max ();
  47   value_type min ();
  48   int foreach (foreach_fn, void *);
  49
  50  private:
  51   /* Copy and assignment ops are not supported.  */
  52   typed_splay_tree (const typed_splay_tree &);
  53   typed_splay_tree & operator = (const typed_splay_tree &);
  54
  55   typedef key_type splay_tree_key;
  56   typedef value_type splay_tree_value;
  57
  58   /* The nodes in the splay tree.  */
  59   struct splay_tree_node_s {
  60     /* The key.  */
  61     splay_tree_key key;
  62
  63     /* The value.  */
  64     splay_tree_value value;
  65
  66     /* The left and right children, respectively.  */
  67     splay_tree_node_s *left, *right;
  68
  69     /* Used as temporary value for tree traversals.  */
  70     splay_tree_node_s *back;
  71   };
  72   typedef splay_tree_node_s *splay_tree_node;
  73
  74   inline void KDEL (splay_tree_key);
  75   inline void VDEL (splay_tree_value);
  76   void splay_tree_delete_helper (splay_tree_node);
  77   static inline void rotate_left (splay_tree_node *,
  78                                   splay_tree_node, splay_tree_node);
  79   static inline void rotate_right (splay_tree_node *,
  80                                    splay_tree_node, splay_tree_node);
  81   void splay_tree_splay (splay_tree_key);
  82   static int splay_tree_foreach_helper (splay_tree_node,
  83                                         foreach_fn, void*);
  84   splay_tree_node splay_tree_insert (splay_tree_key, splay_tree_value);
  85   void splay_tree_remove (splay_tree_key key);
  86   splay_tree_node splay_tree_lookup (splay_tree_key key);
  87   splay_tree_node splay_tree_predecessor (splay_tree_key);
  88   splay_tree_node splay_tree_successor (splay_tree_key);
  89   splay_tree_node splay_tree_max ();
  90   splay_tree_node splay_tree_min ();
  91
  92   static value_type node_to_value (splay_tree_node node);
  93
  94   /* The root of the tree.  */
  95   splay_tree_node root;
  96
  97   /* The comparision function.  */
  98   compare_fn comp;
  99
 100   /* The deallocate-key function.  NULL if no cleanup is necessary.  */
 101   delete_key_fn delete_key;
 102
 103   /* The deallocate-value function.  NULL if no cleanup is necessary.  */
 104   delete_value_fn delete_value;
 105 };
 106
 107 /* Constructor for typed_splay_tree <K, V>.  */
 108
 109 template <typename KEY_TYPE, typename VALUE_TYPE>
 110 inline typed_splay_tree<KEY_TYPE, VALUE_TYPE>::
 111   typed_splay_tree (compare_fn compare_fn,
 112                     delete_key_fn delete_key_fn,
 113                     delete_value_fn delete_value_fn)
 114 {
 115   root = NULL;
 116   comp = compare_fn;
 117   delete_key = delete_key_fn;
 118   delete_value = delete_value_fn;
 119 }
 120
 121 /* Destructor for typed_splay_tree <K, V>.  */
 122
 123 template <typename KEY_TYPE, typename VALUE_TYPE>
 124 inline typed_splay_tree<KEY_TYPE, VALUE_TYPE>::
 125   ~typed_splay_tree ()
 126 {
 127   splay_tree_delete_helper (root);
 128 }
 129
 130 /* Lookup KEY, returning a value if present, and NULL
 131    otherwise.  */
 132
 133 template <typename KEY_TYPE, typename VALUE_TYPE>
 134 inline VALUE_TYPE
 135 typed_splay_tree<KEY_TYPE, VALUE_TYPE>::lookup (key_type key)
 136 {
 137   splay_tree_node node = splay_tree_lookup (key);
 138   return node_to_value (node);
 139 }
 140
 141 /* Return the immediate predecessor of KEY, or NULL if there is no
 142    predecessor.  KEY need not be present in the tree.  */
 143
 144 template <typename KEY_TYPE, typename VALUE_TYPE>
 145 inline VALUE_TYPE
 146 typed_splay_tree<KEY_TYPE, VALUE_TYPE>::predecessor (key_type key)
 147 {
 148   splay_tree_node node = splay_tree_predecessor (key);
 149   return node_to_value (node);
 150 }
 151
 152 /* Return the immediate successor of KEY, or NULL if there is no
 153    successor.  KEY need not be present in the tree.  */
 154
 155 template <typename KEY_TYPE, typename VALUE_TYPE>
 156 inline VALUE_TYPE
 157 typed_splay_tree<KEY_TYPE, VALUE_TYPE>::successor (key_type key)
 158 {
 159   splay_tree_node node = splay_tree_successor (key);
 160   return node_to_value (node);
 161 }
 162
 163 /* Insert a new node (associating KEY with VALUE).  If a
 164    previous node with the indicated KEY exists, its data is replaced
 165    with the new value.  */
 166
 167 template <typename KEY_TYPE, typename VALUE_TYPE>
 168 inline void
 169 typed_splay_tree<KEY_TYPE, VALUE_TYPE>::insert (key_type key,
 170                                                 value_type value)
 171 {
 172   splay_tree_insert (key, value);
 173 }
 174
 175 /* Remove a node (associating KEY with VALUE).  */
 176
 177 template <typename KEY_TYPE, typename VALUE_TYPE>
 178 inline void
 179 typed_splay_tree<KEY_TYPE, VALUE_TYPE>::remove (key_type key)
 180 {
 181   splay_tree_remove (key);
 182 }
 183
 184 /* Get the value with maximal key.  */
 185
 186 template <typename KEY_TYPE, typename VALUE_TYPE>
 187 inline VALUE_TYPE
 188 typed_splay_tree<KEY_TYPE, VALUE_TYPE>::max ()
 189 {
 190   return node_to_value (splay_tree_max ());
 191 }
 192
 193 /* Get the value with minimal key.  */
 194
 195 template <typename KEY_TYPE, typename VALUE_TYPE>
 196 inline VALUE_TYPE
 197 typed_splay_tree<KEY_TYPE, VALUE_TYPE>::min ()
 198 {
 199   return node_to_value (splay_tree_min ());
 200 }
 201
 202 /* Call OUTER_CB, passing it the OUTER_USER_DATA, for every node,
 203    following an in-order traversal.  If OUTER_CB ever returns a non-zero
 204    value, the iteration ceases immediately, and the value is returned.
 205    Otherwise, this function returns 0.  */
 206
 207 template <typename KEY_TYPE, typename VALUE_TYPE>
 208 inline int
 209 typed_splay_tree<KEY_TYPE, VALUE_TYPE>::foreach (foreach_fn foreach_fn,
 210                                                  void *user_data)
 211 {
 212   return splay_tree_foreach_helper (root, foreach_fn, user_data);
 213 }
 214
 215 /* Internal function for converting from splay_tree_node to
 216    VALUE_TYPE.  */
 217 template <typename KEY_TYPE, typename VALUE_TYPE>
 218 inline VALUE_TYPE
 219 typed_splay_tree<KEY_TYPE, VALUE_TYPE>::node_to_value (splay_tree_node node)
 220 {
 221   if (node)
 222     return node->value;
 223   else
 224     return 0;
 225 }
 226
 227 template <typename KEY_TYPE, typename VALUE_TYPE>
 228 inline void
 229 typed_splay_tree<KEY_TYPE, VALUE_TYPE>::KDEL(splay_tree_key x)
 230 {
 231   if (delete_key)
 232     (*delete_key)(x);
 233 }
 234
 235 template <typename KEY_TYPE, typename VALUE_TYPE>
 236 inline void
 237 typed_splay_tree<KEY_TYPE, VALUE_TYPE>::VDEL(splay_tree_value x)
 238 {
 239   if (delete_value)
 240     (*delete_value)(x);
 241 }
 242
 243 /* Deallocate NODE (a member of SP), and all its sub-trees.  */
 244
 245 template <typename KEY_TYPE, typename VALUE_TYPE>
 246 void
 247 typed_splay_tree<KEY_TYPE,
 248                  VALUE_TYPE>::splay_tree_delete_helper (splay_tree_node node)
 249 {
 250   splay_tree_node pending = NULL;
 251   splay_tree_node active = NULL;
 252
 253   if (!node)
 254     return;
 255
 256   KDEL (node->key);
 257   VDEL (node->value);
 258
 259   /* We use the "back" field to hold the "next" pointer.  */
 260   node->back = pending;
 261   pending = node;
 262
 263   /* Now, keep processing the pending list until there aren't any
 264      more.  This is a little more complicated than just recursing, but
 265      it doesn't toast the stack for large trees.  */
 266
 267   while (pending)
 268     {
 269       active = pending;
 270       pending = NULL;
 271       while (active)
 272         {
 273           splay_tree_node temp;
 274
 275           /* active points to a node which has its key and value
 276              deallocated, we just need to process left and right.  */
 277
 278           if (active->left)
 279             {
 280               KDEL (active->left->key);
 281               VDEL (active->left->value);
 282               active->left->back = pending;
 283               pending = active->left;
 284             }
 285           if (active->right)
 286             {
 287               KDEL (active->right->key);
 288               VDEL (active->right->value);
 289               active->right->back = pending;
 290               pending = active->right;
 291             }
 292
 293           temp = active;
 294           active = temp->back;
 295           delete temp;
 296         }
 297     }
 298 }
 299
 300 /* Rotate the edge joining the left child N with its parent P.  PP is the
 301    grandparents' pointer to P.  */
 302
 303 template <typename KEY_TYPE, typename VALUE_TYPE>
 304 inline void
 305 typed_splay_tree<KEY_TYPE, VALUE_TYPE>::rotate_left (splay_tree_node *pp,
 306                                                      splay_tree_node p,
 307                                                      splay_tree_node n)
 308 {
 309   splay_tree_node tmp;
 310   tmp = n->right;
 311   n->right = p;
 312   p->left = tmp;
 313   *pp = n;
 314 }
 315
 316 /* Rotate the edge joining the right child N with its parent P.  PP is the
 317    grandparents' pointer to P.  */
 318
 319 template <typename KEY_TYPE, typename VALUE_TYPE>
 320 inline void
 321 typed_splay_tree<KEY_TYPE, VALUE_TYPE>::rotate_right (splay_tree_node *pp,
 322                                                       splay_tree_node p,
 323                                                       splay_tree_node n)
 324 {
 325   splay_tree_node tmp;
 326   tmp = n->left;
 327   n->left = p;
 328   p->right = tmp;
 329   *pp = n;
 330 }
 331
 332 /* Bottom up splay of key.  */
 333
 334 template <typename KEY_TYPE, typename VALUE_TYPE>
 335 void
 336 typed_splay_tree<KEY_TYPE, VALUE_TYPE>::splay_tree_splay (splay_tree_key key)
 337 {
 338   if (root == NULL)
 339     return;
 340
 341   do {
 342     int cmp1, cmp2;
 343     splay_tree_node n, c;
 344
 345     n = root;
 346     cmp1 = (*comp) (key, n->key);
 347
 348     /* Found.  */
 349     if (cmp1 == 0)
 350       return;
 351
 352     /* Left or right?  If no child, then we're done.  */
 353     if (cmp1 < 0)
 354       c = n->left;
 355     else
 356       c = n->right;
 357     if (!c)
 358       return;
 359
 360     /* Next one left or right?  If found or no child, we're done
 361        after one rotation.  */
 362     cmp2 = (*comp) (key, c->key);
 363     if (cmp2 == 0
 364         || (cmp2 < 0 && !c->left)
 365         || (cmp2 > 0 && !c->right))
 366       {
 367         if (cmp1 < 0)
 368           rotate_left (&root, n, c);
 369         else
 370           rotate_right (&root, n, c);
 371         return;
 372       }
 373
 374     /* Now we have the four cases of double-rotation.  */
 375     if (cmp1 < 0 && cmp2 < 0)
 376       {
 377         rotate_left (&n->left, c, c->left);
 378         rotate_left (&root, n, n->left);
 379       }
 380     else if (cmp1 > 0 && cmp2 > 0)
 381       {
 382         rotate_right (&n->right, c, c->right);
 383         rotate_right (&root, n, n->right);
 384       }
 385     else if (cmp1 < 0 && cmp2 > 0)
 386       {
 387         rotate_right (&n->left, c, c->right);
 388         rotate_left (&root, n, n->left);
 389       }
 390     else if (cmp1 > 0 && cmp2 < 0)
 391       {
 392         rotate_left (&n->right, c, c->left);
 393         rotate_right (&root, n, n->right);
 394       }
 395   } while (1);
 396 }
 397
 398 /* Call FN, passing it the DATA, for every node below NODE, all of
 399    which are from SP, following an in-order traversal.  If FN every
 400    returns a non-zero value, the iteration ceases immediately, and the
 401    value is returned.  Otherwise, this function returns 0.  */
 402
 403 template <typename KEY_TYPE, typename VALUE_TYPE>
 404 int
 405 typed_splay_tree<KEY_TYPE, VALUE_TYPE>::splay_tree_foreach_helper (
 406                                                 splay_tree_node node,
 407                                                 foreach_fn fn, void *data)
 408 {
 409   int val;
 410   splay_tree_node stack;
 411
 412   /* A non-recursive implementation is used to avoid filling the stack
 413      for large trees.  Splay trees are worst case O(n) in the depth of
 414      the tree.  */
 415
 416   stack = NULL;
 417   val = 0;
 418
 419   for (;;)
 420     {
 421       while (node != NULL)
 422         {
 423           node->back = stack;
 424           stack = node;
 425           node = node->left;
 426         }
 427
 428       if (stack == NULL)
 429         break;
 430
 431       node = stack;
 432       stack = stack->back;
 433
 434       val = (*fn) (node->key, node->value, data);
 435       if (val)
 436         break;
 437
 438       node = node->right;
 439     }
 440
 441   return val;
 442 }
 443
 444 /* Insert a new node (associating KEY with DATA) into SP.  If a
 445    previous node with the indicated KEY exists, its data is replaced
 446    with the new value.  Returns the new node.  */
 447
 448 template <typename KEY_TYPE, typename VALUE_TYPE>
 449 typename typed_splay_tree<KEY_TYPE, VALUE_TYPE>::splay_tree_node
 450 typed_splay_tree<KEY_TYPE, VALUE_TYPE>::splay_tree_insert (
 451                                                 splay_tree_key key,
 452                                                 splay_tree_value value)
 453 {
 454   int comparison = 0;
 455
 456   splay_tree_splay (key);
 457
 458   if (root)
 459     comparison = (*comp)(root->key, key);
 460
 461   if (root && comparison == 0)
 462     {
 463       /* If the root of the tree already has the indicated KEY, just
 464          replace the value with VALUE.  */
 465       VDEL(root->value);
 466       root->value = value;
 467     }
 468   else
 469     {
 470       /* Create a new node, and insert it at the root.  */
 471       splay_tree_node node;
 472
 473       node = new splay_tree_node_s;
 474       node->key = key;
 475       node->value = value;
 476
 477       if (!root)
 478         node->left = node->right = 0;
 479       else if (comparison < 0)
 480         {
 481           node->left = root;
 482           node->right = node->left->right;
 483           node->left->right = 0;
 484         }
 485       else
 486         {
 487           node->right = root;
 488           node->left = node->right->left;
 489           node->right->left = 0;
 490         }
 491
 492       root = node;
 493     }
 494
 495   return root;
 496 }
 497
 498 /* Remove KEY from SP.  It is not an error if it did not exist.  */
 499
 500 template <typename KEY_TYPE, typename VALUE_TYPE>
 501 void
 502 typed_splay_tree<KEY_TYPE, VALUE_TYPE>::splay_tree_remove (splay_tree_key key)
 503 {
 504   splay_tree_splay (key);
 505
 506   if (root && (*comp) (root->key, key) == 0)
 507     {
 508       splay_tree_node left, right;
 509
 510       left = root->left;
 511       right = root->right;
 512
 513       /* Delete the root node itself.  */
 514       VDEL (root->value);
 515       delete root;
 516
 517       /* One of the children is now the root.  Doesn't matter much
 518          which, so long as we preserve the properties of the tree.  */
 519       if (left)
 520         {
 521           root = left;
 522
 523           /* If there was a right child as well, hang it off the
 524              right-most leaf of the left child.  */
 525           if (right)
 526             {
 527               while (left->right)
 528                 left = left->right;
 529               left->right = right;
 530             }
 531         }
 532       else
 533         root = right;
 534     }
 535 }
 536
 537 /* Lookup KEY in SP, returning VALUE if present, and NULL
 538    otherwise.  */
 539
 540 template <typename KEY_TYPE, typename VALUE_TYPE>
 541 typename typed_splay_tree<KEY_TYPE, VALUE_TYPE>::splay_tree_node
 542 typed_splay_tree<KEY_TYPE, VALUE_TYPE>::splay_tree_lookup (splay_tree_key key)
 543 {
 544   splay_tree_splay (key);
 545
 546   if (root && (*comp)(root->key, key) == 0)
 547     return root;
 548   else
 549     return 0;
 550 }
 551
 552 /* Return the node in SP with the greatest key.  */
 553
 554 template <typename KEY_TYPE, typename VALUE_TYPE>
 555 typename typed_splay_tree<KEY_TYPE, VALUE_TYPE>::splay_tree_node
 556 typed_splay_tree<KEY_TYPE, VALUE_TYPE>::splay_tree_max ()
 557 {
 558   splay_tree_node n = root;
 559
 560   if (!n)
 561     return NULL;
 562
 563   while (n->right)
 564     n = n->right;
 565
 566   return n;
 567 }
 568
 569 /* Return the node in SP with the smallest key.  */
 570
 571 template <typename KEY_TYPE, typename VALUE_TYPE>
 572 typename typed_splay_tree<KEY_TYPE, VALUE_TYPE>::splay_tree_node
 573 typed_splay_tree<KEY_TYPE, VALUE_TYPE>::splay_tree_min ()
 574 {
 575   splay_tree_node n = root;
 576
 577   if (!n)
 578     return NULL;
 579
 580   while (n->left)
 581     n = n->left;
 582
 583   return n;
 584 }
 585
 586 /* Return the immediate predecessor KEY, or NULL if there is no
 587    predecessor.  KEY need not be present in the tree.  */
 588
 589 template <typename KEY_TYPE, typename VALUE_TYPE>
 590 typename typed_splay_tree<KEY_TYPE, VALUE_TYPE>::splay_tree_node
 591 typed_splay_tree<KEY_TYPE,
 592                  VALUE_TYPE>::splay_tree_predecessor (splay_tree_key key)
 593 {
 594   int comparison;
 595   splay_tree_node node;
 596
 597   /* If the tree is empty, there is certainly no predecessor.  */
 598   if (!root)
 599     return NULL;
 600
 601   /* Splay the tree around KEY.  That will leave either the KEY
 602      itself, its predecessor, or its successor at the root.  */
 603   splay_tree_splay (key);
 604   comparison = (*comp)(root->key, key);
 605
 606   /* If the predecessor is at the root, just return it.  */
 607   if (comparison < 0)
 608     return root;
 609
 610   /* Otherwise, find the rightmost element of the left subtree.  */
 611   node = root->left;
 612   if (node)
 613     while (node->right)
 614       node = node->right;
 615
 616   return node;
 617 }
 618
 619 /* Return the immediate successor KEY, or NULL if there is no
 620    successor.  KEY need not be present in the tree.  */
 621
 622 template <typename KEY_TYPE, typename VALUE_TYPE>
 623 typename typed_splay_tree<KEY_TYPE, VALUE_TYPE>::splay_tree_node
 624 typed_splay_tree<KEY_TYPE,
 625                  VALUE_TYPE>::splay_tree_successor (splay_tree_key key)
 626 {
 627   int comparison;
 628   splay_tree_node node;
 629
 630   /* If the tree is empty, there is certainly no successor.  */
 631   if (!root)
 632     return NULL;
 633
 634   /* Splay the tree around KEY.  That will leave either the KEY
 635      itself, its predecessor, or its successor at the root.  */
 636   splay_tree_splay (key);
 637   comparison = (*comp)(root->key, key);
 638
 639   /* If the successor is at the root, just return it.  */
 640   if (comparison > 0)
 641     return root;
 642
 643   /* Otherwise, find the leftmost element of the right subtree.  */
 644   node = root->right;
 645   if (node)
 646     while (node->left)
 647       node = node->left;
 648
 649   return node;
 650 }
 651
 652 #endif  /* GCC_TYPED_SPLAY_TREE_H  */