freebsd-dev/contrib/binutils/libiberty/ternary.c
David E. O'Brien dbbf32dd39 Enlist the FreeBSD-CURRENT users as testers of what is to become Binutils
version 2.12.0.  These bits are taken from the FSF anoncvs repo on
27-January-2002 03:41 PST.
2002-01-27 12:00:11 +00:00

167 lines
4.0 KiB
C

/* ternary.c - Ternary Search Trees
Copyright (C) 2001 Free Software Foundation, Inc.
Contributed by Daniel Berlin (dan@cgsoftware.com)
This program is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by the
Free Software Foundation; either version 2, or (at your option) any
later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
USA. */
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#ifdef HAVE_STDLIB_H
#include <stdlib.h>
#endif
#include <stdio.h>
#include "libiberty.h"
#include "ternary.h"
/* Non-recursive so we don't waste stack space/time on large
insertions. */
PTR
ternary_insert (root, s, data, replace)
ternary_tree *root;
const char *s;
PTR data;
int replace;
{
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 = (ternary_tree) xmalloc (sizeof (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);
}
}
/* Free the ternary search tree rooted at p. */
void
ternary_cleanup (p)
ternary_tree p;
{
if (p)
{
ternary_cleanup (p->lokid);
if (p->splitchar)
ternary_cleanup (p->eqkid);
ternary_cleanup (p->hikid);
free (p);
}
}
/* Non-recursive find of a string in the ternary tree */
PTR
ternary_search (p, s)
const ternary_node *p;
const char *s;
{
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;
}
/* For those who care, the recursive version of the search. Useful if
you want a starting point for pmsearch or nearsearch. */
static PTR
ternary_recursivesearch (p, s)
const ternary_node *p;
const char *s;
{
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);
}
}