* misc/efgvt_r.c: New file. Reentrant version of [efg]cvt functions.
authorroland <roland>
Sun, 17 Sep 1995 19:55:12 +0000 (19:55 +0000)
committerroland <roland>
Sun, 17 Sep 1995 19:55:12 +0000 (19:55 +0000)
misc/hsearch_r.c: New file.  Reentrant version of functions from
hsearch family.
misc/efgcvt.c, misc/hsearch.c: Rewrite to use reentrant functions.
misc/Makefile: Add efgcvt_r.c and hsearch_r.c.

misc/Makefile
misc/efgcvt.c
misc/efgcvt_r.c [new file with mode: 0644]
misc/hsearch_r.c [new file with mode: 0644]
misc/tsearch.c [new file with mode: 0644]
search.h [new file with mode: 0644]

index c626dd7..213ca9f 100644 (file)
@@ -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
index 6473475..95b0b0d 100644 (file)
@@ -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 (file)
index 0000000..fb0d591
--- /dev/null
@@ -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_r.c b/misc/hsearch_r.c
new file mode 100644 (file)
index 0000000..5ea1d5e
--- /dev/null
@@ -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 (file)
index 0000000..cb06b7d
--- /dev/null
@@ -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);
+}
diff --git a/search.h b/search.h
new file mode 100644 (file)
index 0000000..ff24508
--- /dev/null
+++ b/search.h
@@ -0,0 +1 @@
+#include <misc/search.h>