Back to index

cell-binutils  2.17cvs20070401
Functions
ternary.c File Reference
#include <stdio.h>
#include "libiberty.h"
#include "ternary.h"

Go to the source code of this file.

Functions

PTR ternary_insert (ternary_tree *root, const char *s, PTR data, int replace)
void ternary_cleanup (ternary_tree p)
PTR ternary_search (const ternary_node *p, const char *s)
static PTR ternary_recursivesearch (const ternary_node *p, const char *s)

Function Documentation

Definition at line 97 of file ternary.c.

{
  if (p)
    {
      ternary_cleanup (p->lokid);
      if (p->splitchar)
       ternary_cleanup (p->eqkid);
      ternary_cleanup (p->hikid);
      free (p);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

PTR ternary_insert ( ternary_tree root,
const char *  s,
PTR  data,
int  replace 
)

Definition at line 37 of file ternary.c.

{
  int diff;
  ternary_tree curr, *pcurr;

  /* Start at the root. */
  pcurr = root;
  /* Loop until we find the right position */
  while ((curr = *pcurr))
    {
      /* Calculate the difference */
      diff = *s - curr->splitchar;
      /* Handle current char equal to node splitchar */
      if (diff == 0)
       {
         /* Handle the case of a string we already have */
         if (*s++ == 0)
           {
             if (replace)
              curr->eqkid = (ternary_tree) data;
             return (PTR) curr->eqkid;
           }
         pcurr = &(curr->eqkid);
       }
      /* Handle current char less than node splitchar */
      else if (diff < 0)
       {
         pcurr = &(curr->lokid);
       }
      /* Handle current char greater than node splitchar */
      else
       {
         pcurr = &(curr->hikid);
       }
    }
  /* It's not a duplicate string, and we should insert what's left of
     the string, into the tree rooted at curr */
  for (;;)
    {
      /* Allocate the memory for the node, and fill it in */
      *pcurr = XNEW (ternary_node);
      curr = *pcurr;
      curr->splitchar = *s;
      curr->lokid = curr->hikid = curr->eqkid = 0;

      /* Place nodes until we hit the end of the string.
         When we hit it, place the data in the right place, and
         return.
       */
      if (*s++ == 0)
       {
         curr->eqkid = (ternary_tree) data;
         return data;
       }
      pcurr = &(curr->eqkid);
    }
}
static PTR ternary_recursivesearch ( const ternary_node p,
const char *  s 
) [static]

Definition at line 143 of file ternary.c.

{
  if (!p)
    return 0;
  if (*s < p->splitchar)
    return ternary_recursivesearch (p->lokid, s);
  else if (*s > p->splitchar)
    return ternary_recursivesearch (p->hikid, s);
  else
    {
      if (*s == 0)
       return (PTR) p->eqkid;
      return ternary_recursivesearch (p->eqkid, ++s);
    }
}
PTR ternary_search ( const ternary_node p,
const char *  s 
)

Definition at line 111 of file ternary.c.

{
  const ternary_node *curr;
  int diff, spchar;
  spchar = *s;
  curr = p;
  /* Loop while we haven't hit a NULL node or returned */
  while (curr)
    {
      /* Calculate the difference */
      diff = spchar - curr->splitchar;
      /* Handle the equal case */
      if (diff == 0)
       {
         if (spchar == 0)
           return (PTR) curr->eqkid;
         spchar = *++s;
         curr = curr->eqkid;
       }
      /* Handle the less than case */
      else if (diff < 0)
       curr = curr->lokid;
      /* All that's left is greater than */
      else
       curr = curr->hikid;
    }
  return NULL;
}

Here is the call graph for this function: