Update.cvs/libc-ud-960808cvs/libc-960809

Thu Aug  8 16:17:38 1996  Ulrich Drepper  <drepper@cygnus.com>

	* pwd/getpwent.c: Define BUFLEN from NSS_BUFLEN_PASSWD.
	* pwd/getpwent_r.c: Likewise.
	* pwd/getpwnam.c: Likewise.
	* pwd/getpwnam_r.c: Likewise.
	* pwd/getpwuid.c: Likewise.
	* pwd/getpwuid_r.c: Likewise.

	* grp/getgrent.c: Define BUFLEN from NSS_BUFLEN_GROUP.
	* grp/getgrent_r.c: Likewise.
	* grp/getgrgid.c: Likewise.
	* grp/getgrgid_r.c: Likewise.
	* grp/getgrnam.c: Likewise.

	* pwd/fgetpwent_r.c: New file.  Reentrant version of fgetpwent.
	* pwd/fgetpwent.c: Rewrite to use fgetpwent_r.
	* pwd/Makefile (routines): Add fgetpwent_r.
	* pwd/pwd.h: Add prototypes for __fgetpwent_r and fgetpwent_r.

	* grp/fgetgrent_r.c: New file.  Reentrant version of fgetgrent.
	* grp/fgetgrent.c: Rewrite to use fgetgrent_r.
	* grp/Makefile (routines): Add fgetgrent_r.
	* grp/grp.h: Add prototypes for __fgetgrent_r and fgetgrent_r.

	Implement shadow password lookup functions.  This is no complete
	shadow password suite.
	* shadow/Makefile: New file.
	* shadow/fgetspent.c: New file.
	* shadow/fgetspent_r.c: New file.
	* shadow/getspent.c: New file.
	* shadow/getspent_r.c: New file.
	* shadow/getspnam.c: New file.
	* shadow/getspnam_r.c: New file.
	* shadow/putspent.c: New file.
	* shadow/sgetspent.c: New file.
	* shadow/sgetspent_r.c: New file.
	* shadow/shadow.h: New file.
	* shadow/spwd-lookup.c: New file.
	* shadow/nss_files/files-spwd.c: New file.

Thu Aug  8 13:33:45 1996  Ulrich Drepper  <drepper@cygnus.com>

	* sysdeps/unix/sysv/linux/ftime.c: New file.  Available system
 	call is only a stub.
	Reported by Matthias Urlichs.

	* Makeconfig [!default_cflags]: Change default value from `-g'
	to `-g -O'.

	* configure.in: Recognize i686.
	* sysdeps/i386/i686/Implies: Default on i586 optimized code.

Thu Aug  8 12:40:20 1996  Matthias Urlichs  <smurf@smurf.noris.de>

	* Makeconfig [$(build-omitfp) == yes]: Add to CFLAGS-.so
	value of CFLAGS-.o, not CFLAGS-o.

	* sysdeps/unix/sysv/linux/init-first.c (init): Add volatile
	pointer to ourself.  Otherwise `gcc -O3' optimized init away.

	sure that all tables in binary file are word-aligned.

3 files changed, 96 insertions, 36 deletions

diff --git a/manual/maint.texi b/manual/maint.texi
index 5bf473ecfd..98467e4b7b 100644
--- a/manual/maint.texi
+++ b/manual/maint.texi
@@ -223,8 +223,8 @@ following patterns:
 
 @smallexample
 alpha-dec-osf1
-alpha-gnu-linux
-alpha-gnu-linuxecoff
+alpha-@var{anything}-linux
+alpha-@var{anything}-linuxecoff
 i@var{x}86-@var{anything}-bsd4.3
 i@var{x}86-@var{anything}-gnu
 i@var{x}86-@var{anything}-isc2.2
diff --git a/manual/memory.texi b/manual/memory.texi
index de543ec684..343da0bb7e 100644
--- a/manual/memory.texi
+++ b/manual/memory.texi
@@ -756,7 +756,7 @@ the padding needed to start each object on a suitable boundary.
 * Obstacks Data Alignment::     Controlling alignment of objects in obstacks.
 * Obstack Chunks::              How obstacks obtain and release chunks;
 				 efficiency considerations.
-* Summary of Obstacks::         
+* Summary of Obstacks::
 @end menu
 
 @node Creating Obstacks
@@ -1182,7 +1182,7 @@ When you check for space using @code{obstack_room} and there is not
 enough room for what you want to add, the fast growth functions
 are not safe.  In this case, simply use the corresponding ordinary
 growth function instead.  Very soon this will copy the object to a
-new chunk; then there will be lots of room available again. 
+new chunk; then there will be lots of room available again.
 
 So, each time you use an ordinary growth function, check afterward for
 sufficient space using @code{obstack_room}.  Once the object is copied
@@ -1206,7 +1206,7 @@ add_string (struct obstack *obstack, const char *ptr, int len)
           obstack_1grow (obstack, *ptr++);
           len--;
         @}
-      else 
+      else
         @{
           if (room > len)
             room = len;
@@ -1494,8 +1494,7 @@ int
 open2 (char *str1, char *str2, int flags, int mode)
 @{
   char *name = (char *) alloca (strlen (str1) + strlen (str2) + 1);
-  strcpy (name, str1);
-  strcat (name, str2);
+  stpcpy (stpcpy (name, str1), str2);
   return open (name, flags, mode);
 @}
 @end smallexample
@@ -1512,8 +1511,7 @@ open2 (char *str1, char *str2, int flags, int mode)
   int desc;
   if (name == 0)
     fatal ("virtual memory exceeded");
-  strcpy (name, str1);
-  strcat (name, str2);
+  stpcpy (stpcpy (name, str1), str2);
   desc = open (name, flags, mode);
   free (name);
   return desc;
@@ -1558,8 +1556,7 @@ int
 open2 (char *str1, char *str2, int flags, int mode)
 @{
   char *name = (char *) alloca (strlen (str1) + strlen (str2) + 1);
-  strcpy (name, str1);
-  strcat (name, str2);
+  stpcpy (stpcpy (name, str1), str2);
   return open_or_report_error (name, flags, mode);
 @}
 @end smallexample
@@ -1606,8 +1603,7 @@ variable size.  Here is how @code{open2} would look then:
 int open2 (char *str1, char *str2, int flags, int mode)
 @{
   char name[strlen (str1) + strlen (str2) + 1];
-  strcpy (name, str1);
-  strcat (name, str2);
+  stpcpy (stpcpy (name, str1), str2);
   return open (name, flags, mode);
 @}
 @end smallexample
@@ -1748,4 +1744,3 @@ Normally it ought to display the string for the user to read.
 The warnings come when memory becomes 75% full, when it becomes 85%
 full, and when it becomes 95% full.  Above 95% you get another warning
 each time memory usage increases.
-
diff --git a/manual/string.texi b/manual/string.texi
index c638912229..8b7e9da96b 100644
--- a/manual/string.texi
+++ b/manual/string.texi
@@ -6,7 +6,7 @@ many programs.  The GNU C library provides an extensive set of string
 utility functions, including functions for copying, concatenating,
 comparing, and searching strings.  Many of these functions can also
 operate on arbitrary regions of storage; for example, the @code{memcpy}
-function can be used to copy the contents of any kind of array.  
+function can be used to copy the contents of any kind of array.
 
 It's fairly common for beginning C programmers to ``reinvent the wheel''
 by duplicating this functionality in their own code, but it pays to
@@ -158,7 +158,7 @@ get the allocation size of the character array that holds a string using
 the @code{sizeof} operator:
 
 @smallexample
-char string[32] = "hello, world"; 
+char string[32] = "hello, world";
 sizeof (string)
     @result{} 32
 strlen (string)
@@ -411,7 +411,7 @@ return a nonzero value if the strings are @emph{not} equivalent rather
 than if they are.  The sign of the value indicates the relative ordering
 of the first characters in the strings that are not equivalent:  a
 negative value indicates that the first string is ``less'' than the
-second, while a positive value indicates that the first string is 
+second, while a positive value indicates that the first string is
 ``greater''.
 
 The most common use of these functions is to check only for equality.
@@ -623,10 +623,10 @@ overlap; see @ref{Copying and Concatenation}.
 
 The return value is the length of the entire transformed string.  This
 value is not affected by the value of @var{size}, but if it is greater
-than @var{size}, it means that the transformed string did not entirely
-fit in the array @var{to}.  In this case, only as much of the string as
-actually fits was stored.  To get the whole transformed string, call
-@code{strxfrm} again with a bigger output array.
+or equal than @var{size}, it means that the transformed string did not
+entirely fit in the array @var{to}.  In this case, only as much of the
+string as actually fits was stored.  To get the whole transformed
+string, call @code{strxfrm} again with a bigger output array.
 
 The transformed string may be longer than the original string, and it
 may also be shorter.
@@ -671,23 +671,32 @@ sort_strings_fast (char **array, int nstrings)
   for (i = 0; i < nstrings; i++)
     @{
       size_t length = strlen (array[i]) * 2;
+      char *transformed;
+      size_t transformed_lenght;
 
       temp_array[i].input = array[i];
 
-      /* @r{Transform @code{array[i]}.}
-         @r{First try a buffer probably big enough.} */
-      while (1)
+      /* @r{First try a buffer perhaps big enough.}  */
+      transformed = (char *) xmalloc (length);
+
+      /* @r{Transform @code{array[i]}.}  */
+      transformed_length = strxfrm (transformed, array[i], length);
+
+      /* @r{If the buffer was not large enough, resize it}
+         @r{and try again.}  */
+      if (transformed_length >= length)
         @{
-          char *transformed = (char *) xmalloc (length);
-          if (strxfrm (transformed, array[i], length) < length)
-            @{
-              temp_array[i].transformed = transformed;
-              break;
-            @}
-          /* @r{Try again with a bigger buffer.} */
-          free (transformed);
-          length *= 2;
+          /* @r{Allocate the needed space. +1 for terminating}
+             @r{@code{NUL} character.}  */
+          transformed = (char *) xrealloc (transformed,
+                                           transformed_length + 1);
+
+          /* @r{The return value is not interesting because we know}
+             @r{how long the transformed string is.}  */
+          (void) strxfrm (transformed, array[i], transformed_length + 1);
         @}
+
+      temp_array[i].transformed = transformed;
     @}
 
   /* @r{Sort @code{temp_array} by comparing transformed strings.} */
@@ -741,7 +750,7 @@ strchr ("hello, world", 'l')
     @result{} "llo, world"
 strchr ("hello, world", '?')
     @result{} NULL
-@end smallexample    
+@end smallexample
 
 The terminating null character is considered to be part of the string,
 so you can use this function get a pointer to the end of a string by
@@ -857,8 +866,6 @@ strpbrk ("hello, world", " \t\n,.;!?")
 @node Finding Tokens in a String,  , Search Functions, String and Array Utilities
 @section Finding Tokens in a String
 
-@c !!! Document strsep, which is a better thing to use than strtok.
-
 @cindex tokenizing strings
 @cindex breaking a string into tokens
 @cindex parsing tokens from a string
@@ -945,3 +952,61 @@ token = strtok (NULL, delimiters);    /* token => "and" */
 token = strtok (NULL, delimiters);    /* token => "punctuation" */
 token = strtok (NULL, delimiters);    /* token => NULL */
 @end smallexample
+
+The GNU C library contains two more functions for tokenizing a string
+which overcome the limitation of non-reentrancy.
+
+@comment string.h
+@comment POSIX
+@deftypefun {char *} strtok_r (char *@var{newstring}, const char *@var{delimiters}, char **@var{save_ptr})
+Just like @code{strtok} this function splits the string into several
+tokens which can be accessed be successive calls to @code{strtok_r}.
+The difference is that the information about the next token is not set
+up in some internal state information.  Instead the caller has to
+provide another argument @var{save_ptr} which is a pointer to a string
+pointer.  Calling @code{strtok_r} with a null pointer for
+@var{newstring} and leaving @var{save_ptr} between the calls unchanged
+does the job without limiting reentrancy.
+
+This function was proposed for POSIX.1b and can be found on many systems
+which support multi-threading.
+@end deftypefun
+
+@comment string.h
+@comment BSD
+@deftypefun {char *} strsep (char **@var{string_ptr}, const char *@var{delimiter})
+A second reentrant approach is to avoid the additional first argument.
+The initialization of the moving pointer has to be done by the user.
+Successive calls of @code{strsep} move the pointer along the tokens
+separated by @var{delimiter}, returning the address of the next token
+and updating @var{string_ptr} to point to the beginning of the next
+token.
+
+This function was introduced in 4.3BSD and therefore is widely available.
+@end deftypefun
+
+Here is how the above example looks like when @code{strsep} is used.
+
+@comment Yes, this example has been tested.
+@smallexample
+#include <string.h>
+#include <stddef.h>
+
+@dots{}
+
+char string[] = "words separated by spaces -- and, punctuation!";
+const char delimiters[] = " .,;:!-";
+char *running;
+char *token;
+
+@dots{}
+
+running = string;
+token = strsep (&running, delimiters);    /* token => "words" */
+token = strsep (&running, delimiters);    /* token => "separated" */
+token = strsep (&running, delimiters);    /* token => "by" */
+token = strsep (&running, delimiters);    /* token => "spaces" */
+token = strsep (&running, delimiters);    /* token => "and" */
+token = strsep (&running, delimiters);    /* token => "punctuation" */
+token = strsep (&running, delimiters);    /* token => NULL */
+@end smallexample