Sat Sep 16 17:47:19 1995 Ulrich Drepper <drepper@ipd.info.uni-karlsruhe.de>

	* elf/elf.h (AT_GID): Fix typo: Read -> Real.

	* misc/efgvt_r.c: New file.  Reentrant version of [efg]cvt functions.
	* misc/efgcvt.c: Rewrite to use reentrant functions.
	* misc/hsearch_r.c: New file.  Reentrant version of functions from
	hsearch family.
	* misc/hsearch.c, misc/tsearch.c: New files.
	* misc/Makefile (routines): Add efgcvt_r, hsearch_r, hsearch, tsearch.

	* posix/unistd.h (ttyname_r): Add prototype for new function.

	* stdlib/drand48_r.c, stdlib/erand48_r.c, stdlib/jrand48_r.c,
	stdlib/lrand48_r.c, stdlib/mrand48_r.c, stdlib/nrand48_r.c,
	stdlib/seed48_r.c, stdlib/srand48_r.c, stdlib/lcong48_r.c,
	stdlib/drand48-iter.c: New files implementing reentrant versions
	of functions from drand48 family.
	* stdlib/seed48.c, stdlib/drand48.c, stdlib/erand48.c,
	stdlib/jrand48.c, stdlib/lrand48.c, stdlib/mrand48.c,
	stdlib/nrand48.c, stdlib/srand48.c, stdlib/lcong48.c:
	Rewrite to use reentrant versions.
	* stdlib/a64l.c, stdlib/l64a.c: New files.  Implement a64l()
	and l64a() functions from SysV library.
	* stdlib/Makefile (routines): Add drand48_r, erand48_r, lrand48_r,
	nrand48_r, mrand48_r, jrand48_r, srand48_r, seed48_r, lcong48_r,
	drand48-iter, a64l, l64a.
	* stdlib/stdlib.h: Declare them.

	* stdlib/random_r.c: New file.  Reentrant version of functions
	from random family.
	* stdlib/stdlib.h: Declare them.
	* stdlib/random.c: Rewrite to use reentrant functions.

	* string/strerror_r.c: New file.  Reentrant version.
	* string/strerror.c: Change for new _strerror_internal form.
	* string/Makefile (routines): Add strerror_r.

	* sysdeps/generic/dl-sysdep.c (_dl_sysdep_start): Set default
	value of user_entry to `_start'.
	Close AT_ENTRY case with `break'.

	* sysdeps/generic/strstr.c: New and much faster implementation
	by Stephen R. van den Berg.

	* sysdeps/generic/_strerror.c: _strerror_internal now takes
	three argument and has and explicit buffer length.
	* sysdeps/mach/_strerror.c: Change for new interface with three
	arguments.
	* stdio/perror.c, stdio/vfprintf.c: Callers changed.
	
	* sysdeps/mach/hurd/ttyname_r.c: New file.  Reentrant version.
	* sysdeps/posix/ttyname_r.c: New file.  Reentrant version.
	* sysdeps/stub/ttyname_r: New file.  Define as dummy function.

	* sysdeps/posix/utimes.c: Include <utime.h> for prototype.
	(utimes): First parameter to utime must be file, not path.

	* sysdeps/posix/sysconf.c (__sysconf): Test for CLK_TCK in case
	_SC_CLK_TCK and return it when available.
	Test for STREAM_MAX in case _SC_STREAM_MAX and return it when
	available.
	Add case for _SC_2_LOCALEDEF which is now available.

	* posix/sys/types.h [__USE_SVID] (key_t): New type.
	* sysvipc/Makefile, sysvipc/ftok.c, sysvipc/sys/ipc.h,
	sysvipc/sys/msg.h, sysvipc/sys/sem.h, sysvipc/sys/shm.h,
	sysdeps/stub/sys/msq_buf.h, sysdeps/stub/sys/sem_buf.h,
	sysdeps/stub/sys/shm_buf.h, sysdeps/stub/sys/ipc_buf.h,
	sysdeps/stub/semctl.c, sysdeps/stub/semget.c, sysdeps/stub/semop.c,
	sysdeps/stub/shmat.c, sysdeps/stub/shmctl.c, sysdeps/stub/shmdt.c,
	sysdeps/stub/shmget.c, sysdeps/stub/msgctl.c, sysdeps/stub/msgget.c,
	sysdeps/stub/msgrcv.c, sysdeps/stub/msgsnd.c: New files.
	Add implementation of System V IPC.

6 files changed, 581 insertions, 28 deletions

diff --git a/misc/Makefile b/misc/Makefile
index c626dd7..213ca9f 100644
--- a/misc/Makefile
+++ b/misc/Makefile
@@ -25,7 +25,7 @@ subdir	:= misc
 headers	:= sys/uio.h sys/ioctl.h sys/ptrace.h ioctls.h sys/file.h	\
 	   a.out.h nlist.h stab.h stab.def sgtty.h sys/dir.h sys/cdefs.h \
 	   ttyent.h syscall.h syslog.h sys/syslog.h paths.h sys/reboot.h \
-	   sys/mman.h sys/param.h fstab.h mntent.h search.h utmp.h
+	   sys/mman.h sys/param.h fstab.h search.h utmp.h
 
 routines := brk sbrk sstk ioctl \
 	    readv writev \
@@ -42,14 +42,15 @@ routines := brk sbrk sstk ioctl \
 	    ualarm usleep \
 	    gtty stty \
 	    ptrace \
-	    nlist fstab mntent \
+	    nlist fstab \
 	    utimes \
 	    truncate ftruncate \
 	    chflags fchflags \
 	    insremque getttyent getusershell getpass ttyslot \
 	    syslog syscall daemon \
 	    mmap munmap mprotect msync madvise \
-	    efgcvt
+	    efgcvt efgcvt_r \
+	    hsearch hsearch_r tsearch
 aux := progname init-misc
 distribute := bsd-compat.c
 extra-objs := bsd-compat.o
diff --git a/misc/efgcvt.c b/misc/efgcvt.c
index 6473475..95b0b0d 100644
--- a/misc/efgcvt.c
+++ b/misc/efgcvt.c
@@ -1,4 +1,4 @@
-/* [efg]cvt -- compatibility functions for floating point formatting
+/* [efg]cvt -- compatibility functions for floating point formatting.
 Copyright (C) 1995 Free Software Foundation, Inc.
 This file is part of the GNU C Library.
 
@@ -18,9 +18,7 @@ not, write to the Free Software Foundation, Inc., 675 Mass Ave,
 Cambridge, MA 02139, USA.  */
 
 #include <stdio.h>
-#include <string.h>
-#include <ctype.h>
-#include <math.h>
+#include <stdlib.h>
 
 char *
 fcvt (value, ndigit, decpt, sign)
@@ -28,24 +26,8 @@ fcvt (value, ndigit, decpt, sign)
      int ndigit, *decpt, *sign;
 {
   static char buf[100];
-  int n, i;
 
-  *sign = value < 0.0;
-  if (*sign)
-    value = - value;
-
-  n = snprintf (buf, sizeof buf, "%.*f", ndigit, value);
-  if (n < 0)
-    return NULL;
-
-  i = 0;
-  while (i < n && isdigit (buf[i]))
-    ++i;
-  *decpt = i;
-  do
-    ++i;
-  while (! isdigit (buf[i]));
-  memmove (&buf[i - *decpt], buf, n - (i - *decpt));
+  (void) fcvt_r (value, ndigit, decpt, sign, buf, sizeof buf);
 
   return buf;
 }
@@ -55,10 +37,11 @@ ecvt (value, ndigit, decpt, sign)
      double value;
      int ndigit, *decpt, *sign;
 {
-  ndigit -= (int) floor (log10 (value));
-  if (ndigit < 0)
-    ndigit = 0;
-  return fcvt (value, ndigit, decpt, sign);
+  static char buf[100];
+
+  (void) ecvt_r (value, ndigit, decpt, sign, buf, sizeof buf);
+
+  return buf;
 }
 
 char *
diff --git a/misc/efgcvt_r.c b/misc/efgcvt_r.c
new file mode 100644
index 0000000..fb0d591
--- /dev/null
+++ b/misc/efgcvt_r.c
@@ -0,0 +1,73 @@
+/* [efg]cvt -- compatibility functions for floating point formatting,
+   reentrent versions.
+Copyright (C) 1995 Free Software Foundation, Inc.
+This file is part of the GNU C Library.
+
+The GNU C Library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Library General Public License as
+published by the Free Software Foundation; either version 2 of the
+License, or (at your option) any later version.
+
+The GNU C Library 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
+Library General Public License for more details.
+
+You should have received a copy of the GNU Library General Public
+License along with the GNU C Library; see the file COPYING.LIB.  If
+not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+Boston, MA 02111-1307, USA.  */
+
+#include <errno.h>
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+#include <math.h>
+
+int
+fcvt_r (value, ndigit, decpt, sign, buf, len)
+     double value;
+     int ndigit, *decpt, *sign;
+     char *buf;
+     int len;
+{
+  int n, i;
+
+  if (buf == NULL)
+    {
+      errno = EINVAL;
+      return -1;
+    }
+
+  *sign = value < 0.0;
+  if (*sign)
+    value = - value;
+
+  n = snprintf (buf, len, "%.*f", ndigit, value);
+  if (n < 0)
+    return -1;
+
+  i = 0;
+  while (i < n && isdigit (buf[i]))
+    ++i;
+  *decpt = i;
+  do
+    ++i;
+  while (! isdigit (buf[i]));
+  memmove (&buf[i - *decpt], buf, n - (i - *decpt));
+
+  return 0;
+}
+
+int
+ecvt_r (value, ndigit, decpt, sign, buf, len)
+     double value;
+     int ndigit, *decpt, *sign;
+     char *buf;
+     int len;
+{
+  ndigit -= (int) floor (log10 (value));
+  if (ndigit < 0)
+    ndigit = 0;
+  return fcvt_r (value, ndigit, decpt, sign, buf, len);
+}
diff --git a/misc/hsearch.c b/misc/hsearch.c
new file mode 100644
index 0000000..7df8686
--- /dev/null
+++ b/misc/hsearch.c
@@ -0,0 +1,52 @@
+/* Copyright (C) 1993, 1995 Free Software Foundation, Inc.
+Contributed by Ulrich Drepper <drepper@gnu.ai.mit.edu>
+This file is part of the GNU C Library.
+
+The GNU C Library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Library General Public License as
+published by the Free Software Foundation; either version 2 of the
+License, or (at your option) any later version.
+
+The GNU C Library 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
+Library General Public License for more details.
+
+You should have received a copy of the GNU Library General Public
+License along with the GNU C Library; see the file COPYING.LIB.  If
+not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+Boston, MA 02111-1307, USA.  */
+
+#include <search.h>
+
+/* The non-reenttrent version use a global space for storing the table.  */
+static struct hsearch_data htab;
+
+
+/* Define the non-reentrent function using the reentrent counterparts.  */
+ENTRY *
+hsearch (item, action)
+     ENTRY item;
+     ACTION action;
+{
+  ENTRY *result;
+
+  (void) hsearch_r (item, action, &result, &htab);
+
+  return result;
+}
+
+
+int
+hcreate (nel)
+     unsigned int nel;
+{
+  return hcreate_r (nel, &htab);
+}
+
+
+void
+hdestroy ()
+{
+  hdestroy_r (&htab);
+}
diff --git a/misc/hsearch_r.c b/misc/hsearch_r.c
new file mode 100644
index 0000000..5ea1d5e
--- /dev/null
+++ b/misc/hsearch_r.c
@@ -0,0 +1,229 @@
+/* Copyright (C) 1993, 1995 Free Software Foundation, Inc.
+Contributed by Ulrich Drepper <drepper@gnu.ai.mit.edu>
+This file is part of the GNU C Library.
+
+The GNU C Library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Library General Public License as
+published by the Free Software Foundation; either version 2 of the
+License, or (at your option) any later version.
+
+The GNU C Library 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
+Library General Public License for more details.
+
+You should have received a copy of the GNU Library General Public
+License along with the GNU C Library; see the file COPYING.LIB.  If
+not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+Boston, MA 02111-1307, USA.  */
+
+#include <errno.h>
+#include <malloc.h>
+#include <string.h>
+
+#include <search.h>
+
+/* [Aho,Sethi,Ullman] Compilers: Principles, Techniques and Tools, 1986
+   [Knuth]            The Art of Computer Programming, part 3 (6.4)  */
+
+
+/* The reentrent version has no static variables to maintain the state.
+   Instead the interface of all functions is extended to take an argument
+   which describes the current status.  */
+typedef struct _ENTRY
+{ 
+  int   used;
+  ENTRY entry;
+}
+_ENTRY;
+
+
+/* For the used double hash method the table size has to be a prime. To
+   correct the user given table size we need a prime test.  This trivial
+   algorithm is adequate because
+   a)  the code is (most probably) called a few times per program run and
+   b)  the number is small because the table must fit in the core  */
+static int
+isprime (number)
+     unsigned int number;
+{
+  /* no even number will be passed */
+  unsigned int div = 3;
+
+  while (div * div < number && number % div != 0)
+    div += 2;
+
+  return number % div != 0;
+}
+
+
+/* Before using the hash table we must allocate memory for it.
+   Test for an existing table are done. We allocate one element
+   more as the found prime number says. This is done for more effective
+   indexing as explained in the comment for the hsearch function.
+   The contents of the table is zeroed, especially the field used 
+   becomes zero.  */
+int
+hcreate_r (nel, htab)
+     unsigned int nel;
+     struct hsearch_data *htab;
+{
+  /* Test for correct arguments.  */
+  if (htab == NULL)
+    {
+      errno = EINVAL;
+      return 0;
+    }
+
+  /* There is still another table active. Return with error. */
+  if (htab->table != NULL)
+    return 0;
+
+  /* Change nel to the first prime number not smaller as nel. */
+  nel |= 1;      /* make odd */
+  while (!isprime (nel))
+    nel += 2;
+
+  htab->size = nel;
+  htab->filled = 0;
+
+  /* allocate memory and zero out */
+  htab->table = (_ENTRY *) calloc (htab->size + 1, sizeof (_ENTRY));
+  if (htab->table == NULL)
+    return 0;
+
+  /* everything went alright */
+  return 1;
+}
+
+
+/* After using the hash table it has to be destroyed. The used memory can
+   be freed and the local static variable can be marked as not used.  */
+void
+hdestroy_r (htab)
+     struct hsearch_data *htab;
+{
+  /* Test for correct arguments.  */
+  if (htab == NULL)
+    {
+      errno = EINVAL;
+      return;
+    }
+
+  if (htab->table != NULL)
+    /* free used memory */
+    free (htab->table);
+
+  /* the sign for an existing table is an value != NULL in htable */ 
+  htab->table = NULL;
+}
+
+
+/* This is the search function. It uses double hashing with open adressing.
+   The argument item.key has to be a pointer to an zero terminated, most
+   probably strings of chars. The function for generating a number of the
+   strings is simple but fast. It can be replaced by a more complex function
+   like ajw (see [Aho,Sethi,Ullman]) if the needs are shown.
+  
+   We use an trick to speed up the lookup. The table is created by hcreate
+   with one more element available. This enables us to use the index zero
+   special. This index will never be used because we store the first hash
+   index in the field used where zero means not used. Every other value
+   means used. The used field can be used as a first fast comparison for
+   equality of the stored and the parameter value. This helps to prevent
+   unnecessary expensive calls of strcmp.  */
+int
+hsearch_r (item, action, retval, htab)
+     ENTRY item;
+     ACTION action;
+     ENTRY **retval;
+     struct hsearch_data *htab;
+{
+  unsigned int hval;
+  unsigned int count;
+  unsigned int len = strlen (item.key);
+  unsigned int idx;
+
+  /* If table is full and another entry should be entered return with 
+     error.  */
+  if (action == ENTER && htab->filled == htab->size)
+    {
+      errno = ENOMEM;
+      *retval = NULL;
+      return 0;
+    }
+
+  /* Compute an value for the given string. Perhaps use a better method. */
+  hval = len;
+  count = len;
+  while (count-- > 0)
+    {
+      hval <<= 4;
+      hval += item.key[count];
+    }
+
+  /* First hash function: simply take the modul but prevent zero. */
+  hval %= htab->size;
+  if (hval == 0)
+    ++hval;
+
+  /* The first index tried. */
+  idx = hval;
+
+  if (htab->table[idx].used)
+    {
+      /* Further action might be required according to the action value. */
+      unsigned hval2;
+
+      if (htab->table[idx].used == hval
+	  && strcmp (item.key, htab->table[idx].entry.key) == 0)
+	{
+          if (action == ENTER) 
+	    htab->table[idx].entry.data = item.data;
+
+	  *retval = &htab->table[idx].entry;
+	  return 1;
+	}
+
+      /* Second hash function, as suggested in [Knuth] */
+      hval2 = 1 + hval % (htab->size - 2);
+	
+      do
+	{
+	  /* Because SIZE is prime this guarantees to step through all
+             available indeces.  */
+          if (idx <= hval2)
+	    idx = htab->size + idx - hval2;
+	  else
+	    idx -= hval2;
+
+            /* If entry is found use it. */
+          if (htab->table[idx].used == hval
+	      && strcmp (item.key, htab->table[idx].entry.key) == 0)
+	    {
+              if (action == ENTER) 
+	        htab->table[idx].entry.data = item.data;
+
+	      *retval = &htab->table[idx].entry;
+	      return 1;
+	    }
+	}
+      while (htab->table[idx].used);
+    }
+
+  /* An empty bucket has been found. */
+  if (action == ENTER)
+    {
+      htab->table[idx].used  = hval;
+      htab->table[idx].entry = item;
+
+      ++htab->filled;
+
+      *retval = &htab->table[idx].entry;
+      return 1;
+    }
+
+  errno = ESRCH;
+  *retval = NULL;
+  return 0;
+}
diff --git a/misc/tsearch.c b/misc/tsearch.c
new file mode 100644
index 0000000..cb06b7d
--- /dev/null
+++ b/misc/tsearch.c
@@ -0,0 +1,215 @@
+/* Copyright (C) 1995 Free Software Foundation, Inc.
+This file is part of the GNU C Library.
+
+The GNU C Library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Library General Public License as
+published by the Free Software Foundation; either version 2 of the
+License, or (at your option) any later version.
+
+The GNU C Library 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
+Library General Public License for more details.
+
+You should have received a copy of the GNU Library General Public
+License along with the GNU C Library; see the file COPYING.LIB.  If
+not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+Boston, MA 02111-1307, USA.  */
+
+/* Tree search generalized from Knuth (6.2.2) Algorithm T just like
+   the AT&T man page says.
+  
+   The node_t structure is for internal use only, lint doesn't grok it.
+  
+   Written by reading the System V Interface Definition, not the code.
+  
+   Totally public domain.  */
+/*LINTLIBRARY*/
+
+#include <stdlib.h>
+#include <search.h>
+
+/* This routine is not very bad.  It makes many assumptions about
+   the compiler. It assumpts that the first field in node must be
+   the "key" field, which points to the datum. It is a very trick
+   stuff. H.J.  */
+
+typedef struct node_t
+{
+  const void *key;
+  struct node_t *left;
+  struct node_t *right;
+}
+node;
+
+/* Prototype fpr local function.  */
+static void trecurse __P ((const void *vroot, __action_fn_t action, int level));
+
+
+/* find or insert datum into search tree.
+char 	*key;		 key to be located
+node	**rootp;	 address of tree root
+int	(*compar)();	 ordering function
+*/
+void *
+tsearch (key, vrootp, compar)
+     const void *key;
+     void **vrootp;
+     __compar_fn_t compar;
+{
+  node *q;
+  node **rootp = (node **) vrootp;
+
+  if (rootp == NULL)
+    return NULL;
+
+  while (*rootp != NULL)		/* Knuth's T1: */
+    {
+      int r;
+
+      r = (*compar) (key, (*rootp)->key);
+      if (r == 0)			/* T2: */
+	return *rootp;			/* we found it! */
+      rootp = (r < 0)
+	      ? &(*rootp)->left		/* T3: follow left branch */
+	      : &(*rootp)->right;	/* T4: follow right branch */
+    }
+
+  q = (node *) malloc (sizeof (node));	/* T5: key not found */
+  if (q != NULL)			/* make new node */
+    {
+      *rootp = q;			/* link new node to old */
+      q->key = key;			/* initialize new node */
+      q->left = q->right = NULL;
+    }
+
+  return q;
+}
+
+
+void *
+tfind (key, vrootp, compar)
+     const void *key;
+     const void **vrootp;
+     __compar_fn_t compar;
+{
+  node **rootp = (node **) vrootp;
+
+  if (rootp == NULL)
+    return NULL;
+
+  while (*rootp != NULL)		/* Knuth's T1: */
+    {
+      int r;
+
+      r = (*compar)(key, (*rootp)->key);
+      if (r == 0)			/* T2: */
+	return *rootp;			/* we found it! */
+
+      rootp = (r < 0)
+	      ? &(*rootp)->left		/* T3: follow left branch */
+	      : &(*rootp)->right;	/* T4: follow right branch */
+    }
+    return NULL;
+}
+
+
+/* delete node with given key
+char	*key;		key to be deleted
+node	**rootp;	address of the root of tree
+int	(*compar)();	comparison function
+*/
+void *
+tdelete (key, vrootp, compar)
+     const void *key;
+     void **vrootp;
+     __compar_fn_t compar;
+{
+  node *p;
+  node *q;
+  node *r;
+  int cmp;
+  node **rootp = (node **) vrootp;
+
+  if (rootp == NULL || (p = *rootp) == NULL)
+    return NULL;
+
+  while ((cmp = (*compar) (key, (*rootp)->key)) != 0)
+    {
+      p = *rootp;
+      rootp = (cmp < 0)
+	      ? &(*rootp)->left		/* follow left branch */
+	      : &(*rootp)->right;	/* follow right branch */
+      if (*rootp == NULL)
+	return NULL;			/* key not found */
+    }
+
+  r = (*rootp)->right;			/* D1: */
+  q = (*rootp)->left;
+  if (q == NULL)			/* Left NULL? */
+    q = r;
+  else if (r != NULL)			/* Right link is NULL? */
+    {
+      if (r->left == NULL)		/* D2: Find successor */
+	{
+	  r->left = q;
+	  q = r;
+	}
+      else
+	{				/* D3: Find (struct node_t *)0 link */
+	  for (q = r->left; q->left != NULL; q = r->left)
+	    r = q;
+	  r->left = q->right;
+	  q->left = (*rootp)->left;
+	  q->right = (*rootp)->right;
+	}
+    }
+  free ((struct node_t *) *rootp);	/* D4: Free node */
+  *rootp = q;				/* link parent to new node */
+  return p;
+}
+
+
+/* Walk the nodes of a tree
+node	*root;		Root of the tree to be walked
+void	(*action)();	Function to be called at each node
+int	level;
+*/
+static void
+trecurse (vroot, action, level)
+     const void *vroot;
+     __action_fn_t action;
+     int level;
+{
+  node *root = (node *) vroot;
+
+  if (root->left == NULL && root->right == NULL)
+    (*action) (root, leaf, level);
+  else
+    {
+      (*action) (root, preorder, level);
+      if (root->left != NULL)
+	trecurse (root->left, action, level + 1);
+      (*action) (root, postorder, level);
+      if (root->right != NULL)
+	trecurse (root->right, action, level + 1);
+      (*action) (root, endorder, level);
+    }
+}
+
+
+/* void twalk(root, action)	Walk the nodes of a tree 
+node	*root;			Root of the tree to be walked
+void	(*action)();		Function to be called at each node
+PTR
+*/
+void
+twalk (vroot, action)
+     const void *vroot;
+     __action_fn_t action;
+{
+  const node *root = (node *) vroot;
+
+  if (root != NULL && action != NULL)
+    trecurse (root, action, 0);
+}