Update from main archive 961219 cvs/libc-961220

Thu Dec 19 23:28:33 1996  Ulrich Drepper  <drepper@cygnus.com>

	* resolv/resolv.h: Update from BIND 4.9.5-P1.
	* resolv/res_comp.c: Likewise.
	* resolv/res_debug.c: Likewise.
	* resolv/Banner: Update version number.

Thu Dec 19 20:58:53 1996  Ulrich Drepper  <drepper@cygnus.com>

	* elf/dlfcn.h: Add extern "C" wrapper.

	* io/utime.h: Don't define NULL since this isn't allowed in POSIX.
	* io/sys/stat.h: Declare `lstat' only if __USE_BSD ||
	__USE_XOPEN_EXTENDED.
	* locale/locale.h: Define NULL.
	* math/math.c: Don't include <errno.h> to define math errors.
	* stdlib/stdlib.h: Likewise.
	* posix/unistd.h: Don't declare environ.
	* posix/sys/utsname.h (struct utsname): Declare member domainname
	as __domainname is !__USE_GNU.
	* signal/signal.h: Declare size_t only if __USE_BSD ||
	__USE_XOPEN_EXTENDED.
	* stdio/stdio.h: Don't declare cuserid when __USE_POSIX, but
	instead when __USE_XOPEN.
	* string/string.h: Define strndup only if __USE_GNU.
	* sysdeps/unix/sysv/linux/clock.c: New file.
	* sysdeps/unix/sysv/linux/timebits.h: Define CLOCKS_PER_SEC as
	1000000 per X/Open standard.
	* features.h: Add code to recognize _POSIX_C_SOURCE value 199309.
	Define __USE_POSIX199309.
	* posix/unistd.h: Declare fdatasync only if __USE_POSIX199309.
	* time/time.c: Declare nanosleep only if __USE_POSIX199309.
	Patches by Rüdiger Helsch <rh@unifix.de>.

	* locale/locale.h: Add declaration of newlocale and freelocale.

	* new-malloc/Makefile (distibute): Add mtrace.awk.
	(dist-routines): Add mcheck and mtrace.
	(install-lib, non-lib.a): Define as libmcheck.a.
	* new-malloc/malloc.h: Add declaration of __malloc_initialized.
	* new-malloc/mcheck.c: New file.
	* new-malloc/mcheck.h: New file.
	* new-malloc/mtrace.c: New file.
	* new-malloc/mtrace.awk: New file.

	* posix/unistd.h: Correct prototype for usleep.
	* sysdeps/unix/bsd/usleep.c: De-ANSI-declfy.  Correct return type.
	* sysdeps/unix/sysv/linux/usleep.c: Real implementation based on
	nanosleep.

	* signal/signal.h: Change protoype of __sigpause to take two
	arguments.  Remove prototype for sigpause.  Add two different
	macros named sigpause selected when __USE_BSD or __USE_XOPEN
	are defined.  This is necessary since the old BSD definition
	of theis function collides with the X/Open definition.
	* sysdeps/posix/sigpause.c: Change function definition to also
	fit X/Open definition.

	* sysdeps/libm-i387/e_exp.S: Make sure stack is empty when the
	function is left.
	* sysdeps/libm-i387/e_expl.S: Likewise.
	Patch by HJ Lu.

1996-12-17  Paul Eggert  <eggert@twinsun.com>

	* many, many files: Spelling corrections.
	* catgets/catgetsinfo.h (mmapped):
	Renamed from mmaped (in struct catalog_info.status).
	* mach/err_kern.sub (err_codes_unix), string/stratcliff.c (main):
	Fix spelling in message.
	* po/libc.pot: Fix spelling in message for `zic'; this anticipates
	a fix in the tzcode distribution.

Wed Dec 18 15:48:02 1996  Ulrich Drepper  <drepper@cygnus.com>

	* time/strftime.c: Implement ^ flag to cause output be converted
	to use upper case characters.

	* time/zic.c: Update from ADO tzcode1996n.

Wed Dec 18 14:29:24 1996  Erik Naggum  <erik@naggum.no>

	* time/strftime.c (add): Don't change global `i' until all is over.
	Define NULL is not already defined.

Tue Dec 17 09:49:03 1996  Andreas Schwab  <schwab@issan.informatik.uni-dortmund.de>

	* libio/iovsprintf.c (_IO_vsprintf): Change `&sf' to `&sf._sbf._f'
	to avoid the need for a cast.
	* libio/iovsscanf.c (_IO_vsscanf): Likewise.

	* sunrpc/rpc/xdr.h: Add prototype for xdr_free.

1 files changed, 41 insertions, 42 deletions

diff --git a/stdlib/qsort.c b/stdlib/qsort.c
index bc8d171b79..0c83c48569 100644
--- a/stdlib/qsort.c
+++ b/stdlib/qsort.c
@@ -1,21 +1,21 @@
-/* Copyright (C) 1991, 1992 Free Software Foundation, Inc.
-This file is part of the GNU C Library.
-Written by Douglas C. Schmidt (schmidt@ics.uci.edu).
+/* Copyright (C) 1991, 1992, 1996 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+   Written by Douglas C. Schmidt (schmidt@ics.uci.edu).
 
-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 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.
+   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., 675 Mass Ave,
-Cambridge, MA 02139, USA.  */
+   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 <ansidecl.h>
 #include <stdlib.h>
@@ -40,7 +40,7 @@ Cambridge, MA 02139, USA.  */
 #define MAX_THRESH 4
 
 /* Stack node declarations used to store unfulfilled partition obligations. */
-typedef struct 
+typedef struct
   {
     char *lo;
     char *hi;
@@ -50,26 +50,26 @@ typedef struct
 #define STACK_SIZE	(8 * sizeof(unsigned long int))
 #define PUSH(low, high)	((void) ((top->lo = (low)), (top->hi = (high)), ++top))
 #define	POP(low, high)	((void) (--top, (low = top->lo), (high = top->hi)))
-#define	STACK_NOT_EMPTY	(stack < top)                
+#define	STACK_NOT_EMPTY	(stack < top)
 
 
 /* Order size using quicksort.  This implementation incorporates
    four optimizations discussed in Sedgewick:
 
-   1. Non-recursive, using an explicit stack of pointer that store the 
-      next array partition to sort.  To save time, this maximum amount 
-      of space required to store an array of MAX_INT is allocated on the 
-      stack.  Assuming a 32-bit integer, this needs only 32 * 
+   1. Non-recursive, using an explicit stack of pointer that store the
+      next array partition to sort.  To save time, this maximum amount
+      of space required to store an array of MAX_INT is allocated on the
+      stack.  Assuming a 32-bit integer, this needs only 32 *
       sizeof(stack_node) == 136 bits.  Pretty cheap, actually.
 
    2. Chose the pivot element using a median-of-three decision tree.
-      This reduces the probability of selecting a bad pivot value and 
+      This reduces the probability of selecting a bad pivot value and
       eliminates certain extraneous comparisons.
 
    3. Only quicksorts TOTAL_ELEMS / MAX_THRESH partitions, leaving
-      insertion sort to order the MAX_THRESH items within each partition.  
+      insertion sort to order the MAX_THRESH items within each partition.
       This is a big win, since insertion sort is faster for small, mostly
-      sorted array segements.
+      sorted array segments.
 
    4. The larger of the two sub-partitions is always pushed onto the
       stack first, with the algorithm then concentrating on the
@@ -108,8 +108,8 @@ DEFUN(_quicksort, (pbase, total_elems, size, cmp),
 	  char *pivot = pivot_buffer;
 
 	  /* Select median value from among LO, MID, and HI. Rearrange
-	     LO and HI so the three values are sorted. This lowers the 
-	     probability of picking a pathological pivot value and 
+	     LO and HI so the three values are sorted. This lowers the
+	     probability of picking a pathological pivot value and
 	     skips a comparison for both the LEFT_PTR and RIGHT_PTR. */
 
 	  char *mid = lo + size * ((hi - lo) / size >> 1);
@@ -118,7 +118,7 @@ DEFUN(_quicksort, (pbase, total_elems, size, cmp),
 	    SWAP(mid, lo, size);
 	  if ((*cmp)((PTR) hi, (PTR) mid) < 0)
 	    SWAP(mid, hi, size);
-	  else 
+	  else
 	    goto jump_over;
 	  if ((*cmp)((PTR) mid, (PTR) lo) < 0)
 	    SWAP(mid, lo, size);
@@ -127,12 +127,12 @@ DEFUN(_quicksort, (pbase, total_elems, size, cmp),
 	  pivot = pivot_buffer;
 
 	  left_ptr  = lo + size;
-	  right_ptr = hi - size; 
+	  right_ptr = hi - size;
 
-	  /* Here's the famous ``collapse the walls'' section of quicksort.  
-	     Gotta like those tight inner loops!  They are the main reason 
+	  /* Here's the famous ``collapse the walls'' section of quicksort.
+	     Gotta like those tight inner loops!  They are the main reason
 	     that this algorithm runs much faster than others. */
-	  do 
+	  do
 	    {
 	      while ((*cmp)((PTR) left_ptr, (PTR) pivot) < 0)
 		left_ptr += size;
@@ -140,23 +140,23 @@ DEFUN(_quicksort, (pbase, total_elems, size, cmp),
 	      while ((*cmp)((PTR) pivot, (PTR) right_ptr) < 0)
 		right_ptr -= size;
 
-	      if (left_ptr < right_ptr) 
+	      if (left_ptr < right_ptr)
 		{
 		  SWAP(left_ptr, right_ptr, size);
 		  left_ptr += size;
 		  right_ptr -= size;
 		}
-	      else if (left_ptr == right_ptr) 
+	      else if (left_ptr == right_ptr)
 		{
 		  left_ptr += size;
 		  right_ptr -= size;
 		  break;
 		}
-	    } 
+	    }
 	  while (left_ptr <= right_ptr);
 
           /* Set up pointers for next iteration.  First determine whether
-             left and right partitions are below the threshold size.  If so, 
+             left and right partitions are below the threshold size.  If so,
              ignore one or both.  Otherwise, push the larger partition's
              bounds on the stack and continue sorting the smaller one. */
 
@@ -164,22 +164,22 @@ DEFUN(_quicksort, (pbase, total_elems, size, cmp),
             {
               if ((size_t) (hi - left_ptr) <= max_thresh)
 		/* Ignore both small partitions. */
-                POP(lo, hi); 
+                POP(lo, hi);
               else
-		/* Ignore small left partition. */  
+		/* Ignore small left partition. */
                 lo = left_ptr;
             }
           else if ((size_t) (hi - left_ptr) <= max_thresh)
 	    /* Ignore small right partition. */
             hi = right_ptr;
           else if ((right_ptr - lo) > (hi - left_ptr))
-            {                   
+            {
 	      /* Push larger left partition indices. */
               PUSH(lo, right_ptr);
               lo = left_ptr;
             }
           else
-            {                   
+            {
 	      /* Push larger right partition indices. */
               PUSH(left_ptr, hi);
               hi = right_ptr;
@@ -188,8 +188,8 @@ DEFUN(_quicksort, (pbase, total_elems, size, cmp),
     }
 
   /* Once the BASE_PTR array is partially sorted by quicksort the rest
-     is completely sorted using insertion sort, since this is efficient 
-     for partitions below MAX_THRESH size. BASE_PTR points to the beginning 
+     is completely sorted using insertion sort, since this is efficient
+     for partitions below MAX_THRESH size. BASE_PTR points to the beginning
      of the array to sort, and END_PTR points at the very last element in
      the array (*not* one beyond it!). */
 
@@ -240,4 +240,3 @@ DEFUN(_quicksort, (pbase, total_elems, size, cmp),
       }
   }
 }
-