Update.

1997-04-21 13:25  Ulrich Drepper  <drepper@cygnus.com>

	* manual/arith.texi: Add description for INFINITY, _Imaginary_I,
	fpclassify & friends, and complex number operations.
	Update various other math functions for ISO C 9X.
	* manual/math.texi: Update various entries for ISO C 9X.
	Add description for complex number functions.
	Add description of rand48 function family.
	* manual/string.h: Add description of a64l and l64a.

	* math/cmathcalls.h: Fix typo.

	* stdlib/a64l.c: Pretty printing.

	* stdlib/seed48_r.c: Also reset `a' and `c' to default values.
	* stdlib/srand48_r.c: Likewise.
	* stdlib/stdlib.h: Pretty printing.

	* sysdeps/i386/fpu/__math.h: Fix typo.

	* sysdeps/libm-ieee754/s_nearbyintf.c: Correctly name function.
	* sysdeps/libm-ieee754/s_nearbyintl.c: Likewise.

1997-04-19 22:16  Andreas Schwab  <schwab@issan.informatik.uni-dortmund.de>

	* sysdeps/m68k/fpu/e_pow.c: Rewrite handling of integral exponent.

1997-04-18 19:34  Andreas Schwab  <schwab@issan.informatik.uni-dortmund.de>

	* sysdeps/m68k/fpu/__math.h: Define optimized versions of
	isgreater, isgreaterequal, isless, islessequal, islessgreater, and
	isunordered.

1997-04-20 01:28  Richard Henderson  <rth@tamu.edu>

	* rellns-sh: Handle files in the same directory correctly.

1997-04-20 11:22  Ulrich Drepper  <drepper@cygnus.com>

	* csu/initfini.c: Place ALIGN instruction at correct positions.
	Patch by Richard Henderson <richard@twiddle.rth.home>.

1997-04-19 17:12  Ulrich Drepper  <drepper@cygnus.com>

	* Make-dist: Don't automatically ignore .c files if the .S or .s file
	is ignored.

	* csu/Makefile (distribute): Add defs.awk.

1997-04-19 15:39  Ulrich Drepper  <drepper@cygnus.com>

	* sysdeps/stub/shmat.c: Update to XPG4.2 interface.
	* sysdeps/stub/shmdt.c: Likewise.
	Reported by Thomas Bushnell, n/BSG.

1997-04-19 13:22  Ulrich Drepper  <drepper@cygnus.com>

	* manual/stdio.texi: Add description of printf_size and
	printf_size_info.  Partly based on the documentation by Larry McVoy.

1997-04-19 02:21  Ulrich Drepper  <drepper@cygnus.com>

	* stdio-common/printf_size.c (printf_size): Correct values for
	`units'.
	Report by Larry McVoy <lm@neteng.engr.sgi.com>.
	* stdio-common/tst-printfsz.c: New file.
	* stdio-common/Makefile (tests): Add tst-printfsz.c.
	(CFLAGS-tst-printfsz.c): Define to prevent warnings about format
	strings.

1997-04-18 15:48  Ulrich Drepper  <drepper@cygnus.com>

	* login/utmp.h: Add prototype for updwtmp.
	* login/logwtmp.c: Add new function updwtmp which allows to write
	a complete record to the wtmp file.
	Patch by Miquel van Smoorenburg <miquels@cistron.nl>.

1997-04-17 17:57  Andreas Schwab  <schwab@issan.informatik.uni-dortmund.de>

	* math/Makefile (headers): Add mathbits.h.

1997-04-16 21:20  Andreas Schwab  <schwab@issan.informatik.uni-dortmund.de>

	* sysdeps/m68k/fpu/__math.h: Add inlined sincos{,l,f}.
	* sysdeps/m68k/fpu/s_sincos.c: New file.
	* sysdeps/m68k/fpu/s_sincosf.c: New file.
	* sysdeps/m68k/fpu/s_sincosl.c: New file.

	* sysdeps/libm-ieee754/e_scalb.c: Use internal names of the
	functions.
	* sysdeps/libm-ieee754/e_scalbl.c: Likewise.

	* sysdeps/libm-ieee754/s_ctanh.c: Use isfinite instead of finite.
	* sysdeps/libm-ieee754/s_ctanhf.c: Likewise.
	* sysdeps/libm-ieee754/s_ctanhl.c: Likewise.
	* sysdeps/libm-ieee754/s_ctan.c: Likewise.
	* sysdeps/libm-ieee754/s_ctanf.c: Likewise.
	* sysdeps/libm-ieee754/s_ctanl.c: Likewise.  Fix type of `res'.

1997-04-18 11:21  Ulrich Drepper  <drepper@cygnus.com>

	* shadow/fgetspent_r.c: Set *RESULT to NULL before returning error.
	Patch by Thorsten Kukuk <kukuk@vt.uni-paderborn.de>.

36 files changed, 1665 insertions, 233 deletions

diff --git a/ChangeLog b/ChangeLog
index 2ffac36869..92ddf3420a 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,107 @@
+1997-04-21 13:25  Ulrich Drepper  <drepper@cygnus.com>
+
+	* manual/arith.texi: Add description for INFINITY, _Imaginary_I,
+	fpclassify & friends, and complex number operations.
+	Update various other math functions for ISO C 9X.
+	* manual/math.texi: Update various entries for ISO C 9X.
+	Add description for complex number functions.
+	Add description of rand48 function family.
+	* manual/string.h: Add description of a64l and l64a.
+
+	* math/cmathcalls.h: Fix typo.
+
+	* stdlib/a64l.c: Pretty printing.
+
+	* stdlib/seed48_r.c: Also reset `a' and `c' to default values.
+	* stdlib/srand48_r.c: Likewise.
+	* stdlib/stdlib.h: Pretty printing.
+
+	* sysdeps/i386/fpu/__math.h: Fix typo.
+
+	* sysdeps/libm-ieee754/s_nearbyintf.c: Correctly name function.
+	* sysdeps/libm-ieee754/s_nearbyintl.c: Likewise.
+
+1997-04-19 22:16  Andreas Schwab  <schwab@issan.informatik.uni-dortmund.de>
+
+	* sysdeps/m68k/fpu/e_pow.c: Rewrite handling of integral exponent.
+
+1997-04-18 19:34  Andreas Schwab  <schwab@issan.informatik.uni-dortmund.de>
+
+	* sysdeps/m68k/fpu/__math.h: Define optimized versions of
+	isgreater, isgreaterequal, isless, islessequal, islessgreater, and
+	isunordered.
+
+1997-04-20 01:28  Richard Henderson  <rth@tamu.edu>
+
+	* rellns-sh: Handle files in the same directory correctly.
+
+1997-04-20 11:22  Ulrich Drepper  <drepper@cygnus.com>
+
+	* csu/initfini.c: Place ALIGN instruction at correct positions.
+	Patch by Richard Henderson <richard@twiddle.rth.home>.
+
+1997-04-19 17:12  Ulrich Drepper  <drepper@cygnus.com>
+
+	* Make-dist: Don't automatically ignore .c files if the .S or .s file
+	is ignored.
+
+	* csu/Makefile (distribute): Add defs.awk.
+
+1997-04-19 15:39  Ulrich Drepper  <drepper@cygnus.com>
+
+	* sysdeps/stub/shmat.c: Update to XPG4.2 interface.
+	* sysdeps/stub/shmdt.c: Likewise.
+	Reported by Thomas Bushnell, n/BSG.
+
+1997-04-19 13:22  Ulrich Drepper  <drepper@cygnus.com>
+
+	* manual/stdio.texi: Add description of printf_size and
+	printf_size_info.  Partly based on the documentation by Larry McVoy.
+
+1997-04-19 02:21  Ulrich Drepper  <drepper@cygnus.com>
+
+	* stdio-common/printf_size.c (printf_size): Correct values for
+	`units'.
+	Report by Larry McVoy <lm@neteng.engr.sgi.com>.
+	* stdio-common/tst-printfsz.c: New file.
+	* stdio-common/Makefile (tests): Add tst-printfsz.c.
+	(CFLAGS-tst-printfsz.c): Define to prevent warnings about format
+	strings.
+
+1997-04-18 15:48  Ulrich Drepper  <drepper@cygnus.com>
+
+	* login/utmp.h: Add prototype for updwtmp.
+	* login/logwtmp.c: Add new function updwtmp which allows to write
+	a complete record to the wtmp file.
+	Patch by Miquel van Smoorenburg <miquels@cistron.nl>.
+
+1997-04-17 17:57  Andreas Schwab  <schwab@issan.informatik.uni-dortmund.de>
+
+	* math/Makefile (headers): Add mathbits.h.
+
+1997-04-16 21:20  Andreas Schwab  <schwab@issan.informatik.uni-dortmund.de>
+
+	* sysdeps/m68k/fpu/__math.h: Add inlined sincos{,l,f}.
+	* sysdeps/m68k/fpu/s_sincos.c: New file.
+	* sysdeps/m68k/fpu/s_sincosf.c: New file.
+	* sysdeps/m68k/fpu/s_sincosl.c: New file.
+
+	* sysdeps/libm-ieee754/e_scalb.c: Use internal names of the
+	functions.
+	* sysdeps/libm-ieee754/e_scalbl.c: Likewise.
+
+	* sysdeps/libm-ieee754/s_ctanh.c: Use isfinite instead of finite.
+	* sysdeps/libm-ieee754/s_ctanhf.c: Likewise.
+	* sysdeps/libm-ieee754/s_ctanhl.c: Likewise.
+	* sysdeps/libm-ieee754/s_ctan.c: Likewise.
+	* sysdeps/libm-ieee754/s_ctanf.c: Likewise.
+	* sysdeps/libm-ieee754/s_ctanl.c: Likewise.  Fix type of `res'.
+
+1997-04-18 11:21  Ulrich Drepper  <drepper@cygnus.com>
+
+	* shadow/fgetspent_r.c: Set *RESULT to NULL before returning error.
+	Patch by Thorsten Kukuk <kukuk@vt.uni-paderborn.de>.
+
 1997-04-18 02:18  Ulrich Drepper  <drepper@cygnus.com>
 
 	* csu/initfini.c: Rewrite by Zack Weinberg
diff --git a/Make-dist b/Make-dist
index afc7bb48a9..bacc8655a9 100644
--- a/Make-dist
+++ b/Make-dist
@@ -118,8 +118,8 @@ foo:=$(shell echo '+out=$(+out)' >&2; echo foofoo >&2)
 	   $(+sysdeps)
 foo:=$(shell echo 'made +tsrcs=$(+tsrcs)'>&2)
 foo:=$(shell echo generated='$(generated)' >&2)
-generated := $(sort $(generated) $(generated:.S=.c) $(generated:.s=.c))
-foo:=$(shell echo now generated='$(generated)' >&2)
+#generated := $(sort $(generated) $(generated:.S=.c) $(generated:.s=.c))
+#foo:=$(shell echo now generated='$(generated)' >&2)
 +tsrcs := $(sort $(filter-out $(generated),$(+tsrcs)))
 foo:=$(shell echo '+tsrcs=$(+tsrcs)'>&2)
 foo:=$(shell echo foobie, dammit! >&2)
diff --git a/config.guess b/config.guess
index 5ef19b5a18..b6f37c9919 100755
--- a/config.guess
+++ b/config.guess
@@ -70,17 +70,23 @@ case "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" in
     amiga:OpenBSD:*:*)
 	echo m68k-unknown-openbsd${UNAME_RELEASE}
 	exit 0 ;;
-    arc:OpenBSD:*:*)
+    arc64:OpenBSD:*:*)
 	echo mips64el-unknown-openbsd${UNAME_RELEASE}
 	exit 0 ;;
-    laguna:OpenBSD:*:*)
-	echo mips64-unknown-openbsd${UNAME_RELEASE}
+    arc:OpenBSD:*:*)
+	echo mipsel-unknown-openbsd${UNAME_RELEASE}
+	exit 0 ;;
+    hkmips:OpenBSD:*:*)
+	echo mips-unknown-openbsd${UNAME_RELEASE}
 	exit 0 ;;
     pmax:OpenBSD:*:*)
-	echo mips64el-unknown-openbsd${UNAME_RELEASE}
+	echo mipsel-unknown-openbsd${UNAME_RELEASE}
+	exit 0 ;;
+    sgi:OpenBSD:*:*)
+	echo mips-unknown-openbsd${UNAME_RELEASE}
 	exit 0 ;;
     wgrisc:OpenBSD:*:*)
-	echo mips64el-unknown-openbsd${UNAME_RELEASE}
+	echo mipsel-unknown-openbsd${UNAME_RELEASE}
 	exit 0 ;;
     arm:RISC*:1.[012]*:*|arm:riscix:1.[012]*:*)
 	echo arm-acorn-riscix${UNAME_RELEASE}
diff --git a/csu/initfini.c b/csu/initfini.c
index 96ee7bc2ae..6906c901c4 100644
--- a/csu/initfini.c
+++ b/csu/initfini.c
@@ -76,12 +76,12 @@ _init (void)
   if (__gmon_start__)
     __gmon_start__ ();
 
+  asm ("ALIGN");
   asm("END_INIT");
   /* Now the epilog. */
   asm ("\n/*@_init_PROLOG_ENDS*/");
   asm ("\n/*@_init_EPILOG_BEGINS*/");
   SECTION(".init");
-  asm ("ALIGN");
 }
 asm ("END_INIT");
 
@@ -95,6 +95,7 @@ _fini (void)
 {
 
   /* End of the _fini prolog. */
+  asm ("ALIGN");
   asm ("END_FINI");
   asm ("\n/*@_fini_PROLOG_ENDS*/");
 
@@ -109,7 +110,6 @@ _fini (void)
   /* Beginning of the _fini epilog. */
   asm ("\n/*@_fini_EPILOG_BEGINS*/");
   SECTION (".fini");
-  asm ("ALIGN");
 }
 asm ("END_FINI");
 
@@ -117,6 +117,5 @@ asm ("END_FINI");
    is shared between both crt files. */
 asm ("\n/*@_fini_EPILOG_ENDS*/");
 asm ("\n/*@TRAILER_BEGINS*/");
-asm ("ALIGN");
 
 /* End of file. */
diff --git a/login/logwtmp.c b/login/logwtmp.c
index 876388323f..b6af813e73 100644
--- a/login/logwtmp.c
+++ b/login/logwtmp.c
@@ -1,4 +1,4 @@
-/* Copyright (C) 1996 Free Software Foundation, Inc.
+/* Copyright (C) 1996, 1997 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Ulrich Drepper <drepper@cygnus.com>, 1996.
 
@@ -25,38 +25,17 @@
 #include <sys/stat.h>
 
 void
-logwtmp (const char *line, const char *name, const char *host)
+updwtmp (const char *wtmp_file, const struct utmp *ut)
 {
-  struct utmp ut;
   struct stat st;
   size_t written;
   int fd;
 
   /* Open WTMP file.  */
-  fd = __open (_PATH_WTMP, O_WRONLY | O_APPEND);
+  fd = __open (wtmp_file, O_WRONLY | O_APPEND);
   if (fd < 0)
       return;
 
-  /* Set information in new entry.  */
-  memset (&ut, 0, sizeof (ut));
-#if _HAVE_UT_PID - 0
-  ut.ut_pid = getpid ();
-#endif
-#if _HAVE_UT_TYPE - 0
-  ut.ut_type = name[0] ? USER_PROCESS : DEAD_PROCESS;
-#endif
-  strncpy (ut.ut_line, line, sizeof ut.ut_line);
-  strncpy (ut.ut_name, name, sizeof ut.ut_name);
-#if _HAVE_UT_HOST - 0
-  strncpy (ut.ut_host, host, sizeof ut.ut_host);
-#endif
-
-#if _HAVE_UT_TV - 0
-  __gettimeofday (&ut.ut_tv, NULL);
-#else
-  time (&ut.ut_time);
-#endif
-
   /* Try to lock the file.  */
   if (__flock (fd, LOCK_EX | LOCK_NB) < 0 && errno != ENOSYS)
     {
@@ -74,8 +53,8 @@ logwtmp (const char *line, const char *name, const char *host)
   /* Write the entry.  If we can't write all the bytes, reset the file
      size back to the original size.  That way, no partial entries
      will remain.  */
-  written = __write (fd, &ut, sizeof (ut));
-  if (written > 0 && written != sizeof (ut))
+  written = __write (fd, ut, sizeof (struct utmp));
+  if (written > 0 && written != sizeof (struct utmp))
     ftruncate (fd, st.st_size);
 
 done:
@@ -85,3 +64,31 @@ done:
   /* Close WTMP file.  */
   __close (fd);
 }
+
+void
+logwtmp (const char *line, const char *name, const char *host)
+{
+  struct utmp ut;
+
+  /* Set information in new entry.  */
+  memset (&ut, 0, sizeof (ut));
+#if _HAVE_UT_PID - 0
+  ut.ut_pid = getpid ();
+#endif
+#if _HAVE_UT_TYPE - 0
+  ut.ut_type = name[0] ? USER_PROCESS : DEAD_PROCESS;
+#endif
+  strncpy (ut.ut_line, line, sizeof ut.ut_line);
+  strncpy (ut.ut_name, name, sizeof ut.ut_name);
+#if _HAVE_UT_HOST - 0
+  strncpy (ut.ut_host, host, sizeof ut.ut_host);
+#endif
+
+#if _HAVE_UT_TV - 0
+  __gettimeofday (&ut.ut_tv, NULL);
+#else
+  time (&ut.ut_time);
+#endif
+
+  updwtmp(_PATH_WTMP, &ut);
+}
diff --git a/login/utmp.h b/login/utmp.h
index 2e87070537..9be0ec5b06 100644
--- a/login/utmp.h
+++ b/login/utmp.h
@@ -49,6 +49,10 @@ extern void login __P ((__const struct utmp *__entry));
 /* Write the utmp entry to say the user on UT_LINE has logged out.  */
 extern int logout __P ((__const char *__ut_line));
 
+/* Append the given entry to a wtmp file.  */
+extern void updwtmp __P ((__const char *__wtmp_file,
+			  __const struct utmp *__entry));
+
 /* Append to wtmp an entry for the current time and the given info.  */
 extern void logwtmp __P ((__const char *__ut_line, __const char *__ut_name,
 			  __const char *__ut_host));
diff --git a/manual/arith.texi b/manual/arith.texi
index d8703ea6c1..86fb2667a0 100644
--- a/manual/arith.texi
+++ b/manual/arith.texi
@@ -3,12 +3,17 @@
 
 This chapter contains information about functions for doing basic
 arithmetic operations, such as splitting a float into its integer and
-fractional parts.  These functions are declared in the header file
-@file{math.h}.
+fractional parts or retrieving the imaginary part of a complex value.
+These functions are declared in the header files @file{math.h} and
+@file{complex.h}.
 
 @menu
+* Infinity::                    What is Infinity and how to test for it.
 * Not a Number::                Making NaNs and testing for NaNs.
+* Imaginary Unit::              Constructing complex Numbers.
 * Predicates on Floats::        Testing for infinity and for NaNs.
+* Floating-Point Classes::      Classifiy floating-point numbers.
+* Operations on Complex::       Projections, Conjugates, and Decomposing.
 * Absolute Value::              Absolute value functions.
 * Normalization Functions::     Hacks for radix-2 representations.
 * Rounding and Remainders::     Determining the integer and
@@ -19,6 +24,44 @@ fractional parts.  These functions are declared in the header file
 			         from strings.
 @end menu
 
+@node Infinity
+@section Infinity Values
+@cindex Infinity
+@cindex IEEE floating point
+
+Mathematical operations easily can produce as the result values which
+are not representable by the floating-point format.  The functions in
+the mathematics library also have this problem.  The situation is
+generally solved by raising an overflow exception and by returning a
+huge value.
+
+The @w{IEEE 754} floating-point defines a special value to be used in
+these situations.  There is a special value for infinity.
+
+@comment math.h
+@comment ISO
+@deftypevr Macro float_t INFINITY
+A expression representing the inifite value.  @code{INFINITY} values are
+produce by mathematical operations like @code{1.0 / 0.0}.  It is
+possible to continue the computations with this value since the basic
+operations as well as the mathematical library functions are prepared to
+handle values like this.
+
+Beside @code{INFINITY} also the value @code{-INIFITY} is representable
+and it is handled differently if needed.  It is possible to test a
+variables for infinite value using a simple comparison but the
+recommended way is to use the the @code{isinf} function.
+
+This macro was introduced in the @w{ISO C 9X} standard.
+@end deftypevr
+
+@vindex HUGE_VAL
+The macros @code{HUGE_VAL}, @code{HUGE_VALF} and @code{HUGE_VALL} are
+defined in a similar way but they are not required to represent the
+infinite value, only a very large value (@pxref{Domain and Range Errors}).
+If actually infinity is wanted, @code{INFINITY} should be used.
+
+
 @node Not a Number
 @section ``Not a Number'' Values
 @cindex NaN
@@ -54,6 +97,46 @@ such as by defining @code{_GNU_SOURCE}, and then you must include
 @file{math.h}.)
 @end deftypevr
 
+@node Imaginary Unit
+@section Constructing complex Numbers
+
+@pindex complex.h
+To construct complex numbers it is necessary have a way to express the
+imaginary part of the numbers.  In mathematics one uses the symbol ``i''
+to mark a number as imaginary.  For convenienve the @file{complex.h}
+header defines two macros which allow to use a similar easy notation.
+
+@deftypevr Macro float_t _Imaginary_I
+This macro is a (compiler specific) representation of the value ``1i''.
+I.e., it is the value for which
+
+@smallexample
+_Imaginary_I * _Imaginary_I = -1
+@end smallexample
+
+@noindent
+One can use it to easily construct complex number like in
+
+@smallexample
+3.0 - _Imaginary_I * 4.0
+@end smallexample
+
+@noindent
+which results in the complex number with a real part of 3.0 and a
+imaginary part -4.0.
+@end deftypevr
+
+@noindent
+A more intuitive approach is to use the following macro.
+
+@deftypevr Macro float_t I
+This macro has exactly the same value as @code{_Imaginary_I}.  The
+problem is that the name @code{I} very easily can clash with macros or
+variables in programs and so it might be a good idea to avoid this name
+and stay at the safe side by using @code{_Imaginary_I}.
+@end deftypevr
+
+
 @node Predicates on Floats
 @section Predicates on Floats
 
@@ -66,6 +149,10 @@ functions, and thus are available if you define @code{_BSD_SOURCE} or
 @comment math.h
 @comment BSD
 @deftypefun int isinf (double @var{x})
+@end deftypefun
+@deftypefun int isinff (float @var{x})
+@end deftypefun
+@deftypefun int isinfl (long double @var{x})
 This function returns @code{-1} if @var{x} represents negative infinity,
 @code{1} if @var{x} represents positive infinity, and @code{0} otherwise.
 @end deftypefun
@@ -73,6 +160,10 @@ This function returns @code{-1} if @var{x} represents negative infinity,
 @comment math.h
 @comment BSD
 @deftypefun int isnan (double @var{x})
+@end deftypefun
+@deftypefun int isnanf (float @var{x})
+@end deftypefun
+@deftypefun int isnanl (long double @var{x})
 This function returns a nonzero value if @var{x} is a ``not a number''
 value, and zero otherwise.  (You can just as well use @code{@var{x} !=
 @var{x}} to get the same result).
@@ -81,6 +172,10 @@ value, and zero otherwise.  (You can just as well use @code{@var{x} !=
 @comment math.h
 @comment BSD
 @deftypefun int finite (double @var{x})
+@end deftypefun
+@deftypefun int finitef (float @var{x})
+@end deftypefun
+@deftypefun int finitel (long double @var{x})
 This function returns a nonzero value if @var{x} is finite or a ``not a
 number'' value, and zero otherwise.
 @end deftypefun
@@ -103,6 +198,189 @@ does not fit the @w{ISO C} specification.
 @strong{Portability Note:} The functions listed in this section are BSD
 extensions.
 
+@node Floating-Point Classes
+@section Floating-Point Number Classification Functions
+
+Instead of using the BSD specific functions from the last section it is
+better to use those in this section will are introduced in the @w{ISO C
+9X} standard and are therefore widely available.
+
+@comment math.h
+@comment ISO
+@deftypefun int fpclassify (@emph{float-type} @var{x})
+This is a generic macro which works on all floating-point types and
+which returns a value of type @code{int}.  The possible values are:
+
+@vtable @code
+@item FP_NAN
+  The floating-point number @var{x} is ``Not a Number'' (@pxref{Not a Number})
+@item FP_INFINITE
+  The value of @var{x} is either plus or minus infinity (@pxref{Infinity})
+@item FP_ZERO
+  The value of @var{x} is zero.  In floating-point formats like @w{IEEE
+  754} where the zero value can be signed this value is also returned if
+  @var{x} is minus zero.
+@item FP_SUBNORMAL
+  Some floating-point formats (such as @w{IEEE 754}) allow floating-point
+  numbers to be represented in a denormalized format.  This happens if the
+  absolute value of the number is too small to be represented in the
+  normal format.  @code{FP_SUBNORMAL} is returned for such values of @var{x}.
+@item FP_NORMAL
+  This value is returned for all other cases which means the number is a
+  plain floating-point number without special meaning.
+@end vtable
+
+This macro is useful if more than property of a number must be
+tested.  If one only has to test for, e.g., a NaN value, there are
+function which are faster.
+@end deftypefun
+
+The remainder of this section introduces some more specific functions.
+They might be implemented faster than the call to @code{fpclassify} and
+if the actual need in the program is covered be these functions they
+should be used (and not @code{fpclassify}).
+
+@comment math.h
+@comment ISO
+@deftypefun int isfinite (@emph{float-type} @var{x})
+The value returned by this macro is nonzero if the value of @var{x} is
+not plus or minus infinity and not NaN.  I.e., it could be implemented as
+
+@smallexample
+(fpclassify (x) != FP_NAN && fpclassify (x) != FP_INFINITE)
+@end smallexample
+
+@code{isfinite} is also implemented as a macro which can handle all
+floating-point types.  Programs should use this function instead of
+@var{finite} (@pxref{Predicates on Floats}).
+@end deftypefun
+
+@comment math.h
+@comment ISO
+@deftypefun int isnormal (@emph{float-type} @var{x})
+If @code{isnormal} returns a nonzero value the value or @var{x} is
+neither a NaN, infinity, zero, nor a denormalized number.  I.e., it
+could be implemented as
+
+@smallexample
+(fpclassify (x) == FP_NORMAL)
+@end smallexample
+@end deftypefun
+
+@comment math.h
+@comment ISO
+@deftypefun int isnan (@emph{float-type} @var{x})
+The situation with this macro is a bit complicated.  Here @code{isnan}
+is a macro which can handle all kinds of floating-point types.  It
+returns a nonzero value is @var{x} does not represent a NaN value and
+could be written like this
+
+@smallexample
+(fpclassify (x) == FP_NAN)
+@end smallexample
+
+The complication is that there is a function of the same name and the
+same semantic defined for compatibility with BSD (@pxref{Predicates on
+Floats}).  Fortunately this should not yield to problems in most cases
+since the macro and the function have the same semantic.  Should in a
+situation the function be absolutely necessary one can use
+
+@smallexample
+(isnan) (x)
+@end smallexample
+
+@noindent
+to avoid the macro expansion.  Using the macro has two big adavantages:
+it is more portable and one does not have to choose the right function
+among @code{isnan}, @code{isnanf}, and @code{isnanl}.
+@end deftypefun
+
+
+@node Operations on Complex
+@section Projections, Conjugates, and Decomposing of Complex Numbers
+@cindex project complex numbers
+@cindex conjugate complex numbers
+@cindex decompose complex numbers
+
+This section lists functions performing some of the simple mathematical
+operations on complex numbers.  Using any of the function requries that
+the C compiler understands the @code{complex} keyword, introduced to the
+C language in the @w{ISO C 9X} standard.
+
+@pindex complex.h
+The prototypes for all functions in this section can be found in
+@file{complex.h}.  All functions are available in three variants, one
+for each of the three floating-point types.
+
+The easiest operation on complex numbers is the decomposition in the
+real part and the imaginary part.  This is done by the next two
+functions.
+
+@comment complex.h
+@comment ISO
+@deftypefun double creal (complex double @var{z})
+@end deftypefun
+@deftypefun float crealf (complex float @var{z})
+@end deftypefun
+@deftypefun {long double} creall (complex long double @var{z})
+These functions return the real part of the complex number @var{z}.
+@end deftypefun
+
+@comment complex.h
+@comment ISO
+@deftypefun double cimag (complex double @var{z})
+@end deftypefun
+@deftypefun float cimagf (complex float @var{z})
+@end deftypefun
+@deftypefun {long double} cimagl (complex long double @var{z})
+These functions return the imaginary part of the complex number @var{z}.
+@end deftypefun
+
+
+The conjugate complex value of a given complex number has the same value
+for the real part but the complex part is negated.
+
+@comment complex.h
+@comment ISO
+@deftypefun {complex double} conj (complex double @var{z})
+@end deftypefun
+@deftypefun {complex float} conjf (complex float @var{z})
+@end deftypefun
+@deftypefun {complex long double} conjl (complex long double @var{z})
+These functions return the conjugate complex value of the complex number
+@var{z}.
+@end deftypefun
+
+@comment complex.h
+@comment ISO
+@deftypefun double carg (complex double @var{z})
+@end deftypefun
+@deftypefun float cargf (complex float @var{z})
+@end deftypefun
+@deftypefun {long double} cargl (complex long double @var{z})
+These functions return argument of the complex number @var{z}.
+
+Mathematically, the argument is the phase angle of @var{z} with a branch
+cut along the negative real axis.
+@end deftypefun
+
+@comment complex.h
+@comment ISO
+@deftypefun {complex double} cproj (complex double @var{z})
+@end deftypefun
+@deftypefun {complex float} cprojf (complex float @var{z})
+@end deftypefun
+@deftypefun {complex long double} cprojl (complex long double @var{z})
+Return the projection of the complex value @var{z} on the Riemann
+sphere.  Values with a infinite complex part (even if the real part
+is NaN) are projected to positive infinte on the real axis.  If the real part is infinite, the result is equivalent to
+
+@smallexample
+INFINITY + I * copysign (0.0, cimag (z))
+@end smallexample
+@end deftypefun
+
+
 @node Absolute Value
 @section Absolute Value
 @cindex absolute value functions
@@ -117,7 +395,8 @@ whose imaginary part is @var{y}, the absolute value is @w{@code{sqrt
 @pindex math.h
 @pindex stdlib.h
 Prototypes for @code{abs} and @code{labs} are in @file{stdlib.h};
-@code{fabs} and @code{cabs} are declared in @file{math.h}.
+@code{fabs}, @code{fabsf} and @code{fabsl} are declared in @file{math.h};
+@code{cabs}, @code{cabsf} and @code{cabsl} are declared in @file{complex.h}.
 
 @comment stdlib.h
 @comment ISO
@@ -139,20 +418,28 @@ are of type @code{long int} rather than @code{int}.
 @comment math.h
 @comment ISO
 @deftypefun double fabs (double @var{number})
+@end deftypefun
+@deftypefun float fabsf (float @var{number})
+@end deftypefun
+@deftypefun {long double} fabsl (long double @var{number})
 This function returns the absolute value of the floating-point number
 @var{number}.
 @end deftypefun
 
-@comment math.h
-@comment BSD
-@deftypefun double cabs (struct @{ double real, imag; @} @var{z})
-The @code{cabs} function returns the absolute value of the complex
-number @var{z}, whose real part is @code{@var{z}.real} and whose
-imaginary part is @code{@var{z}.imag}.  (See also the function
-@code{hypot} in @ref{Exponents and Logarithms}.)  The value is:
+@comment complex.h
+@comment ISO
+@deftypefun double cabs (complex double @var{z})
+@end deftypefun
+@deftypefun float cabsf (complex float @var{z})
+@end deftypefun
+@deftypefun {long double} cabsl (complex long double @var{z})
+These functions return the absolute value of the complex number @var{z}.
+The compiler must support complex numbers to use these functions.  (See
+also the function @code{hypot} in @ref{Exponents and Logarithms}.)  The
+value is:
 
 @smallexample
-sqrt (@var{z}.real*@var{z}.real + @var{z}.imag*@var{z}.imag)
+sqrt (creal (@var{z}) * creal (@var{z}) + cimag (@var{z}) * cimag (@var{z}))
 @end smallexample
 @end deftypefun
 
@@ -174,7 +461,11 @@ All these functions are declared in @file{math.h}.
 @comment math.h
 @comment ISO
 @deftypefun double frexp (double @var{value}, int *@var{exponent})
-The @code{frexp} function is used to split the number @var{value}
+@end deftypefun
+@deftypefun float frexpf (float @var{value}, int *@var{exponent})
+@end deftypefun
+@deftypefun {long double} frexpl (long double @var{value}, int *@var{exponent})
+These functions are used to split the number @var{value}
 into a normalized fraction and an exponent.
 
 If the argument @var{value} is not zero, the return value is @var{value}
@@ -193,7 +484,11 @@ zero is stored in @code{*@var{exponent}}.
 @comment math.h
 @comment ISO
 @deftypefun double ldexp (double @var{value}, int @var{exponent})
-This function returns the result of multiplying the floating-point
+@end deftypefun
+@deftypefun float ldexpf (float @var{value}, int @var{exponent})
+@end deftypefun
+@deftypefun {long double} ldexpl (long double @var{value}, int @var{exponent})
+These functions return the result of multiplying the floating-point
 number @var{value} by 2 raised to the power @var{exponent}.  (It can
 be used to reassemble floating-point numbers that were taken apart
 by @code{frexp}.)
@@ -207,13 +502,21 @@ equivalent to those of @code{ldexp} and @code{frexp}:
 @comment math.h
 @comment BSD
 @deftypefun double scalb (double @var{value}, int @var{exponent})
+@end deftypefun
+@deftypefun float scalbf (float @var{value}, int @var{exponent})
+@end deftypefun
+@deftypefun {long double} scalbl (long double @var{value}, int @var{exponent})
 The @code{scalb} function is the BSD name for @code{ldexp}.
 @end deftypefun
 
 @comment math.h
 @comment BSD
 @deftypefun double logb (double @var{x})
-This BSD function returns the integer part of the base-2 logarithm of
+@end deftypefun
+@deftypefun float logbf (float @var{x})
+@end deftypefun
+@deftypefun {long double} logbl (long double @var{x})
+These BSD functions return the integer part of the base-2 logarithm of
 @var{x}, an integer value represented in type @code{double}.  This is
 the highest integer power of @code{2} contained in @var{x}.  The sign of
 @var{x} is ignored.  For example, @code{logb (3.5)} is @code{1.0} and
@@ -231,11 +534,28 @@ The value returned by @code{logb} is one less than the value that
 @end deftypefun
 
 @comment math.h
-@comment BSD
+@comment ISO
 @deftypefun double copysign (double @var{value}, double @var{sign})
-The @code{copysign} function returns a value whose absolute value is the
+@end deftypefun
+@deftypefun float copysignf (float @var{value}, float @var{sign})
+@end deftypefun
+@deftypefun {long double} copysignl (long double @var{value}, long double @var{sign})
+These functions return a value whose absolute value is the
 same as that of @var{value}, and whose sign matches that of @var{sign}.
-This is a BSD function.
+This function appears in BSD and was standardized in @w{ISO C 9X}.
+@end deftypefun
+
+@comment math.h
+@comment ISO
+@deftypefun int signbit (@emph{float-type} @var{x})
+@code{signbit} is a generic macro which can work on all floating-point
+types.  It returns a nonzero value if the value of @var{x} has its sign
+bit set.
+
+This is not the same as @code{x < 0.0} since in some floating-point
+formats (e.g., @w{IEEE 754}) the zero value is optionally signed.  The
+comparison @code{-0.0 < 0.0} will not be true while @code{signbit
+(-0.0)} will return a nonzeri value.
 @end deftypefun
 
 @node Rounding and Remainders
@@ -260,7 +580,11 @@ result as a @code{double} instead to get around this problem.
 @comment math.h
 @comment ISO
 @deftypefun double ceil (double @var{x})
-The @code{ceil} function rounds @var{x} upwards to the nearest integer,
+@end deftypefun
+@deftypefun float ceilf (float @var{x})
+@end deftypefun
+@deftypefun {long double} ceill (long double @var{x})
+These functions round @var{x} upwards to the nearest integer,
 returning that value as a @code{double}.  Thus, @code{ceil (1.5)}
 is @code{2.0}.
 @end deftypefun
@@ -268,15 +592,23 @@ is @code{2.0}.
 @comment math.h
 @comment ISO
 @deftypefun double floor (double @var{x})
-The @code{ceil} function rounds @var{x} downwards to the nearest
+@end deftypefun
+@deftypefun float floorf (float @var{x})
+@end deftypefun
+@deftypefun {long double} floorl (long double @var{x})
+These functions round @var{x} downwards to the nearest
 integer, returning that value as a @code{double}.  Thus, @code{floor
 (1.5)} is @code{1.0} and @code{floor (-1.5)} is @code{-2.0}.
 @end deftypefun
 
 @comment math.h
-@comment BSD
+@comment ISO
 @deftypefun double rint (double @var{x})
-This function rounds @var{x} to an integer value according to the
+@end deftypefun
+@deftypefun float rintf (float @var{x})
+@end deftypefun
+@deftypefun {long double} rintl (long double @var{x})
+These functions round @var{x} to an integer value according to the
 current rounding mode.  @xref{Floating Point Parameters}, for
 information about the various rounding modes.  The default
 rounding mode is to round to the nearest integer; some machines
@@ -286,8 +618,24 @@ you explicit select another.
 
 @comment math.h
 @comment ISO
+@deftypefun double nearbyint (double @var{x})
+@end deftypefun
+@deftypefun float nearbyintf (float @var{x})
+@end deftypefun
+@deftypefun {long double} nearbyintl (long double @var{x})
+These functions return the same value as the @code{rint} functions but
+even some rounding actually takes place @code{nearbyint} does @emph{not}
+raise the inexact exception.
+@end deftypefun
+
+@comment math.h
+@comment ISO
 @deftypefun double modf (double @var{value}, double *@var{integer-part})
-This function breaks the argument @var{value} into an integer part and a
+@end deftypefun
+@deftypefun float modff (flaot @var{value}, float *@var{integer-part})
+@end deftypefun
+@deftypefun {long double} modfl (long double @var{value}, long double *@var{integer-part})
+These functions break the argument @var{value} into an integer part and a
 fractional part (between @code{-1} and @code{1}, exclusive).  Their sum
 equals @var{value}.  Each of the parts has the same sign as @var{value},
 so the rounding of the integer part is towards zero.
@@ -300,7 +648,11 @@ returns @code{0.5} and stores @code{2.0} into @code{intpart}.
 @comment math.h
 @comment ISO
 @deftypefun double fmod (double @var{numerator}, double @var{denominator})
-This function computes the remainder from the division of
+@end deftypefun
+@deftypefun float fmodf (float @var{numerator}, float @var{denominator})
+@end deftypefun
+@deftypefun {long double} fmodl (long double @var{numerator}, long double @var{denominator})
+These functions compute the remainder from the division of
 @var{numerator} by @var{denominator}.  Specifically, the return value is
 @code{@var{numerator} - @w{@var{n} * @var{denominator}}}, where @var{n}
 is the quotient of @var{numerator} divided by @var{denominator}, rounded
@@ -317,7 +669,11 @@ If @var{denominator} is zero, @code{fmod} fails and sets @code{errno} to
 @comment math.h
 @comment BSD
 @deftypefun double drem (double @var{numerator}, double @var{denominator})
-The function @code{drem} is like @code{fmod} except that it rounds the
+@end deftypefun
+@deftypefun float dremf (float @var{numerator}, float @var{denominator})
+@end deftypefun
+@deftypefun {long double} dreml (long double @var{numerator}, long double @var{denominator})
+These functions are like @code{fmod} etc except that it rounds the
 internal quotient @var{n} to the nearest integer instead of towards zero
 to an integer.  For example, @code{drem (6.5, 2.3)} returns @code{-0.4},
 which is @code{6.5} minus @code{6.9}.
diff --git a/manual/math.texi b/manual/math.texi
index 543647297f..78d567b367 100644
--- a/manual/math.texi
+++ b/manual/math.texi
@@ -7,14 +7,22 @@ these functions have prototypes declared in the header file
 @file{math.h}.
 @pindex math.h
 
-All of the functions that operate on floating-point numbers accept
-arguments and return results of type @code{double}.  In the future,
-there may be additional functions that operate on @code{float} and
-@code{long double} values.  For example, @code{cosf} and @code{cosl}
-would be versions of the @code{cos} function that operate on
-@code{float} and @code{long double} arguments, respectively.  In the
-meantime, you should avoid using these names yourself.  @xref{Reserved
-Names}.
+For all functions which take a single floating-point argument and for
+several other functions as well there are three different functions
+available for the type @code{double}, @code{float}, and @code{long
+double}.  The @code{double} versions of the functions are mostly defined
+even in the @w{ISO C 89} standard.  The @code{float} and @code{long
+double} variants are introduced in the numeric extensions for the C
+language which are part of the @w{ISO C 9X} standard.
+
+Which of the three versions of the function should be used depends on
+the situation.  For most functions and implementation it is true that
+speed and precision do not go together.  I.e., the @code{float} versions
+are normally faster than the @code{double} and @code{long double}
+versions.  On the other hand the @code{long double} version has the
+highest precision.  One should always think about the actual needs and
+in case of double using @code{double} is a good compromise.
+
 
 @menu
 * Domain and Range Errors::     Detecting overflow conditions and the like.
@@ -119,11 +127,15 @@ The arguments to all of these functions are in units of radians; recall
 that pi radians equals 180 degrees.
 
 @cindex pi (trigonometric constant)
-The math library doesn't define a symbolic constant for pi, but you can
-define your own if you need one:
+The math library does define a symbolic constant for pi in @file{math.h}
+when BSD compliance is required (@pxref{Feature Test Macros}).  Beside
+pi several other constants are defined.
+
+@noindent
+In case it is not possible to use this macro one easily can define it:
 
 @smallexample
-#define PI 3.14159265358979323846264338327
+#define M_PI 3.14159265358979323846264338327
 @end smallexample
 
 @noindent
@@ -134,21 +146,33 @@ You can also compute the value of pi with the expression @code{acos
 @comment math.h
 @comment ISO
 @deftypefun double sin (double @var{x})
-This function returns the sine of @var{x}, where @var{x} is given in
+@end deftypefun
+@deftypefun float sinf (float @var{x})
+@end deftypefun
+@deftypefun {long double} sinl (long double @var{x})
+These functions return the sine of @var{x}, where @var{x} is given in
 radians.  The return value is in the range @code{-1} to @code{1}.
 @end deftypefun
 
 @comment math.h
 @comment ISO
 @deftypefun double cos (double @var{x})
-This function returns the cosine of @var{x}, where @var{x} is given in
+@end deftypefun
+@deftypefun float cosf (float @var{x})
+@end deftypefun
+@deftypefun {long double} cosl (long double @var{x})
+These functions return the cosine of @var{x}, where @var{x} is given in
 radians.  The return value is in the range @code{-1} to @code{1}.
 @end deftypefun
 
 @comment math.h
 @comment ISO
 @deftypefun double tan (double @var{x})
-This function returns the tangent of @var{x}, where @var{x} is given in
+@end deftypefun
+@deftypefun float tanf (float @var{x})
+@end deftypefun
+@deftypefun {long double} tanl (long double @var{x})
+These functions return the tangent of @var{x}, where @var{x} is given in
 radians.
 
 The following @code{errno} error conditions are defined for this function:
@@ -162,6 +186,76 @@ either positive or negative @code{HUGE_VAL}.
 @end table
 @end deftypefun
 
+In many applications where @code{sin} and @code{cos} are used, the value
+for the same argument of both of these functions is used at the same
+time.  Since the algorithm to compute these values is very similar for
+both functions there is an additional function with computes both values
+at the same time.
+
+@comment math.h
+@comment GNU
+@deftypefun void sincos (double @var{x}, double *@var{sinx}, double *@var{cosx})
+@end deftypefun
+@deftypefun void sincosf (float @var{x}, float *@var{sinx}, float *@var{cosx})
+@end deftypefun
+@deftypefun void sincosl (long double @var{x}, long double *@var{sinx}, long double *@var{cosx})
+These functions return the sine of @var{x} in @code{*@var{sinx}} and the
+cosine of @var{x} in @code{*@var{cos}}, where @var{x} is given in
+radians.  Both values, @code{*@var{sinx}} and @code{*@var{cosx}}, are in
+the range of @code{-1} to @code{1}.
+@end deftypefun
+
+@cindex complex trigonometric functions
+
+The trigonometric functions are in mathematics not only on real numbers.
+They can be extended to complex numbers and the @w{ISO C 9X} standard
+introduces these variants in the standard math library.
+
+@comment complex.h
+@comment ISO
+@deftypefun {complex double} csin (complex double @var{z})
+@end deftypefun
+@deftypefun {complex float} csinf (complex float @var{z})
+@end deftypefun
+@deftypefun {complex long double} csinl (complex long double @var{z})
+These functions return the complex sine of the complex value in @var{z}.
+The mathematical definition of the complex sine is
+
+@smallexample
+sin (z) = 1/(2*i) * (exp (z*i) - exp (-z*i))
+@end smallexample
+@end deftypefun
+
+@comment complex.h
+@comment ISO
+@deftypefun {complex double} ccos (complex double @var{z})
+@end deftypefun
+@deftypefun {complex float} ccosf (complex float @var{z})
+@end deftypefun
+@deftypefun {complex long double} ccosl (complex long double @var{z})
+These functions return the complex cosine of the complex value in @var{z}.
+The mathematical definition of the complex cosine is
+
+@smallexample
+cos (z) = 1/2 * (exp (z*i) + exp (-z*i))
+@end smallexample
+@end deftypefun
+
+@comment complex.h
+@comment ISO
+@deftypefun {complex double} ctan (complex double @var{z})
+@end deftypefun
+@deftypefun {complex float} ctanf (complex float @var{z})
+@end deftypefun
+@deftypefun {complex long double} ctanl (complex long double @var{z})
+These functions return the complex tangent of the complex value in @var{z}.
+The mathematical definition of the complex tangent is
+
+@smallexample
+tan (z) = 1/i * (exp (z*i) - exp (-z*i)) / (exp (z*i) + exp (-z*i))
+@end smallexample
+@end deftypefun
+
 
 @node Inverse Trig Functions
 @section Inverse Trigonometric Functions
@@ -174,7 +268,11 @@ respectively.
 @comment math.h
 @comment ISO
 @deftypefun double asin (double @var{x})
-This function computes the arc sine of @var{x}---that is, the value whose
+@end deftypefun
+@deftypefun float asinf (float @var{x})
+@end deftypefun
+@deftypefun {long double} asinl (long double @var{x})
+These functions compute the arc sine of @var{x}---that is, the value whose
 sine is @var{x}.  The value is in units of radians.  Mathematically,
 there are infinitely many such values; the one actually returned is the
 one between @code{-pi/2} and @code{pi/2} (inclusive).
@@ -187,7 +285,11 @@ over the domain @code{-1} to @code{1}.
 @comment math.h
 @comment ISO
 @deftypefun double acos (double @var{x})
-This function computes the arc cosine of @var{x}---that is, the value
+@end deftypefun
+@deftypefun float acosf (float @var{x})
+@end deftypefun
+@deftypefun {long double} acosl (long double @var{x})
+These functions compute the arc cosine of @var{x}---that is, the value
 whose cosine is @var{x}.  The value is in units of radians.
 Mathematically, there are infinitely many such values; the one actually
 returned is the one between @code{0} and @code{pi} (inclusive).
@@ -201,7 +303,11 @@ over the domain @code{-1} to @code{1}.
 @comment math.h
 @comment ISO
 @deftypefun double atan (double @var{x})
-This function computes the arc tangent of @var{x}---that is, the value
+@end deftypefun
+@deftypefun float atanf (float @var{x})
+@end deftypefun
+@deftypefun {long double} atanl (long double @var{x})
+These functions compute the arc tangent of @var{x}---that is, the value
 whose tangent is @var{x}.  The value is in units of radians.
 Mathematically, there are infinitely many such values; the one actually
 returned is the one between @code{-pi/2} and @code{pi/2}
@@ -211,6 +317,10 @@ returned is the one between @code{-pi/2} and @code{pi/2}
 @comment math.h
 @comment ISO
 @deftypefun double atan2 (double @var{y}, double @var{x})
+@end deftypefun
+@deftypefun float atan2f (float @var{y}, float @var{x})
+@end deftypefun
+@deftypefun {long double} atan2l (long double @var{y}, long double @var{x})
 This is the two argument arc tangent function.  It is similar to computing
 the arc tangent of @var{y}/@var{x}, except that the signs of both arguments
 are used to determine the quadrant of the result, and @var{x} is
@@ -229,6 +339,51 @@ The function @code{atan2} sets @code{errno} to @code{EDOM} if both
 case.
 @end deftypefun
 
+@cindex inverse complex trigonometric functions
+
+The inverse trigonometric functions also exist is separate versions
+which are usable with complex numbers.
+
+@comment complex.h
+@comment ISO
+@deftypefun {complex double} casin (complex double @var{z})
+@end deftypefun
+@deftypefun {complex float} casinf (complex float @var{z})
+@end deftypefun
+@deftypefun {complex long double} casinl (complex long double @var{z})
+These functions compute the complex arc sine of @var{z}---that is, the
+value whose sine is @var{z}.  The value is in units of radians.
+
+Unlike the real version of the arc sine function @code{casin} has no
+limitation on the argument @var{z}.
+@end deftypefun
+
+@comment complex.h
+@comment ISO
+@deftypefun {complex double} cacos (complex double @var{z})
+@end deftypefun
+@deftypefun {complex float} cacosf (complex float @var{z})
+@end deftypefun
+@deftypefun {complex long double} cacosl (complex long double @var{z})
+These functions compute the complex arc cosine of @var{z}---that is, the
+value whose cosine is @var{z}.  The value is in units of radians.
+
+Unlike the real version of the arc cosine function @code{cacos} has no
+limitation on the argument @var{z}.
+@end deftypefun
+
+
+@comment complex.h
+@comment ISO
+@deftypefun {complex double} catan (complex double @var{z})
+@end deftypefun
+@deftypefun {complex float} catanf (complex float @var{z})
+@end deftypefun
+@deftypefun {complex long double} catanl (complex long double @var{z})
+These functions compute the complex arc tangent of @var{z}---that is,
+the value whose tangent is @var{z}.  The value is in units of radians.
+@end deftypefun
+
 
 @node Exponents and Logarithms
 @section Exponentiation and Logarithms
@@ -239,7 +394,11 @@ case.
 @comment math.h
 @comment ISO
 @deftypefun double exp (double @var{x})
-The @code{exp} function returns the value of e (the base of natural
+@end deftypefun
+@deftypefun float expf (float @var{x})
+@end deftypefun
+@deftypefun {long double} expl (long double @var{x})
+These functions return the value of @code{e} (the base of natural
 logarithms) raised to power @var{x}.
 
 The function fails, and sets @code{errno} to @code{ERANGE}, if the
@@ -248,8 +407,41 @@ magnitude of the result is too large to be representable.
 
 @comment math.h
 @comment ISO
+@deftypefun double exp10 (double @var{x})
+@end deftypefun
+@deftypefun float exp10f (float @var{x})
+@end deftypefun
+@deftypefun {long double} exp10l (long double @var{x})
+These functions return the value of @code{10} raised to the power @var{x}.
+Mathematically, @code{exp10 (x)} is the same as @code{exp (x * log (10))}.
+
+The function fails, and sets @code{errno} to @code{ERANGE}, if the
+magnitude of the result is too large to be representable.
+@end deftypefun
+
+@comment math.h
+@comment ISO
+@deftypefun double exp2 (double @var{x})
+@end deftypefun
+@deftypefun float exp2f (float @var{x})
+@end deftypefun
+@deftypefun {long double} exp2l (long double @var{x})
+These functions return the value of @code{2} raised to the power @var{x}.
+Mathematically, @code{exp2 (x)} is the same as @code{exp (x * log (2))}.
+
+The function fails, and sets @code{errno} to @code{ERANGE}, if the
+magnitude of the result is too large to be representable.
+@end deftypefun
+
+
+@comment math.h
+@comment ISO
 @deftypefun double log (double @var{x})
-This function returns the natural logarithm of @var{x}.  @code{exp (log
+@end deftypefun
+@deftypefun float logf (floatdouble @var{x})
+@end deftypefun
+@deftypefun {long double} logl (long double @var{x})
+These functions return the natural logarithm of @var{x}.  @code{exp (log
 (@var{x}))} equals @var{x}, exactly in mathematics and approximately in
 C.
 
@@ -268,15 +460,35 @@ The argument is zero.  The log of zero is not defined.
 @comment math.h
 @comment ISO
 @deftypefun double log10 (double @var{x})
-This function returns the base-10 logarithm of @var{x}.  Except for the
+@end deftypefun
+@deftypefun float log10f (float @var{x})
+@end deftypefun
+@deftypefun {long double} log10l (long double @var{x})
+These functions return the base-10 logarithm of @var{x}.  Except for the
 different base, it is similar to the @code{log} function.  In fact,
 @code{log10 (@var{x})} equals @code{log (@var{x}) / log (10)}.
 @end deftypefun
 
 @comment math.h
 @comment ISO
+@deftypefun double log2 (double @var{x})
+@end deftypefun
+@deftypefun float log2f (float @var{x})
+@end deftypefun
+@deftypefun {long double} log2l (long double @var{x})
+These functions return the base-2 logarithm of @var{x}.  Except for the
+different base, it is similar to the @code{log} function.  In fact,
+@code{log2 (@var{x})} equals @code{log (@var{x}) / log (2)}.
+@end deftypefun
+
+@comment math.h
+@comment ISO
 @deftypefun double pow (double @var{base}, double @var{power})
-This is a general exponentiation function, returning @var{base} raised
+@end deftypefun
+@deftypefun float powf (float @var{base}, float @var{power})
+@end deftypefun
+@deftypefun {long double} powl (long double @var{base}, long double @var{power})
+These are general exponentiation functions, returning @var{base} raised
 to @var{power}.
 
 @need 250
@@ -296,48 +508,142 @@ An underflow or overflow condition was detected in the result.
 @comment math.h
 @comment ISO
 @deftypefun double sqrt (double @var{x})
-This function returns the nonnegative square root of @var{x}.
+@end deftypefun
+@deftypefun float sqrtf (float @var{x})
+@end deftypefun
+@deftypefun {long double} sqrtl (long double @var{x})
+These functions return the nonnegative square root of @var{x}.
 
 The @code{sqrt} function fails, and sets @code{errno} to @code{EDOM}, if
 @var{x} is negative.  Mathematically, the square root would be a complex
 number.
+@c (@pxref{csqrt})
 @end deftypefun
 
 @cindex cube root function
 @comment math.h
 @comment BSD
 @deftypefun double cbrt (double @var{x})
-This function returns the cube root of @var{x}.  This function cannot
+@end deftypefun
+@deftypefun float cbrtf (float @var{x})
+@end deftypefun
+@deftypefun {long double} cbrtl (long double @var{x})
+These functions return the cube root of @var{x}.  They cannot
 fail; every representable real value has a representable real cube root.
 @end deftypefun
 
 @comment math.h
-@comment BSD
+@comment ISO
 @deftypefun double hypot (double @var{x}, double @var{y})
-The @code{hypot} function returns @code{sqrt (@var{x}*@var{x} +
+@end deftypefun
+@deftypefun float hypotf (float @var{x}, float @var{y})
+@end deftypefun
+@deftypefun {long double} hypotl (long double @var{x}, long double @var{y})
+These functions return @code{sqrt (@var{x}*@var{x} +
 @var{y}*@var{y})}.  (This is the length of the hypotenuse of a right
 triangle with sides of length @var{x} and @var{y}, or the distance
-of the point (@var{x}, @var{y}) from the origin.)  See also the function
-@code{cabs} in @ref{Absolute Value}.
+of the point (@var{x}, @var{y}) from the origin.)  Using this function
+instead of the direct formula is highly appreciated since the error is
+much smaller.  See also the function @code{cabs} in @ref{Absolute Value}.
 @end deftypefun
 
 @comment math.h
-@comment BSD
+@comment ISO
 @deftypefun double expm1 (double @var{x})
-This function returns a value equivalent to @code{exp (@var{x}) - 1}.
+@end deftypefun
+@deftypefun float expm1f (float @var{x})
+@end deftypefun
+@deftypefun {long double} expm1l (long double @var{x})
+These functions return a value equivalent to @code{exp (@var{x}) - 1}.
 It is computed in a way that is accurate even if the value of @var{x} is
 near zero---a case where @code{exp (@var{x}) - 1} would be inaccurate due
 to subtraction of two numbers that are nearly equal.
 @end deftypefun
 
 @comment math.h
-@comment BSD
+@comment ISO
 @deftypefun double log1p (double @var{x})
+@end deftypefun
+@deftypefun float log1pf (float @var{x})
+@end deftypefun
+@deftypefun {long double} log1pl (long double @var{x})
 This function returns a value equivalent to @w{@code{log (1 + @var{x})}}.
 It is computed in a way that is accurate even if the value of @var{x} is
 near zero.
 @end deftypefun
 
+@cindex complex exponentiation functions
+@cindex complex logarithm functions
+
+@w{ISO C 9X} defines variants of some of the exponentiation and
+logarithm functions.  As for the other functions handlung complex
+numbers these functions are perhaps better optimized and provide better
+error checking than a direct use of the formulas of the mathematical
+definition.
+
+@comment complex.h
+@comment ISO
+@deftypefun {complex double} cexp (complex double @var{z})
+@end deftypefun
+@deftypefun {complex float} cexpf (complex float @var{z})
+@end deftypefun
+@deftypefun {complex long double} cexpl (complex long double @var{z})
+These functions return the value of @code{e} (the base of natural
+logarithms) raised to power of the complex value @var{z}.
+
+Mathematically this corresponds to the value
+
+@smallexample
+exp (z) = exp (creal (z)) * (cos (cimag (z)) + I * sin (cimag (z)))
+@end smallexample
+@end deftypefun
+
+@comment complex.h
+@comment ISO
+@deftypefun {complex double} clog (complex double @var{z})
+@end deftypefun
+@deftypefun {complex float} clogf (complex float @var{z})
+@end deftypefun
+@deftypefun {complex long double} clogl (complex long double @var{z})
+These functions return the natural logarithm of the complex value
+@var{z}.  Unlike the real value version @code{log} and its variants,
+@code{clog} has no limit for the range of its argument @var{z}.
+
+Mathematically this corresponds to the value
+
+@smallexample
+log (z) = log (cabs (z)) + I * carg (z)
+@end smallexample
+@end deftypefun
+
+@comment complex.h
+@comment ISO
+@deftypefun {complex double} csqrt (complex double @var{z})
+@end deftypefun
+@deftypefun {complex float} csqrtf (complex float @var{z})
+@end deftypefun
+@deftypefun {complex long double} csqrtl (complex long double @var{z})
+These functions return the complex root of the argument @var{z}.  Unlike
+the @code{sqrt} function these functions do not have any restriction on
+the value of the argument.
+@end deftypefun
+
+@comment complex.h
+@comment ISO
+@deftypefun {complex double} cpow (complex double @var{base}, complex double @var{power})
+@end deftypefun
+@deftypefun {complex float} cpowf (complex float @var{base}, complex float @var{power})
+@end deftypefun
+@deftypefun {complex long double} cpowl (complex long double @var{base}, complex long double @var{power})
+These functions return the complex value @var{BASE} raised to the power of
+@var{power}.  This is computed as
+
+@smallexample
+cpow (x, y) = cexp (y * clog (x))
+@end smallexample
+@end deftypefun
+
+
 @node Hyperbolic Functions
 @section Hyperbolic Functions
 @cindex hyperbolic functions
@@ -348,8 +654,12 @@ see @ref{Exponents and Logarithms}.
 @comment math.h
 @comment ISO
 @deftypefun double sinh (double @var{x})
-The @code{sinh} function returns the hyperbolic sine of @var{x}, defined
-mathematically as @w{@code{exp (@var{x}) - exp (-@var{x}) / 2}}.  The
+@end deftypefun
+@deftypefun float sinhf (float @var{x})
+@end deftypefun
+@deftypefun {long double} sinhl (long double @var{x})
+These functions return the hyperbolic sine of @var{x}, defined
+mathematically as @w{@code{(exp (@var{x}) - exp (-@var{x})) / 2}}.  The
 function fails, and sets @code{errno} to @code{ERANGE}, if the value of
 @var{x} is too large; that is, if overflow occurs.
 @end deftypefun
@@ -357,8 +667,12 @@ function fails, and sets @code{errno} to @code{ERANGE}, if the value of
 @comment math.h
 @comment ISO
 @deftypefun double cosh (double @var{x})
-The @code{cosh} function returns the hyperbolic cosine of @var{x},
-defined mathematically as @w{@code{exp (@var{x}) + exp (-@var{x}) / 2}}.
+@end deftypefun
+@deftypefun float coshf (float @var{x})
+@end deftypefun
+@deftypefun {long double} coshl (long double @var{x})
+These function return the hyperbolic cosine of @var{x},
+defined mathematically as @w{@code{(exp (@var{x}) + exp (-@var{x})) / 2}}.
 The function fails, and sets @code{errno} to @code{ERANGE}, if the value
 of @var{x} is too large; that is, if overflow occurs.
 @end deftypefun
@@ -366,36 +680,136 @@ of @var{x} is too large; that is, if overflow occurs.
 @comment math.h
 @comment ISO
 @deftypefun double tanh (double @var{x})
-This function returns the hyperbolic tangent of @var{x}, whose
+@end deftypefun
+@deftypefun float tanhf (float @var{x})
+@end deftypefun
+@deftypefun {long double} tanhl (long double @var{x})
+These functions return the hyperbolic tangent of @var{x}, whose
 mathematical definition is @w{@code{sinh (@var{x}) / cosh (@var{x})}}.
 @end deftypefun
 
+@cindex hyperbolic functions
+
+There are counterparts for these hyperbolic functions which work with
+complex valued arguments.  They should always be used instead of the
+obvious mathematical formula since the implementations in the math
+library are optimized for accuracy and speed.
+
+@comment complex.h
+@comment ISO
+@deftypefun {complex double} csinh (complex double @var{z})
+@end deftypefun
+@deftypefun {complex float} csinhf (complex float @var{z})
+@end deftypefun
+@deftypefun {complex long double} csinhl (complex long double @var{z})
+These functions return the complex hyperbolic sine of @var{z}, defined
+mathematically as @w{@code{(exp (@var{z}) - exp (-@var{z})) / 2}}.  The
+function fails, and sets @code{errno} to @code{ERANGE}, if the value of
+result is too large.
+@end deftypefun
+
+@comment complex.h
+@comment ISO
+@deftypefun {complex double} ccosh (complex double @var{z})
+@end deftypefun
+@deftypefun {complex float} ccoshf (complex float @var{z})
+@end deftypefun
+@deftypefun {complex long double} ccoshl (complex long double @var{z})
+These functions return the complex hyperbolic cosine of @var{z}, defined
+mathematically as @w{@code{(exp (@var{z}) + exp (-@var{z})) / 2}}.  The
+function fails, and sets @code{errno} to @code{ERANGE}, if the value of
+result is too large.
+@end deftypefun
+
+@comment complex.h
+@comment ISO
+@deftypefun {complex double} ctanh (complex double @var{z})
+@end deftypefun
+@deftypefun {complex float} ctanhf (complex float @var{z})
+@end deftypefun
+@deftypefun {complex long double} ctanhl (complex long double @var{z})
+These functions return the complex hyperbolic tangent of @var{z}, whose
+mathematical definition is @w{@code{csinh (@var{z}) / ccosh (@var{z})}}.
+@end deftypefun
+
+
 @cindex inverse hyperbolic functions
 
 @comment math.h
-@comment BSD
+@comment ISO
 @deftypefun double asinh (double @var{x})
-This function returns the inverse hyperbolic sine of @var{x}---the
+@end deftypefun
+@deftypefun float asinhf (float @var{x})
+@end deftypefun
+@deftypefun {long double} asinhl (long double @var{x})
+These functions return the inverse hyperbolic sine of @var{x}---the
 value whose hyperbolic sine is @var{x}.
 @end deftypefun
 
 @comment math.h
-@comment BSD
+@comment ISO
 @deftypefun double acosh (double @var{x})
-This function returns the inverse hyperbolic cosine of @var{x}---the
+@end deftypefun
+@deftypefun float acoshf (float @var{x})
+@end deftypefun
+@deftypefun {long double} acoshl (long double @var{x})
+These functions return the inverse hyperbolic cosine of @var{x}---the
 value whose hyperbolic cosine is @var{x}.  If @var{x} is less than
 @code{1}, @code{acosh} returns @code{HUGE_VAL}.
 @end deftypefun
 
 @comment math.h
-@comment BSD
+@comment ISO
 @deftypefun double atanh (double @var{x})
-This function returns the inverse hyperbolic tangent of @var{x}---the
+@end deftypefun
+@deftypefun float atanhf (float @var{x})
+@end deftypefun
+@deftypefun {long double} atanhl (long double @var{x})
+These functions return the inverse hyperbolic tangent of @var{x}---the
 value whose hyperbolic tangent is @var{x}.  If the absolute value of
 @var{x} is greater than or equal to @code{1}, @code{atanh} returns
 @code{HUGE_VAL}.
 @end deftypefun
 
+@cindex inverse complex hyperbolic functions
+
+@comment complex.h
+@comment ISO
+@deftypefun {complex double} casinh (complex double @var{z})
+@end deftypefun
+@deftypefun {complex float} casinhf (complex float @var{z})
+@end deftypefun
+@deftypefun {complex long double} casinhl (complex long double @var{z})
+These functions return the inverse complex hyperbolic sine of
+@var{z}---the value whose complex hyperbolic sine is @var{z}.
+@end deftypefun
+
+@comment complex.h
+@comment ISO
+@deftypefun {complex double} cacosh (complex double @var{z})
+@end deftypefun
+@deftypefun {complex float} cacoshf (complex float @var{z})
+@end deftypefun
+@deftypefun {complex long double} cacoshl (complex long double @var{z})
+These functions return the inverse complex hyperbolic cosine of
+@var{z}---the value whose complex hyperbolic cosine is @var{z}.  Unlike
+the real valued function @code{acosh} there is not limit for the range
+of the argument.
+@end deftypefun
+
+@comment complex.h
+@comment ISO
+@deftypefun {complex double} catanh (complex double @var{z})
+@end deftypefun
+@deftypefun {complex float} catanhf (complex float @var{z})
+@end deftypefun
+@deftypefun {complex long double} catanhl (complex long double @var{z})
+These functions return the inverse complex hyperbolic tangent of
+@var{z}---the value whose complex hyperbolic tangent is @var{z}.  Unlike
+the real valued function @code{atanh} there is not limit for the range
+of the argument.
+@end deftypefun
+
 @node Pseudo-Random Numbers
 @section Pseudo-Random Numbers
 @cindex random numbers
@@ -431,6 +845,7 @@ ones, @code{rand} and @code{srand}.
 @menu
 * ISO Random::       @code{rand} and friends.
 * BSD Random::       @code{random} and friends.
+* SVID Random::      @code{drand48} and friends.
 @end menu
 
 @node ISO Random
@@ -526,3 +941,346 @@ The return value is the previous value of the state information array.
 You can use thise value later as an argument to @code{setstate} to
 restore that state.
 @end deftypefun
+
+
+@node SVID Random
+@subsection SVID Random Number Function
+
+The C library on SVID systems contains yet another kind of random number
+generator functions.  They use a state of 48 bits of data.  The user can
+choose among a collection of functions which all return the random bits
+in different forms.
+
+Generally there are two kinds of functions: those which use a state of
+the random number generator which is shared among several functions and
+by all threads of the process.  The second group of functions require
+the user to handle the state.
+
+All functions have in common that they use the same congruential
+formula with the same constants.  The formula is
+
+@smallexample
+Y = (a * X + c) mod m
+@end smallexample
+
+@noindent
+where @var{X} is the state of the generator at the beginning and
+@var{Y} the state at the end.  @code{a} and @code{c} are constants
+determining the way the generator work.  By default they are
+
+@smallexample
+a = 0x5DEECE66D = 25214903917
+c = 0xb = 11
+@end smallexample
+
+@noindent
+but they can also be changed by the user.  @code{m} is of course 2^48
+since the state consists of a 48 bit array.
+
+
+@comment stdlib.h
+@comment SVID
+@deftypefun double drand48 ()
+This function returns a @code{double} value in the range of @code{0.0}
+to @code{1.0} (exclusive).  The random bits are determined by the global
+state of the random number generator in the C library.
+
+Since the @code{double} type according to @w{IEEE 754} has a 52 bit
+mantissa this means 4 bits are not initialized by the random number
+generator.  These are (of course) chosen to be the least significant
+bits and they are initialized to @code{0}.
+@end deftypefun
+
+@comment stdlib.h
+@comment SVID
+@deftypefun double erand48 (unsigned short int @var{xsubi}[3])
+This function returns a @code{double} value in the range of @code{0.0}
+to @code{1.0} (exclusive), similar to @code{drand48}.  The argument is
+an array describing the state of the random number generator.
+
+This function can be called subsequently since it updates the array to
+guarantee random numbers.  The array should have been initialized before
+using to get reproducible results.
+@end deftypefun
+
+@comment stdlib.h
+@comment SVID
+@deftypefun {long int} lrand48 ()
+The @code{lrand48} functions return an integer value in the range of
+@code{0} to @code{2^31} (exclusive).  Even if the size of the @code{long
+int} type can take more than 32 bits no higher numbers are returned.
+The random bits are determined by the global state of the random number
+generator in the C library.
+@end deftypefun
+
+@comment stdlib.h
+@comment SVID
+@deftypefun {long int} nrand48 (unsigned short int @var{xsubi}[3])
+This function is similar to the @code{lrand48} function in that it
+returns a number in the range of @code{0} to @code{2^31} (exclusive) but
+the state of the random number generator used to produce the random bits
+is determined by the array provided as the parameter to the function.
+
+The numbers in the array are afterwards updated so that subsequent calls
+to this function yield to different results (as it is expected by a
+random number generator).  The array should have been initialized before
+the first call to get reproducible results.
+@end deftypefun
+
+@comment stdlib.h
+@comment SVID
+@deftypefun {long int} mrand48 ()
+The @code{mrand48} function is similar to @code{lrand48}.  The only
+difference is that the numbers returned are in the range @code{-2^31} to
+@code{2^31} (exclusive).
+@end deftypefun
+
+@comment stdlib.h
+@comment SVID
+@deftypefun {long int} jrand48 (unsigned short int @var{xsubi}[3])
+The @code{jrand48} function is similar to @code{nrand48}.  The only
+difference is that the numbers returned are in the range @code{-2^31} to
+@code{2^31} (exclusive).  For the @code{xsubi} parameter the same
+requirements are necessary.
+@end deftypefun
+
+The internal state of the random number generator can be initialized in
+several ways.  The functions differ in the completeness of the
+information provided.
+
+@comment stdlib.h
+@comment SVID
+@deftypefun void srand48 (long int @var{seedval}))
+The @code{srand48} function sets the most significant 32 bits of the
+state internal state of the random number generator to the least
+significant 32 bits of the @var{seedval} parameter.  The lower 16 bts
+are initilialized to the value @code{0x330E}.  Even if the @code{long
+int} type contains more the 32 bits only the lower 32 bits are used.
+
+Due to this limitation the initialization of the state using this
+function of not very useful.  But it makes it easy to use a constrcut
+like @code{srand48 (time (0))}.
+
+A side-effect of this function is that the values @code{a} and @code{c}
+from the internal state, which are used in the congruential formula,
+are reset to the default values given above.  This is of importance once
+the user called the @code{lcong48} function (see below).
+@end deftypefun
+
+@comment stdlib.h
+@comment SVID
+@deftypefun {unsigned short int *} seed48 (unsigned short int @var{seed16v}[3])
+The @code{seed48} function initializes all 48 bits of the state of the
+internal random number generator from the content of the parameter
+@var{seed16v}.  Here the lower 16 bits of the first element of
+@var{see16v} initialize the least significant 16 bits of the internal
+state, the lower 16 bits of @code{@var{seed16v}[1]} initialize the mid-order
+16 bits of the state and the 16 lower bits of @code{@var{seed16v}[2]}
+initialize the most significant 16 bits of the state.
+
+Unlike @code{srand48} this function lets the user initialize all 48 bits
+of the state.
+
+The value returned by @code{seed48} is a pointer to an array containing
+the values of the internal state before the change.  This might be
+useful to restart the random number generator at a certain state.
+Otherwise, the value can simply be ignored.
+
+As for @code{srand48}, the values @code{a} and @code{c} from the
+congruential formula are reset to the default values.
+@end deftypefun
+
+There is one more function to initialize the random number generator
+which allows to specify even more information by allowing to change the
+parameters in the congruential formula.
+
+@comment stdlib.h
+@comment SVID
+@deftypefun void lcong48 (unsigned short int @var{param}[7])
+The @code{lcong48} function allows the user to change the complete state
+of the random number generator.  Unlike @code{srand48} and
+@code{seed48}, this function also changes the constants in the
+congruential formula.
+
+From the seven elements in the array @var{param} the least significant
+16 bits of the entries @code{@var{param}[0]} to @code{@var{param}[2]}
+determine the the initial state, the least 16 bits of
+@code{@var{param}[3]} to @code{@var{param}[5]} determine the 48 bit
+constant @code{a} and @code{@var{param}[6]} determines the 16 bit value
+@code{c}.
+@end deftypefun
+
+All the above functions have in common that they use the global
+parameters for the congruential formula.  In multi-threaded programs it
+might sometimes be useful to have different parameters in different
+threads.  For this reason all the above functions have a counterpart
+which works on a description of the random number generator in the
+user-supplied buffer instead of the global state.
+
+Please note that it is no problem if several threads use the global
+state if all threads use the functions which take a pointer to an array
+containing the state.  The random numbers are computed following the
+same loop but if the state in the array is different all threads will
+get an individuual random number generator.
+
+The user supplied buffer must be of type @code{struct drand48_data}.
+This type should be regarded as opaque and no member should be used
+directly.
+
+@comment stdlib.h
+@comment GNU
+@deftypefun int drand48_r (struct drand48_data *@var{buffer}, double *@var{result})
+This function is equivalent to the @code{drand48} function with the
+difference it does not modify the global random number generator
+parameters but instead the parameters is the buffer supplied by the
+buffer through the pointer @var{buffer}.  The random number is return in
+the variable pointed to by @var{result}.
+
+The return value of the function indicate whether the call succeeded.
+If the value is less than @code{0} an error occurred and @var{errno} is
+set to indicate the problem.
+
+This function is a GNU extension and should not be used in portable
+programs.
+@end deftypefun
+
+@comment stdlib.h
+@comment GNU
+@deftypefun int erand48_r (unsigned short int @var{xsubi}[3], struct drand48_data *@var{buffer}, double *@var{result})
+The @code{erand48_r} function works like the @code{erand48} and it takes
+an argument @var{buffer} which describes the random number generator.
+The state of the random number genertor is taken from the @code{xsubi}
+array, the parameters for the congruential formula from the global
+random number generator data.  The random number is return in the
+variable pointed to by @var{result}.
+
+The return value is non-negative is the call succeeded.
+
+This function is a GNU extension and should not be used in portable
+programs.
+@end deftypefun
+
+@comment stdlib.h
+@comment GNU
+@deftypefun int lrand48_r (struct drand48_data *@var{buffer}, double *@var{result})
+This function is similar to @code{lrand48} and it takes a pointer to a
+buffer describing the state of the random number generator as a
+parameter just like @code{drand48}.
+
+If the return value of the function is non-negative the variable pointed
+to by @var{result} contains the result.  Otherwise an error occurred.
+
+This function is a GNU extension and should not be used in portable
+programs.
+@end deftypefun
+
+@comment stdlib.h
+@comment GNU
+@deftypefun int nrand48_r (unsigned short int @var{xsubi}[3], struct drand48_data *@var{buffer}, long int *@var{result})
+The @code{nrand48_r} function works like @code{nrand48} in that it
+produces a random number in range @code{0} to @code{2^31}.  But instead
+of using the global parameters for the congruential formula it uses the
+information from the buffer pointed to by @var{buffer}.  The state is
+described by the values in @var{xsubi}.
+
+If the return value is non-negative the variable pointed to by
+@var{result} contains the result.
+
+This function is a GNU extension and should not be used in portable
+programs.
+@end deftypefun
+
+@comment stdlib.h
+@comment GNU
+@deftypefun int mrand48_r (struct drand48_data *@var{buffer}, double *@var{result})
+This function is similar to @code{mrand48} but as the other reentrant
+function it uses the random number generator described by the value in
+the buffer pointed to by @var{buffer}.
+
+If the return value is non-negative the variable pointed to by
+@var{result} contains the result.
+
+This function is a GNU extension and should not be used in portable
+programs.
+@end deftypefun
+
+@comment stdlib.h
+@comment GNU
+@deftypefun int jrand48_r (unsigned short int @var{xsubi}[3], struct drand48_data *@var{buffer}, long int *@var{result})
+The @code{jrand48_r} function is similar to @code{jrand48}.  But as the
+other reentrant functions of this function family it uses the
+congruential formula parameters from the buffer pointed to by
+@var{buffer}.
+
+If the return value is non-negative the variable pointed to by
+@var{result} contains the result.
+
+This function is a GNU extension and should not be used in portable
+programs.
+@end deftypefun
+
+Before any of the above functions should be used the buffer of type
+@code{struct drand48_data} should initialized.  The easiest way is to
+fill the whole buffer with null bytes, e.g., using
+
+@smallexample
+memset (buffer, '\0', sizeof (struct drand48_data));
+@end smallexample
+
+@noindent
+Using any of the reetrant functions of this family now will
+automatically initialize the random number generator to the default
+values for the state and the parameters of the congruential formula.
+
+The other possibility is too use any of the functions which explicitely
+initialize the buffer.  Though it might be obvious how to initialize the
+buffer from the data given as parameter from the function it is highly
+recommended to use these functions since the result might not always be
+what you expect.
+
+@comment stdlib.h
+@comment GNU
+@deftypefun int srand48_r (long int @var{seedval}, struct drand48_data *@var{buffer})
+The description of the random number generator represented by the
+information in @var{buffer} is initialized similar to what the function
+@code{srand48} does.  The state is initialized from the paramter
+@var{seedval} and the paameters for the congruential formula are
+initialized to the default values.
+
+If the return value is non-negative the function call succeeded.
+
+This function is a GNU extension and should not be used in portable
+programs.
+@end deftypefun
+
+@comment stdlib.h
+@comment GNU
+@deftypefun int seed48_r (unsigned short int @var{seed16v}[3], struct drand48_data *@var{buffer})
+This function is similar to @code{srand48_r} but like @code{seed48} it
+initializes all 48 bits of the state from the parameter @var{seed16v}.
+
+If the return value is non-negative the function call succeeded.  It
+does not return a pointer to the previous state of the random number
+generator like the @code{seed48} function does.  if the user wants to
+preserve the state for a later rerun s/he can copy the whole buffer
+pointed to by @var{buffer}.
+
+This function is a GNU extension and should not be used in portable
+programs.
+@end deftypefun
+
+@comment stdlib.h
+@comment GNU
+@deftypefun int lcong48_r (unsigned short int @var{param}[7], struct drand48_data *@var{buffer})
+This function initializes all aspects of the random number generator
+described in @var{buffer} by the data in @var{param}.  Here it is
+especially true the function does more than just copying the contents of
+@var{param} of @var{buffer}.  Some more actions are required and
+therefore it is important to use this function and not initialized the
+random number generator directly.
+
+If the return value is non-negative the function call succeeded.
+
+This function is a GNU extension and should not be used in portable
+programs.
+@end deftypefun
diff --git a/manual/string.texi b/manual/string.texi
index 9d242b7c19..8f09ac9728 100644
--- a/manual/string.texi
+++ b/manual/string.texi
@@ -32,9 +32,10 @@ too.
 * Search Functions::            Searching for a specific element or substring.
 * Finding Tokens in a String::  Splitting a string into tokens by looking
 				 for delimiters.
+* Encode Binary Data::          Encoding and Decoding of Binary Data.
 @end menu
 
-@node Representation of Strings, String/Array Conventions,  , String and Array Utilities
+@node Representation of Strings
 @section Representation of Strings
 @cindex string, representation of
 
@@ -99,7 +100,7 @@ checks for overflowing the array.  Many of the library functions
 an extra byte to hold the null character that marks the end of the
 string.
 
-@node String/Array Conventions, String Length, Representation of Strings, String and Array Utilities
+@node String/Array Conventions
 @section String and Array Conventions
 
 This chapter describes both functions that work on arbitrary arrays or
@@ -132,7 +133,7 @@ other hand, when you are manipulating null-terminated strings it is
 usually more convenient to use the @samp{str} functions, unless you
 already know the length of the string in advance.
 
-@node String Length, Copying and Concatenation, String/Array Conventions, String and Array Utilities
+@node String Length
 @section String Length
 
 You can get the length of a string using the @code{strlen} function.
@@ -166,7 +167,7 @@ strlen (string)
 @end smallexample
 @end deftypefun
 
-@node Copying and Concatenation, String/Array Comparison, String Length, String and Array Utilities
+@node Copying and Concatenation
 @section Copying and Concatenation
 
 You can use the functions described in this section to copy the contents
@@ -470,7 +471,7 @@ BSD.  Note that it is not as general as @code{memset}, because the only
 value it can store is zero.
 @end deftypefun
 
-@node String/Array Comparison, Collation Functions, Copying and Concatenation, String and Array Utilities
+@node String/Array Comparison
 @section String/Array Comparison
 @cindex comparing strings and arrays
 @cindex string comparison functions
@@ -613,7 +614,7 @@ strncmp ("hello, world", "hello, stupid world!!!", 5)
 This is an obsolete alias for @code{memcmp}, derived from BSD.
 @end deftypefun
 
-@node Collation Functions, Search Functions, String/Array Comparison, String and Array Utilities
+@node Collation Functions
 @section Collation Functions
 
 @cindex collating strings
@@ -792,9 +793,9 @@ sort_strings_fast (char **array, int nstrings)
 @end smallexample
 
 @strong{Compatibility Note:}  The string collation functions are a new
-feature of @w{ISO C}.  Older C dialects have no equivalent feature.
+feature of @w{ISO C 89}.  Older C dialects have no equivalent feature.
 
-@node Search Functions, Finding Tokens in a String, Collation Functions, String and Array Utilities
+@node Search Functions
 @section Search Functions
 
 This section describes library functions which perform various kinds
@@ -940,7 +941,7 @@ strpbrk ("hello, world", " \t\n,.;!?")
 @c @end group
 @end deftypefun
 
-@node Finding Tokens in a String,  , Search Functions, String and Array Utilities
+@node Finding Tokens in a String
 @section Finding Tokens in a String
 
 @cindex tokenizing strings
@@ -1087,3 +1088,65 @@ token = strsep (&running, delimiters);    /* token => "and" */
 token = strsep (&running, delimiters);    /* token => "punctuation" */
 token = strsep (&running, delimiters);    /* token => NULL */
 @end smallexample
+
+@node Encode Binary Data
+@section Encode Binary Data
+
+To store or transfer binary data in environments which only support text
+one has to encode the binary data by mapping the input bytes to
+characters in the range allowed for storing or transfering.  SVID
+systems (and nowadays XPG compliant systems) have such a function in the
+C library.
+
+@comment stdlib.h
+@comment XPG
+@deftypefun {char *} l64a (long int @var{n})
+This function encodes an input value with 32 bits using characters from
+the basic character set.  Groups of 6 bits are encoded using the
+following table:
+
+@multitable {xxxxx} {xxx} {xxx} {xxx} {xxx} {xxx} {xxx} {xxx} {xxx}
+@item              @tab 0 @tab 1 @tab 2 @tab 3 @tab 4 @tab 5 @tab 6 @tab 7
+@item       0      @tab @code{.} @tab @code{/} @tab @code{0} @tab @code{1}
+                   @tab @code{2} @tab @code{3} @tab @code{4} @tab @code{5}
+@item       8      @tab @code{6} @tab @code{7} @tab @code{8} @tab @code{9}
+                   @tab @code{A} @tab @code{B} @tab @code{C} @tab @code{D}
+@item       16     @tab @code{E} @tab @code{F} @tab @code{G} @tab @code{H}
+                   @tab @code{I} @tab @code{J} @tab @code{K} @tab @code{L}
+@item       24     @tab @code{M} @tab @code{N} @tab @code{O} @tab @code{P}
+                   @tab @code{Q} @tab @code{R} @tab @code{S} @tab @code{T}
+@item       32     @tab @code{U} @tab @code{V} @tab @code{W} @tab @code{X}
+                   @tab @code{Y} @tab @code{Z} @tab @code{a} @tab @code{b}
+@item       40     @tab @code{c} @tab @code{d} @tab @code{e} @tab @code{f}
+                   @tab @code{g} @tab @code{h} @tab @code{i} @tab @code{j}
+@item       48     @tab @code{k} @tab @code{l} @tab @code{m} @tab @code{n}
+                   @tab @code{o} @tab @code{p} @tab @code{q} @tab @code{r}
+@item       56     @tab @code{s} @tab @code{t} @tab @code{u} @tab @code{v}
+                   @tab @code{w} @tab @code{x} @tab @code{y} @tab @code{z}
+@end multitable
+
+The function returns a pointer to a static buffer which contains the
+string representing of the encoding of @var{n}.  To encoded a series of
+bytes the use should append the new string to the destination buffer.
+@emph{Warning:} Since a static buffer is used this function should not
+be used in multi-threaded programs.  There is no thread-safe alternatice
+to this function in the C library.
+@end deftypefun
+
+To decode data produced with @code{l64a} the following function should be
+used.
+
+@deftypefun {long int} a64l (const char *@var{string})
+The parameter @var{string} should contain a string which was produced by
+a call to @code{l64a}.  The function processes the next 6 characters and
+decodes the characters it finds according to the table above.
+Characters not in the conversion table are simply ignored.  This is
+useful for breaking the information in lines in which case the end of
+line characters are simply ignored.
+
+The decoded number is returned at the end as a @code{long int} value.
+Consecutive calls to this function are possible but the caller must make
+sure the buffer pointer is update after each call to @code{a64l} since
+this function does not modify the buffer pointer.  Every call consumes 6
+characters.
+@end deftypefun
diff --git a/math/Makefile b/math/Makefile
index 1ff61a03c8..839e441354 100644
--- a/math/Makefile
+++ b/math/Makefile
@@ -23,7 +23,7 @@ subdir		:= math
 # Installed header files.
 headers		:= math.h mathcalls.h __math.h huge_val.h nan.h		\
 		   fpu_control.h complex.h cmathcalls.h fenv.h		\
-		   fenvbits.h
+		   fenvbits.h mathbits.h
 
 # Internal header files.
 distribute	:= math_private.h machine/asm.h machine/endian.h
diff --git a/math/cmathcalls.h b/math/cmathcalls.h
index b2a8382721..73a1c2a5da 100644
--- a/math/cmathcalls.h
+++ b/math/cmathcalls.h
@@ -100,7 +100,7 @@ __MATHCALL (cpow, (_Mdouble_complex_ __x, _Mdouble_complex_ __y));
 __MATHCALL (csqrt, (_Mdouble_complex_ __z));
 
 
-/* Absolute value, projections, conjugates, and projection.  */
+/* Absolute value, conjugates, and projection.  */
 
 /* Absolute value of Z.  */
 __MATHDECL (_Mdouble_,cabs, (_Mdouble_complex_ __z));
diff --git a/rellns-sh b/rellns-sh
index e66010d513..890f4eea3a 100755
--- a/rellns-sh
+++ b/rellns-sh
@@ -27,7 +27,11 @@ if test -d $1; then
   to=`cd $1 && /bin/pwd`
 else
   temp=`echo $1 | sed 's%/*[^/]*$%%'`
-  to=`cd $temp && /bin/pwd`
+  if test -z "$temp"; then
+    to=`/bin/pwd`
+  else
+    to=`cd $temp && /bin/pwd`
+  fi
   to="$to/`echo $1 | sed 's%.*/\([^/][^/]*\)$%\1%'`"
 fi
 to=`echo $to | sed 's%^/%%'`
diff --git a/shadow/fgetspent_r.c b/shadow/fgetspent_r.c
index 4614b514c8..403eecf761 100644
--- a/shadow/fgetspent_r.c
+++ b/shadow/fgetspent_r.c
@@ -42,7 +42,10 @@ __fgetspent_r (FILE *stream, struct spwd *resbuf, char *buffer, size_t buflen,
     {
       p = fgets (buffer, buflen, stream);
       if (p == NULL)
-	return errno;
+	{
+	  *result = NULL;
+	  return errno;
+	}
 
       /* Skip leading blanks.  */
       while (isspace (*p))
diff --git a/stdio-common/Makefile b/stdio-common/Makefile
index e85cc1db23..86c64762f5 100644
--- a/stdio-common/Makefile
+++ b/stdio-common/Makefile
@@ -42,7 +42,7 @@ tests := tst-printf tstscanf test_rdwr test-popen tstgetln test-fseek \
 	 temptest tst-fileno test-fwrite tst-ungetc tst-ferror \
 	 xbug errnobug \
 	 bug1 bug2 bug3 bug4 bug5 bug6 bug7 bug8 bug9 bug10 bug11 \
-	 tfformat tiformat tstdiomisc \
+	 tfformat tiformat tstdiomisc tst-printfsz \
 	 scanf1 scanf2 scanf3 scanf4 scanf5 scanf7 scanf8 scanf9 scanf10
 
 
@@ -54,6 +54,7 @@ CFLAGS-tst-printf.c = -Wno-format
 CFLAGS-tstdiomisc.c = -Wno-format
 CFLAGS-scanf4.c = -Wno-format
 CFLAGS-scanf7.c = -Wno-format
+CFLAGS-tst-printfsz.c = -Wno-format
 
 ifeq ($(stdio),libio)
 ifneq (,$(filter %REENTRANT, $(defines)))
diff --git a/stdlib/a64l.c b/stdlib/a64l.c
index 11ecd6a054..9d462c77f3 100644
--- a/stdlib/a64l.c
+++ b/stdlib/a64l.c
@@ -19,12 +19,12 @@
 
 #include <stdlib.h>
 
-long
+long int
 a64l (string)
      const char *string;
 {
-  int cnt;
-  long result = 0l;
+  size_t cnt;
+  long int result = 0l;
 
   for (cnt = 0; cnt < 6; ++cnt)
     {
diff --git a/stdlib/seed48_r.c b/stdlib/seed48_r.c
index fe4a0a8b3c..186d96cdd3 100644
--- a/stdlib/seed48_r.c
+++ b/stdlib/seed48_r.c
@@ -29,7 +29,25 @@ seed48_r (seed16v, buffer)
   memcpy (buffer->old_X, buffer->X, sizeof (buffer->X));
 
   /* Install new state.  */
-  memcpy (buffer->X, seed16v, sizeof (buffer->X));
+#if USHRT_MAX == 0xffffU
+  buffer->X[2] = seed16v[2];
+  buffer->X[1] = seed16v[1];
+  buffer->X[0] = seed16v[0];
+
+  buffer->a[2] = 0x5;
+  buffer->a[1] = 0xdeec;
+  buffer->a[0] = 0xe66d;
+#else
+  buffer->X[2] = (seed16v[2] << 16) | seed16v[1];
+  buffer->X[1] = seed16v[0] << 16;
+  buffer->X[0] = 0;
+
+  buffer->a[2] = 0x5deecUL;
+  buffer->a[1] = 0xe66d0000UL;
+  buffer->a[0] = 0;
+#endif
+  buffer->c = 0xb;
+  buffer->init = 1;
 
   return 0;
 }
diff --git a/stdlib/srand48_r.c b/stdlib/srand48_r.c
index 80cc7eb6c8..042c669950 100644
--- a/stdlib/srand48_r.c
+++ b/stdlib/srand48_r.c
@@ -22,22 +22,32 @@
 
 int
 srand48_r (seedval, buffer)
-     long seedval;
+     long int seedval;
      struct drand48_data *buffer;
 {
   /* The standards say we only have 32 bits.  */
-  if (sizeof (long) > 4)
+  if (sizeof (long int) > 4)
     seedval &= 0xffffffffl;
 
-#if (USHRT_MAX == 0xffffU)
+#if USHRT_MAX == 0xffffU
   buffer->X[2] = seedval >> 16;
   buffer->X[1] = seedval & 0xffffl;
   buffer->X[0] = 0x330e;
+
+  buffer->a[2] = 0x5;
+  buffer->a[1] = 0xdeec;
+  buffer->a[0] = 0xe66d;
 #else
   buffer->X[2] = seedval;
   buffer->X[1] = 0x330e0000UL;
   buffer->X[0] = 0;
+
+  buffer->a[2] = 0x5deecUL;
+  buffer->a[1] = 0xe66d0000UL;
+  buffer->a[0] = 0;
 #endif
+  buffer->c = 0xb;
+  buffer->init = 1;
 
   return 0;
 }
diff --git a/stdlib/stdlib.h b/stdlib/stdlib.h
index cc86d38361..4e60201bad 100644
--- a/stdlib/stdlib.h
+++ b/stdlib/stdlib.h
@@ -310,15 +310,15 @@ extern double drand48 __P ((void));
 extern double erand48 __P ((unsigned short int __xsubi[3]));
 
 /* Return non-negative, long integer in [0,2^31).  */
-extern long lrand48 __P ((void));
-extern long nrand48 __P ((unsigned short int __xsubi[3]));
+extern long int lrand48 __P ((void));
+extern long int nrand48 __P ((unsigned short int __xsubi[3]));
 
 /* Return signed, long integers in [-2^31,2^31).  */
-extern long mrand48 __P ((void));
-extern long jrand48 __P ((unsigned short int __xsubi[3]));
+extern long int mrand48 __P ((void));
+extern long int jrand48 __P ((unsigned short int __xsubi[3]));
 
 /* Seed random number generator.  */
-extern void srand48 __P ((long __seedval));
+extern void srand48 __P ((long int __seedval));
 extern unsigned short int *seed48 __P ((unsigned short int __seed16v[3]));
 extern void lcong48 __P ((unsigned short int __param[7]));
 
@@ -339,17 +339,17 @@ extern int erand48_r __P ((unsigned short int __xsubi[3],
 			   struct drand48_data *__buffer, double *__result));
 
 /* Return non-negative, long integer in [0,2^31).  */
-extern int lrand48_r __P ((struct drand48_data *__buffer, long *__result));
+extern int lrand48_r __P ((struct drand48_data *__buffer, long int *__result));
 extern int nrand48_r __P ((unsigned short int __xsubi[3],
-			   struct drand48_data *__buffer, long *__result));
+			   struct drand48_data *__buffer, long int *__result));
 
 /* Return signed, long integers in [-2^31,2^31).  */
-extern int mrand48_r __P ((struct drand48_data *__buffer, long *__result));
+extern int mrand48_r __P ((struct drand48_data *__buffer, long int *__result));
 extern int jrand48_r __P ((unsigned short int __xsubi[3],
-			   struct drand48_data *__buffer, long *__result));
+			   struct drand48_data *__buffer, long int *__result));
 
 /* Seed random number generator.  */
-extern int srand48_r __P ((long __seedval, struct drand48_data *__buffer));
+extern int srand48_r __P ((long int __seedval, struct drand48_data *__buffer));
 extern int seed48_r __P ((unsigned short int __seed16v[3],
 			  struct drand48_data *__buffer));
 extern int lcong48_r __P ((unsigned short int __param[7],
diff --git a/sysdeps/i386/fpu/__math.h b/sysdeps/i386/fpu/__math.h
index 4e34fa0263..d79fe7dd5c 100644
--- a/sysdeps/i386/fpu/__math.h
+++ b/sysdeps/i386/fpu/__math.h
@@ -470,7 +470,7 @@ __finite (double __x)
 
 /* ISO C 9X defines some macros to perform unordered comparisons.  The
    ix87 FPU supports this with special opcodes and we should use them.
-   This must not be inline functions since we  have to be able to handle
+   These must not be inline functions since we have to be able to handle
    all floating-point types.  */
 #undef isgreater
 #define isgreater(x, y) \
diff --git a/sysdeps/libm-ieee754/e_scalb.c b/sysdeps/libm-ieee754/e_scalb.c
index 7f66ec7737..86d10bf683 100644
--- a/sysdeps/libm-ieee754/e_scalb.c
+++ b/sysdeps/libm-ieee754/e_scalb.c
@@ -40,16 +40,16 @@ static char rcsid[] = "$NetBSD: e_scalb.c,v 1.6 1995/05/10 20:46:09 jtc Exp $";
 #endif
 {
 #ifdef _SCALB_INT
-	return scalbn(x,fn);
+	return __scalbn(x,fn);
 #else
-	if (isnan(x)||isnan(fn)) return x*fn;
-	if (!finite(fn)) {
+	if (__isnan(x)||__isnan(fn)) return x*fn;
+	if (!__finite(fn)) {
 	    if(fn>0.0) return x*fn;
 	    else       return x/(-fn);
 	}
-	if (rint(fn)!=fn) return (fn-fn)/(fn-fn);
-	if ( fn > 65000.0) return scalbn(x, 65000);
-	if (-fn > 65000.0) return scalbn(x,-65000);
-	return scalbn(x,(int)fn);
+	if (__rint(fn)!=fn) return (fn-fn)/(fn-fn);
+	if ( fn > 65000.0) return __scalbn(x, 65000);
+	if (-fn > 65000.0) return __scalbn(x,-65000);
+	return __scalbn(x,(int)fn);
 #endif
 }
diff --git a/sysdeps/libm-ieee754/e_scalbl.c b/sysdeps/libm-ieee754/e_scalbl.c
index 0dd36d422d..823eebda91 100644
--- a/sysdeps/libm-ieee754/e_scalbl.c
+++ b/sysdeps/libm-ieee754/e_scalbl.c
@@ -44,16 +44,16 @@ static char rcsid[] = "$NetBSD: $";
 #endif
 {
 #ifdef _SCALB_INT
-	return scalbnl(x,fn);
+	return __scalbnl(x,fn);
 #else
-	if (isnanl(x)||isnanl(fn)) return x*fn;
-	if (!finitel(fn)) {
+	if (__isnanl(x)||__isnanl(fn)) return x*fn;
+	if (!__finitel(fn)) {
 	    if(fn>0.0) return x*fn;
 	    else       return x/(-fn);
 	}
-	if (rintl(fn)!=fn) return (fn-fn)/(fn-fn);
-	if ( fn > 65000.0) return scalbnl(x, 65000);
-	if (-fn > 65000.0) return scalbnl(x,-65000);
-	return scalbnl(x,(int)fn);
+	if (__rintl(fn)!=fn) return (fn-fn)/(fn-fn);
+	if ( fn > 65000.0) return __scalbnl(x, 65000);
+	if (-fn > 65000.0) return __scalbnl(x,-65000);
+	return __scalbnl(x,(int)fn);
 #endif
 }
diff --git a/sysdeps/libm-ieee754/s_ctan.c b/sysdeps/libm-ieee754/s_ctan.c
index 069b96c1d6..c68c3ad3e4 100644
--- a/sysdeps/libm-ieee754/s_ctan.c
+++ b/sysdeps/libm-ieee754/s_ctan.c
@@ -29,7 +29,7 @@ __ctan (__complex__ double x)
 {
   __complex__ double res;
 
-  if (!finite (__real__ x) || !finite (__imag__ x))
+  if (!isfinite (__real__ x) || !isfinite (__imag__ x))
     {
       if (__isinf (__imag__ x))
 	{
diff --git a/sysdeps/libm-ieee754/s_ctanf.c b/sysdeps/libm-ieee754/s_ctanf.c
index 1c6fdca81d..4209587b37 100644
--- a/sysdeps/libm-ieee754/s_ctanf.c
+++ b/sysdeps/libm-ieee754/s_ctanf.c
@@ -29,7 +29,7 @@ __ctanf (__complex__ float x)
 {
   __complex__ float res;
 
-  if (!finite (__real__ x) || !finite (__imag__ x))
+  if (!isfinite (__real__ x) || !isfinite (__imag__ x))
     {
       if (__isinff (__imag__ x))
 	{
diff --git a/sysdeps/libm-ieee754/s_ctanh.c b/sysdeps/libm-ieee754/s_ctanh.c
index a16f9c8d02..eb6ff84817 100644
--- a/sysdeps/libm-ieee754/s_ctanh.c
+++ b/sysdeps/libm-ieee754/s_ctanh.c
@@ -29,7 +29,7 @@ __ctanh (__complex__ double x)
 {
   __complex__ double res;
 
-  if (!finite (__real__ x) || !finite (__imag__ x))
+  if (!isfinite (__real__ x) || !isfinite (__imag__ x))
     {
       if (__isinf (__real__ x))
 	{
diff --git a/sysdeps/libm-ieee754/s_ctanhf.c b/sysdeps/libm-ieee754/s_ctanhf.c
index 45548d518c..aec02fe7c4 100644
--- a/sysdeps/libm-ieee754/s_ctanhf.c
+++ b/sysdeps/libm-ieee754/s_ctanhf.c
@@ -29,7 +29,7 @@ __ctanhf (__complex__ float x)
 {
   __complex__ float res;
 
-  if (!finite (__real__ x) || !finite (__imag__ x))
+  if (!isfinite (__real__ x) || !isfinite (__imag__ x))
     {
       if (__isinff (__real__ x))
 	{
diff --git a/sysdeps/libm-ieee754/s_ctanhl.c b/sysdeps/libm-ieee754/s_ctanhl.c
index 5c466167a6..8ed131e9a6 100644
--- a/sysdeps/libm-ieee754/s_ctanhl.c
+++ b/sysdeps/libm-ieee754/s_ctanhl.c
@@ -29,7 +29,7 @@ __ctanhl (__complex__ long double x)
 {
   __complex__ long double res;
 
-  if (!finite (__real__ x) || !finite (__imag__ x))
+  if (!isfinite (__real__ x) || !isfinite (__imag__ x))
     {
       if (__isinfl (__real__ x))
 	{
diff --git a/sysdeps/libm-ieee754/s_ctanl.c b/sysdeps/libm-ieee754/s_ctanl.c
index b4a2b4a13c..88c02da2ea 100644
--- a/sysdeps/libm-ieee754/s_ctanl.c
+++ b/sysdeps/libm-ieee754/s_ctanl.c
@@ -27,9 +27,9 @@
 __complex__ long double
 __ctanl (__complex__ long double x)
 {
-  __complex__ double res;
+  __complex__ long double res;
 
-  if (!finite (__real__ x) || !finite (__imag__ x))
+  if (!isfinite (__real__ x) || !isfinite (__imag__ x))
     {
       if (__isinfl (__imag__ x))
 	{
diff --git a/sysdeps/libm-ieee754/s_nearbyintf.c b/sysdeps/libm-ieee754/s_nearbyintf.c
index dc33fa59f9..7d6f262f51 100644
--- a/sysdeps/libm-ieee754/s_nearbyintf.c
+++ b/sysdeps/libm-ieee754/s_nearbyintf.c
@@ -14,9 +14,6 @@
  * ====================================================
  */
 
-#if defined(LIBM_SCCS) && !defined(lint)
-static char rcsid[] = "$NetBSD: s_rintf.c,v 1.4 1995/05/10 20:48:06 jtc Exp $";
-#endif
 
 #include <fenv.h>
 #include "math.h"
@@ -33,9 +30,9 @@ TWO23[2]={
 };
 
 #ifdef __STDC__
-	float __rintf(float x)
+	float __nearbyintf(float x)
 #else
-	float __rintf(x)
+	float __nearbyintf(x)
 	float x;
 #endif
 {
@@ -77,4 +74,4 @@ TWO23[2]={
 	fesetenv (&env);
 	return t;
 }
-weak_alias (__rintf, rintf)
+weak_alias (__nearbyintf, nearbyintf)
diff --git a/sysdeps/libm-ieee754/s_nearbyintl.c b/sysdeps/libm-ieee754/s_nearbyintl.c
index b6a865443a..3b0715e5a5 100644
--- a/sysdeps/libm-ieee754/s_nearbyintl.c
+++ b/sysdeps/libm-ieee754/s_nearbyintl.c
@@ -15,10 +15,6 @@
  * ====================================================
  */
 
-#if defined(LIBM_SCCS) && !defined(lint)
-static char rcsid[] = "$NetBSD: $";
-#endif
-
 /*
  * rintl(x)
  * Return x rounded to integral value according to the prevailing
@@ -44,9 +40,9 @@ TWO63[2]={
 };
 
 #ifdef __STDC__
-	long double __rintl(long double x)
+	long double __nearbyintl(long double x)
 #else
-	long double __rintl(x)
+	long double __nearbyintl(x)
 	long double x;
 #endif
 {
@@ -101,4 +97,4 @@ TWO63[2]={
 	fesetenv (&env);
 	return t;
 }
-weak_alias (__rintl, rintl)
+weak_alias (__nearbyintl, nearbyintl)
diff --git a/sysdeps/m68k/fpu/__math.h b/sysdeps/m68k/fpu/__math.h
index 68a6d90e32..92487f9b04 100644
--- a/sysdeps/m68k/fpu/__math.h
+++ b/sysdeps/m68k/fpu/__math.h
@@ -274,6 +274,14 @@ __m81_defun (float_type, __CONCAT(__nearbyint,s), (float_type __x))	  \
   __asm __volatile__ ("fmove%.l %0, %!" : /* No outputs.  */		  \
 		      : "dmi" (__ctrl_reg));				  \
   return __result;							  \
+}									  \
+									  \
+__m81_inline void							  \
+__m81_u(__CONCAT(__sincos,s))(float_type __x, float_type *__sinx,	  \
+			      float_type *__cosx)			  \
+{									  \
+  __asm ("fsincos%.x %2,%1:%0"						  \
+	 : "=f" (*__sinx), "=f" (*__cosx) : "f" (__x));			  \
 }
 
 /* This defines the three variants of the inline functions.  */
@@ -324,6 +332,10 @@ __inline_forward_c(int,ilogb, (double __value), (__value))
 #ifdef __USE_ISOC9X
 __inline_forward_c(double,nearbyint, (double __value), (__value))
 #endif
+#ifdef __USE_GNU
+__inline_forward(void,sincos, (double __x, double *__sinx, double *__cosx),
+		 (__x, __sinx, __cosx))
+#endif
 
 #if defined __USE_MISC || defined __USE_ISOC9X
 
@@ -341,6 +353,10 @@ __inline_forward_c(int,ilogbf, (float __value), (__value))
 #ifdef __USE_ISOC9X
 __inline_forward_c(float,nearbyintf, (float __value), (__value))
 #endif
+#ifdef __USE_GNU
+__inline_forward(void,sincosf, (float __x, float *__sinx, float *__cosx),
+		 (__x, __sinx, __cosx))
+#endif
 
 __inline_forward(long double,frexpl, (long double __value, int *__expptr),
 		 (__value, __expptr))
@@ -358,12 +374,72 @@ __inline_forward_c(int,ilogbl, (long double __value), (__value))
 __inline_forward_c(long double,nearbyintl, (long double __value), (__value))
 __inline_forward_c(long int,rinttol, (long double __value), (__value))
 #endif
+#ifdef __USE_GNU
+__inline_forward(void,sincosl,
+		 (long double __x, long double *__sinx, long double *__cosx),
+		 (__x, __sinx, __cosx))
+#endif
 
 #endif /* Use misc or ISO C9X */
 
 #undef __inline_forward
 #undef __inline_forward_c
 
+#ifdef __USE_ISOC9X
+
+/* ISO C 9X defines some macros to perform unordered comparisons.  The
+   m68k FPU supports this with special opcodes and we should use them.
+   These must not be inline functions since we have to be able to handle
+   all floating-point types.  */
+#undef isgreater
+#define isgreater(x, y)					\
+   __extension__					\
+   ({ char __result;					\
+      __asm__ ("fcmp %2,%1; fsogt %0"			\
+	       : "=dm" (__result) : "f" (x), "f" (y));	\
+      (int) __result; })
+
+#undef isgreaterequal
+#define isgreaterequal(x, y)				\
+   __extension__					\
+   ({ char __result;					\
+      __asm__ ("fcmp %2,%1; fsoge %0"			\
+	       : "=dm" (__result) : "f" (x), "f" (y));	\
+      (int) __result; })
+
+#undef isless
+#define isless(x, y)					\
+   __extension__					\
+   ({ char __result;					\
+      __asm__ ("fcmp %2,%1; fsolt %0"			\
+	       : "=dm" (__result) : "f" (x), "f" (y));	\
+      (int) __result; })
+
+#undef islessequal
+#define islessequal(x, y)				\
+   __extension__					\
+   ({ char __result;					\
+      __asm__ ("fcmp %2,%1; fsole %0"			\
+	       : "=dm" (__result) : "f" (x), "f" (y));	\
+      (int) __result; })
+
+#undef islessgreater
+#define islessgreater(x, y)				\
+   __extension__					\
+   ({ char __result;					\
+      __asm__ ("fcmp %2,%1; fsogl %0"			\
+	       : "=dm" (__result) : "f" (x), "f" (y));	\
+      (int) __result; })
+
+#undef isunordered
+#define isunordered(x, y)				\
+   __extension__					\
+   ({ char __result;					\
+      __asm__ ("fcmp %2,%1; fsun %0"			\
+	       : "=dm" (__result) : "f" (x), "f" (y));	\
+      (int) __result; })
+#endif
+
 #endif /* !__NO_MATH_INLINES && __OPTIMIZE__ */
 
 #endif	/* GCC.  */
diff --git a/sysdeps/m68k/fpu/e_pow.c b/sysdeps/m68k/fpu/e_pow.c
index 284f1bf294..a39b63d342 100644
--- a/sysdeps/m68k/fpu/e_pow.c
+++ b/sysdeps/m68k/fpu/e_pow.c
@@ -80,51 +80,36 @@ s(__ieee754_pow) (float_type x, float_type y)
 	z = 1 / z;
       if (m81(__signbit) (x))
 	{
-	  float_type temp = m81(__rint) (y);
-	  if (y != temp)
+	  if (y != m81(__rint) (y))
 	    {
 	      if (x == -1)
 		z = 0.0/0.0;
 	    }
 	  else
-	    {
-	      if (sizeof (float_type) == sizeof (float))
-		{
-		  long i = (long) y;
-		  if (i & 1)
-		    z = -z;
-		}
-	      else
-		{
-		  long long i = (long long) y;
-		  if ((float_type) i == y && i & 1)
-		    z = -z;
-		}
-	    }
+	    goto maybe_negate;
 	}
       return z;
     }
 
   if (x < 0.0)
     {
-      float_type temp = m81(__rint) (y);
-      if (y == temp)
+      if (y == m81(__rint) (y))
 	{
-	  long long i = (long long) y;
 	  z = m81(__ieee754_exp) (y * m81(__ieee754_log) (-x));
-	  if (sizeof (float_type) == sizeof (float))
-	    {
-	      long i = (long) y;
-	      if (i & 1)
-		z = -z;
-	    }
-	  else
-	    {
-	      /* If the conversion to long long was inexact assume that y
-		 is an even integer.  */
-	      if ((float_type) i == y && i & 1)
-		z = -z;
-	    }
+	maybe_negate:
+	  /* We always use the long double format, since y is already in
+	     this format and rounding won't change the result.  */
+	  {
+	    int32_t exponent;
+	    u_int32_t i0, i1;
+	    GET_LDOUBLE_WORDS (exponent, i0, i1, y);
+	    exponent = (exponent & 0x7fff) - 0x3fff;
+	    if (exponent <= 31
+		? i0 & (1 << (31 - exponent))
+		: (exponent <= 63
+		   && i1 & (1 << (63 - exponent))))
+	      z = -z;
+	  }
 	}
       else
 	z = 0.0/0.0;
diff --git a/sysdeps/m68k/fpu/s_sincos.c b/sysdeps/m68k/fpu/s_sincos.c
new file mode 100644
index 0000000000..ada21d0fb1
--- /dev/null
+++ b/sysdeps/m68k/fpu/s_sincos.c
@@ -0,0 +1,39 @@
+/* Copyright (C) 1997 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.  */
+
+#define __LIBC_M81_MATH_INLINES
+#include <math.h>
+
+#ifndef FUNC
+#define FUNC sincos
+#endif
+#ifndef float_type
+#define float_type double
+#endif
+
+#define CONCATX(a,b) __CONCAT(a,b)
+
+void
+CONCATX(__,FUNC) (x, sinx, cosx)
+     float_type x, *sinx, *cosx;
+{
+  __m81_u(CONCATX(__,FUNC))(x, sinx, cosx);
+}
+
+#define weak_aliasx(a,b) weak_alias(a,b)
+weak_aliasx (CONCATX(__,FUNC), FUNC)
diff --git a/sysdeps/m68k/fpu/s_sincosf.c b/sysdeps/m68k/fpu/s_sincosf.c
new file mode 100644
index 0000000000..7ee2ec6600
--- /dev/null
+++ b/sysdeps/m68k/fpu/s_sincosf.c
@@ -0,0 +1,3 @@
+#define FUNC sincosf
+#define float_type float
+#include <s_sincos.c>
diff --git a/sysdeps/m68k/fpu/s_sincosl.c b/sysdeps/m68k/fpu/s_sincosl.c
new file mode 100644
index 0000000000..f998cc0977
--- /dev/null
+++ b/sysdeps/m68k/fpu/s_sincosl.c
@@ -0,0 +1,3 @@
+#define FUNC sincosl
+#define float_type long double
+#include <s_sincos.c>
diff --git a/sysdeps/stub/shmat.c b/sysdeps/stub/shmat.c
index 9d5629b06c..b33cad117b 100644
--- a/sysdeps/stub/shmat.c
+++ b/sysdeps/stub/shmat.c
@@ -1,21 +1,21 @@
-/* Copyright (C) 1995, 1996 Free Software Foundation, Inc.
-This file is part of the GNU C Library.
-Contributed by Ulrich Drepper <drepper@gnu.ai.mit.edu>, August 1995.
+/* Copyright (C) 1995, 1996, 1997 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+   Contributed by Ulrich Drepper <drepper@gnu.ai.mit.edu>, August 1995.
 
-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., 59 Temple Place - Suite 330,
-Boston, MA 02111-1307, 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 <sys/shm.h>
 #include <errno.h>
@@ -24,14 +24,14 @@ Boston, MA 02111-1307, USA.  */
    segment of the calling process.  SHMADDR and SHMFLG determine how
    and where the segment is attached.  */
 
-char *
+void *
 shmat (shmid, shmaddr, shmflg)
      int shmid;
-     char *shmaddr;
+     const void *shmaddr;
      int shmflg;
 {
   __set_errno (ENOSYS);
-  return (char *) -1;
+  return (void *) -1;
 }
 
 stub_warning (shmat)
diff --git a/sysdeps/stub/shmdt.c b/sysdeps/stub/shmdt.c
index 8cca7743b6..ab9609e55f 100644
--- a/sysdeps/stub/shmdt.c
+++ b/sysdeps/stub/shmdt.c
@@ -1,21 +1,21 @@
-/* Copyright (C) 1995, 1996 Free Software Foundation, Inc.
-This file is part of the GNU C Library.
-Contributed by Ulrich Drepper <drepper@gnu.ai.mit.edu>, August 1995.
+/* Copyright (C) 1995, 1996, 1997 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+   Contributed by Ulrich Drepper <drepper@gnu.ai.mit.edu>, August 1995.
 
-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., 59 Temple Place - Suite 330,
-Boston, MA 02111-1307, 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 <sys/shm.h>
 #include <errno.h>
@@ -25,7 +25,7 @@ Boston, MA 02111-1307, USA.  */
 
 int
 shmdt (shmaddr)
-     char *shmaddr;
+     const void *shmaddr;
 {
   __set_errno (ENOSYS);
   return -1;