Changes to gnats/libiberty/splay-tree.c

[Milan Zamazal]

Index: gnats/libiberty/splay-tree.c
diff -c gnats/libiberty/splay-tree.c:1.1 gnats/libiberty/splay-tree.c:1.2
*** gnats/libiberty/splay-tree.c:1.1    Tue Oct 26 03:10:16 1999
--- gnats/libiberty/splay-tree.c        Mon Dec 10 18:03:26 2001
***************
*** 1,5 ****
  /* A splay-tree datatype.  
!    Copyright (C) 1998 Free Software Foundation, Inc.
     Contributed by Mark Mitchell (address@hidden).
  
  This file is part of GNU CC.
--- 1,5 ----
  /* A splay-tree datatype.  
!    Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
     Contributed by Mark Mitchell (address@hidden).
  
  This file is part of GNU CC.
***************
*** 32,37 ****
--- 32,39 ----
  #include <stdlib.h>
  #endif
  
+ #include <stdio.h>
+ 
  #include "libiberty.h"
  #include "splay-tree.h"
  
***************
*** 235,241 ****
       splay_tree_delete_key_fn delete_key_fn;
       splay_tree_delete_value_fn delete_value_fn;
  {
!   splay_tree sp = (splay_tree) xmalloc (sizeof (struct splay_tree));
    sp->root = 0;
    sp->comp = compare_fn;
    sp->delete_key = delete_key_fn;
--- 237,243 ----
       splay_tree_delete_key_fn delete_key_fn;
       splay_tree_delete_value_fn delete_value_fn;
  {
!   splay_tree sp = (splay_tree) xmalloc (sizeof (struct splay_tree_s));
    sp->root = 0;
    sp->comp = compare_fn;
    sp->delete_key = delete_key_fn;
***************
*** 256,270 ****
  
  /* Insert a new node (associating KEY with DATA) into SP.  If a
     previous node with the indicated KEY exists, its data is replaced
!    with the new value.  */
  
! void 
  splay_tree_insert (sp, key, value)
       splay_tree sp;
       splay_tree_key key;
       splay_tree_value value;
  {
!   int comparison;
  
    splay_tree_splay (sp, key);
  
--- 258,272 ----
  
  /* Insert a new node (associating KEY with DATA) into SP.  If a
     previous node with the indicated KEY exists, its data is replaced
!    with the new value.  Returns the new node.  */
  
! splay_tree_node
  splay_tree_insert (sp, key, value)
       splay_tree sp;
       splay_tree_key key;
       splay_tree_value value;
  {
!   int comparison = 0;
  
    splay_tree_splay (sp, key);
  
***************
*** 284,290 ****
        /* Create a new node, and insert it at the root.  */
        splay_tree_node node;
        
!       node = (splay_tree_node) xmalloc (sizeof (struct splay_tree_node));
        node->key = key;
        node->value = value;
        
--- 286,292 ----
        /* Create a new node, and insert it at the root.  */
        splay_tree_node node;
        
!       node = (splay_tree_node) xmalloc (sizeof (struct splay_tree_node_s));
        node->key = key;
        node->value = value;
        
***************
*** 303,310 ****
          node->right->left = 0;
        }
  
!     sp->root = node;
!   }
  }
  
  /* Lookup KEY in SP, returning VALUE if present, and NULL 
--- 305,355 ----
          node->right->left = 0;
        }
  
!       sp->root = node;
!     }
! 
!   return sp->root;
! }
! 
! /* Remove KEY from SP.  It is not an error if it did not exist.  */
! 
! void
! splay_tree_remove (sp, key)
!      splay_tree sp;
!      splay_tree_key key;
! {
!   splay_tree_splay (sp, key);
! 
!   if (sp->root && (*sp->comp) (sp->root->key, key) == 0)
!     {
!       splay_tree_node left, right;
! 
!       left = sp->root->left;
!       right = sp->root->right;
! 
!       /* Delete the root node itself.  */
!       if (sp->delete_value)
!       (*sp->delete_value) (sp->root->value);
!       free (sp->root);
! 
!       /* One of the children is now the root.  Doesn't matter much
!        which, so long as we preserve the properties of the tree.  */
!       if (left)
!       {
!         sp->root = left;
! 
!         /* If there was a right child as well, hang it off the 
!            right-most leaf of the left child.  */
!         if (right)
!           {
!             while (left->right)
!               left = left->right;
!             left->right = right;
!           }
!       }
!       else
!       sp->root = right;
!     }
  }
  
  /* Lookup KEY in SP, returning VALUE if present, and NULL 
***************
*** 321,326 ****
--- 366,471 ----
      return sp->root;
    else
      return 0;
+ }
+ 
+ /* Return the node in SP with the greatest key.  */
+ 
+ splay_tree_node
+ splay_tree_max (sp)
+      splay_tree sp;
+ {
+   splay_tree_node n = sp->root;
+ 
+   if (!n)
+     return NULL;
+ 
+   while (n->right)
+     n = n->right;
+ 
+   return n;
+ }
+ 
+ /* Return the node in SP with the smallest key.  */
+ 
+ splay_tree_node
+ splay_tree_min (sp)
+      splay_tree sp;
+ {
+   splay_tree_node n = sp->root;
+ 
+   if (!n)
+     return NULL;
+ 
+   while (n->left)
+     n = n->left;
+ 
+   return n;
+ }
+ 
+ /* Return the immediate predecessor KEY, or NULL if there is no
+    predecessor.  KEY need not be present in the tree.  */
+ 
+ splay_tree_node
+ splay_tree_predecessor (sp, key)
+      splay_tree sp;
+      splay_tree_key key;
+ {
+   int comparison;
+   splay_tree_node node;
+ 
+   /* If the tree is empty, there is certainly no predecessor.  */
+   if (!sp->root)
+     return NULL;
+ 
+   /* Splay the tree around KEY.  That will leave either the KEY
+      itself, its predecessor, or its successor at the root.  */
+   splay_tree_splay (sp, key);
+   comparison = (*sp->comp)(sp->root->key, key);
+ 
+   /* If the predecessor is at the root, just return it.  */
+   if (comparison < 0)
+     return sp->root;
+ 
+   /* Otherwise, find the leftmost element of the right subtree.  */
+   node = sp->root->left;
+   if (node)
+     while (node->right)
+       node = node->right;
+ 
+   return node;
+ }
+ 
+ /* Return the immediate successor KEY, or NULL if there is no
+    predecessor.  KEY need not be present in the tree.  */
+ 
+ splay_tree_node
+ splay_tree_successor (sp, key)
+      splay_tree sp;
+      splay_tree_key key;
+ {
+   int comparison;
+   splay_tree_node node;
+ 
+   /* If the tree is empty, there is certainly no predecessor.  */
+   if (!sp->root)
+     return NULL;
+ 
+   /* Splay the tree around KEY.  That will leave either the KEY
+      itself, its predecessor, or its successor at the root.  */
+   splay_tree_splay (sp, key);
+   comparison = (*sp->comp)(sp->root->key, key);
+ 
+   /* If the successor is at the root, just return it.  */
+   if (comparison > 0)
+     return sp->root;
+ 
+   /* Otherwise, find the rightmost element of the left subtree.  */
+   node = sp->root->right;
+   if (node)
+     while (node->left)
+       node = node->left;
+ 
+   return node;
  }
  
  /* Call FN, passing it the DATA, for every node in SP, following an