Update.

1998-07-10 18:14 -0400  Zack Weinberg  <zack@rabi.phys.columbia.edu>

	* manual/Makefile: Overhauled.  Generate libc.texinfo from the
	chapter files.  Exorcise the chapters, chapters-incl mess.
	Support inserting doc chapters from add-on modules.
	(chapters): New variable.
	(add-chapters): New variable.
	(appendices): New variable.
	(libc.texinfo): New target.
	(clean): Fix bugs.
	(realclean): Fix bugs.

	* manual/texis.awk: New file.
	* manual/libc-texinfo.sh: New file.
	* manual/libc-texinfo.in: New file.

	* manual/conf.texi (top @node): Remove next pointer.
	* manual/lang.texi (top @node): Remove prev pointer.

	* manual/job.texi (top @node): Add explicit pointers.
	* manual/message.texi (top @node): Add explicit pointers.
	* manual/nss.texi (top @node): Add explicit pointers.
	* manual/process.texi (top @node): Add explicit pointers.
	* manual/startup.texi (top @node): Add explicit pointers.
	* manual/terminal.texi (top @node): Add explicit pointers.
	* manual/users.texi (top @node): Add explicit pointers.

	* manual/arith.texi: Add %MENU% tag.
	* manual/conf.texi: Add %MENU% tag.
	* manual/contrib.texi: Add %MENU% tag.
	* manual/ctype.texi: Add %MENU% tag.
	* manual/errno.texi: Add %MENU% tag.
	* manual/filesys.texi: Add %MENU% tag.
	* manual/header.texi: Add %MENU% tag.
	* manual/install.texi: Add %MENU% tag.
	* manual/intro.texi: Add %MENU% tag.
	* manual/io.texi: Add %MENU% tag.
	* manual/job.texi: Add %MENU% tag.
	* manual/lang.texi: Add %MENU% tag.
	* manual/llio.texi: Add %MENU% tag.
	* manual/locale.texi: Add %MENU% tag.
	* manual/maint.texi: Add %MENU% tag.
	* manual/math.texi: Add %MENU% tag.
	* manual/mbyte.texi: Add %MENU% tag.
	* manual/memory.texi: Add %MENU% tag.
	* manual/message.texi: Add %MENU% tag.
	* manual/nss.texi: Add %MENU% tag.
	* manual/pattern.texi: Add %MENU% tag.
	* manual/pipe.texi: Add %MENU% tag.
	* manual/process.texi: Add %MENU% tag.
	* manual/search.texi: Add %MENU% tag.
	* manual/setjmp.texi: Add %MENU% tag.
	* manual/signal.texi: Add %MENU% tag.
	* manual/socket.texi: Add %MENU% tag.
	* manual/startup.texi: Add %MENU% tag.
	* manual/stdio.texi: Add %MENU% tag.
	* manual/string.texi: Add %MENU% tag.
	* manual/sysinfo.texi: Add %MENU% tag.
	* manual/terminal.texi: Add %MENU% tag.
	* manual/time.texi: Add %MENU% tag.
	* manual/users.texi: Add %MENU% tag.

1998-07-13  Ulrich Drepper  <drepper@cygnus.com>

	* sysdeps/unix/sysv/linux/i386/dl-procinfo.h (x86_cap_flags):
	Update.

1998-07-11  Andreas Jaeger  <aj@arthur.rhein-neckar.de>

	* sysdeps/unix/sysv/linux/recvmsg.c (__libc_recvmsg): Use ANSI
	style declaration to avoid warning.
	* sysdeps/unix/sysv/linux/sendmsg.c (__libc_sendmsg): Likewise.

1998-07-04  Mark Kettenis  <kettenis@phys.uva.nl>

	* elf/rtld.c (process_dl_debug): Add missing continue.

1998-07-12  Mark Kettenis  <kettenis@phys.uva.nl>

	* elf/rtld.c (_dl_skip_args): Make global because the Hurd startup
	code needs it.

1998-07-10  Andreas Schwab  <schwab@issan.informatik.uni-dortmund.de>

	* Makeconfig ($(common-objpfx)sysd-dirs): Write out definition of
	sysd-dirs-done.
	* Makerules: Don't generate version maps too early.
	($(common-objpfx)sysd-versions): Force regeneration if the list of
	subdirs has changed.

1998-07-10  Andreas Schwab  <schwab@issan.informatik.uni-dortmund.de>

	* elf/dlfcn.h (DL_CALL_FCT): Use portable comma expression.

1998-07-11  Andreas Schwab  <schwab@issan.informatik.uni-dortmund.de>

	* iconv/gconv_db.c (gen_steps): Always set *handle and *nsteps.
	* iconv/gconv_dl.c (__gconv_find_shlib): Correct use of tfind
	return value.

1998-07-12  Andreas Schwab  <schwab@issan.informatik.uni-dortmund.de>

	* elf/dl-open.c (dl_open_worker): New function.
	(_dl_open): Call it to do the actual work while catching errors.
	* elf/dl-close.c (_dl_close): Only call termination function if
	the initialisation function was called.

1998-07-13  Ulrich Drepper  <drepper@cygnus.com>

	* libio/libioP.h (_IO_cleanup_registration_needed): Use __PMT.
	Reported by Felix von Leitner <leitner@amdiv.de>.

1998-07-13 10:28  Andreas Schwab  <schwab@issan.informatik.uni-dortmund.de>
	* elf/rtld.c (process_dl_debug): Add missing continue.

1998-06-23  Mark Kettenis  <kettenis@phys.uva.nl>

42 files changed, 2582 insertions, 2566 deletions

diff --git a/manual/.cvsignore b/manual/.cvsignore
index 92494696db..01f89684cf 100644
--- a/manual/.cvsignore
+++ b/manual/.cvsignore
@@ -5,7 +5,7 @@ TODO COPYING* AUTHORS copyr-* copying.*
 glibc-*
 
 *.dvi* *.info* *.c.texi *.ps
-*.toc *.aux *.log
+*.toc *.aux *.log *.tmp
 *.cp *.cps *.fn *.fns *.vr *.vrs *.tp *.tps *.ky *.kys *.pg *.pgs
 
 chapters chapters-incl1 chapters-incl2 summary.texi stamp-*
diff --git a/manual/Makefile b/manual/Makefile
index c5ca263537..8af1d6c1a2 100644
--- a/manual/Makefile
+++ b/manual/Makefile
@@ -41,47 +41,37 @@ all: info
 info: libc.info dir-add.info
 endif
 
-# Set chapters and chapters-incl[12].
--include chapters
-chapters: libc.texinfo
-	$(find-includes)
-ifdef chapters
-# @includes in chapter files
--include chapters-incl1
-chapters-incl1: $(chapters)
-	$(find-includes)
-chapters-incl1 := $(filter-out summary.texi,$(chapters-incl1))
-endif
-ifdef chapters-incl1
-# @includes in files included by chapter files, if any
--include chapters-incl2
-chapters-incl2: $(chapters-incl1)
-	$(find-includes)
-endif
-
-chapters-incl := $(chapters-incl1) $(chapters-incl2)
-
-define find-includes
-(echo '$(@F) :=' \\	;\
- $(AWK) '$$1 == "@include" { print $$2 " \\" }' $^) > $@.new
-mv -f $@.new $@
-endef
-
 # scripts we use
 ifndef move-if-change
 move-if-change = ./move-if-change
 endif
 mkinstalldirs = $(..)scripts/mkinstalldirs
 
-libc.dvi libc.info: $(chapters) summary.texi $(chapters-incl)
+chapters = $(addsuffix .texi, \
+	   intro errno memory ctype string mbyte locale message search	\
+	   pattern io stdio llio filesys pipe socket terminal math	\
+	   arith time setjmp signal startup process job nss users	\
+	   sysinfo conf)
+add-chapters = $(wildcard $(patsubst %, ../%.texi, \
+		 $(join $(add-ons:=/),$(add-ons))))
+appendices = lang.texi header.texi install.texi maint.texi contrib.texi
+
+-include texis
+texis: $(chapters) $(add-chapters) $(appendices) lgpl.texinfo
+	$(AWK) -f texis.awk $^ > $@.T
+	mv -f $@.T $@
+
+nonexamples = $(filter-out %.c.texi, $(texis))
+examples = $(filter %.c.texi, $(texis))
+
+# Kludge: implicit rule so Make knows the one command does it all.
+chapters.% top-menu.%: $(texis)
+	AWK=$(AWK) $(SHELL) libc-texinfo.sh \
+	'$(chapters)' '$(add-chapters)' '$(appendices)'
+
+libc.dvi libc.info: chapters.texi top-menu.texi
 libc.dvi: texinfo.tex
 
-%.info: %.texinfo
-	$(MAKEINFO) $<
-
-%.dvi: %.texinfo
-	$(TEXI2DVI) $<
-
 # Generate the summary from the Texinfo source files for each chapter.
 summary.texi: stamp-summary ;
 stamp-summary: summary.awk $(chapters) $(chapters-incl)
@@ -93,7 +83,7 @@ stamp-summary: summary.awk $(chapters) $(chapters-incl)
 # Generate a file which can be added to the `dir' content to provide direct
 # access to the documentation of the function, variables, and other
 # definitions.
-dir-add.texinfo: xtract-typefun.awk $(chapters) $(chapters-incl)
+dir-add.texinfo: xtract-typefun.awk $(texis)
 	(echo "@dircategory GNU C library functions";			\
 	 echo "@direntry";						\
 	 $(AWK) -f $^;							\
@@ -109,18 +99,22 @@ dir-add.texinfo: xtract-typefun.awk $(chapters) $(chapters-incl)
 	    $< | expand > $@.new
 	mv -f $@.new $@
 
+%.info: %.texinfo
+	$(MAKEINFO) $<
+
+%.dvi: %.texinfo
+	$(TEXI2DVI) $<
+
+# Distribution.
+minimal-dist =  summary.awk texis.awk libc-texinfo.sh libc.texinfo	\
+		$(filter-out summary.texi, $(nonexamples))		\
+	       $(patsubst %.c.texi,examples/%.c, $(examples))
 
-minimal-dist = summary.awk libc.texinfo $(chapters)			\
-	       $(patsubst %.c.texi,examples/%.c,			\
-			  $(filter-out summary.texi,$(chapters-incl)))
 doc-only-dist = Makefile COPYING.LIB
-distribute = $(minimal-dist)	       					\
-	     $(patsubst examples/%.c,%.c.texi,$(filter examples/%.c,	\
-			$(minimal-dist)))				\
-	     libc.info* libc.?? libc.??s texinfo.tex summary.texi	\
-	     stamp-summary chapters chapters-incl1 chapters-incl2	\
+distribute = $(minimal-dist) $(examples) texis stdio-fp.c		\
+	     libc.info* libc.?? libc.??s texinfo.tex stamp-summary	\
 	     xtract-typefun.awk dir-add.texinfo dir-add.info dir	\
-	     stdio-fp.c
+	     chapters.texi top-menu.texi
 export distribute := $(distribute)
 
 tar-it = tar chovf $@ $^
@@ -149,15 +143,17 @@ glibc-doc-$(edition).tar: $(doc-only-dist) $(distribute)
 
 .PHONY: mostlyclean distclean realclean clean
 mostlyclean:
-	-rm -f libc.dvi libc.info* dir-add.info stubs
+	-rm -f libc.dvi libc.tmp libc.info* dir-add.info
+	-rm -f $(objpfx)stubs $(objpfx)distinfo
 	-rm -f $(foreach o,$(object-suffixes-for-libc),$(objpfx)stamp$o)
 clean: mostlyclean
 distclean: clean
 indices = cp fn pg tp vr ky
 realclean: distclean
-	-rm -f chapters chapters-incl* summary.texi stamp-summary *.c.texi
+	-rm -f texis summary.texi stamp-summary *.c.texi
 	-rm -f $(foreach index,$(indices),libc.$(index) libc.$(index)s)
-	-rm -f libc.log libc.aux libc.toc dir-add.texi
+	-rm -f libc.log libc.aux libc.toc dir-add.texinfo
+	-rm -f top-menu.texi chapters.texi
 
 .PHONY: install subdir_install installdirs install-data
 install-data subdir_install: install
diff --git a/manual/arith.texi b/manual/arith.texi
index 8822a8ce9d..bb7ec34793 100644
--- a/manual/arith.texi
+++ b/manual/arith.texi
@@ -1,30 +1,6 @@
-@c We need some definitions here.
-@c No we don't, they were done by math.texi. -zw
-@ignore
-@ifclear cdot
-@ifhtml
-@set cdot ·
-@macro mul
-·
-@end macro
-@end ifhtml
-@iftex
-@set cdot ·
-@macro mul
-@cdot
-@end macro
-@end iftex
-@ifclear cdot
-@set cdot x
-@macro mul
-x
-@end macro
-@end ifclear
-@end ifclear
-@end ignore
-
 @node Arithmetic, Date and Time, Mathematics, Top
-@chapter Low-Level Arithmetic Functions
+@c %MENU% Low level arithmetic functions
+@chapter Arithmetic Functions
 
 This chapter contains information about functions for doing basic
 arithmetic operations, such as splitting a float into its integer and
@@ -33,176 +9,145 @@ 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::      Classify 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
-			         fractional parts of a float.
-* Arithmetic on FP Values::     Setting and Modifying Single Bits of FP Values.
-* Special arithmetic on FPs::   Special Arithmetic on FPs.
-* Integer Division::            Functions for performing integer
-				 division.
-* Parsing of Numbers::          Functions for ``reading'' numbers
-			         from strings.
-* Old-style number conversion:: Low-level number to string conversion.
+* Floating Point Numbers::      Basic concepts.  IEEE 754.
+* Floating Point Classes::      The five kinds of floating-point number.
+* Floating Point Errors::       When something goes wrong in a calculation.
+* Rounding::                    Controlling how results are rounded.
+* Control Functions::           Saving and restoring the FPU's state.
+* Arithmetic Functions::        Fundamental operations provided by the library.
+* Complex Numbers::             The types.  Writing complex constants.
+* Operations on Complex::       Projection, conjugation, decomposition.
+* Integer Division::            Integer division with guaranteed rounding.
+* Parsing of Numbers::          Converting strings to numbers.
+* System V Number Conversion::  An archaic way to convert numbers to strings.
 @end menu
 
-@node Infinity
-@section Infinity Values
-@cindex Infinity
+@node Floating Point Numbers
+@section Floating Point Numbers
+@cindex floating point
+@cindex IEEE 754
 @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.
+Most computer hardware has support for two different kinds of numbers:
+integers (@math{@dots{}-3, -2, -1, 0, 1, 2, 3@dots{}}) and
+floating-point numbers.  Floating-point numbers have three parts: the
+@dfn{mantissa}, the @dfn{exponent}, and the @dfn{sign bit}.  The real
+number represented by a floating-point value is given by
+@tex
+$(s \mathrel? -1 \mathrel: 1) \cdot 2^e \cdot M$
+@end tex
+@ifnottex
+@math{(s ? -1 : 1) @mul{} 2^e @mul{} M}
+@end ifnottex
+where @math{s} is the sign bit, @math{e} the exponent, and @math{M}
+the mantissa.  @xref{Floating Point Concepts}, for details.  (It is
+possible to have a different @dfn{base} for the exponent, but all modern
+hardware uses @math{2}.)
+
+Floating-point numbers can represent a finite subset of the real
+numbers.  While this subset is large enough for most purposes, it is
+important to remember that the only reals that can be represented
+exactly are rational numbers that have a terminating binary expansion
+shorter than the width of the mantissa.  Even simple fractions such as
+@math{1/5} can only be approximated by floating point.
+
+Mathematical operations and functions frequently need to produce values
+that are not representable.  Often these values can be approximated
+closely enough for practical purposes, but sometimes they can't.
+Historically there was no way to tell when the results of a calculation
+were inaccurate.  Modern computers implement the @w{IEEE 754} standard
+for numerical computations, which defines a framework for indicating to
+the program when the results of calculation are not trustworthy.  This
+framework consists of a set of @dfn{exceptions} that indicate why a
+result could not be represented, and the special values @dfn{infinity}
+and @dfn{not a number} (NaN).
+
+@node Floating Point Classes
+@section Floating-Point Number Classification Functions
+@cindex floating-point classes
+@cindex classes, floating-point
+@pindex math.h
 
-The @w{IEEE 754} floating-point defines a special value to be used in
-these situations.  There is a special value for infinity.
+@w{ISO C 9x} defines macros that let you determine what sort of
+floating-point number a variable holds.
 
 @comment math.h
 @comment ISO
-@deftypevr Macro float INFINITY
-An expression representing the infinite value.  @code{INFINITY} values are
-produced 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{-INFINITY} is representable
-and it is handled differently if needed.  It is possible to test a
-value for infiniteness using a simple comparison but the
-recommended way is to use 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
-@cindex not a number
-@cindex IEEE floating point
+@deftypefn {Macro} 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:
 
-The IEEE floating point format used by most modern computers supports
-values that are ``not a number''.  These values are called @dfn{NaNs}.
-``Not a number'' values result from certain operations which have no
-meaningful numeric result, such as zero divided by zero or infinity
-divided by infinity.
+@vtable @code
+@item FP_NAN
+The floating-point number @var{x} is ``Not a Number'' (@pxref{Infinity
+and NaN})
+@item FP_INFINITE
+The value of @var{x} is either plus or minus infinity (@pxref{Infinity
+and NaN})
+@item FP_ZERO
+The value of @var{x} is zero.  In floating-point formats like @w{IEEE
+754}, where zero can be signed, this value is also returned if
+@var{x} is negative zero.
+@item FP_SUBNORMAL
+Numbers whose absolute value is too small to be represented in the
+normal format are represented in an alternate, @dfn{denormalized} format
+(@pxref{Floating Point Concepts}).  This format is less precise but can
+represent values closer to zero.  @code{fpclassify} returns this value
+for values of @var{x} in this alternate format.
+@item FP_NORMAL
+This value is returned for all other values of @var{x}.  It indicates
+that there is nothing special about the number.
+@end vtable
 
-One noteworthy property of NaNs is that they are not equal to
-themselves.  Thus, @code{x == x} can be 0 if the value of @code{x} is a
-NaN.  You can use this to test whether a value is a NaN or not: if it is
-not equal to itself, then it is a NaN.  But the recommended way to test
-for a NaN is with the @code{isnan} function (@pxref{Predicates on Floats}).
+@end deftypefn
 
-Almost any arithmetic operation in which one argument is a NaN returns
-a NaN.
+@code{fpclassify} is most useful if more than one property of a number
+must be tested.  There are more specific macros which only test one
+property at a time.  Generally these macros execute faster than
+@code{fpclassify}, since there is special hardware support for them.
+You should therefore use the specific macros whenever possible.
 
 @comment math.h
-@comment GNU
-@deftypevr Macro float NAN
-An expression representing a value which is ``not a number''.  This
-macro is a GNU extension, available only on machines that support ``not
-a number'' values---that is to say, on all machines that support IEEE
-floating point.
-
-You can use @samp{#ifdef NAN} to test whether the machine supports
-NaNs.  (Of course, you must arrange for GNU extensions to be visible,
-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 convenience the @file{complex.h}
-header defines two macros which allow to use a similar easy notation.
-
-@deftypevr Macro {const float complex} _Complex_I
-This macro is a representation of the complex number ``@math{0+1i}''.
-Computing
-
-@smallexample
-_Complex_I * _Complex_I = -1
-@end smallexample
-
-@noindent
-leads to a real-valued result.  If no @code{imaginary} types are
-available it is easiest to use this value to construct complex numbers
-from real values:
+@comment ISO
+@deftypefn {Macro} int isfinite (@emph{float-type} @var{x})
+This macro returns a nonzero value if @var{x} is finite: not plus or
+minus infinity, and not NaN.  It is equivalent to
 
 @smallexample
-3.0 - _Complex_I * 4.0
+(fpclassify (x) != FP_NAN && fpclassify (x) != FP_INFINITE)
 @end smallexample
-@end deftypevr
 
-@noindent
-Without an optimizing compiler this is more expensive than the use of
-@code{_Imaginary_I} but with is better than nothing.  You can avoid all
-the hassles if you use the @code{I} macro below if the name is not
-problem.
+@code{isfinite} is implemented as a macro which accepts any
+floating-point type.
+@end deftypefn
 
-@deftypevr Macro {const float imaginary} _Imaginary_I
-This macro is a representation of the value ``@math{1i}''.  I.e., it is
-the value for which
+@comment math.h
+@comment ISO
+@deftypefn {Macro} int isnormal (@emph{float-type} @var{x})
+This macro returns a nonzero value if @var{x} is finite and normalized.
+It is equivalent to
 
 @smallexample
-_Imaginary_I * _Imaginary_I = -1
+(fpclassify (x) == FP_NORMAL)
 @end smallexample
+@end deftypefn
 
-@noindent
-The result is not of type @code{float imaginary} but instead @code{float}.
-One can use it to easily construct complex number like in
+@comment math.h
+@comment ISO
+@deftypefn {Macro} int isnan (@emph{float-type} @var{x})
+This macro returns a nonzero value if @var{x} is NaN.  It is equivalent
+to
 
 @smallexample
-3.0 - _Imaginary_I * 4.0
+(fpclassify (x) == FP_NAN)
 @end smallexample
+@end deftypefn
 
-@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 {const float imaginary} 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}.
-
-If the implementation does not support the @code{imaginary} types
-@code{I} is defined as @code{_Complex_I} which is the second best
-solution.  It still can be used in the same way but requires a most
-clever compiler to get the same results.
-@end deftypevr
-
-
-@node Predicates on Floats
-@section Predicates on Floats
-
-@pindex math.h
-This section describes some miscellaneous test functions on doubles.
-Prototypes for these functions appear in @file{math.h}.  These are BSD
-functions, and thus are available if you define @code{_BSD_SOURCE} or
-@code{_GNU_SOURCE}.
+Another set of floating-point classification functions was provided by
+BSD.  The GNU C library also supports these functions; however, we
+recommend that you use the C9x macros in new code.  Those are standard
+and will be available more widely.  Also, since they are macros, you do
+not have to worry about the type of their argument.
 
 @comment math.h
 @comment BSD
@@ -219,15 +164,16 @@ This function returns @code{-1} if @var{x} represents negative infinity,
 @deftypefunx int isnanf (float @var{x})
 @deftypefunx 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).
+value, and zero otherwise.
 
-However, @code{isnan} will not raise an invalid exception if @var{x} is
-a signalling NaN, while @code{@var{x} != @var{x}} will.  This makes
-@code{isnan} much slower than the alternative; in code where performance
-matters and signalling NaNs are unimportant, it's usually better to use
-@code{@var{x} != @var{x}}, even though this is harder to understand.
+@strong{Note:} The @code{isnan} macro defined by @w{ISO C 9x} overrides
+the BSD function.  This is normally not a problem, because the two
+routines behave identically.  However, if you really need to get the BSD
+function for some reason, you can write
 
+@smallexample
+(isnan) (x)
+@end smallexample
 @end deftypefun
 
 @comment math.h
@@ -242,12 +188,11 @@ number'' value, and zero otherwise.
 @comment math.h
 @comment BSD
 @deftypefun double infnan (int @var{error})
-This function is provided for compatibility with BSD.  The other
-mathematical functions use @code{infnan} to decide what to return on
-occasion of an error.  Its argument is an error code, @code{EDOM} or
-@code{ERANGE}; @code{infnan} returns a suitable value to indicate this
-with.  @code{-ERANGE} is also acceptable as an argument, and corresponds
-to @code{-HUGE_VAL} as a value.
+This function is provided for compatibility with BSD.  Its argument is
+an error code, @code{EDOM} or @code{ERANGE}; @code{infnan} returns the
+value that a math function would return if it set @code{errno} to that
+value.  @xref{Math Error Reporting}.  @code{-ERANGE} is also acceptable
+as an argument, and corresponds to @code{-HUGE_VAL} as a value.
 
 In the BSD library, on certain machines, @code{infnan} raises a fatal
 signal in all cases.  The GNU library does not do likewise, because that
@@ -257,182 +202,602 @@ 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 which are introduced in the @w{ISO C
-9X} standard and are therefore widely available.
+@node Floating Point Errors
+@section Errors in Floating-Point Calculations
+
+@menu
+* FP Exceptions::               IEEE 754 math exceptions and how to detect them.
+* Infinity and NaN::            Special values returned by calculations.
+* Status bit operations::       Checking for exceptions after the fact.
+* Math Error Reporting::        How the math functions report errors.
+@end menu
+
+@node FP Exceptions
+@subsection FP Exceptions
+@cindex exception
+@cindex signal
+@cindex zero divide
+@cindex division by zero
+@cindex inexact exception
+@cindex invalid exception
+@cindex overflow exception
+@cindex underflow exception
+
+The @w{IEEE 754} standard defines five @dfn{exceptions} that can occur
+during a calculation.  Each corresponds to a particular sort of error,
+such as overflow.
+
+When exceptions occur (when exceptions are @dfn{raised}, in the language
+of the standard), one of two things can happen.  By default the
+exception is simply noted in the floating-point @dfn{status word}, and
+the program continues as if nothing had happened.  The operation
+produces a default value, which depends on the exception (see the table
+below).  Your program can check the status word to find out which
+exceptions happened.
+
+Alternatively, you can enable @dfn{traps} for exceptions.  In that case,
+when an exception is raised, your program will receive the @code{SIGFPE}
+signal.  The default action for this signal is to terminate the
+program.  @xref{Signal Handling} for how you can change the effect of
+the signal.
+
+@findex matherr
+In the System V math library, the user-defined function @code{matherr}
+is called when certain exceptions occur inside math library functions.
+However, the Unix98 standard deprecates this interface.  We support it
+for historical compatibility, but recommend that you do not use it in
+new programs.
+
+@noindent
+The exceptions defined in @w{IEEE 754} are:
+
+@table @samp
+@item Invalid Operation
+This exception is raised if the given operands are invalid for the
+operation to be performed.  Examples are
+(see @w{IEEE 754}, @w{section 7}):
+@enumerate
+@item
+Addition or subtraction: @math{@infinity{} - @infinity{}}.  (But
+@math{@infinity{} + @infinity{} = @infinity{}}).
+@item
+Multiplication: @math{0 @mul{} @infinity{}}.
+@item
+Division: @math{0/0} or @math{@infinity{}/@infinity{}}.
+@item
+Remainder: @math{x} REM @math{y}, where @math{y} is zero or @math{x} is
+infinite.
+@item
+Square root if the operand is less then zero.  More generally, any
+mathematical function evaluated outside its domain produces this
+exception.
+@item
+Conversion of a floating-point number to an integer or decimal
+string, when the number cannot be represented in the target format (due
+to overflow, infinity, or NaN).
+@item
+Conversion of an unrecognizable input string.
+@item
+Comparison via predicates involving @math{<} or @math{>}, when one or
+other of the operands is NaN.  You can prevent this exception by using
+the unordered comparison functions instead; see @ref{FP Comparison Functions}.
+@end enumerate
+
+If the exception does not trap, the result of the operation is NaN.
+
+@item Division by Zero
+This exception is raised when a finite nonzero number is divided
+by zero.  If no trap occurs the result is either @math{+@infinity{}} or
+@math{-@infinity{}}, depending on the signs of the operands.
+
+@item Overflow
+This exception is raised whenever the result cannot be represented
+as a finite value in the precision format of the destination.  If no trap
+occurs the result depends on the sign of the intermediate result and the
+current rounding mode (@w{IEEE 754}, @w{section 7.3}):
+@enumerate
+@item
+Round to nearest carries all overflows to @math{@infinity{}}
+with the sign of the intermediate result.
+@item
+Round toward @math{0} carries all overflows to the largest representable
+finite number with the sign of the intermediate result.
+@item
+Round toward @math{-@infinity{}} carries positive overflows to the
+largest representable finite number and negative overflows to
+@math{-@infinity{}}.
+
+@item
+Round toward @math{@infinity{}} carries negative overflows to the
+most negative representable finite number and positive overflows
+to @math{@infinity{}}.
+@end enumerate
+
+Whenever the overflow exception is raised, the inexact exception is also
+raised.
+
+@item Underflow
+The underflow exception is raised when an intermediate result is too
+small to be calculated accurately, or if the operation's result rounded
+to the destination precision is too small to be normalized.
+
+When no trap is installed for the underflow exception, underflow is
+signaled (via the underflow flag) only when both tininess and loss of
+accuracy have been detected.  If no trap handler is installed the
+operation continues with an imprecise small value, or zero if the
+destination precision cannot hold the small exact result.
+
+@item Inexact
+This exception is signalled if a rounded result is not exact (such as
+when calculating the square root of two) or a result overflows without
+an overflow trap.
+@end table
+
+@node Infinity and NaN
+@subsection Infinity and NaN
+@cindex infinity
+@cindex not a number
+@cindex NaN
+
+@w{IEEE 754} floating point numbers can represent positive or negative
+infinity, and @dfn{NaN} (not a number).  These three values arise from
+calculations whose result is undefined or cannot be represented
+accurately.  You can also deliberately set a floating-point variable to
+any of them, which is sometimes useful.  Some examples of calculations
+that produce infinity or NaN:
+
+@ifnottex
+@smallexample
+@math{1/0 = @infinity{}}
+@math{log (0) = -@infinity{}}
+@math{sqrt (-1) = NaN}
+@end smallexample
+@end ifnottex
+@tex
+$${1\over0} = \infty$$
+$$\log 0 = -\infty$$
+$$\sqrt{-1} = \hbox{NaN}$$
+@end tex
+
+When a calculation produces any of these values, an exception also
+occurs; see @ref{FP Exceptions}.
+
+The basic operations and math functions all accept infinity and NaN and
+produce sensible output.  Infinities propagate through calculations as
+one would expect: for example, @math{2 + @infinity{} = @infinity{}},
+@math{4/@infinity{} = 0}, atan @math{(@infinity{}) = @pi{}/2}.  NaN, on
+the other hand, infects any calculation that involves it.  Unless the
+calculation would produce the same result no matter what real value
+replaced NaN, the result is NaN.
+
+In comparison operations, positive infinity is larger than all values
+except itself and NaN, and negative infinity is smaller than all values
+except itself and NaN.  NaN is @dfn{unordered}: it is not equal to,
+greater than, or less than anything, @emph{including itself}. @code{x ==
+x} is false if the value of @code{x} is NaN.  You can use this to test
+whether a value is NaN or not, but the recommended way to test for NaN
+is with the @code{isnan} function (@pxref{Floating Point Classes}).  In
+addition, @code{<}, @code{>}, @code{<=}, and @code{>=} will raise an
+exception when applied to NaNs.
+
+@file{math.h} defines macros that allow you to explicitly set a variable
+to infinity or NaN.
 
 @comment math.h
 @comment ISO
-@deftypefn {Macro} 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:
+@deftypevr Macro float INFINITY
+An expression representing positive infinity.  It is equal to the value
+produced  by mathematical operations like @code{1.0 / 0.0}.
+@code{-INFINITY} represents negative infinity.
+
+You can test whether a floating-point value is infinite by comparing it
+to this macro.  However, this is not recommended; you should use the
+@code{isfinite} macro instead.  @xref{Floating Point Classes}.
+
+This macro was introduced in the @w{ISO C 9X} standard.
+@end deftypevr
+
+@comment math.h
+@comment GNU
+@deftypevr Macro float NAN
+An expression representing a value which is ``not a number''.  This
+macro is a GNU extension, available only on machines that support the
+``not a number'' value---that is to say, on all machines that support
+IEEE floating point.
+
+You can use @samp{#ifdef NAN} to test whether the machine supports
+NaN.  (Of course, you must arrange for GNU extensions to be visible,
+such as by defining @code{_GNU_SOURCE}, and then you must include
+@file{math.h}.)
+@end deftypevr
+
+@w{IEEE 754} also allows for another unusual value: negative zero.  This
+value is produced when you divide a positive number by negative
+infinity, or when a negative result is smaller than the limits of
+representation.  Negative zero behaves identically to zero in all
+calculations, unless you explicitly test the sign bit with
+@code{signbit} or @code{copysign}.
+
+@node Status bit operations
+@subsection Examining the FPU status word
+
+@w{ISO C 9x} defines functions to query and manipulate the
+floating-point status word.  You can use these functions to check for
+untrapped exceptions when it's convenient, rather than worrying about
+them in the middle of a calculation.
+
+These constants represent the various @w{IEEE 754} exceptions.  Not all
+FPUs report all the different exceptions.  Each constant is defined if
+and only if the FPU you are compiling for supports that exception, so
+you can test for FPU support with @samp{#ifdef}.  They are defined in
+@file{fenv.h}.
 
 @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.
+@comment fenv.h
+@comment ISO
+@item FE_INEXACT
+ The inexact exception.
+@comment fenv.h
+@comment ISO
+@item FE_DIVBYZERO
+ The divide by zero exception.
+@comment fenv.h
+@comment ISO
+@item FE_UNDERFLOW
+ The underflow exception.
+@comment fenv.h
+@comment ISO
+@item FE_OVERFLOW
+ The overflow exception.
+@comment fenv.h
+@comment ISO
+@item FE_INVALID
+ The invalid exception.
 @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 deftypefn
+The macro @code{FE_ALL_EXCEPT} is the bitwise OR of all exception macros
+which are supported by the FP implementation.
 
-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}).
+These functions allow you to clear exception flags, test for exceptions,
+and save and restore the set of exceptions flagged.
 
-@comment math.h
+@comment fenv.h
 @comment ISO
-@deftypefn {Macro} 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
+@deftypefun void feclearexcept (int @var{excepts})
+This function clears all of the supported exception flags indicated by
+@var{excepts}.
+@end deftypefun
+
+@comment fenv.h
+@comment ISO
+@deftypefun int fetestexcept (int @var{excepts})
+Test whether the exception flags indicated by the parameter @var{except}
+are currently set.  If any of them are, a nonzero value is returned
+which specifies which exceptions are set.  Otherwise the result is zero.
+@end deftypefun
+
+To understand these functions, imagine that the status word is an
+integer variable named @var{status}.  @code{feclearexcept} is then
+equivalent to @samp{status &= ~excepts} and @code{fetestexcept} is
+equivalent to @samp{(status & excepts)}.  The actual implementation may
+be very different, of course.
+
+Exception flags are only cleared when the program explicitly requests it,
+by calling @code{feclearexcept}.  If you want to check for exceptions
+from a set of calculations, you should clear all the flags first.  Here
+is a simple example of the way to use @code{fetestexcept}:
 
 @smallexample
-(fpclassify (x) != FP_NAN && fpclassify (x) != FP_INFINITE)
+@{
+  double f;
+  int raised;
+  feclearexcept (FE_ALL_EXCEPT);
+  f = compute ();
+  raised = fetestexcept (FE_OVERFLOW | FE_INVALID);
+  if (raised & FE_OVERFLOW) @{ /* ... */ @}
+  if (raised & FE_INVALID) @{ /* ... */ @}
+  /* ... */
+@}
 @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 deftypefn
+You cannot explicitly set bits in the status word.  You can, however,
+save the entire status word and restore it later.  This is done with the
+following functions:
 
-@comment math.h
+@comment fenv.h
 @comment ISO
-@deftypefn {Macro} 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
+@deftypefun void fegetexceptflag (fexcept_t *@var{flagp}, int @var{excepts})
+This function stores in the variable pointed to by @var{flagp} an
+implementation-defined value representing the current setting of the
+exception flags indicated by @var{excepts}.
+@end deftypefun
 
-@smallexample
-(fpclassify (x) == FP_NORMAL)
-@end smallexample
-@end deftypefn
+@comment fenv.h
+@comment ISO
+@deftypefun void fesetexceptflag (const fexcept_t *@var{flagp}, int
+@var{excepts})
+This function restores the flags for the exceptions indicated by
+@var{excepts} to the values stored in the variable pointed to by
+@var{flagp}.
+@end deftypefun
+
+Note that the value stored in @code{fexcept_t} bears no resemblance to
+the bit mask returned by @code{fetestexcept}.  The type may not even be
+an integer.  Do not attempt to modify an @code{fexcept_t} variable.
+
+@node Math Error Reporting
+@subsection Error Reporting by Mathematical Functions
+@cindex errors, mathematical
+@cindex domain error
+@cindex range error
+
+Many of the math functions are defined only over a subset of the real or
+complex numbers.  Even if they are mathematically defined, their result
+may be larger or smaller than the range representable by their return
+type.  These are known as @dfn{domain errors}, @dfn{overflows}, and
+@dfn{underflows}, respectively.  Math functions do several things when
+one of these errors occurs.  In this manual we will refer to the
+complete response as @dfn{signalling} a domain error, overflow, or
+underflow.
+
+When a math function suffers a domain error, it raises the invalid
+exception and returns NaN.  It also sets @var{errno} to @code{EDOM};
+this is for compatibility with old systems that do not support @w{IEEE
+754} exception handling.  Likewise, when overflow occurs, math
+functions raise the overflow exception and return @math{@infinity{}} or
+@math{-@infinity{}} as appropriate.  They also set @var{errno} to
+@code{ERANGE}.  When underflow occurs, the underflow exception is
+raised, and zero (appropriately signed) is returned.  @var{errno} may be
+set to @code{ERANGE}, but this is not guaranteed.
+
+Some of the math functions are defined mathematically to result in a
+complex value over parts of their domains.  The most familiar example of
+this is taking the square root of a negative number.  The complex math
+functions, such as @code{csqrt}, will return the appropriate complex value
+in this case.  The real-valued functions, such as @code{sqrt}, will
+signal a domain error.
+
+Some older hardware does not support infinities.  On that hardware,
+overflows instead return a particular very large number (usually the
+largest representable number).  @file{math.h} defines macros you can use
+to test for overflow on both old and new hardware.
 
 @comment math.h
 @comment ISO
-@deftypefn {Macro} 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
+@deftypevr Macro double HUGE_VAL
+@deftypevrx Macro float HUGE_VALF
+@deftypevrx Macro {long double} HUGE_VALL
+An expression representing a particular very large number.  On machines
+that use @w{IEEE 754} floating point format, @code{HUGE_VAL} is infinity.
+On other machines, it's typically the largest positive number that can
+be represented.
+
+Mathematical functions return the appropriately typed version of
+@code{HUGE_VAL} or @code{@minus{}HUGE_VAL} when the result is too large
+to be represented.
+@end deftypevr
 
-@smallexample
-(fpclassify (x) == FP_NAN)
-@end smallexample
+@node Rounding
+@section Rounding Modes
+
+Floating-point calculations are carried out internally with extra
+precision, and then rounded to fit into the destination type.  This
+ensures that results are as precise as the input data.  @w{IEEE 754}
+defines four possible rounding modes:
+
+@table @asis
+@item Round to nearest.
+This is the default mode.  It should be used unless there is a specific
+need for one of the others.  In this mode results are rounded to the
+nearest representable value.  If the result is midway between two
+representable values, the even representable is chosen. @dfn{Even} here
+means the lowest-order bit is zero.  This rounding mode prevents
+statistical bias and guarantees numeric stability: round-off errors in a
+lengthy calculation will remain smaller than half of @code{FLT_EPSILON}.
+
+@c @item Round toward @math{+@infinity{}}
+@item Round toward plus Infinity.
+All results are rounded to the smallest representable value
+which is greater than the result.
+
+@c @item Round toward @math{-@infinity{}}
+@item Round toward minus Infinity.
+All results are rounded to the largest representable value which is less
+than the result.
+
+@item Round toward zero.
+All results are rounded to the largest representable value whose
+magnitude is less than that of the result.  In other words, if the
+result is negative it is rounded up; if it is positive, it is rounded
+down.
+@end table
 
-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
+@noindent
+@file{fenv.h} defines constants which you can use to refer to the
+various rounding modes.  Each one will be defined if and only if the FPU
+supports the corresponding rounding mode.
 
-@smallexample
-(isnan) (x)
-@end smallexample
+@table @code
+@comment fenv.h
+@comment ISO
+@vindex FE_TONEAREST
+@item FE_TONEAREST
+Round to nearest.
 
-@noindent
-to avoid the macro expansion.  Using the macro has two big advantages:
-it is more portable and one does not have to choose the right function
-among @code{isnan}, @code{isnanf}, and @code{isnanl}.
-@end deftypefn
+@comment fenv.h
+@comment ISO
+@vindex FE_UPWARD
+@item FE_UPWARD
+Round toward @math{+@infinity{}}.
 
+@comment fenv.h
+@comment ISO
+@vindex FE_DOWNWARD
+@item FE_DOWNWARD
+Round toward @math{-@infinity{}}.
 
-@node Operations on Complex
-@section Projections, Conjugates, and Decomposing of Complex Numbers
-@cindex project complex numbers
-@cindex conjugate complex numbers
-@cindex decompose complex numbers
+@comment fenv.h
+@comment ISO
+@vindex FE_TOWARDZERO
+@item FE_TOWARDZERO
+Round toward zero.
+@end table
 
-This section lists functions performing some of the simple mathematical
-operations on complex numbers.  Using any of the function requires that
-the C compiler understands the @code{complex} keyword, introduced to the
-C language in the @w{ISO C 9X} standard.
+Underflow is an unusual case.  Normally, @w{IEEE 754} floating point
+numbers are always normalized (@pxref{Floating Point Concepts}).
+Numbers smaller than @math{2^r} (where @math{r} is the minimum exponent,
+@code{FLT_MIN_RADIX-1} for @var{float}) cannot be represented as
+normalized numbers.  Rounding all such numbers to zero or @math{2^r}
+would cause some algorithms to fail at 0.  Therefore, they are left in
+denormalized form.  That produces loss of precision, since some bits of
+the mantissa are stolen to indicate the decimal point.
+
+If a result is too small to be represented as a denormalized number, it
+is rounded to zero.  However, the sign of the result is preserved; if
+the calculation was negative, the result is @dfn{negative zero}.
+Negative zero can also result from some operations on infinity, such as
+@math{4/-@infinity{}}.  Negative zero behaves identically to zero except
+when the @code{copysign} or @code{signbit} functions are used to check
+the sign bit directly.
+
+At any time one of the above four rounding modes is selected.  You can
+find out which one with this function:
+
+@comment fenv.h
+@comment ISO
+@deftypefun int fegetround (void)
+Returns the currently selected rounding mode, represented by one of the
+values of the defined rounding mode macros.
+@end deftypefun
 
-@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.
+@noindent
+To change the rounding mode, use this function:
 
-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 fenv.h
+@comment ISO
+@deftypefun int fesetround (int @var{round})
+Changes the currently selected rounding mode to @var{round}.  If
+@var{round} does not correspond to one of the supported rounding modes
+nothing is changed.  @code{fesetround} returns a nonzero value if it
+changed the rounding mode, zero if the mode is not supported.
+@end deftypefun
 
-@comment complex.h
+You should avoid changing the rounding mode if possible.  It can be an
+expensive operation; also, some hardware requires you to compile your
+program differently for it to work.  The resulting code may run slower.
+See your compiler documentation for details.
+@c This section used to claim that functions existed to round one number
+@c in a specific fashion.  I can't find any functions in the library
+@c that do that. -zw
+
+@node Control Functions
+@section Floating-Point Control Functions
+
+@w{IEEE 754} floating-point implementations allow the programmer to
+decide whether traps will occur for each of the exceptions, by setting
+bits in the @dfn{control word}.  In C, traps result in the program
+receiving the @code{SIGFPE} signal; see @ref{Signal Handling}.
+
+@strong{Note:} @w{IEEE 754} says that trap handlers are given details of
+the exceptional situation, and can set the result value.  C signals do
+not provide any mechanism to pass this information back and forth.
+Trapping exceptions in C is therefore not very useful.
+
+It is sometimes necessary to save the state of the floating-point unit
+while you perform some calculation.  The library provides functions
+which save and restore the exception flags, the set of exceptions that
+generate traps, and the rounding mode.  This information is known as the
+@dfn{floating-point environment}.
+
+The functions to save and restore the floating-point environment all use
+a variable of type @code{fenv_t} to store information.  This type is
+defined in @file{fenv.h}.  Its size and contents are
+implementation-defined.  You should not attempt to manipulate a variable
+of this type directly.
+
+To save the state of the FPU, use one of these functions:
+
+@comment fenv.h
 @comment ISO
-@deftypefun double creal (complex double @var{z})
-@deftypefunx float crealf (complex float @var{z})
-@deftypefunx {long double} creall (complex long double @var{z})
-These functions return the real part of the complex number @var{z}.
+@deftypefun void fegetenv (fenv_t *@var{envp})
+Store the floating-point environment in the variable pointed to by
+@var{envp}.
 @end deftypefun
 
-@comment complex.h
+@comment fenv.h
 @comment ISO
-@deftypefun double cimag (complex double @var{z})
-@deftypefunx float cimagf (complex float @var{z})
-@deftypefunx {long double} cimagl (complex long double @var{z})
-These functions return the imaginary part of the complex number @var{z}.
+@deftypefun int feholdexcept (fenv_t *@var{envp})
+Store the current floating-point environment in the object pointed to by
+@var{envp}.  Then clear all exception flags, and set the FPU to trap no
+exceptions.  Not all FPUs support trapping no exceptions; if
+@code{feholdexcept} cannot set this mode, it returns zero.  If it
+succeeds, it returns a nonzero value.
 @end deftypefun
 
+The functions which restore the floating-point environment can take two
+kinds of arguments:
 
-The conjugate complex value of a given complex number has the same value
-for the real part but the complex part is negated.
+@itemize @bullet
+@item
+Pointers to @code{fenv_t} objects, which were initialized previously by a
+call to @code{fegetenv} or @code{feholdexcept}.
+@item
+@vindex FE_DFL_ENV
+The special macro @code{FE_DFL_ENV} which represents the floating-point
+environment as it was available at program start.
+@item
+Implementation defined macros with names starting with @code{FE_}.
 
-@comment complex.h
+@vindex FE_NOMASK_ENV
+If possible, the GNU C Library defines a macro @code{FE_NOMASK_ENV}
+which represents an environment where every exception raised causes a
+trap to occur.  You can test for this macro using @code{#ifdef}.  It is
+only defined if @code{_GNU_SOURCE} is defined.
+
+Some platforms might define other predefined environments.
+@end itemize
+
+@noindent
+To set the floating-point environment, you can use either of these
+functions:
+
+@comment fenv.h
 @comment ISO
-@deftypefun {complex double} conj (complex double @var{z})
-@deftypefunx {complex float} conjf (complex float @var{z})
-@deftypefunx {complex long double} conjl (complex long double @var{z})
-These functions return the conjugate complex value of the complex number
-@var{z}.
+@deftypefun void fesetenv (const fenv_t *@var{envp})
+Set the floating-point environment to that described by @var{envp}.
 @end deftypefun
 
-@comment complex.h
+@comment fenv.h
 @comment ISO
-@deftypefun double carg (complex double @var{z})
-@deftypefunx float cargf (complex float @var{z})
-@deftypefunx {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.
+@deftypefun void feupdateenv (const fenv_t *@var{envp})
+Like @code{fesetenv}, this function sets the floating-point environment
+to that described by @var{envp}.  However, if any exceptions were
+flagged in the status word before @code{feupdateenv} was called, they
+remain flagged after the call.  In other words, after @code{feupdateenv}
+is called, the status word is the bitwise OR of the previous status word
+and the one saved in @var{envp}.
 @end deftypefun
 
-@comment complex.h
-@comment ISO
-@deftypefun {complex double} cproj (complex double @var{z})
-@deftypefunx {complex float} cprojf (complex float @var{z})
-@deftypefunx {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 infinite on the real axis.  If the
-real part is infinite, the result is equivalent to
+@node Arithmetic Functions
+@section Arithmetic Functions
 
-@smallexample
-INFINITY + I * copysign (0.0, cimag (z))
-@end smallexample
-@end deftypefun
+The C library provides functions to do basic operations on
+floating-point numbers.  These include absolute value, maximum and minimum,
+normalization, bit twiddling, rounding, and a few others.
 
+@menu
+* Absolute Value::              Absolute values of integers and floats.
+* Normalization Functions::     Extracting exponents and putting them back.
+* Rounding Functions::          Rounding floats to integers.
+* Remainder Functions::         Remainders on division, precisely defined.
+* FP Bit Twiddling::            Sign bit adjustment.  Adding epsilon.
+* FP Comparison Functions::     Comparisons without risk of exceptions.
+* Misc FP Arithmetic::          Max, min, positive difference, multiply-add.
+@end menu
 
 @node Absolute Value
-@section Absolute Value
+@subsection Absolute Value
 @cindex absolute value functions
 
 These functions are provided for obtaining the @dfn{absolute value} (or
@@ -445,33 +810,21 @@ whose imaginary part is @var{y}, the absolute value is @w{@code{sqrt
 @pindex math.h
 @pindex stdlib.h
 Prototypes for @code{abs}, @code{labs} and @code{llabs} are in @file{stdlib.h};
-@code{fabs}, @code{fabsf} and @code{fabsl} 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
 @deftypefun int abs (int @var{number})
-This function returns the absolute value of @var{number}.
+@deftypefunx {long int} labs (long int @var{number})
+@deftypefunx {long long int} llabs (long long int @var{number})
+These functions return the absolute value of @var{number}.
 
 Most computers use a two's complement integer representation, in which
 the absolute value of @code{INT_MIN} (the smallest possible @code{int})
 cannot be represented; thus, @w{@code{abs (INT_MIN)}} is not defined.
-@end deftypefun
 
-@comment stdlib.h
-@comment ISO
-@deftypefun {long int} labs (long int @var{number})
-This is similar to @code{abs}, except that both the argument and result
-are of type @code{long int} rather than @code{int}.
-@end deftypefun
-
-@comment stdlib.h
-@comment ISO
-@deftypefun {long long int} llabs (long long int @var{number})
-This is similar to @code{abs}, except that both the argument and result
-are of type @code{long long int} rather than @code{int}.
-
-This function is defined in @w{ISO C 9X}.
+@code{llabs} is new to @w{ISO C 9x}
 @end deftypefun
 
 @comment math.h
@@ -488,24 +841,21 @@ This function returns the absolute value of the floating-point number
 @deftypefun double cabs (complex double @var{z})
 @deftypefunx float cabsf (complex float @var{z})
 @deftypefunx {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.  The
-value is:
+These functions return the absolute  value of the complex number @var{z}
+(@pxref{Complex Numbers}).  The absolute value of a complex number is:
 
 @smallexample
 sqrt (creal (@var{z}) * creal (@var{z}) + cimag (@var{z}) * cimag (@var{z}))
 @end smallexample
 
-This function should always be used instead of the direct formula since
-using the simple straight-forward method can mean to lose accuracy.  If
-one of the squared values is neglectable in size compared to the other
-value the result should be the same as the larger value.  But squaring
-the value and afterwards using the square root function leads to
-inaccuracy.  See @code{hypot} in @xref{Exponents and Logarithms}.
+This function should always be used instead of the direct formula
+because it takes special care to avoid losing precision.  It may also
+take advantage of hardware support for this operation. See @code{hypot}
+in @xref{Exponents and Logarithms}.
 @end deftypefun
 
 @node Normalization Functions
-@section Normalization Functions
+@subsection Normalization Functions
 @cindex normalization functions (floating-point)
 
 The functions described in this section are primarily provided as a way
@@ -553,23 +903,15 @@ by @code{frexp}.)
 For example, @code{ldexp (0.8, 4)} returns @code{12.8}.
 @end deftypefun
 
-The following functions which come from BSD provide facilities
-equivalent to those of @code{ldexp} and @code{frexp}:
-
-@comment math.h
-@comment BSD
-@deftypefun double scalb (double @var{value}, int @var{exponent})
-@deftypefunx float scalbf (float @var{value}, int @var{exponent})
-@deftypefunx {long double} scalbl (long double @var{value}, int @var{exponent})
-The @code{scalb} function is the BSD name for @code{ldexp}.
-@end deftypefun
+The following functions, which come from BSD, provide facilities
+equivalent to those of @code{ldexp} and @code{frexp}.
 
 @comment math.h
 @comment BSD
 @deftypefun double logb (double @var{x})
 @deftypefunx float logbf (float @var{x})
 @deftypefunx {long double} logbl (long double @var{x})
-These BSD functions return the integer part of the base-2 logarithm of
+These 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
@@ -578,25 +920,62 @@ the highest integer power of @code{2} contained in @var{x}.  The sign of
 When @code{2} raised to this power is divided into @var{x}, it gives a
 quotient between @code{1} (inclusive) and @code{2} (exclusive).
 
-If @var{x} is zero, the value is minus infinity (if the machine supports
-such a value), or else a very small number.  If @var{x} is infinity, the
-value is infinity.
+If @var{x} is zero, the return value is minus infinity if the machine
+supports infinities, and a very small number if it does not.  If @var{x}
+is infinity, the return value is infinity.
+
+For finite @var{x}, the value returned by @code{logb} is one less than
+the value that @code{frexp} would store into @code{*@var{exponent}}.
+@end deftypefun
+
+@comment math.h
+@comment BSD
+@deftypefun double scalb (double @var{value}, int @var{exponent})
+@deftypefunx float scalbf (float @var{value}, int @var{exponent})
+@deftypefunx {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 {long long int} scalbn (double @var{x}, int n)
+@deftypefunx {long long int} scalbnf (float @var{x}, int n)
+@deftypefunx {long long int} scalbnl (long double @var{x}, int n)
+@code{scalbn} is identical to @code{scalb}, except that the exponent
+@var{n} is an @code{int} instead of a floating-point number.
+@end deftypefun
+
+@comment math.h
+@comment BSD
+@deftypefun {long long int} scalbln (double @var{x}, long int n)
+@deftypefunx {long long int} scalblnf (float @var{x}, long int n)
+@deftypefunx {long long int} scalblnl (long double @var{x}, long int n)
+@code{scalbln} is identical to @code{scalb}, except that the exponent
+@var{n} is a @code{long int} instead of a floating-point number.
+@end deftypefun
 
-The value returned by @code{logb} is one less than the value that
-@code{frexp} would store into @code{*@var{exponent}}.
+@comment math.h
+@comment BSD
+@deftypefun {long long int} significand (double @var{x})
+@deftypefunx {long long int} significandf (float @var{x})
+@deftypefunx {long long int} significandl (long double @var{x})
+@code{significand} returns the mantissa of @var{x} scaled to the range
+@math{[1, 2)}.
+It is equivalent to @w{@code{scalb (@var{x}, (double) -ilogb (@var{x}))}}.
+
+This function exists mainly for use in certain standardized tests
+of @w{IEEE 754} conformance.
 @end deftypefun
 
-@node Rounding and Remainders
-@section Rounding and Remainder Functions
-@cindex rounding functions
-@cindex remainder functions
+@node Rounding Functions
+@subsection Rounding Functions
 @cindex converting floats to integers
 
 @pindex math.h
-The functions listed here perform operations such as rounding,
-truncation, and remainder in division of floating point numbers.  Some
-of these functions convert floating point numbers to integer values.
-They are all declared in @file{math.h}.
+The functions listed here perform operations such as rounding and
+truncation of floating-point values. Some of these functions convert
+floating point numbers to integer values.  They are all declared in
+@file{math.h}.
 
 You can also convert floating-point numbers to integers simply by
 casting them to @code{int}.  This discards the fractional part,
@@ -627,6 +1006,14 @@ integer, returning that value as a @code{double}.  Thus, @code{floor
 
 @comment math.h
 @comment ISO
+@deftypefun double trunc (double @var{x})
+@deftypefunx float truncf (float @var{x})
+@deftypefunx {long double} truncl (long double @var{x})
+@code{trunc} is another name for @code{floor}
+@end deftypefun
+
+@comment math.h
+@comment ISO
 @deftypefun double rint (double @var{x})
 @deftypefunx float rintf (float @var{x})
 @deftypefunx {long double} rintl (long double @var{x})
@@ -635,7 +1022,10 @@ 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
 support other modes, but round-to-nearest is always used unless
-you explicit select another.
+you explicitly select another.
+
+If @var{x} was not initially an integer, these functions raise the
+inexact exception.
 @end deftypefun
 
 @comment math.h
@@ -643,26 +1033,78 @@ you explicit select another.
 @deftypefun double nearbyint (double @var{x})
 @deftypefunx float nearbyintf (float @var{x})
 @deftypefunx {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.
+These functions return the same value as the @code{rint} functions, but
+do not raise the inexact exception if @var{x} is not an integer.
+@end deftypefun
+
+@comment math.h
+@comment ISO
+@deftypefun double round (double @var{x})
+@deftypefunx float roundf (float @var{x})
+@deftypefunx {long double} roundl (long double @var{x})
+These functions are similar to @code{rint}, but they round halfway
+cases away from zero instead of to the nearest even integer.
+@end deftypefun
+
+@comment math.h
+@comment ISO
+@deftypefun {long int} lrint (double @var{x})
+@deftypefunx {long int} lrintf (float @var{x})
+@deftypefunx {long int} lrintl (long double @var{x})
+These functions are just like @code{rint}, but they return a
+@code{long int} instead of a floating-point number.
+@end deftypefun
+
+@comment math.h
+@comment ISO
+@deftypefun {long long int} llrint (double @var{x})
+@deftypefunx {long long int} llrintf (float @var{x})
+@deftypefunx {long long int} llrintl (long double @var{x})
+These functions are just like @code{rint}, but they return a
+@code{long long int} instead of a floating-point number.
 @end deftypefun
 
 @comment math.h
 @comment ISO
+@deftypefun {long int} lround (double @var{x})
+@deftypefunx {long int} lroundf (float @var{x})
+@deftypefunx {long int} lroundl (long double @var{x})
+These functions are just like @code{round}, but they return a
+@code{long int} instead of a floating-point number.
+@end deftypefun
+
+@comment math.h
+@comment ISO
+@deftypefun {long long int} llround (double @var{x})
+@deftypefunx {long long int} llroundf (float @var{x})
+@deftypefunx {long long int} llroundl (long double @var{x})
+These functions are just like @code{round}, but they return a
+@code{long long int} instead of a floating-point number.
+@end deftypefun
+
+
+@comment math.h
+@comment ISO
 @deftypefun double modf (double @var{value}, double *@var{integer-part})
 @deftypefunx float modff (float @var{value}, float *@var{integer-part})
 @deftypefunx {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.
+and the integer part is always rounded toward zero.
 
 @code{modf} stores the integer part in @code{*@var{integer-part}}, and
 returns the fractional part.  For example, @code{modf (2.5, &intpart)}
 returns @code{0.5} and stores @code{2.0} into @code{intpart}.
 @end deftypefun
 
+@node Remainder Functions
+@subsection Remainder Functions
+
+The functions in this section compute the remainder on division of two
+floating-point numbers.  Each is a little different; pick the one that
+suits your problem.
+
 @comment math.h
 @comment ISO
 @deftypefun double fmod (double @var{numerator}, double @var{denominator})
@@ -678,8 +1120,7 @@ towards zero to an integer.  Thus, @w{@code{fmod (6.5, 2.3)}} returns
 The result has the same sign as the @var{numerator} and has magnitude
 less than the magnitude of the @var{denominator}.
 
-If @var{denominator} is zero, @code{fmod} fails and sets @code{errno} to
-@code{EDOM}.
+If @var{denominator} is zero, @code{fmod} signals a domain error.
 @end deftypefun
 
 @comment math.h
@@ -687,7 +1128,7 @@ If @var{denominator} is zero, @code{fmod} fails and sets @code{errno} to
 @deftypefun double drem (double @var{numerator}, double @var{denominator})
 @deftypefunx float dremf (float @var{numerator}, float @var{denominator})
 @deftypefunx {long double} dreml (long double @var{numerator}, long double @var{denominator})
-These functions are like @code{fmod} etc except that it rounds the
+These functions are like @code{fmod} except that they 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}.
@@ -698,33 +1139,38 @@ absolute value of the @var{denominator}.  The difference between
 (@var{numerator}, @var{denominator})} is always either
 @var{denominator}, minus @var{denominator}, or zero.
 
-If @var{denominator} is zero, @code{drem} fails and sets @code{errno} to
-@code{EDOM}.
+If @var{denominator} is zero, @code{drem} signals a domain error.
 @end deftypefun
 
+@comment math.h
+@comment BSD
+@deftypefun double remainder (double @var{numerator}, double @var{denominator})
+@deftypefunx float remainderf (float @var{numerator}, float @var{denominator})
+@deftypefunx {long double} remainderl (long double @var{numerator}, long double @var{denominator})
+This function is another name for @code{drem}.
+@end deftypefun
 
-@node Arithmetic on FP Values
-@section Setting and modifying Single Bits of FP Values
+@node FP Bit Twiddling
+@subsection Setting and modifying single bits of FP values
 @cindex FP arithmetic
 
-In certain situations it is too complicated (or expensive) to modify a
-floating-point value by the normal operations.  For a few operations
-@w{ISO C 9X} defines functions to modify the floating-point value
-directly.
+There are some operations that are too complicated or expensive to
+perform by hand on floating-point numbers.  @w{ISO C 9x} defines
+functions to do these operations, which mostly involve changing single
+bits.
 
 @comment math.h
 @comment ISO
 @deftypefun double copysign (double @var{x}, double @var{y})
 @deftypefunx float copysignf (float @var{x}, float @var{y})
 @deftypefunx {long double} copysignl (long double @var{x}, long double @var{y})
-The @code{copysign} function allows to specifiy the sign of the
-floating-point value given in the parameter @var{x} by discarding the
-prior content and replacing it with the sign of the value @var{y}.
-The so found value is returned.
+These functions return @var{x} but with the sign of @var{y}.  They work
+even if @var{x} or @var{y} are NaN or zero.  Both of these can carry a
+sign (although not all implementations support it) and this is one of
+the few operations that can tell the difference.
 
-This function also works and throws no exception if the parameter
-@var{x} is a @code{NaN}.  If the platform supports the signed zero
-representation @var{x} might also be zero.
+@code{copysign} never raises an exception.
+@c except signalling NaNs
 
 This function is defined in @w{IEC 559} (and the appendix with
 recommended functions in @w{IEEE 754}/@w{IEEE 854}).
@@ -737,10 +1183,9 @@ recommended functions in @w{IEEE 754}/@w{IEEE 854}).
 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 nonzero value.
+This is not the same as @code{x < 0.0}, because @w{IEEE 754} floating
+point allows zero to be signed.  The comparison @code{-0.0 < 0.0} is
+false, but @code{signbit (-0.0)} will return a nonzero value.
 @end deftypefun
 
 @comment math.h
@@ -749,58 +1194,151 @@ comparison @code{-0.0 < 0.0} will not be true while @code{signbit
 @deftypefunx float nextafterf (float @var{x}, float @var{y})
 @deftypefunx {long double} nextafterl (long double @var{x}, long double @var{y})
 The @code{nextafter} function returns the next representable neighbor of
-@var{x} in the direction towards @var{y}.  Depending on the used data
-type the steps make have a different size.  If @math{@var{x} = @var{y}}
-the function simply returns @var{x}.  If either value is a @code{NaN}
-one the @code{NaN} values is returned.  Otherwise a value corresponding
-to the value of the least significant bit in the mantissa is
-added/subtracted (depending on the direction).  If the resulting value
-is not finite but @var{x} is, overflow is signaled.  Underflow is
-signaled if the resulting value is a denormalized number (if the @w{IEEE
-754}/@w{IEEE 854} representation is used).
+@var{x} in the direction towards @var{y}.  The size of the step between
+@var{x} and the result depends on the type of the result.  If
+@math{@var{x} = @var{y}} the function simply returns @var{x}.  If either
+value is @code{NaN}, @code{NaN} is returned.  Otherwise
+a value corresponding to the value of the least significant bit in the
+mantissa is added or subtracted, depending on the direction.
+@code{nextafter} will signal overflow or underflow if the result goes
+outside of the range of normalized numbers.
 
 This function is defined in @w{IEC 559} (and the appendix with
 recommended functions in @w{IEEE 754}/@w{IEEE 854}).
 @end deftypefun
 
+@comment math.h
+@comment ISO
+@deftypefun {long long int} nextafterx (double @var{x}, long double @var{y})
+@deftypefunx {long long int} nextafterxf (float @var{x}, long double @var{y})
+@deftypefunx {long long int} nextafterxl (long double @var{x}, long double @var{y})
+These functions are identical to the corresponding versions of
+@code{nextafter} except that their second argument is a @code{long
+double}.
+@end deftypefun
+
 @cindex NaN
 @comment math.h
 @comment ISO
 @deftypefun double nan (const char *@var{tagp})
 @deftypefunx float nanf (const char *@var{tagp})
 @deftypefunx {long double} nanl (const char *@var{tagp})
-The @code{nan} function returns a representation of the NaN value.  If
-quiet NaNs are supported by the platform a call like @code{nan
-("@var{n-char-sequence}")} is equivalent to @code{strtod
-("NAN(@var{n-char-sequence})")}.  The exact implementation is left
-unspecified but on systems using IEEE arithmethic the
-@var{n-char-sequence} specifies the bits of the mantissa for the NaN
-value.
+The @code{nan} function returns a representation of NaN, provided that
+NaN is supported by the target platform.
+@code{nan ("@var{n-char-sequence}")} is equivalent to
+@code{strtod ("NAN(@var{n-char-sequence})")}.
+
+The argument @var{tagp} is used in an unspecified manner.  On @w{IEEE
+754} systems, there are many representations of NaN, and @var{tagp}
+selects one.  On other systems it may do nothing.
 @end deftypefun
 
+@node FP Comparison Functions
+@subsection Floating-Point Comparison Functions
+@cindex unordered comparison
 
-@node Special arithmetic on FPs
-@section Special Arithmetic on FPs
-@cindex positive difference
+The standard C comparison operators provoke exceptions when one or other
+of the operands is NaN.  For example,
+
+@smallexample
+int v = a < 1.0;
+@end smallexample
+
+@noindent
+will raise an exception if @var{a} is NaN.  (This does @emph{not}
+happen with @code{==} and @code{!=}; those merely return false and true,
+respectively, when NaN is examined.)  Frequently this exception is
+undesirable.  @w{ISO C 9x} therefore defines comparison functions that
+do not raise exceptions when NaN is examined.  All of the functions are
+implemented as macros which allow their arguments to be of any
+floating-point type.  The macros are guaranteed to evaluate their
+arguments only once.
+
+@comment math.h
+@comment ISO
+@deftypefn Macro int isgreater (@emph{real-floating} @var{x}, @emph{real-floating} @var{y})
+This macro determines whether the argument @var{x} is greater than
+@var{y}.  It is equivalent to @code{(@var{x}) > (@var{y})}, but no
+exception is raised if @var{x} or @var{y} are NaN.
+@end deftypefn
+
+@comment math.h
+@comment ISO
+@deftypefn Macro int isgreaterequal (@emph{real-floating} @var{x}, @emph{real-floating} @var{y})
+This macro determines whether the argument @var{x} is greater than or
+equal to @var{y}.  It is equivalent to @code{(@var{x}) >= (@var{y})}, but no
+exception is raised if @var{x} or @var{y} are NaN.
+@end deftypefn
+
+@comment math.h
+@comment ISO
+@deftypefn Macro int isless (@emph{real-floating} @var{x}, @emph{real-floating} @var{y})
+This macro determines whether the argument @var{x} is less than @var{y}.
+It is equivalent to @code{(@var{x}) < (@var{y})}, but no exception is
+raised if @var{x} or @var{y} are NaN.
+@end deftypefn
+
+@comment math.h
+@comment ISO
+@deftypefn Macro int islessequal (@emph{real-floating} @var{x}, @emph{real-floating} @var{y})
+This macro determines whether the argument @var{x} is less than or equal
+to @var{y}.  It is equivalent to @code{(@var{x}) <= (@var{y})}, but no
+exception is raised if @var{x} or @var{y} are NaN.
+@end deftypefn
+
+@comment math.h
+@comment ISO
+@deftypefn Macro int islessgreater (@emph{real-floating} @var{x}, @emph{real-floating} @var{y})
+This macro determines whether the argument @var{x} is less or greater
+than @var{y}.  It is equivalent to @code{(@var{x}) < (@var{y}) ||
+(@var{x}) > (@var{y})} (although it only evaluates @var{x} and @var{y}
+once), but no exception is raised if @var{x} or @var{y} are NaN.
+
+This macro is not equivalent to @code{@var{x} != @var{y}}, because that
+expression is true if @var{x} or @var{y} are NaN.
+@end deftypefn
+
+@comment math.h
+@comment ISO
+@deftypefn Macro int isunordered (@emph{real-floating} @var{x}, @emph{real-floating} @var{y})
+This macro determines whether its arguments are unordered.  In other
+words, it is true if @var{x} or @var{y} are NaN, and false otherwise.
+@end deftypefn
+
+Not all machines provide hardware support for these operations.  On
+machines that don't, the macros can be very slow.  Therefore, you should
+not use these functions when NaN is not a concern.
+
+@strong{Note:} There are no macros @code{isequal} or @code{isunequal}.
+They are unnecessary, because the @code{==} and @code{!=} operators do
+@emph{not} throw an exception if one or both of the operands are NaN.
+
+@node Misc FP Arithmetic
+@subsection Miscellaneous FP arithmetic functions
 @cindex minimum
 @cindex maximum
+@cindex positive difference
+@cindex multiply-add
 
-A frequent operation of numbers is the determination of mimuma, maxima,
-or the difference between numbers.  The @w{ISO C 9X} standard introduces
-three functions which implement this efficiently while also providing
-some useful functions which is not so efficient to implement.  Machine
-specific implementation might perform this very efficient.
+The functions in this section perform miscellaneous but common
+operations that are awkward to express with C operators.  On some
+processors these functions can use special machine instructions to
+perform these operations faster than the equivalent C code.
 
 @comment math.h
 @comment ISO
 @deftypefun double fmin (double @var{x}, double @var{y})
 @deftypefunx float fminf (float @var{x}, float @var{y})
 @deftypefunx {long double} fminl (long double @var{x}, long double @var{y})
-The @code{fmin} function determine the minimum of the two values @var{x}
-and @var{y} and returns it.
+The @code{fmin} function returns the lesser of the two values @var{x}
+and @var{y}.  It is similar to the expression
+@smallexample
+((x) < (y) ? (x) : (y))
+@end smallexample
+except that @var{x} and @var{y} are only evaluated once.
 
-If an argument is NaN it as treated as missing and the other value is
-returned.  If both values are NaN one of the values is returned.
+If an argument is NaN, the other argument is returned.  If both arguments
+are NaN, NaN is returned.
 @end deftypefun
 
 @comment math.h
@@ -808,11 +1346,11 @@ returned.  If both values are NaN one of the values is returned.
 @deftypefun double fmax (double @var{x}, double @var{y})
 @deftypefunx float fmaxf (float @var{x}, float @var{y})
 @deftypefunx {long double} fmaxl (long double @var{x}, long double @var{y})
-The @code{fmax} function determine the maximum of the two values @var{x}
-and @var{y} and returns it.
+The @code{fmax} function returns the greater of the two values @var{x}
+and @var{y}.
 
-If an argument is NaN it as treated as missing and the other value is
-returned.  If both values are NaN one of the values is returned.
+If an argument is NaN, the other argument is returned.  If both arguments
+are NaN, NaN is returned.
 @end deftypefun
 
 @comment math.h
@@ -820,13 +1358,11 @@ returned.  If both values are NaN one of the values is returned.
 @deftypefun double fdim (double @var{x}, double @var{y})
 @deftypefunx float fdimf (float @var{x}, float @var{y})
 @deftypefunx {long double} fdiml (long double @var{x}, long double @var{y})
-The @code{fdim} function computes the positive difference between
-@var{x} and @var{y} and returns this value.  @dfn{Positive difference}
-means that if @var{x} is greater than @var{y} the value @math{@var{x} -
-@var{y}} is returned.  Otherwise the return value is @math{+0}.
+The @code{fdim} function returns the positive difference between
+@var{x} and @var{y}.  The positive difference is @math{@var{x} -
+@var{y}} if @var{x} is greater than @var{y}, and @math{0} otherwise.
 
-If any of the arguments is NaN this value is returned.  If both values
-are NaN, one of the values is returned.
+If @var{x}, @var{y}, or both are NaN, NaN is returned.
 @end deftypefun
 
 @comment math.h
@@ -835,39 +1371,192 @@ are NaN, one of the values is returned.
 @deftypefunx float fmaf (float @var{x}, float @var{y}, float @var{z})
 @deftypefunx {long double} fmal (long double @var{x}, long double @var{y}, long double @var{z})
 @cindex butterfly
-The name of the function @code{fma} means floating-point multiply-add.
-I.e., the operation performed is @math{(@var{x} @mul{} @var{y}) + @var{z}}.
-The speciality of this function is that the intermediate
-result is not rounded and the addition is performed with the full
-precision of the multiplcation.
-
-This function was introduced because some processors provide such a
-function in their FPU implementation.  Since compilers cannot optimize
-code which performs the operation in single steps using this opcode
-because of rounding differences the operation is available separately so
-the programmer can select when the rounding of the intermediate result
-is not important.
+The @code{fma} function performs floating-point multiply-add.  This is
+the operation @math{(@var{x} @mul{} @var{y}) + @var{z}}, but the
+intermediate result is not rounded to the destination type.  This can
+sometimes improve the precision of a calculation.
+
+This function was introduced because some processors have a special
+instruction to perform multiply-add.  The C compiler cannot use it
+directly, because the expression @samp{x*y + z} is defined to round the
+intermediate result.  @code{fma} lets you choose when you want to round
+only once.
 
 @vindex FP_FAST_FMA
-If the @file{math.h} header defines the symbol @code{FP_FAST_FMA} (or
-@code{FP_FAST_FMAF} and @code{FP_FAST_FMAL} for @code{float} and
-@code{long double} respectively) the processor typically defines the
-operation in hardware.  The symbols might also be defined if the
-software implementation is as fast as a multiply and an add but in the
-GNU C Library the macros indicate hardware support.
+On processors which do not implement multiply-add in hardware,
+@code{fma} can be very slow since it must avoid intermediate rounding.
+@file{math.h} defines the symbols @code{FP_FAST_FMA},
+@code{FP_FAST_FMAF}, and @code{FP_FAST_FMAL} when the corresponding
+version of @code{fma} is no slower than the expression @samp{x*y + z}.
+In the GNU C library, this always means the operation is implemented in
+hardware.
 @end deftypefun
 
+@node Complex Numbers
+@section Complex Numbers
+@pindex complex.h
+@cindex complex numbers
+
+@w{ISO C 9x} introduces support for complex numbers in C.  This is done
+with a new type qualifier, @code{complex}.  It is a keyword if and only
+if @file{complex.h} has been included.  There are three complex types,
+corresponding to the three real types:  @code{float complex},
+@code{double complex}, and @code{long double complex}.
+
+To construct complex numbers you need a way to indicate the imaginary
+part of a number.  There is no standard notation for an imaginary
+floating point constant.  Instead, @file{complex.h} defines two macros
+that can be used to create complex numbers.
+
+@deftypevr Macro {const float complex} _Complex_I
+This macro is a representation of the complex number ``@math{0+1i}''.
+Multiplying a real floating-point value by @code{_Complex_I} gives a
+complex number whose value is purely imaginary.  You can use this to
+construct complex constants:
+
+@smallexample
+@math{3.0 + 4.0i} = @code{3.0 + 4.0 * _Complex_I}
+@end smallexample
+
+Note that @code{_Complex_I * _Complex_I} has the value @code{-1}, but
+the type of that value is @code{complex}.
+@end deftypevr
+
+@c Put this back in when gcc supports _Imaginary_I.  It's too confusing.
+@ignore
+@noindent
+Without an optimizing compiler this is more expensive than the use of
+@code{_Imaginary_I} but with is better than nothing.  You can avoid all
+the hassles if you use the @code{I} macro below if the name is not
+problem.
+
+@deftypevr Macro {const float imaginary} _Imaginary_I
+This macro is a representation of the value ``@math{1i}''.  I.e., it is
+the value for which
+
+@smallexample
+_Imaginary_I * _Imaginary_I = -1
+@end smallexample
+
+@noindent
+The result is not of type @code{float imaginary} but instead @code{float}.
+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
+@end ignore
+
+@noindent
+@code{_Complex_I} is a bit of a mouthful.  @file{complex.h} also defines
+a shorter name for the same constant.
+
+@deftypevr Macro {const float complex} I
+This macro has exactly the same value as @code{_Complex_I}.  Most of the
+time it is preferable.  However, it causes problems if you want to use
+the identifier @code{I} for something else.  You can safely write
+
+@smallexample
+#include <complex.h>
+#undef I
+@end smallexample
+
+@noindent
+if you need @code{I} for your own purposes.  (In that case we recommend
+you also define some other short name for @code{_Complex_I}, such as
+@code{J}.)
+
+@ignore
+If the implementation does not support the @code{imaginary} types
+@code{I} is defined as @code{_Complex_I} which is the second best
+solution.  It still can be used in the same way but requires a most
+clever compiler to get the same results.
+@end ignore
+@end deftypevr
+
+@node Operations on Complex
+@section Projections, Conjugates, and Decomposing of Complex Numbers
+@cindex project complex numbers
+@cindex conjugate complex numbers
+@cindex decompose complex numbers
+@pindex complex.h
+
+@w{ISO C 9x} also defines functions that perform basic operations on
+complex numbers, such as decomposition and conjugation.  The prototypes
+for all these functions are in @file{complex.h}.  All functions are
+available in three variants, one for each of the three complex types.
+
+@comment complex.h
+@comment ISO
+@deftypefun double creal (complex double @var{z})
+@deftypefunx float crealf (complex float @var{z})
+@deftypefunx {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})
+@deftypefunx float cimagf (complex float @var{z})
+@deftypefunx {long double} cimagl (complex long double @var{z})
+These functions return the imaginary part of the complex number @var{z}.
+@end deftypefun
+
+@comment complex.h
+@comment ISO
+@deftypefun {complex double} conj (complex double @var{z})
+@deftypefunx {complex float} conjf (complex float @var{z})
+@deftypefunx {complex long double} conjl (complex long double @var{z})
+These functions return the conjugate value of the complex number
+@var{z}.  The conjugate of a complex number has the same real part and a
+negated imaginary part.  In other words, @samp{conj(a + bi) = a + -bi}.
+@end deftypefun
+
+@comment complex.h
+@comment ISO
+@deftypefun double carg (complex double @var{z})
+@deftypefunx float cargf (complex float @var{z})
+@deftypefunx {long double} cargl (complex long double @var{z})
+These functions return the argument of the complex number @var{z}.
+The argument of a complex number is the angle in the complex plane
+between the positive real axis and a line passing through zero and the
+number.  This angle is measured in the usual fashion and ranges from @math{0}
+to @math{2@pi{}}.
+
+@code{carg} has a branch cut along the positive real axis.
+@end deftypefun
+
+@comment complex.h
+@comment ISO
+@deftypefun {complex double} cproj (complex double @var{z})
+@deftypefunx {complex float} cprojf (complex float @var{z})
+@deftypefunx {complex long double} cprojl (complex long double @var{z})
+These functions return the projection of the complex value @var{z} onto
+the Riemann sphere.  Values with a infinite imaginary part are projected
+to positive infinity on the real axis, even if the real part is NaN.  If
+the real part is infinite, the result is equivalent to
+
+@smallexample
+INFINITY + I * copysign (0.0, cimag (z))
+@end smallexample
+@end deftypefun
 
 @node Integer Division
 @section Integer Division
 @cindex integer division functions
 
 This section describes functions for performing integer division.  These
-functions are redundant in the GNU C library, since in GNU C the @samp{/}
-operator always rounds towards zero.  But in other C implementations,
-@samp{/} may round differently with negative arguments.  @code{div} and
-@code{ldiv} are useful because they specify how to round the quotient:
-towards zero.  The remainder has the same sign as the numerator.
+functions are redundant when GNU CC is used, because in GNU C the
+@samp{/} operator always rounds towards zero.  But in other C
+implementations, @samp{/} may round differently with negative arguments.
+@code{div} and @code{ldiv} are useful because they specify how to round
+the quotient: towards zero.  The remainder has the same sign as the
+numerator.
 
 These functions are specified to return a result @var{r} such that the value
 @code{@var{r}.quot*@var{denominator} + @var{r}.rem} equals
@@ -940,7 +1629,7 @@ structure of type @code{ldiv_t}.
 @end deftypefun
 
 @comment stdlib.h
-@comment GNU
+@comment ISO
 @deftp {Data Type} lldiv_t
 This is a structure type used to hold the result returned by the @code{lldiv}
 function.  It has the following members:
@@ -958,14 +1647,13 @@ type @code{long long int} rather than @code{int}.)
 @end deftp
 
 @comment stdlib.h
-@comment GNU
+@comment ISO
 @deftypefun lldiv_t lldiv (long long int @var{numerator}, long long int @var{denominator})
 The @code{lldiv} function is like the @code{div} function, but the
 arguments are of type @code{long long int} and the result is returned as
 a structure of type @code{lldiv_t}.
 
-The @code{lldiv} function is a GNU extension but it will eventually be
-part of the next ISO C standard.
+The @code{lldiv} function was added in @w{ISO C 9x}.
 @end deftypefun
 
 
@@ -1047,10 +1735,13 @@ representable because of overflow, @code{strtol} returns either
 appropriate for the sign of the value.  It also sets @code{errno}
 to @code{ERANGE} to indicate there was overflow.
 
-Because the value @code{0l} is a correct result for @code{strtol} the
-user who is interested in handling errors should set the global variable
-@code{errno} to @code{0} before calling this function, so that the program
-can later test whether an error occurred.
+You should not check for errors by examining the return value of
+@code{strtol}, because the string might be a valid representation of
+@code{0l}, @code{LONG_MAX}, or @code{LONG_MIN}.  Instead, check whether
+@var{tailptr} points to what you expect after the number
+(e.g. @code{'\0'} if the string should end after the number).  You also
+need to clear @var{errno} before the call and check it afterward, in
+case there was overflow.
 
 There is an example at the end of this section.
 @end deftypefun
@@ -1059,22 +1750,22 @@ There is an example at the end of this section.
 @comment ISO
 @deftypefun {unsigned long int} strtoul (const char *@var{string}, char **@var{tailptr}, int @var{base})
 The @code{strtoul} (``string-to-unsigned-long'') function is like
-@code{strtol} except it deals with unsigned numbers, and returns its
-value with type @code{unsigned long int}.  If the number has a leading
-@samp{-} sign the negated value is returned.  The syntax is the same as
-described above for @code{strtol}.  The value returned in case of
-overflow is @code{ULONG_MAX} (@pxref{Range of Type}).
-
-Like @code{strtol} this function sets @code{errno} and returns the value
-@code{0ul} in case the value for @var{base} is not in the legal range.
+@code{strtol} except it returns an @code{unsigned long int} value.  If
+the number has a leading @samp{-} sign, the return value is negated.
+The syntax is the same as described above for @code{strtol}.  The value
+returned on overflow is @code{ULONG_MAX} (@pxref{Range of
+Type}).
+
+@code{strtoul} sets @var{errno} to @code{EINVAL} if @var{base} is out of
+range, or @code{ERANGE} on overflow.
 @end deftypefun
 
 @comment stdlib.h
-@comment GNU
+@comment ISO
 @deftypefun {long long int} strtoll (const char *@var{string}, char **@var{tailptr}, int @var{base})
-The @code{strtoll} function is like @code{strtol} except that is deals
-with extra long numbers and it returns its value with type @code{long
-long int}.
+The @code{strtoll} function is like @code{strtol} except that it returns
+a @code{long long int} value, and accepts numbers with a correspondingly
+larger range.
 
 If the string has valid syntax for an integer but the value is not
 representable because of overflow, @code{strtoll} returns either
@@ -1082,36 +1773,29 @@ representable because of overflow, @code{strtoll} returns either
 appropriate for the sign of the value.  It also sets @code{errno} to
 @code{ERANGE} to indicate there was overflow.
 
-The @code{strtoll} function is a GNU extension but it will eventually be
-part of the next ISO C standard.
+The @code{strtoll} function was introduced in @w{ISO C 9x}.
 @end deftypefun
 
 @comment stdlib.h
 @comment BSD
 @deftypefun {long long int} strtoq (const char *@var{string}, char **@var{tailptr}, int @var{base})
-@code{strtoq} (``string-to-quad-word'') is only an commonly used other
-name for the @code{strtoll} function.  Everything said for
-@code{strtoll} applies to @code{strtoq} as well.
+@code{strtoq} (``string-to-quad-word'') is the BSD name for @code{strtoll}.
 @end deftypefun
 
 @comment stdlib.h
-@comment GNU
+@comment ISO
 @deftypefun {unsigned long long int} strtoull (const char *@var{string}, char **@var{tailptr}, int @var{base})
-The @code{strtoull} function is like @code{strtoul} except that is deals
-with extra long numbers and it returns its value with type
-@code{unsigned long long int}.  The value returned in case of overflow
+The @code{strtoull} function is like @code{strtoul} except that it
+returns an @code{unsigned long long int}.  The value returned on overflow
 is @code{ULONG_LONG_MAX} (@pxref{Range of Type}).
 
-The @code{strtoull} function is a GNU extension but it will eventually be
-part of the next ISO C standard.
+The @code{strtoull} function was introduced in @w{ISO C 9x}.
 @end deftypefun
 
 @comment stdlib.h
 @comment BSD
 @deftypefun {unsigned long long int} strtouq (const char *@var{string}, char **@var{tailptr}, int @var{base})
-@code{strtouq} (``string-to-unsigned-quad-word'') is only an commonly
-used other name for the @code{strtoull} function.  Everything said for
-@code{strtoull} applies to @code{strtouq} as well.
+@code{strtouq} is the BSD name for @code{strtoull}.
 @end deftypefun
 
 @comment stdlib.h
@@ -1126,43 +1810,40 @@ existing code; using @code{strtol} is more robust.
 @comment stdlib.h
 @comment ISO
 @deftypefun int atoi (const char *@var{string})
-This function is like @code{atol}, except that it returns an @code{int}
-value rather than @code{long int}.  The @code{atoi} function is also
-considered obsolete; use @code{strtol} instead.
+This function is like @code{atol}, except that it returns an @code{int}.
+The @code{atoi} function is also considered obsolete; use @code{strtol}
+instead.
 @end deftypefun
 
 @comment stdlib.h
-@comment GNU
+@comment ISO
 @deftypefun {long long int} atoll (const char *@var{string})
 This function is similar to @code{atol}, except it returns a @code{long
-long int} value rather than @code{long int}.
+long int}.
 
-The @code{atoll} function is a GNU extension but it will eventually be
-part of the next ISO C standard.
+The @code{atoll} function was introduced in @w{ISO C 9x}.  It too is
+obsolete (despite having just been added); use @code{strtoll} instead.
 @end deftypefun
 
-The POSIX locales contain some information about how to format numbers
-(@pxref{General Numeric}).  This mainly deals with representing numbers
-for better readability for humans.  The functions present so far in this
-section cannot handle numbers in this form.
-
-If this functionality is needed in a program one can use the functions
-from the @code{scanf} family which know about the flag @samp{'} for
-parsing numeric input (@pxref{Numeric Input Conversions}).  Sometimes it
-is more desirable to have finer control.
-
-In these situation one could use the function
-@code{__strto@var{XXX}_internal}.  @var{XXX} here stands for any of the
-above forms.  All numeric conversion functions (including the functions
-to process floating-point numbers) have such a counterpart.  The
-difference to the normal form is the extra argument at the end of the
-parameter list.  If this value has an non-zero value the handling of
-number grouping is enabled.  The advantage of using these functions is
-that the @var{tailptr} parameters allow to determine which part of the
-input is processed.  The @code{scanf} functions don't provide this
-information.  The drawback of using these functions is that they are not
-portable.  They only exist in the GNU C library.
-
+@c !!! please fact check this paragraph -zw
+@findex strtol_l
+@findex strtoul_l
+@findex strtoll_l
+@findex strtoull_l
+@cindex parsing numbers and locales
+@cindex locales, parsing numbers and
+Some locales specify a printed syntax for numbers other than the one
+that these functions understand.  If you need to read numbers formatted
+in some other locale, you can use the @code{strtoX_l} functions.  Each
+of the @code{strtoX} functions has a counterpart with @samp{_l} added to
+its name.  The @samp{_l} counterparts take an additional argument: a
+pointer to an @code{locale_t} structure, which describes how the numbers
+to be read are formatted.  @xref{Locales}.
+
+@strong{Portability Note:} These functions are all GNU extensions.  You
+can also use @code{scanf} or its relatives, which have the @samp{'} flag
+for parsing numeric input according to the current locale
+(@pxref{Numeric Input Conversions}).  This feature is standard.
 
 Here is a function which parses a string as a sequence of integers and
 returns the sum of them:
@@ -1249,78 +1930,40 @@ In a locale other than the standard @code{"C"} or @code{"POSIX"} locales,
 this function may recognize additional locale-dependent syntax.
 
 If the string has valid syntax for a floating-point number but the value
-is not representable because of overflow, @code{strtod} returns either
-positive or negative @code{HUGE_VAL} (@pxref{Mathematics}), depending on
-the sign of the value.  Similarly, if the value is not representable
-because of underflow, @code{strtod} returns zero.  It also sets @code{errno}
-to @code{ERANGE} if there was overflow or underflow.
-
-There are two more special inputs which are recognized by @code{strtod}.
-The string @code{"inf"} or @code{"infinity"} (without consideration of
-case and optionally preceded by a @code{"+"} or @code{"-"} sign) is
-changed to the floating-point value for infinity if the floating-point
-format supports this; and to the largest representable value otherwise.
-
-If the input string is @code{"nan"} or
-@code{"nan(@var{n-char-sequence})"} the return value of @code{strtod} is
-the representation of the NaN (not a number) value (if the
-floating-point format supports this).  In the second form the part
-@var{n-char-sequence} allows to specify the form of the NaN value in an
-implementation specific way.  When using the @w{IEEE 754}
-floating-point format, the NaN value can have a lot of forms since only
-at least one bit in the mantissa must be set.  In the GNU C library
-implementation of @code{strtod} the @var{n-char-sequence} is interpreted
-as a number (as recognized by @code{strtol}, @pxref{Parsing of Integers}).
-The mantissa of the return value corresponds to this given number.
-
-Since the value zero which is returned in the error case is also a valid
-result the user should set the global variable @code{errno} to zero
-before calling this function.  So one can test for failures after the
-call since all failures set @code{errno} to a non-zero value.
+is outside the range of a @code{double}, @code{strtod} will signal
+overflow or underflow as described in @ref{Math Error Reporting}.
+
+@code{strtod} recognizes four special input strings.  The strings
+@code{"inf"} and @code{"infinity"} are converted to @math{@infinity{}},
+or to the largest representable value if the floating-point format
+doesn't support infinities.  You can prepend a @code{"+"} or @code{"-"}
+to specify the sign.  Case is ignored when scanning these strings.
+
+The strings @code{"nan"} and @code{"nan(@var{chars...})"} are converted
+to NaN.  Again, case is ignored.  If @var{chars...} are provided, they
+are used in some unspecified fashion to select a particular
+representation of NaN (there can be several).
+
+Since zero is a valid result as well as the value returned on error, you
+should check for errors in the same way as for @code{strtol}, by
+examining @var{errno} and @var{tailptr}.
 @end deftypefun
 
 @comment stdlib.h
 @comment GNU
 @deftypefun float strtof (const char *@var{string}, char **@var{tailptr})
-This function is similar to the @code{strtod} function but it returns a
-@code{float} value instead of a @code{double} value.  If the precision
-of a @code{float} value is sufficient this function should be used since
-it is much faster than @code{strtod} on some architectures.  The reasons
-are obvious: @w{IEEE 754} defines @code{float} to have a mantissa of 23
-bits while @code{double} has 53 bits and every additional bit of
-precision can require additional computation.
-
-If the string has valid syntax for a floating-point number but the value
-is not representable because of overflow, @code{strtof} returns either
-positive or negative @code{HUGE_VALF} (@pxref{Mathematics}), depending on
-the sign of the value.
-
-This function is a GNU extension.
+@deftypefunx {long double} strtold (const char *@var{string}, char **@var{tailptr})
+These functions are analogous to @code{strtod}, but return @code{float}
+and @code{long double} values respectively.  They report errors in the
+same way as @code{strtod}.  @code{strtof} can be substantially faster
+than @code{strtod}, but has less precision; conversely, @code{strtold}
+can be much slower but has more precision (on systems where @code{long
+double} is a separate type).
+
+These functions are GNU extensions.
 @end deftypefun
 
 @comment stdlib.h
-@comment GNU
-@deftypefun {long double} strtold (const char *@var{string}, char **@var{tailptr})
-This function is similar to the @code{strtod} function but it returns a
-@code{long double} value instead of a @code{double} value.  It should be
-used when high precision is needed.  On systems which define a @code{long
-double} type (i.e., on which it is not the same as @code{double})
-running this function might take significantly more time since more bits
-of precision are required.
-
-If the string has valid syntax for a floating-point number but the value
-is not representable because of overflow, @code{strtold} returns either
-positive or negative @code{HUGE_VALL} (@pxref{Mathematics}), depending on
-the sign of the value.
-
-This function is a GNU extension.
-@end deftypefun
-
-As for the integer parsing functions there are additional functions
-which will handle numbers represented using the grouping scheme of the
-current locale (@pxref{Parsing of Integers}).
-
-@comment stdlib.h
 @comment ISO
 @deftypefun double atof (const char *@var{string})
 This function is similar to the @code{strtod} function, except that it
@@ -1329,168 +1972,140 @@ is provided mostly for compatibility with existing code; using
 @code{strtod} is more robust.
 @end deftypefun
 
+The GNU C library also provides @samp{_l} versions of thse functions,
+which take an additional argument, the locale to use in conversion.
+@xref{Parsing of Integers}.
 
-@node Old-style number conversion
-@section Old-style way of converting numbers to strings
+@node System V Number Conversion
+@section Old-fashioned System V number-to-string functions
 
-The @w{System V} library provided three functions to convert numbers to
-strings which have a unusual and hard-to-be-used semantic.  The GNU C
-library also provides these functions together with some useful
-extensions in the same sense.
+The old @w{System V} C library provided three functions to convert
+numbers to strings, with unusual and hard-to-use semantics.  The GNU C
+library also provides these functions and some natural extensions.
 
-Generally, you should avoid using these functions unless the really fit
-into the problem you have to solve.  Otherwise it is almost always
-better to use @code{sprintf} since its greater availability (it is an
-@w{ISO C} function).
+These functions are only available in glibc and on systems descended
+from AT&T Unix.  Therefore, unless these functions do precisely what you
+need, it is better to use @code{sprintf}, which is standard.
 
+All these functions are defined in @file{stdlib.h}.
 
 @comment stdlib.h
 @comment SVID, Unix98
-@deftypefun {char *} ecvt (double @var{value}, int @var{ndigit}, int *@var{decpt}, int *@var{sign})
+@deftypefun {char *} ecvt (double @var{value}, int @var{ndigit}, int *@var{decpt}, int *@var{neg})
 The function @code{ecvt} converts the floating-point number @var{value}
-to a string with at most @var{ndigit} decimal digits.  If @code{ndigit}
-is greater than the accuracy of the @code{double} floating-point type
-the implementation can shorten @var{ndigit} to a reasonable value. The
-returned string neither contains decimal point nor sign. The high-order
+to a string with at most @var{ndigit} decimal digits.
+The returned string contains no decimal point or sign. The first
 digit of the string is non-zero (unless @var{value} is actually zero)
-and the low-order digit is rounded. The variable pointed to by
-@var{decpt} gets the position of the decimal character relative to the
-start of the string. If @var{value} is negative, @var{sign} is set to a
-non-zero value, otherwise to 0.
+and the last digit is rounded to nearest.  @var{decpt} is set to the
+index in the string of the first digit after the decimal point.
+@var{neg} is set to a nonzero value if @var{value} is negative, zero
+otherwise.
 
 The returned string is statically allocated and overwritten by each call
 to @code{ecvt}.
 
-If @var{value} is zero, it's implementation defined if @var{decpt} is
+If @var{value} is zero, it's implementation defined whether @var{decpt} is
 @code{0} or @code{1}.
 
-The prototype for this function can be found in @file{stdlib.h}.
+For example: @code{ecvt (12.3, 5, &decpt, &neg)} returns @code{"12300"}
+and sets @var{decpt} to @code{2} and @var{neg} to @code{0}.
 @end deftypefun
 
-As an example @code{ecvt (12.3, 5, &decpt, &sign)} returns @code{"12300"}
-and sets @var{decpt} to @code{2} and @var{sign} to @code{0}.
-
 @comment stdlib.h
 @comment SVID, Unix98
-@deftypefun {char *} fcvt (double @var{value}, int @var{ndigit}, int @var{decpt}, int *@var{sign})
-The function @code{fcvt} is similar to @code{ecvt} with the difference
-that @var{ndigit} specifies the digits after the decimal point.  If
-@var{ndigit} is less than zero, @var{value} is rounded to the left of
-the decimal point upto the reasonable limit (e.g., @math{123.45} is only
-rounded to the third digit before the decimal point, even if
-@var{ndigit} is less than @math{-3}).
+@deftypefun {char *} fcvt (double @var{value}, int @var{ndigit}, int @var{decpt}, int *@var{neg})
+The function @code{fcvt} is like @code{ecvt}, but @var{ndigit} specifies
+the number of digits after the decimal point.  If @var{ndigit} is less
+than zero, @var{value} is rounded to the @math{@var{ndigit}+1}'th place to the
+left of the decimal point.  For example, if @var{ndigit} is @code{-1},
+@var{value} will be rounded to the nearest 10.  If @var{ndigit} is
+negative and larger than the number of digits to the left of the decimal
+point in @var{value}, @var{value} will be rounded to one significant digit.
 
 The returned string is statically allocated and overwritten by each call
 to @code{fcvt}.
-
-The prototype for this function can be found in @file{stdlib.h}.
 @end deftypefun
 
 @comment stdlib.h
 @comment SVID, Unix98
 @deftypefun {char *} gcvt (double @var{value}, int @var{ndigit}, char *@var{buf})
-The @code{gcvt} function also converts @var{value} to a NUL terminated
-string but in a way similar to the @code{%g} format of
-@code{sprintf}.  It also does not use a static buffer but instead uses
-the user-provided buffer starting at @var{buf}.  It is the user's
-responsibility to make sure the buffer is long enough to contain the
-result.  Unlike the @code{ecvt} and @code{fcvt} functions @code{gcvt}
-includes the sign and the decimal point characters (which are determined
-according to the current locale) in the result.  Therefore there are yet
-less reasons to use this function instead of @code{sprintf}.
-
-The return value is @var{buf}.
-
-The prototype for this function can be found in @file{stdlib.h}.
+@code{gcvt} is functionally equivalent to @samp{sprintf(buf, "%*g",
+ndigit, value}.  It is provided only for compatibility's sake.  It
+returns @var{buf}.
 @end deftypefun
 
-
-All three functions have in common that they use @code{double}
-values as parameter.  Calling these functions using @code{long
-double} values would mean a loss of precision due to the implicit
-rounding.  Therefore the GNU C library contains three more functions
-with similar semantics which take @code{long double} values.
+As extensions, the GNU C library provides versions of these three
+functions that take @code{long double} arguments.
 
 @comment stdlib.h
 @comment GNU
-@deftypefun {char *} qecvt (long double @var{value}, int @var{ndigit}, int *@var{decpt}, int *@var{sign})
-This function is equivalent to the @code{ecvt} function except that it
-takes an @code{long double} value for the first parameter.
-
-This function is a GNU extension.  The prototype can be found in
-@file{stdlib.h}.
+@deftypefun {char *} qecvt (long double @var{value}, int @var{ndigit}, int *@var{decpt}, int *@var{neg})
+This function is equivalent to @code{ecvt} except that it
+takes a @code{long double} for the first parameter.
 @end deftypefun
 
 @comment stdlib.h
 @comment GNU
-@deftypefun {char *} qfcvt (long double @var{value}, int @var{ndigit}, int @var{decpt}, int *@var{sign})
-This function is equivalent to the @code{fcvt} function except that it
-takes an @code{long double} value for the first parameter.
-
-This function is a GNU extension.  The prototype can be found in
-@file{stdlib.h}.
+@deftypefun {char *} qfcvt (long double @var{value}, int @var{ndigit}, int @var{decpt}, int *@var{neg})
+This function is equivalent to @code{fcvt} except that it
+takes a @code{long double} for the first parameter.
 @end deftypefun
 
 @comment stdlib.h
 @comment GNU
 @deftypefun {char *} qgcvt (long double @var{value}, int @var{ndigit}, char *@var{buf})
-This function is equivalent to the @code{gcvt} function except that it
-takes an @code{long double} value for the first parameter.
-
-This function is a GNU extension.  The prototype can be found in
-@file{stdlib.h}.
+This function is equivalent to @code{gcvt} except that it
+takes a @code{long double} for the first parameter.
 @end deftypefun
 
 
 @cindex gcvt_r
-As said above the @code{ecvt} and @code{fcvt} function along with their
-@code{long double} equivalents have the problem that they return a value
-located in a static buffer which is overwritten by the next call of the
-function.  This limitation is lifted in yet another set of functions
-which also are GNU extensions.  These reentrant functions can be
-recognized by the by the conventional @code{_r} ending.  Obviously there
-is no need for a @code{gcvt_r} function.
+The @code{ecvt} and @code{fcvt} functions, and their @code{long double}
+equivalents, all return a string located in a static buffer which is
+overwritten by the next call to the function.  The GNU C library
+provides another set of extended functions which write the converted
+string into a user-supplied buffer.  These have the conventional
+@code{_r} suffix.
+
+@code{gcvt_r} is not necessary, because @code{gcvt} already uses a
+user-supplied buffer.
 
 @comment stdlib.h
 @comment GNU
-@deftypefun {char *} ecvt_r (double @var{value}, int @var{ndigit}, int *@var{decpt}, int *@var{sign}, char *@var{buf}, size_t @var{len})
-The @code{ecvt_r} function is similar to the @code{ecvt} function except
-that it places its result into the user-specified buffer starting at
-@var{buf} with length @var{len}.
+@deftypefun {char *} ecvt_r (double @var{value}, int @var{ndigit}, int *@var{decpt}, int *@var{neg}, char *@var{buf}, size_t @var{len})
+The @code{ecvt_r} function is the same as @code{ecvt}, except
+that it places its result into the user-specified buffer pointed to by
+@var{buf}, with length @var{len}.
 
-This function is a GNU extension.  The prototype can be found in
-@file{stdlib.h}.
+This function is a GNU extension.
 @end deftypefun
 
 @comment stdlib.h
 @comment SVID, Unix98
-@deftypefun {char *} fcvt_r (double @var{value}, int @var{ndigit}, int @var{decpt}, int *@var{sign}, char *@var{buf}, size_t @var{len})
-The @code{fcvt_r} function is similar to the @code{fcvt} function except
-that it places its result into the user-specified buffer starting at
-@var{buf} with length @var{len}.
+@deftypefun {char *} fcvt_r (double @var{value}, int @var{ndigit}, int @var{decpt}, int *@var{neg}, char *@var{buf}, size_t @var{len})
+The @code{fcvt_r} function is the same as @code{fcvt}, except
+that it places its result into the user-specified buffer pointed to by
+@var{buf}, with length @var{len}.
 
-This function is a GNU extension.  The prototype can be found in
-@file{stdlib.h}.
+This function is a GNU extension.
 @end deftypefun
 
 @comment stdlib.h
 @comment GNU
-@deftypefun {char *} qecvt_r (long double @var{value}, int @var{ndigit}, int *@var{decpt}, int *@var{sign}, char *@var{buf}, size_t @var{len})
-The @code{qecvt_r} function is similar to the @code{qecvt} function except
-that it places its result into the user-specified buffer starting at
-@var{buf} with length @var{len}.
+@deftypefun {char *} qecvt_r (long double @var{value}, int @var{ndigit}, int *@var{decpt}, int *@var{neg}, char *@var{buf}, size_t @var{len})
+The @code{qecvt_r} function is the same as @code{qecvt}, except
+that it places its result into the user-specified buffer pointed to by
+@var{buf}, with length @var{len}.
 
-This function is a GNU extension.  The prototype can be found in
-@file{stdlib.h}.
+This function is a GNU extension.
 @end deftypefun
 
 @comment stdlib.h
 @comment GNU
-@deftypefun {char *} qfcvt_r (long double @var{value}, int @var{ndigit}, int @var{decpt}, int *@var{sign}, char *@var{buf}, size_t @var{len})
-The @code{qfcvt_r} function is similar to the @code{qfcvt} function except
-that it places its result into the user-specified buffer starting at
-@var{buf} with length @var{len}.
+@deftypefun {char *} qfcvt_r (long double @var{value}, int @var{ndigit}, int @var{decpt}, int *@var{neg}, char *@var{buf}, size_t @var{len})
+The @code{qfcvt_r} function is the same as @code{qfcvt}, except
+that it places its result into the user-specified buffer pointed to by
+@var{buf}, with length @var{len}.
 
-This function is a GNU extension.  The prototype can be found in
-@file{stdlib.h}.
+This function is a GNU extension.
 @end deftypefun
diff --git a/manual/chapters.texi b/manual/chapters.texi
new file mode 100644
index 0000000000..a5a8a57903
--- /dev/null
+++ b/manual/chapters.texi
@@ -0,0 +1,35 @@
+@include intro.texi
+@include errno.texi
+@include memory.texi
+@include ctype.texi
+@include string.texi
+@include mbyte.texi
+@include locale.texi
+@include message.texi
+@include search.texi
+@include pattern.texi
+@include io.texi
+@include stdio.texi
+@include llio.texi
+@include filesys.texi
+@include pipe.texi
+@include socket.texi
+@include terminal.texi
+@include math.texi
+@include arith.texi
+@include time.texi
+@include setjmp.texi
+@include signal.texi
+@include startup.texi
+@include process.texi
+@include job.texi
+@include nss.texi
+@include users.texi
+@include sysinfo.texi
+@include conf.texi
+@include ../linuxthreads/linuxthreads.texi
+@include lang.texi
+@include header.texi
+@include install.texi
+@include maint.texi
+@include contrib.texi
diff --git a/manual/conf.texi b/manual/conf.texi
index 529c3ad7ab..eabbce62fe 100644
--- a/manual/conf.texi
+++ b/manual/conf.texi
@@ -1,4 +1,6 @@
-@node System Configuration, Language Features, System Information, Top
+@c This node must have no next pointer.
+@node System Configuration, , System Information, Top
+@c %MENU% Parameters describing operating system limits
 @chapter System Configuration Parameters
 
 The functions and macros listed in this chapter give information about
diff --git a/manual/contrib.texi b/manual/contrib.texi
index 11c0dd2c2d..84362cb446 100644
--- a/manual/contrib.texi
+++ b/manual/contrib.texi
@@ -1,4 +1,5 @@
 @node Contributors, Copying, Maintenance, Top
+@c %MENU% Who wrote what parts of the GNU C library
 @appendix Contributors to the GNU C Library
 
 The GNU C library was written originally by Roland McGrath, and is
diff --git a/manual/ctype.texi b/manual/ctype.texi
index 8e8db4a88a..26e40a1c53 100644
--- a/manual/ctype.texi
+++ b/manual/ctype.texi
@@ -1,4 +1,5 @@
 @node Character Handling, String and Array Utilities, Memory Allocation, Top
+@c %MENU% Character testing and conversion functions
 @chapter Character Handling
 
 Programs that work with characters and strings often need to classify a
diff --git a/manual/errno.texi b/manual/errno.texi
index f006bf7aca..e0c5b870f9 100644
--- a/manual/errno.texi
+++ b/manual/errno.texi
@@ -1,5 +1,6 @@
 @node Error Reporting, Memory Allocation, Introduction, Top
 @chapter Error Reporting
+@c %MENU% How library functions report errors
 @cindex error reporting
 @cindex reporting errors
 @cindex error codes
diff --git a/manual/filesys.texi b/manual/filesys.texi
index ddb028624d..5d6df0a1ac 100644
--- a/manual/filesys.texi
+++ b/manual/filesys.texi
@@ -1,4 +1,5 @@
 @node File System Interface, Pipes and FIFOs, Low-Level I/O, Top
+@c %MENU% Functions for manipulating files
 @chapter File System Interface
 
 This chapter describes the GNU C library's functions for manipulating
diff --git a/manual/header.texi b/manual/header.texi
index b6ca60ee96..0ab36d7e5e 100644
--- a/manual/header.texi
+++ b/manual/header.texi
@@ -1,4 +1,5 @@
 @node Library Summary, Installation, Language Features, Top
+@c %MENU% A summary showing the syntax, header file, and derivation of each library feature
 @appendix Summary of Library Facilities
 
 This appendix is a complete list of the facilities declared within the
diff --git a/manual/install.texi b/manual/install.texi
index 716c2b9f46..00b4cbe520 100644
--- a/manual/install.texi
+++ b/manual/install.texi
@@ -3,6 +3,7 @@
 @setfilename INSTALL
 
 @node Installation, Maintenance, Library Summary, Top
+@c %MENU% How to install the GNU C library
 @appendix Installing the GNU C Library
 
 @menu
diff --git a/manual/intro.texi b/manual/intro.texi
index fa16041b9b..3d674ac15d 100644
--- a/manual/intro.texi
+++ b/manual/intro.texi
@@ -1,5 +1,6 @@
 @node Introduction, Error Reporting, Top, Top
 @chapter Introduction
+@c %MENU% Purpose of the GNU C Library
 
 The C language provides no built-in facilities for performing such
 common operations as input/output, memory management, string
diff --git a/manual/io.texi b/manual/io.texi
index e43685ffec..34fb352956 100644
--- a/manual/io.texi
+++ b/manual/io.texi
@@ -1,4 +1,5 @@
 @node I/O Overview, I/O on Streams, Pattern Matching, Top
+@c %MENU% Introduction to the I/O facilities
 @chapter Input/Output Overview
 
 Most programs need to do either input (reading data) or output (writing
diff --git a/manual/job.texi b/manual/job.texi
index 342aee326b..44b8783299 100644
--- a/manual/job.texi
+++ b/manual/job.texi
@@ -1,4 +1,5 @@
-@node Job Control
+@node Job Control, Name Service Switch, Processes, Top
+@c %MENU% All about process groups and sessions
 @chapter Job Control
 
 @cindex process groups
diff --git a/manual/lang.texi b/manual/lang.texi
index 889bda374d..ff80e164a0 100644
--- a/manual/lang.texi
+++ b/manual/lang.texi
@@ -1,4 +1,6 @@
-@node Language Features, Library Summary, System Configuration, Top
+@c This node must not have a prev pointer.
+@node Language Features, Library Summary, , Top
+@c %MENU% C language features provided by the library
 @appendix C Language Facilities in the Library
 
 Some of the facilities implemented by the C library really should be
diff --git a/manual/libc-texinfo.sh b/manual/libc-texinfo.sh
new file mode 100644
index 0000000000..88733cb079
--- /dev/null
+++ b/manual/libc-texinfo.sh
@@ -0,0 +1,115 @@
+#! /bin/sh
+
+# Create libc.texinfo from the chapter files.
+
+grep '^@node.*Top' $1 | cut -d, -f-2 |
+    sed 's/, /:/; s/:@node /:/; s/ /_/g; s/:/ /g' >cnodes.$$
+
+$AWK '{ file[$2] = $1; nnode[$2] = $3 }
+END  { for(x in file)
+	if(file[x] != "")
+	    print file[x] ":" x, file[nnode[x]] ":" nnode[x] }' \
+    cnodes.$$ | tsort | sed 's/_/ /g; $d' >corder.$$
+
+[ -z "$2" ] || grep '^@node.*Top' `echo $2 /dev/null | tr ' ' '\n' | sort` |
+    cut -d, -f1 | sed 's/@node //' >xorder.$$
+
+grep '^@node.*Top' $3 | cut -d, -f-2 |
+    sed 's/, /:/; s/:@node /:/; s/ /_/g; s/:/ /g' >anodes.$$
+
+$AWK '{ file[$2] = $1; nnode[$2] = $3 }
+END  { for(x in file)
+	if(file[x] != "")
+	    print file[x] ":" x, file[nnode[x]] ":" nnode[x] }' \
+    anodes.$$ | tsort | sed 's/_/ /g; $d' >aorder.$$
+
+IFS=:
+
+>incl.$$
+>smenu.$$
+>lmenu.$$
+
+while read file node; do
+    echo "@include $file" >>incl.$$
+    echo "* $node:: `sed -n 's/^@c %MENU% //p' $file`" >>smenu.$$
+    lmenu=`sed -n '/^@menu/,/^@end menu/p; /^@end menu/q' $file |
+	sed '/^@menu/d; /^@end menu/d'`
+    [ -z "$lmenu" ] || (
+	echo; echo "$node"; echo
+	echo "$lmenu"
+    ) >>lmenu.$$
+done <corder.$$
+
+if [ -f xorder.$$ ]; then
+
+    (echo; echo 'Add-ons'; echo) >>smenu.$$
+
+    while read file node; do
+	echo "@include $file" >>incl.$$
+	echo "* $node:: `sed -n 's/^@c %MENU% //p' $file`" >>smenu.$$
+	lmenu=`sed -n '/^@menu/,/^@end menu/p; /^@end menu/q' $file |
+	    sed '/^@menu/d; /^@end menu/d'`
+	[ -z "$lmenu" ] || (
+	    echo; echo "$node"; echo
+	    echo "$lmenu"
+	) >>lmenu.$$
+    done <xorder.$$
+fi
+
+(echo; echo 'Appendices'; echo) >>smenu.$$
+
+while read file node; do
+    echo "@include $file" >>incl.$$
+    echo "* $node:: `sed -n 's/^@c %MENU% //p' $file`" >>smenu.$$
+    lmenu=`sed -n '/^@menu/,/^@end menu/p; /^@end menu/q' $file |
+	sed '/^@menu/d; /^@end menu/d'`
+    [ -z "$lmenu" ] || (
+	echo; echo "$node"; echo
+	echo "$lmenu"
+    ) >>lmenu.$$
+done <aorder.$$
+
+$AWK '
+BEGIN { FS=":" }
+
+/^\*/ {
+  printf("%-32s", $1 "::");
+  x = split($3, word, " ");
+  hpos = 34;
+  for(i = 1; i <= x; i++) {
+    hpos += length(word[i]) + 1;
+    if(hpos > 78) {
+      printf("\n%34s", "");
+      hpos = 35 + length(word[i]);
+    }
+    printf(" %s", word[i]);
+  }
+  print ".";
+}
+
+!/^\*/ { print; }
+' smenu.$$ >smenux.$$
+
+mv -f incl.$$ chapters.texi
+
+(echo '@menu'
+ cat smenux.$$
+ cat <<EOF
+* Copying::                      The GNU Library General Public License says
+                                  how you can copy and share the GNU C Library.
+
+Indices
+
+* Concept Index::                Index of concepts and names.
+* Type Index::                   Index of types and type qualifiers.
+* Function Index::               Index of functions and function-like macros.
+* Variable Index::               Index of variables and variable-like macros.
+* File Index::                   Index of programs and files.
+
+ --- The Detailed Node Listing ---
+EOF
+ cat lmenu.$$
+ echo '@end menu' ) >top-menu.texi.$$
+mv -f top-menu.texi.$$ top-menu.texi
+
+rm -f *.$$
diff --git a/manual/libc.texinfo b/manual/libc.texinfo
index 1e92d52456..0beec66fd6 100644
--- a/manual/libc.texinfo
+++ b/manual/libc.texinfo
@@ -109,896 +109,8 @@ This is Edition @value{EDITION}, last updated @value{UPDATED}, of
 of the GNU C Library.
 @end ifinfo
 
-
-@menu
-* Introduction::                Purpose of the GNU C Library.
-* Error Reporting::             How the GNU Library functions report
-                                 error conditions.
-* Memory Allocation::           Your program can allocate memory dynamically
-                                 and manipulate it via pointers.
-* Character Handling::          Character testing and conversion functions.
-* String and Array Utilities::  Utilities for copying and comparing
-                                 strings and arrays.
-* Extended Characters::         Support for extended character sets.
-* Locales::                     The country and language can affect
-                                 the behavior of library functions.
-* Message Translation::         How to make the program speak the users
-                                 language.
-* Searching and Sorting::       General searching and sorting functions.
-* Pattern Matching::            Matching wildcards and regular expressions,
-                                 and shell-style ``word expansion''.
-* I/O Overview::                Introduction to the I/O facilities.
-* Streams: I/O on Streams.      High-level, portable I/O facilities.
-* Low-Level I/O::               Low-level, less portable I/O.
-* File System Interface::       Functions for manipulating files.
-* Pipes and FIFOs::             A simple interprocess communication mechanism.
-* Sockets::                     A more complicated interprocess communication
-                                 mechanism, with support for networking.
-* Low-Level Terminal Interface::How to change the characteristics
-                                 of a terminal device.
-* Mathematics::                 Math functions (transcendental functions,
-                                 random numbers, absolute value, etc.).
-* Arithmetic::                  Low-level arithmetic functions.
-* Date and Time::               Functions for getting the date and time,
-                                 and for conversion between formats.
-* Non-Local Exits::             The @code{setjmp} and @code{longjmp} facilities.
-* Signal Handling::             All about signals; how to send them,
-                                 block them, and handle them.
-* Process Startup::             Writing the beginning and end of your program.
-* Processes::                   How to create processes and run other programs.
-* Job Control::                 All about process groups and sessions.
-* Name Service Switch::         Accessing the various system databases.
-* Users and Groups::            How users are identified and classified.
-* System Information::          Getting information about the
-                                 hardware and software configuration
-                                 of the machine a program runs on.
-* System Configuration::        Parameters describing operating system limits.
-
-Appendices
-
-* Language Features::           C language features provided by the library.
-
-* Library Summary::             A summary showing the syntax, header file,
-                                 and derivation of each library feature.
-* Installation::                How to install the GNU C library.
-* Maintenance::                 How to enhance and port the GNU C Library.
-* Contributors::                Who wrote what parts of the GNU C Library.
-* Copying::                     The GNU Library General Public License says
-                                 how you can copy and share the GNU C Library.
-
-Indices
-
-* Concept Index::               Index of concepts and names.
-* Type Index::                  Index of types and type qualifiers.
-* Function Index::              Index of functions and function-like macros.
-* Variable Index::              Index of variables and variable-like macros.
-* File Index::                  Index of programs and files.
-
- --- The Detailed Node Listing ---
-
-Introduction
-
-* Getting Started::             Getting Started
-* Standards and Portability::   Standards and Portability
-* Using the Library::           Using the Library
-* Roadmap to the Manual::       Roadmap to the Manual
-
-Standards and Portability
-
-* ISO C::                       The American National Standard for the
-                                 C programming language.
-* POSIX::                       The ISO/IEC 9945 (aka IEEE 1003) standards
-                                 for operating systems.
-* Berkeley Unix::               BSD and SunOS.
-* SVID::                        The System V Interface Description.
-
-Using the Library
-
-* Header Files::                How to use the header files in your programs.
-* Macro Definitions::           Some functions in the library may really
-                                 be implemented as macros.
-* Reserved Names::              The C standard reserves some names for
-                                 the library, and some for users.
-* Feature Test Macros::         How to control what names are defined.
-
-Error Reporting
-
-* Checking for Errors::         How errors are reported by library functions.
-* Error Codes::                 What all the error codes are.
-* Error Messages::              Mapping error codes onto error messages.
-
-Memory Allocation
-
-* Memory Concepts::             An introduction to concepts and terminology.
-* Dynamic Allocation and C::    How to get different kinds of allocation in C.
-* Unconstrained Allocation::    The @code{malloc} facility allows fully general
-                                 dynamic allocation.
-* Obstacks::                    Obstacks are less general than malloc
-                                 but more efficient and convenient.
-* Variable Size Automatic::     Allocation of variable-sized blocks
-                                 of automatic storage that are freed when the
-                                 calling function returns.
-* Relocating Allocator::        Waste less memory, if you can tolerate
-                                 automatic relocation of the blocks you get.
-
-Unconstrained Allocation
-
-* Basic Allocation::            Simple use of @code{malloc}.
-* Malloc Examples::             Examples of @code{malloc}.  @code{xmalloc}.
-* Freeing after Malloc::        Use @code{free} to free a block you
-                                 got with @code{malloc}.
-* Changing Block Size::         Use @code{realloc} to make a block
-                                 bigger or smaller.
-* Allocating Cleared Space::    Use @code{calloc} to allocate a
-                                 block and clear it.
-* Efficiency and Malloc::       Efficiency considerations in use of
-                                 these functions.
-* Aligned Memory Blocks::       Allocating specially aligned memory:
-                                 @code{memalign} and @code{valloc}.
-* Heap Consistency Checking::   Automatic checking for errors.
-* Hooks for Malloc::            You can use these hooks for debugging
-				 programs that use @code{malloc}.
-* Statistics of Malloc::        Getting information about how much
-				 memory your program is using.
-* Summary of Malloc::           Summary of @code{malloc} and related functions.
-
-Obstacks
-
-* Creating Obstacks::		How to declare an obstack in your program.
-* Preparing for Obstacks::	Preparations needed before you can
-				 use obstacks.
-* Allocation in an Obstack::    Allocating objects in an obstack.
-* Freeing Obstack Objects::     Freeing objects in an obstack.
-* Obstack Functions::		The obstack functions are both
-				 functions and macros.
-* Growing Objects::             Making an object bigger by stages.
-* Extra Fast Growing::		Extra-high-efficiency (though more
-				 complicated) growing objects.
-* Status of an Obstack::        Inquiries about the status of an obstack.
-* Obstacks Data Alignment::     Controlling alignment of objects in obstacks.
-* Obstack Chunks::              How obstacks obtain and release chunks.
-				Efficiency considerations.
-* Summary of Obstacks::
-
-Automatic Storage with Variable Size
-
-* Alloca Example::              Example of using @code{alloca}.
-* Advantages of Alloca::        Reasons to use @code{alloca}.
-* Disadvantages of Alloca::     Reasons to avoid @code{alloca}.
-* GNU C Variable-Size Arrays::  Only in GNU C, here is an alternative
-				 method of allocating dynamically and
-				 freeing automatically.
-Relocating Allocator
-
-* Relocator Concepts::		How to understand relocating allocation.
-* Using Relocator::		Functions for relocating allocation.
-
-Character Handling
-
-* Classification of Characters::Testing whether characters are
-                                 letters, digits, punctuation, etc.
-* Case Conversion::             Case mapping, and the like.
-
-String and Array Utilities
-
-* Representation of Strings::   Introduction to basic concepts.
-* String/Array Conventions::    Whether to use a string function or an
-				 arbitrary array function.
-* String Length::               Determining the length of a string.
-* Copying and Concatenation::   Functions to copy the contents of strings
-				 and arrays.
-* String/Array Comparison::     Functions for byte-wise and character-wise
-				 comparison.
-* Collation Functions::         Functions for collating strings.
-* Search Functions::            Searching for a specific element or substring.
-* Finding Tokens in a String::  Splitting a string into tokens by looking
-				 for delimiters.
-
-Extended Characters
-
-* Extended Char Intro::         Multibyte codes versus wide characters.
-* Locales and Extended Chars::  The locale selects the character codes.
-* Multibyte Char Intro::        How multibyte codes are represented.
-* Wide Char Intro::             How wide characters are represented.
-* Wide String Conversion::      Converting wide strings to multibyte code
-                                   and vice versa.
-* Length of Char::              how many bytes make up one multibyte char.
-* Converting One Char::         Converting a string character by character.
-* Example of Conversion::       Example showing why converting
-				   one character at a time may be useful.
-* Shift State::                 Multibyte codes with "shift characters".
-
-Locales and Internationalization
-
-* Effects of Locale::           Actions affected by the choice of locale.
-* Choosing Locale::             How the user specifies a locale.
-* Locale Categories::           Different purposes for which
-                                 you can select a locale.
-* Setting the Locale::          How a program specifies the locale.
-* Standard Locales::            Locale names available on all systems.
-* Numeric Formatting::          How to format numbers for the chosen locale.
-
-Message Translation
-
-* Message catalogs a la X/Open::  The @code{catgets} family of functions.
-* The Uniforum approach::         The @code{gettext} family of functions.
-
-Searching and Sorting
-
-* Comparison Functions::        Defining how to compare two objects.
-				Since the sort and search facilities are
-				general, you have to specify the ordering.
-* Array Search Function::       The @code{bsearch} function.
-* Array Sort Function::         The @code{qsort} function.
-* Search/Sort Example::         An example program.
-
-Pattern Matching
-
-* Wildcard Matching::    Matching a wildcard pattern against a single string.
-* Globbing::             Finding the files that match a wildcard pattern.
-* Regular Expressions::  Matching regular expressions against strings.
-* Word Expansion::       Expanding shell variables, nested commands,
-                          arithmetic, and wildcards.
-			  This is what the shell does with shell commands.
-
-I/O Overview
-
-* I/O Concepts::                Some basic information and terminology.
-* File Names::                  How to refer to a file.
-
-I/O Concepts
-
-* Streams and File Descriptors:: The GNU Library provides two ways
-                                  to access the contents of files.
-* File Position::               The number of bytes from the
-                                 beginning of the file.
-
-File Names
-
-* Directories::                 Directories contain entries for files.
-* File Name Resolution::        A file name specifies how to look up a file.
-* File Name Errors::            Error conditions relating to file names.
-* File Name Portability::       File name portability and syntax issues.
-
-I/O on Streams
-
-* Streams::                     About the data type representing a stream.
-* Standard Streams::            Streams to the standard input and output
-                                 devices are created for you.
-* Opening Streams::             How to create a stream to talk to a file.
-* Closing Streams::             Close a stream when you are finished with it.
-* Simple Output::               Unformatted output by characters and lines.
-* Character Input::             Unformatted input by characters and words.
-* Line Input::                  Reading a line or a record from a stream.
-* Unreading::                   Peeking ahead/pushing back input just read.
-* Formatted Output::            @code{printf} and related functions.
-* Customizing Printf::          You can define new conversion specifiers for
-                                 @code{printf} and friends.
-* Formatted Input::             @code{scanf} and related functions.
-* Block Input/Output::          Input and output operations on blocks of data.
-* EOF and Errors::              How you can tell if an I/O error happens.
-* Binary Streams::              Some systems distinguish between text files
-                                 and binary files.
-* File Positioning::            About random-access streams.
-* Portable Positioning::        Random access on peculiar ISO C systems.
-* Stream Buffering::            How to control buffering of streams.
-* Temporary Files::             How to open a temporary file.
-* Other Kinds of Streams::      Other Kinds of Streams
-
-Unreading
-
-* Unreading Idea::              An explanation of unreading with pictures.
-* How Unread::                  How to call @code{ungetc} to do unreading.
-
-Formatted Output
-
-* Formatted Output Basics::     Some examples to get you started.
-* Output Conversion Syntax::    General syntax of conversion specifications.
-* Table of Output Conversions:: Summary of output conversions, what they do.
-* Integer Conversions::         Details of formatting integers.
-* Floating-Point Conversions::  Details of formatting floating-point numbers.
-* Other Output Conversions::    Details about formatting of strings,
-                                 characters, pointers, and the like.
-* Formatted Output Functions::  Descriptions of the actual functions.
-* Variable Arguments Output::   @code{vprintf} and friends.
-* Parsing a Template String::   What kinds of arguments does
-                                 a given template call for?
-
-Customizing Printf
-
-* Registering New Conversions::
-* Conversion Specifier Options::
-* Defining the Output Handler::
-* Printf Extension Example::
-
-Formatted Input
-
-* Formatted Input Basics::      Some basics to get you started.
-* Input Conversion Syntax::     Syntax of conversion specifications.
-* Table of Input Conversions::  Summary of input conversions and what they do.
-* Numeric Input Conversions::   Details of conversions for reading numbers.
-* String Input Conversions::    Details of conversions for reading strings.
-* Other Input Conversions::     Details of miscellaneous other conversions.
-* Formatted Input Functions::   Descriptions of the actual functions.
-* Variable Arguments Input::    @code{vscanf} and friends.
-
-Stream Buffering
-
-* Buffering Concepts::          Terminology is defined here.
-* Flushing Buffers::            How to ensure that output buffers are flushed.
-* Controlling Buffering::       How to specify what kind of buffering to use.
-
-Other Kinds of Streams
-
-* String Streams::
-* Custom Streams::
-
-Programming Your Own Custom Streams
-
-* Streams and Cookies::
-* Hook Functions::
-
-Low-Level I/O
-
-* Opening and Closing Files::   How to open and close file descriptors.
-* I/O Primitives::              Reading and writing data.
-* File Position Primitive::     Setting a descriptor's file position.
-* Descriptors and Streams::     Converting descriptor to stream or vice-versa.
-* Stream/Descriptor Precautions::  Precautions needed if you use both
-                                    descriptors and streams.
-* Waiting for I/O::             How to check for input or output
-                                 on multiple file descriptors.
-* Control Operations::          Various other operations on file descriptors.
-* Duplicating Descriptors::     Fcntl commands for duplicating descriptors.
-* Descriptor Flags::            Fcntl commands for manipulating flags
-                                 associated with file descriptors.
-* File Status Flags::           Fcntl commands for manipulating flags
-                                 associated with open files.
-* File Locks::                  Fcntl commands for implementing file locking.
-* Interrupt Input::             Getting a signal when input arrives.
-
-File System Interface
-
-* Working Directory::           This is used to resolve relative file names.
-* Accessing Directories::       Finding out what files a directory contains.
-* Hard Links::                  Adding alternate names to a file.
-* Symbolic Links::              A file that ``points to'' a file name.
-* Deleting Files::              How to delete a file, and what that means.
-* Renaming Files::              Changing a file's name.
-* Creating Directories::        A system call just for creating a directory.
-* File Attributes::             Attributes of individual files.
-* Making Special Files::        How to create special files.
-
-Accessing Directories
-
-* Directory Entries::           Format of one directory entry.
-* Opening a Directory::         How to open a directory stream.
-* Reading/Closing Directory::   How to read directory entries from the stream.
-* Simple Directory Lister::     A very simple directory listing program.
-* Random Access Directory::     Rereading part of the directory
-                                  already read with the same stream.
-
-File Attributes
-
-* Attribute Meanings::          The names of the file attributes,
-                                 and what their values mean.
-* Reading Attributes::          How to read the attributes of a file.
-* Testing File Type::           Distinguishing ordinary files,
-                                 directories, links...
-* File Owner::                  How ownership for new files is determined,
-                                 and how to change it.
-* Permission Bits::             How information about a file's access mode
-                                 is stored.
-* Access Permission::           How the system decides who can access a file.
-* Setting Permissions::         How permissions for new files are assigned,
-                                 and how to change them.
-* Testing File Access::         How to find out if your process can
-                                 access a file.
-* File Times::                  About the time attributes of a file.
-
-Pipes and FIFOs
-
-* Creating a Pipe::             Making a pipe with the @code{pipe} function.
-* Pipe to a Subprocess::        Using a pipe to communicate with a child.
-* FIFO Special Files::          Making a FIFO special file.
-
-Sockets
-
-* Socket Concepts::             Basic concepts you need to know about.
-* Communication Styles::        Stream communication, datagrams, and others.
-* Socket Addresses::            How socket names (``addresses'') work.
-* Local Namespace::             Details about the local namespace.
-* Internet Namespace::          Details about the Internet namespace.
-* Open/Close Sockets::          Creating sockets and destroying them.
-* Connections::                 Operations on sockets with connection state.
-* Datagrams::                   Operations on datagram sockets.
-* Socket Options::              Miscellaneous low-level socket options.
-* Networks Database::           Accessing the database of network names.
-
-Socket Addresses
-
-* Address Formats::             About @code{struct sockaddr}.
-* Setting Address::             Binding an address to a socket.
-* Reading Address::             Reading the address of a socket.
-
-Internet Domain
-
-* Internet Address Formats::    How socket addresses are specified in the
-                                 Internet namespace.
-* Host Addresses::              All about host addresses of Internet hosts.
-* Protocols Database::          Referring to protocols by name.
-* Services Database::           Ports may have symbolic names.
-* Byte Order::                  Different hosts may use different byte
-                                 ordering conventions; you need to
-                                 canonicalize host address and port number.
-* Inet Example::                Putting it all together.
-
-Host Addresses
-
-* Abstract Host Addresses::             What a host number consists of.
-* Data type: Host Address Data Type.    Data type for a host number.
-* Functions: Host Address Functions.    Functions to operate on them.
-* Names: Host Names.                    Translating host names to host numbers.
-
-Open/Close Sockets
-
-* Creating a Socket::           How to open a socket.
-* Closing a Socket::            How to close a socket.
-* Socket Pairs::                These are created like pipes.
-
-Connections
-
-* Connecting::                  What the client program must do.
-* Listening::                   How a server program waits for requests.
-* Accepting Connections::       What the server does when it gets a request.
-* Who is Connected::            Getting the address of the
-                                 other side of a connection.
-* Transferring Data::           How to send and receive data.
-* Byte Stream Example::         An example client for communicating over a
-                                 byte stream socket in the Internet namespace.
-* Server Example::              A corresponding server program.
-* Out-of-Band Data::            This is an advanced feature.
-
-Transferring Data
-
-* Sending Data::                Sending data with @code{write}.
-* Receiving Data::              Reading data with @code{read}.
-* Socket Data Options::         Using @code{send} and @code{recv}.
-
-Datagrams
-
-* Sending Datagrams::           Sending packets on a datagram socket.
-* Receiving Datagrams::         Receiving packets on a datagram socket.
-* Datagram Example::            An example program: packets sent over a
-                                 datagram stream in the local namespace.
-* Example Receiver::            Another program, that receives those packets.
-
-Socket Options
-
-* Socket Option Functions::     The basic functions for setting and getting
-                                 socket options.
-* Socket-Level Options::        Details of the options at the socket level.
-
-Low-Level Terminal Interface
-
-* Is It a Terminal::            How to determine if a file is a terminal
-                                 device, and what its name is.
-* I/O Queues::                  About flow control and typeahead.
-* Canonical or Not::            Two basic styles of input processing.
-* Terminal Modes::              How to examine and modify flags controlling
-                                 terminal I/O: echoing, signals, editing.
-* Line Control::                Sending break sequences, clearing  buffers...
-* Noncanon Example::            How to read single characters without echo.
-
-Terminal Modes
-
-* Mode Data Types::             The data type @code{struct termios} and related types.
-* Mode Functions::              Functions to read and set terminal attributes.
-* Setting Modes::               The right way to set attributes reliably.
-* Input Modes::                 Flags controlling low-level input handling.
-* Output Modes::                Flags controlling low-level output handling.
-* Control Modes::               Flags controlling serial port behavior.
-* Local Modes::                 Flags controlling high-level input handling.
-* Line Speed::                  How to read and set the terminal line speed.
-* Special Characters::          Characters that have special effects,
-                                 and how to change them.
-* Noncanonical Input::          Controlling how long to wait for input.
-
-Special Characters
-
-* Editing Characters::
-* Signal Characters::
-* Start/Stop Characters::
-
-Mathematics
-
-* Domain and Range Errors::     How overflow conditions and the
-                                 like are reported.
-* Not a Number::                Making NANs and testing for NANs.
-* Trig Functions::              Sine, cosine, and tangent.
-* Inverse Trig Functions::      Arc sine, arc cosine, and arc tangent.
-* Exponents and Logarithms::    Also includes square root.
-* Hyperbolic Functions::        Hyperbolic sine and friends.
-* Pseudo-Random Numbers::       Functions for generating pseudo-random numbers.
-* Absolute Value::              Absolute value functions.
-
-Pseudo-Random Numbers
-
-* ISO Random::                  @code{rand} and friends.
-* BSD Random::                  @code{random} and friends.
-
-Low-Level Arithmetic Functions
-
-* Normalization Functions::     Hacks for radix-2 representations.
-* Rounding and Remainders::     Determining the integer and
-                                 fractional parts of a float.
-* Integer Division::            Functions for performing integer division.
-* Parsing of Numbers::          Functions for ``reading'' numbers from strings.
-* Predicates on Floats::        Some miscellaneous test functions.
-
-Parsing of Numbers
-
-* Parsing of Integers::         Functions for conversion of integer values.
-* Parsing of Floats::           Functions for conversion of floating-point.
-
-Date and Time
-
-* Processor Time::              Measures processor time used by a program.
-* Calendar Time::               Manipulation of ``real'' dates and times.
-* Setting an Alarm::            Sending a signal after a specified time.
-* Sleeping::                    Waiting for a period of time.
-
-Processor Time
-
-* Basic CPU Time::              The @code{clock} function.
-* Detailed CPU Time::           The @code{times} function.
-
-Calendar Time
-
-* Simple Calendar Time::        Facilities for manipulating calendar time.
-* High-Resolution Calendar::    A time representation with greater precision.
-* Broken-down Time::            Facilities for manipulating local time.
-* Formatting Date and Time::    Converting times to strings.
-* TZ Variable::                 How users specify the time zone.
-* Time Zone Functions::         Functions to examine or specify the time zone.
-* Time Functions Example::      An example program showing use of some of
-                                 the time functions.
-
-Signal Handling
-
-* Concepts of Signals::         Introduction to the signal facilities.
-* Standard Signals::            Particular kinds of signals with standard
-                                 names and meanings.
-* Signal Actions::              Specifying what happens when a particular
-                                 signal is delivered.
-* Defining Handlers::           How to write a signal handler function.
-* Generating Signals::          How to send a signal to a process.
-* Blocking Signals::            Making the system hold signals temporarily.
-* Waiting for a Signal::        Suspending your program until a signal arrives.
-* Signal Stack::                Using a Separate Signal Stack
-* BSD Signal Handling::         Additional functions for backward
-                                 compatibility with BSD.
-
-Basic Concepts of Signals
-
-* Kinds of Signals::            Some examples of what can cause a signal.
-* Signal Generation::           Concepts of why and how signals occur.
-* Delivery of Signal::          Concepts of what a signal does to the process.
-
-Standard Signals
-
-* Program Error Signals::       Used to report serious program errors.
-* Termination Signals::         Used to interrupt and/or terminate the program.
-* Alarm Signals::               Used to indicate expiration of timers.
-* Asynchronous I/O Signals::    Used to indicate input is available.
-* Job Control Signals::         Signals used to support job control.
-* Operation Error Signals::     Used to report operational system errors.
-* Miscellaneous Signals::       Miscellaneous Signals.
-* Signal Messages::             Printing a message describing a signal.
-
-Specifying Signal Actions
-
-* Basic Signal Handling::       The simple @code{signal} function.
-* Advanced Signal Handling::    The more powerful @code{sigaction} function.
-* Signal and Sigaction::        How those two functions interact.
-* Sigaction Function Example::  An example of using the sigaction function.
-* Flags for Sigaction::         Specifying options for signal handling.
-* Initial Signal Actions::      How programs inherit signal actions.
-
-Defining Signal Handlers
-
-* Handler Returns::
-* Termination in Handler::
-* Longjmp in Handler::
-* Signals in Handler::
-* Nonreentrancy::
-* Atomic Data Access::
-
-Generating Signals
-
-* Signaling Yourself::          Signaling Yourself
-* Signaling Another Process::   Send a signal to another process.
-* Permission for kill::         Permission for using @code{kill}
-* Kill Example::                Using @code{kill} for Communication
-
-Blocking Signals
-
-* Why Block::                   The purpose of blocking signals.
-* Signal Sets::                 How to specify which signals to block.
-* Process Signal Mask::         Blocking delivery of signals to your
-                                 process during normal execution.
-* Testing for Delivery::        Blocking to Test for Delivery of a Signal
-* Blocking for Handler::        Blocking additional signals while a
-                                 handler is being run.
-* Checking for Pending Signals::Checking for Pending Signals
-* Remembering a Signal::        How you can get almost the same effect
-                                 as blocking a signal, by handling it
-                                 and setting a flag to be tested later.
-
-Waiting for a Signal
-
-* Using Pause::                 The simple way, using @code{pause}.
-* Pause Problems::              Why the simple way is often not very good.
-* Sigsuspend::                  Reliably waiting for a specific signal.
-
-BSD Signal Handling
-
-* BSD Handler::                 BSD Function to Establish a Handler.
-* Blocking in BSD::             BSD Functions for Blocking Signals
-
-Process Startup and Termination
-
-* Program Arguments::           Parsing your program's command-line arguments.
-* Environment Variables::       How to access parameters inherited from
-                                 a parent process.
-* Program Termination::         How to cause a process to terminate and
-                                 return status information to its parent.
-
-Program Arguments
-
-* Argument Syntax::             By convention, options start with a hyphen.
-* Parsing Program Arguments::   Ways to parse program options and arguments.
-
-Parsing Program Arguments
-
-* Getopt::                      Parsing program options using @code{getopt}.
-* Argp::                        Parsing program options using @code{argp_parse}.
-* Suboptions::                  Some programs need more detailed options.
-* Suboptions Example::          This shows how it could be done for @code{mount}.
-
-Environment Variables
-
-* Environment Access::          How to get and set the values of
-                                 environment variables.
-* Standard Environment::        These environment variables have
-                                 standard interpretations.
-
-Program Termination
-
-* Normal Termination::          If a program calls @code{exit}, a
-                                 process terminates normally.
-* Exit Status::                 The @code{exit status} provides information
-                                 about why the process terminated.
-* Cleanups on Exit::            A process can run its own cleanup
-                                 functions upon normal termination.
-* Aborting a Program::          The @code{abort} function causes
-                                 abnormal program termination.
-* Termination Internals::       What happens when a process terminates.
-
-
-Child Processes
-
-* Running a Command::           The easy way to run another program.
-* Process Creation Concepts::   An overview of the hard way to do it.
-* Process Identification::      How to get the process ID of a process.
-* Creating a Process::          How to fork a child process.
-* Executing a File::            How to make a child execute another program.
-* Process Completion::          How to tell when a child process has completed.
-* Process Completion Status::   How to interpret the status value
-                                 returned from a child process.
-* BSD Wait Functions::          More functions, for backward compatibility.
-* Process Creation Example::    A complete example program.
-
-Job Control
-
-* Concepts of Job Control ::    Concepts of Job Control
-* Job Control is Optional::     Not all POSIX systems support job control.
-* Controlling Terminal::        How a process gets its controlling terminal.
-* Access to the Terminal::      How processes share the controlling terminal.
-* Orphaned Process Groups::     Jobs left after the user logs out.
-* Implementing a Shell::        What a shell must do to implement job control.
-* Functions for Job Control::   Functions to control process groups.
-
-Implementing a Job Control Shell
-
-* Data Structures::             Introduction to the sample shell.
-* Initializing the Shell::      What the shell must do to take
-                                 responsibility for job control.
-* Launching Jobs::              Creating jobs to execute commands.
-* Foreground and Background::   Putting a job in foreground of background.
-* Stopped and Terminated Jobs:: Reporting job status.
-* Continuing Stopped Jobs::     How to continue a stopped job in
-                                 the foreground or background.
-* Missing Pieces::              Other parts of the shell.
-
-Functions for Job Control
-
-* Identifying the Terminal::    Determining the controlling terminal's name.
-* Process Group Functions::     Functions for manipulating process groups.
-* Terminal Access Functions::   Functions for controlling terminal access.
-
-Name Service Switch
-
-* NSS Basics::                  What is this NSS good for.
-* NSS Configuration File::      Configuring NSS.
-* NSS Module Internals::        How does it work internally.
-* Extending NSS::               What to do to add services or databases.
-
-Users and Groups
-
-* User and Group IDs::          Each user and group has a unique numeric ID.
-* Process Persona::             The user IDs and group IDs of a process.
-* Why Change Persona::          Why a program might need to change
-                                 its user and/or group IDs.
-* How Change Persona::          Restrictions on changing user and group IDs.
-* Reading Persona::             Examining the process's user and group IDs.
-* Setting User ID::
-* Setting Groups::
-* Enable/Disable Setuid::
-* Setuid Program Example::      Setuid Program Example
-* Tips for Setuid::
-* Who Logged In::               Getting the name of the user who logged in,
-                                 or of the real user ID of the current process.
-
-* User Database::               Functions and data structures for
-                                 accessing the user database.
-* Group Database::              Functions and data structures for
-                                 accessing the group database.
-* Database Example::            Example program showing use of database
-                                 inquiry functions.
-
-User Database
-
-* User Data Structure::
-* Lookup User::
-* Scanning All Users::          Scanning the List of All Users
-* Writing a User Entry::
-
-Group Database
-
-* Group Data Structure::
-* Lookup Group::
-* Scanning All Groups::         Scanning the List of All Groups
-
-System Information
-
-* Host Identification::         Determining the name of the machine.
-* Hardware/Software Type ID::   Determining the hardware type and
-                                 operating system type.
-
-System Configuration Limits
-
-* General Limits::		Constants and functions that describe
-				 various process-related limits that have
-				 one uniform value for any given machine.
-* System Options::		Optional POSIX features.
-* Version Supported::		Version numbers of POSIX.1 and POSIX.2.
-* Sysconf::			Getting specific configuration values
-				 of general limits and system options.
-* Minimums::			Minimum values for general limits.
-
-* Limits for Files::		Size limitations on individual files.
-				 These can vary between file systems
-				  or even from file to file.
-* Options for Files::		Optional features that some files may support.
-* File Minimums::		Minimum values for file limits.
-* Pathconf::			Getting the limit values for a particular file.
-
-* Utility Limits::		Capacity limits of POSIX.2 utility programs.
-* Utility Minimums::		Minimum allowable values of those limits.
-
-* String Parameters::		Getting the default search path.
-
-Library Facilities that are Part of the C Language
-
-* Consistency Checking::        Using @code{assert} to abort
-				 if something ``impossible'' happens.
-* Variadic Functions::          Defining functions with varying
-                                 numbers of arguments.
-* Null Pointer Constant::       The macro @code{NULL}.
-* Important Data Types::        Data types for object sizes.
-* Data Type Measurements::      Parameters of data type representations.
-
-Variadic Functions
-
-* Why Variadic::                Reasons for making functions take
-                                 variable arguments.
-* How Variadic::                How to define and call variadic functions.
-* Argument Macros::             Detailed specification of the macros
-				 for accessing variable arguments.
-* Variadic Example::            A complete example.
-
-How Variadic Functions are Defined and Used
-
-* Variadic Prototypes::         How to make a prototype for a function
-				 with variable arguments.
-* Receiving Arguments::		Steps you must follow to access the
-				 optional argument values.
-* How Many Arguments::          How to decide whether there are more arguments.
-* Calling Variadics::		Things you need to know about calling
-				 variable arguments functions.
-
-Data Type Measurements
-
-* Width of Type::		How many bits does an integer type hold?
-* Range of Type::		What are the largest and smallest values
-				 that an integer type can hold?
-* Floating Type Macros::        Parameters that measure floating-point types.
-* Structure Measurement::       Getting measurements on structure types.
-
-Floating Type Macros
-
-* Floating Point Concepts::     Definitions of terminology.
-* Floating Point Parameters::   Dimensions, limits of floating point types.
-* IEEE Floating Point::         How one common representation is described.
-
-Library Maintenance
-
-* Installation::                How to configure, compile and install
-                                 the GNU C library.
-* Reporting Bugs::              How to report bugs (if you want to
-                                 get them fixed) and other troubles
-                                 you may have with the GNU C library.
-@c * Traditional C Compatibility::  Using the GNU C library with non-ANSI
-@c                                          C compilers.
-
-Porting the GNU C Library
-
-* Hierarchy Conventions::       How the @file{sysdeps} hierarchy is
-                                 layed out.
-* Porting to Unix::             Porting the library to an average
-                                 Unix-like system.
-@end menu
-
-
-@comment Includes of all the individual chapters.
-@include intro.texi
-@include errno.texi
-@include memory.texi
-@include ctype.texi
-@include string.texi
-@include mbyte.texi
-@include locale.texi
-@include message.texi
-@include search.texi
-@include pattern.texi
-@include io.texi
-@include stdio.texi
-@include llio.texi
-@include filesys.texi
-@include pipe.texi
-@include socket.texi
-@include terminal.texi
-@include math.texi
-@include arith.texi
-@include time.texi
-@include setjmp.texi
-@include signal.texi
-@include startup.texi
-@include process.texi
-@include job.texi
-@include nss.texi
-@include users.texi
-@include sysinfo.texi
-@include conf.texi
-
-@comment Includes of the appendices.
-@include lang.texi
-@include header.texi
-@include install.texi
-@include maint.texi
-@include contrib.texi
-
+@include top-menu.texi
+@include chapters.texi
 
 @set lgpl-appendix
 @node Copying, Concept Index, Contributors, Top
diff --git a/manual/llio.texi b/manual/llio.texi
index 6387eecbe0..459032ee3a 100644
--- a/manual/llio.texi
+++ b/manual/llio.texi
@@ -1,4 +1,5 @@
 @node Low-Level I/O, File System Interface, I/O on Streams, Top
+@c %MENU% Low-level, less portable I/O
 @chapter Low-Level Input/Output
 
 This chapter describes functions for performing low-level input/output
diff --git a/manual/locale.texi b/manual/locale.texi
index dfc9117176..f4fa3a71a5 100644
--- a/manual/locale.texi
+++ b/manual/locale.texi
@@ -1,4 +1,5 @@
 @node Locales, Message Translation, Extended Characters, Top
+@c %MENU% The country and language can affect the behavior of library functions
 @chapter Locales and Internationalization
 
 Different countries and cultures have varying conventions for how to
diff --git a/manual/maint.texi b/manual/maint.texi
index a7e0cc4b0a..3d8d24f16a 100644
--- a/manual/maint.texi
+++ b/manual/maint.texi
@@ -1,4 +1,5 @@
 @node Maintenance, Contributors, Installation, Top
+@c %MENU% How to enhance and port the GNU C Library
 @appendix Library Maintenance
 
 @menu
diff --git a/manual/math.texi b/manual/math.texi
index 1991bfbdb8..10b326287e 100644
--- a/manual/math.texi
+++ b/manual/math.texi
@@ -1,739 +1,129 @@
 @c We need some definitions here.
+@ifclear mult
 @ifhtml
-@set mult ·
+@set mult &middot;
+@set infty &infin;
+@set pie &pi;
 @end ifhtml
 @iftex
 @set mult @cdot
+@set infty @infty
 @end iftex
 @ifclear mult
-@set mult x
+@set mult *
+@set infty oo
+@set pie pi
 @end ifclear
 @macro mul
 @value{mult}
 @end macro
-@iftex
-@set infty @infty
-@end iftex
-@ifclear infty
-@set infty oo
-@end ifclear
 @macro infinity
 @value{infty}
 @end macro
+@ifnottex
+@macro pi
+@value{pie}
+@end macro
+@end ifnottex
+@end ifclear
 
 @node Mathematics, Arithmetic, Low-Level Terminal Interface, Top
+@c %MENU% Math functions, useful constants, random numbers
 @chapter Mathematics
 
 This chapter contains information about functions for performing
 mathematical computations, such as trigonometric functions.  Most of
 these functions have prototypes declared in the header file
-@file{math.h}.
+@file{math.h}.  The complex-valued functions are defined in
+@file{complex.h}.
 @pindex math.h
-
-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.
-
+@pindex complex.h
+
+All mathematical functions which take a floating-point argument
+have three variants, one each for @code{double}, @code{float}, and
+@code{long double} arguments.  The @code{double} versions are mostly
+defined in @w{ISO C 89}.  The @code{float} and @code{long double}
+versions are from the numeric extensions to C included in @w{ISO C 9X}.
+
+Which of the three versions of a function should be used depends on the
+situation.  For most calculations, the @code{float} functions are the
+fastest.  On the other hand, the @code{long double} functions have the
+highest precision.  @code{double} is somewhere in between.  It is
+usually wise to pick the narrowest type that can accomodate your data.
+Not all machines have a distinct @code{long double} type; it may be the
+same as @code{double}.
 
 @menu
-* Domain and Range Errors::      Detecting overflow conditions and the like.
-* Exceptions in Math Functions:: Signalling exception in math functions.
-* Mathematical Constants::       Precise numeric values for often used
-                                  constant.
-* FP Comparison Functions::      Special functions to compare floating-point
-                                  numbers.
-* FP Function Optimizations::    Fast code or small code.
-* Trig Functions::               Sine, cosine, and tangent.
-* Inverse Trig Functions::       Arc sine, arc cosine, and arc tangent.
-* Exponents and Logarithms::     Also includes square root.
-* Hyperbolic Functions::         Hyperbolic sine and friends.
-* Pseudo-Random Numbers::        Functions for generating pseudo-random
-				  numbers.
+* Mathematical Constants::      Precise numeric values for often-used
+                                 constants.
+* Trig Functions::              Sine, cosine, tangent, and friends.
+* Inverse Trig Functions::      Arcsine, arccosine, etc.
+* Exponents and Logarithms::    Also pow and sqrt.
+* Hyperbolic Functions::        sinh, cosh, tanh, etc.
+* Special Functions::           Bessel, gamma, erf.
+* Pseudo-Random Numbers::       Functions for generating pseudo-random
+				 numbers.
+* FP Function Optimizations::   Fast code or small code.
 @end menu
 
-@node Domain and Range Errors
-@section Domain and Range Errors
-
-@cindex domain error
-Many of the functions listed in this chapter are defined mathematically
-over a domain that is only a subset of real numbers.  For example, the
-@code{acos} function is defined over the domain between @code{@minus{}1} and
-@code{1}.  If you pass an argument to one of these functions that is
-outside the domain over which it is defined, the function sets
-@code{errno} to @code{EDOM} to indicate a @dfn{domain error}.  On
-machines that support @w{IEEE 754} floating point, functions reporting
-error @code{EDOM} also return a NaN.
-
-Some of these functions are defined mathematically to result in a
-complex value over parts of their domains.  The most familiar example of
-this is taking the square root of a negative number.  The functions in
-this chapter take only real arguments and return only real values;
-therefore, if the value ought to be nonreal, this is treated as a domain
-error.
-
-@cindex range error
-A related problem is that the mathematical result of a function may not
-be representable as a floating point number.  If magnitude of the
-correct result is too large to be represented, the function sets
-@code{errno} to @code{ERANGE} to indicate a @dfn{range error}, and
-returns a particular very large value (named by the macro
-@code{HUGE_VAL}) or its negation (@code{@minus{}HUGE_VAL}).
-
-If the magnitude of the result is too small, a value of zero is returned
-instead.  In this case, @code{errno} might or might not be
-set to @code{ERANGE}.
-
-The only completely reliable way to check for domain and range errors is
-to set @code{errno} to @code{0} before you call the mathematical function
-and test @code{errno} afterward.  As a consequence of this use of
-@code{errno}, use of the mathematical functions is not reentrant if you
-check for errors.
-
-@c ### This is no longer true.  --drepper
-@c None of the mathematical functions ever generates signals as a result of
-@c domain or range errors.  In particular, this means that you won't see
-@c @code{SIGFPE} signals generated within these functions.  (@xref{Signal
-@c Handling}, for more information about signals.)
-
-@comment math.h
-@comment ISO
-@deftypevr Macro double HUGE_VAL
-An expression representing a particular very large number.  On machines
-that use @w{IEEE 754}/@w{IEEE 854} floating point format, the value is
-``infinity''.  On other machines, it's typically the largest positive
-number that can be represented.
-
-The value of this macro is used as the return value from various
-mathematical @code{double} returning functions in overflow situations.
-@end deftypevr
-
-@comment math.h
-@comment ISO
-@deftypevr Macro float HUGE_VALF
-This macro is similar to the @code{HUGE_VAL} macro except that it is
-used by functions returning @code{float} values.
-
-This macro is introduced in @w{ISO C 9X}.
-@end deftypevr
-
-@comment math.h
-@comment ISO
-@deftypevr Macro {long double} HUGE_VALL
-This macro is similar to the @code{HUGE_VAL} macro except that it is
-used by functions returning @code{long double} values.  The value is
-only different from @code{HUGE_VAL} if the architecture really supports
-@code{long double} values.
-
-This macro is introduced in @w{ISO C 9X}.
-@end deftypevr
-
-
-A special case is the @code{ilogb} function @pxref{Exponents and
-Logarithms}.  Since the return value is an integer value, one cannot
-compare with @code{HUGE_VAL} etc.  Therefore two further values are
-defined.
-
-@comment math.h
-@comment ISO
-@deftypevr Macro int FP_ILOGB0
-This value is returned by @code{ilogb} if the argument is @code{0}.  The
-numeric value is either @code{INT_MIN} or @code{-INT_MAX}.
-
-This macro is introduced in @w{ISO C 9X}.
-@end deftypevr
-
-@comment math.h
-@comment ISO
-@deftypevr Macro int FP_ILOGBNAN
-This value is returned by @code{ilogb} if the argument is @code{NaN}.  The
-numeric value is either @code{INT_MIN} or @code{INT_MAX}.
-
-This macro is introduced in @w{ISO C 9X}.
-@end deftypevr
-
-
-For more information about floating-point representations and limits,
-see @ref{Floating Point Parameters}.  In particular, the macro
-@code{DBL_MAX} might be more appropriate than @code{HUGE_VAL} for many
-uses other than testing for an error in a mathematical function.
-
-
-@node Exceptions in Math Functions
-@section Exceptions in Math Functions
-@cindex exception
-@cindex signal
-
-Due to the restrictions in the size of the floating-point number
-representation or the limitation of the input range of certain functions
-some of the mathematical operations and functions have to signal
-exceptional situations.  The @w{IEEE 754} standard specifies which
-exceptions have to be supported and how they can be handled.
-
-@w{IEEE 754} specifies two actions for floating-point exception: taking
-a trap or continuing without doing so.  If the trap is taken a
-(possibly) user defined trap handler is called and this function can
-correct the argument or react somehow else on the call.  If the trap
-handler returns, its return value is taken as the result of the
-operation.
-
-If no trap handler is called each of the known exceptions has a default
-action.  This consists of setting a corresponding bit in the
-floating-point status word to indicate which kind of exception was
-raised and to return a default value, which depends on the exception
-(see the table below).
-
-@noindent
-The exceptions defined in @w{IEEE 754} are:
-
-@table @samp
-@item Invalid Operation
-This exception is raised if the given operands are invalid for the
-operation to be performed.  Examples are
-(see @w{IEEE 754}, @w{section 7}):
-@enumerate
-@item
-Any operation on a signalling NaN.
-@item
-Addition or subtraction; magnitude subtraction of infinities such as
-@math{(+@infinity{}) + (-@infinity{})}.
-@item
-Multiplication:
-@math{0 @mul{} @infinity{}}.
-
-@item
-Division: @math{0/0} or @math{@infinity{}/@infinity{}}.
-
-@item
-Remainder: @math{x} REM @math{y}, where @math{y} is zero or @math{x} is
-infinite.
-@item
-Square root if the operand is less then zero.
-@item
-Conversion of an internal floating-point number to an integer or to a
-decimal string when overflow, infinity, or NaN precludes a faithful
-representation in that format and this cannot otherwise be signaled.
-@item
-Conversion of an unrecognizable input string.
-@item
-Comparison via predicates involving @math{<} or @math{>}, without
-@code{?}, when the operands are @dfn{unordered}.  (@math{?>} means the
-unordered greater relation, @xref{FP Comparison Functions}).
-@end enumerate
-
-If the exception does not cause a trap handler to be called the result
-of the operation is taken as a quiet NaN.
-
-@item Division by Zero
-This exception is raised if the divisor is zero and the dividend is a
-finite nonzero number.  If no trap occurs the result is either
-@math{+@infinity{}} or @math{-@infinity{}}, depending on the
-signs of the operands.
-
-@item Overflow
-This exception is signalled whenever the result cannot be represented
-as a finite value in the precision format of the destination.  If no trap
-occurs the result depends on the sign of the intermediate result and the
-current rounding mode (@w{IEEE 754}, @w{section 7.3}):
-@enumerate
-@item
-Round to nearest carries all overflows to @math{@infinity{}}
-with the sign of the intermediate result.
-@item
-Round toward @math{0} carries all overflows to the precision's largest
-finite number with the sign of the intermediate result.
-@item
-Round toward @math{-@infinity{}} carries positive overflows to the
-precision's largest finite number and carries negative overflows to
-@math{-@infinity{}}.
-
-@item
-Round toward @math{@infinity{}} carries negative overflows to the
-precision's most negative finite number and carries positive overflows
-to @math{@infinity{}}.
-@end enumerate
-
-@item Underflow
-The underflow exception is created when an intermediate result is too
-small for the operation or if the operations result rounded to the
-destination precision causes a loss of accuracy by approximating the
-result by denormalized numbers.
-
-When no trap is installed for the underflow exception, underflow shall
-be signaled (via the underflow flag) only when both tininess and loss of
-accuracy have been detected.  If no trap handler is installed the
-operation continues with an inprecise small value or zero if the
-destination precision cannot hold the small exact result.
-
-@item Inexact
-This exception is signalled if the rounded result is not exact (such as
-computing the square root of two) or the result overflows without an
-overflow trap.
-@end table
-
-To control whether an exception causes a trap to occur all @w{IEEE 754}
-conformant floating-point implementations (either hardware or software)
-have a control word.  By setting specific bits for each exception in
-this control word the programmer can decide whether a trap is wanted or
-not.
-
-@w{ISO C 9X} introduces a set of function which can be used to control
-exceptions.  There are functions to manipulate the control word, to
-query the status word or to save and restore the whole state of the
-floating-point unit.  There are also functions to control the rounding
-mode used.
-
-@menu
-* Status bit operations::       Manipulate the FP status word.
-* FPU environment::             Controlling the status of the FPU.
-* Rounding Modes::              Controlling the rounding mode.
-@end menu
-
-@node Status bit operations
-@subsection Controlling the FPU status word
-
-To control the five types of exceptions defined in @w{IEEE 754} some
-functions are defined which abstract the interface to the FPU.  The
-actual implementation can be very different, depending on the underlying
-hardware or software.
-
-To address the single exception the @file{fenv.h} headers defines a
-number of macros:
-
-@vtable @code
-@comment fenv.h
-@comment ISO
-@item FE_INEXACT
-Represents the inexact exception iff the FPU supports this exception.
-@comment fenv.h
-@comment ISO
-@item FE_DIVBYZERO
-Represents the divide by zero exception iff the FPU supports this exception.
-@comment fenv.h
-@comment ISO
-@item FE_UNDERFLOW
-Represents the underflow exception iff the FPU supports this exception.
-@comment fenv.h
-@comment ISO
-@item FE_OVERFLOW
-Represents the overflow exception iff the FPU supports this exception.
-@comment fenv.h
-@comment ISO
-@item FE_INVALID
-Represents the invalid exception iff the FPU supports this exception.
-@end vtable
-
-The macro @code{FE_ALL_EXCEPT} is the bitwise OR of all exception macros
-which are supported by the FP implementation.
-
-Each of the supported exception flags can either be set or unset.  The
-@w{ISO C 9X} standard defines functions to set, unset and test the
-status of the flags.
-
-@comment fenv.h
-@comment ISO
-@deftypefun void feclearexcept (int @var{excepts})
-This function clears all of the supported exception flags denoted by
-@var{excepts} in the status word.
-@end deftypefun
-
-To safe the current status of the flags in the status word @file{fenv.h}
-defines the type @code{fexcept_t} which can hold all the information.
-The following function can be used to retrieve the current setting.
-
-@comment fenv.h
-@comment ISO
-@deftypefun void fegetexceptflag (fexcept_t *@var{flagp}, int @var{excepts})
-Store in the variable pointed to by @var{flagp} an
-implementation-defined value representing the current setting of the
-exception flags indicated by the parameter @var{excepts}.
-@end deftypefun
-
-@noindent
-To restore the previously saved values one can use this function:
-
-@comment fenv.h
-@comment ISO
-@deftypefun void fesetexceptflag (const fexcept_t *@var{flagp}, int @var{excepts})
-Restore from the variable pointed to by @var{flagp} the setting of the
-flags for the exceptions denoted by the value of the parameter
-@var{excepts}.
-@end deftypefun
-
-The last function allows to query the current status of the flags.  The
-flags can be set either explicitely (using @code{fesetexceptflag} or
-@code{feclearexcept}) or by a floating-point operation which happened
-before.  Since the flags are accumulative, the flags must be explicitely
-reset using @code{feclearexcept} if one wants to test for a certain
-exceptions raised by a specific piece of code.
-
-@comment fenv.h
-@comment ISO
-@deftypefun int fetestexcept (int @var{excepts})
-Test whether a subset of the flags indicated by the parameter
-@var{except} is currently set.  If yes, a nonzero value is returned
-which specifies which exceptions are set.  Otherwise the result is zero.
-@end deftypefun
-
-@noindent
-Code which uses the @code{fetestexcept} function could look like this:
-
-@smallexample
-@{
-  double f;
-  int raised;
-  feclearexcept (FE_ALL_EXCEPT);
-  f = compute ();
-  raised = fetestexcept (FE_OVERFLOW | FE_INVALID);
-  if (raised & FE_OVERFLOW) @{ /* ... */ @}
-  if (raised & FE_INVALID) @{ /* ... */ @}
-  /* ... */
-@}
-@end smallexample
-
-Please note that the return value of @code{fetestexcept} is @code{int}
-but this does not mean that the @code{fexcept_t} type is generally
-representable as an integer.  These are completely independent types.
-
-
-@node FPU environment
-@subsection Controlling the Floating-Point environment
-
-It is sometimes necessary so save the complete status of the
-floating-point unit for a certain time to perform some completely
-different actions.  Beside the status of the exception flags, the
-control word for the exceptions and the rounding mode can be saved.
-
-The file @file{fenv.h} defines the type @code{fenv_t}.  The layout of a
-variable of this type is implementation defined but the variable is able
-to contain the complete status information.  To fill a variable of this
-type one can use this function:
-
-@comment fenv.h
-@comment ISO
-@deftypefun void fegetenv (fenv_t *@var{envp})
-Store the current floating-point environment in the object pointed to by
-@var{envp}.
-@end deftypefun
-
-@noindent
-Another possibility which is useful in several situations is
-
-@comment fenv.h
-@comment ISO
-@deftypefun int feholdexcept (fenv_t *@var{envp})
-Store the current floating-point environment in the object pointed to by
-@var{envp}.  Afterwards, all exception flags are cleared and if
-available a mode is installed which continues on all exceptions and does
-not cause a trap to occur.  In this case a nonzero value is returned.
-
-If the floating-point implementation does not support such a non-stop
-mode, the return value is zero.
-@end deftypefun
-
-The functions which allow a state of the floating-point unit to be
-restored can take two kinds of arguments:
-
-@itemize @bullet
-@item
-Pointers to @code{fenv_t} objects which were initialized previously by a
-call to @code{fegetenv} or @code{feholdexcept}.
-@item
-@vindex FE_DFL_ENV
-The special macro @code{FE_DFL_ENV} which represents the floating-point
-environment as it was available at program start.
-@item
-Implementation defined macros with names starting with @code{FE_}.
-
-@vindex FE_NOMASK_ENV
-If possible, the GNU C Library defines a macro @code{FE_NOMASK_ENV}
-which represents an environment where no exceptions are masked, so every
-exception raised causes a trap to occur.  You can test for this macro
-using @code{#ifdef}.
-
-Some platforms might define other predefined environments.
-@end itemize
-
-@noindent
-To set any of the environments there are two functions defined.
-
-@deftypefun void fesetenv (const fenv_t *@var{envp})
-Establish the floating-point environment described in the object pointed
-to by @var{envp}.  Even if one or more exceptions flags in the restored
-environment are set no exception is raised.
-@end deftypefun
-
-In some situations the previous status of the exception flags must not
-simply be discarded and so this function is useful:
-
-@deftypefun void feupdateenv (const fenv_t *@var{envp})
-The current status of the floating-point unit is preserved in some
-automatic storage before the environment described by the object pointed
-to by @var{envp} is installed.  Once this is finished all exceptions set
-in the original environment which is saved in the automatic storage, is
-raised.
-@end deftypefun
-
-This function can be used to execute a part of the program with an
-environment which masks all exceptions and before switching back remove
-unwanted exception and raise the remaining exceptions.
-
-
-@node Rounding Modes
-@subsection Rounding modes of the Floating-Point Unit
-
-@w{IEEE 754} defines four different rounding modes.  If the rounding
-mode is supported by the floating-point implementation the corresponding
-of the following macros is defined:
-
-@table @code
-@comment fenv.h
-@comment ISO
-@vindex FE_TONEAREST
-@item FE_TONEAREST
-Round to nearest.  This is the default mode and should always be used
-except when a different mode is explicitely required.  Only rounding to
-nearest guarantees numeric stability of the computations.
-
-@comment fenv.h
-@comment ISO
-@vindex FE_UPWARD
-@item FE_UPWARD
-Round toward @math{+@infinity{}}.
-
-@comment fenv.h
-@comment ISO
-@vindex FE_DOWNWARD
-@item FE_DOWNWARD
-Round toward @math{-@infinity{}}.
-
-@comment fenv.h
-@comment ISO
-@vindex FE_TOWARDZERO
-@item FE_TOWARDZERO
-Round toward zero.
-@end table
-
-At any time one of the above four rounding modes is selected.  To get
-information about the currently selected mode one can use this function:
-
-@comment fenv.h
-@comment ISO
-@deftypefun int fegetround (void)
-Return the currently selected rounding mode, represented by one of the
-values of the defined rounding mode macros.
-@end deftypefun
-
-@noindent
-To set a specific rounding mode the next function can be used.
-
-@comment fenv.h
-@comment ISO
-@deftypefun int fesetround (int @var{round})
-Change the currently selected rounding mode to the mode described by the
-parameter @var{round}.  If @var{round} does not correspond to one of the
-supported rounding modes nothing is changed.
-
-The function returns a nonzero value iff the requested rounding mode can
-be established.  Otherwise zero is returned.
-@end deftypefun
-
-Changing the rounding mode might be necessary for various reasons.  But
-changing the mode only to round a given number normally is no good idea.
-The standard defines a set of functions which can be used to round an
-argument according to some rules and for all of the rounding modes there
-is a corresponding function.
-
-If a large set of number has to be rounded it might be good to change
-the rounding mode and to not use the function the library provides.  So
-the perhaps necessary switching of the rounding mode in the library
-function can be avoided.  But since not all rounding modes are
-guaranteed to exist on any platform this possible implementation cannot
-be portably used.  A default method has to be implemented as well.
-
-
 @node Mathematical Constants
 @section Predefined Mathematical Constants
 @cindex constants
 @cindex mathematical constants
 
-The header @file{math.h} defines a series of mathematical constants if
-@code{_BSD_SOURCE} or a more general feature select macro is defined
-before including this file.  All values are defined as preprocessor
-macros starting with @code{M_}.  The collection includes:
+The header @file{math.h} defines several useful mathematical constants.
+All values are defined as preprocessor macros starting with @code{M_}.
+The values provided are:
 
 @vtable @code
 @item M_E
-The value is that of the base of the natural logarithm.
+The base of natural logarithms.
 @item M_LOG2E
-The value is computed as the logarithm to base @code{2} of @code{M_E}.
+The logarithm to base @code{2} of @code{M_E}.
 @item M_LOG10E
-The value is computed as the logarithm to base @code{10} of @code{M_E}.
+The logarithm to base @code{10} of @code{M_E}.
 @item M_LN2
-The value is computed as the natural logarithm of @code{2}.
+The natural logarithm of @code{2}.
 @item M_LN10
-The value is computed as the natural logarithm of @code{10}.
+The natural logarithm of @code{10}.
 @item M_PI
-The value is those of the number pi.
+Pi, the ratio of a circle's circumrefence to its diameter.
 @item M_PI_2
-The value is those of the number pi divided by two.
+Pi divided by two.
 @item M_PI_4
-The value is those of the number pi divided by four.
+Pi divided by four.
 @item M_1_PI
-The value is the reziprocal of the value of the number pi.
+The reciprocal of pi (1/pi)
 @item M_2_PI
-The value is two times the reziprocal of the value of the number pi.
+Two times the reciprocal of pi.
 @item M_2_SQRTPI
-The value is two times the reziprocal of the square root of the number pi.
+Two times the reciprocal of the square root of pi.
 @item M_SQRT2
-The value is the square root of the value of the number pi.
+The square root of two.
 @item M_SQRT1_2
-The value is the reziprocal of the square root of the value of the number pi.
+The reciprocal of the square root of two (also the square root of 1/2).
 @end vtable
 
-All values are defined as @code{long double} values unless the compiler
-does not support this type or @code{__STDC__} is not defined (both is
-unlikely).  Historically the numbers were @code{double} values and some
-old code still relies on this so you might want to add explicit casts if
-the extra precision of the @code{long double} value is not needed.  One
-critical case are functions with a variable number of arguments, such as
-@code{printf}.
+These constants come from the Unix98 standard and were also available in
+4.4BSD; therefore, they are only defined if @code{_BSD_SOURCE} or
+@code{_XOPEN_SOURCE=500}, or a more general feature select macro, is
+defined.  The default set of features includes these constants.
+@xref{Feature Test Macros}.
+
+All values are of type @code{double}.  As an extension, the GNU C
+library also defines these constants with type @code{long double}.  The
+@code{long double} macros have a lowercase @samp{l} appended to their
+names: @code{M_El}, @code{M_PIl}, and so forth.  These are only
+available if @code{_GNU_SOURCE} is defined.
 
 @vindex PI
 @emph{Note:} Some programs use a constant named @code{PI} which has the
-same value as @code{M_PI}.  This probably derives from Stroustroup's
-book about his C++ programming language where this value is used in
-examples (and perhaps some AT&T headers contain this value).  But due to
-possible name space problems (@code{PI} is a quite frequently used name)
-this value is not added to @file{math.h}.  Every program should use
-@code{M_PI} instead or add on the compiler command line
-@code{-DPI=M_PI}.
-
-
-@node FP Comparison Functions
-@section Floating-Point Comparison Functions
-@cindex unordered comparison
-
-The @w{IEEE 754} standards defines a set of functions which allows to
-compare even those numbers which normally would cause an exception to be
-raised since they are unordered.  E.g., the expression
-
-@smallexample
-int v = a < 1.0;
-@end smallexample
-
-@noindent
-would raise an exception if @var{a} would be a NaN.  Functions to
-compare unordered numbers are part of the FORTRAN language for a long
-time and the extensions in @w{ISO C 9X} finally introduce them as well
-for the C programming language.
-
-All of the operations are implemented as macros which allow their
-arguments to be of either @code{float}, @code{double}, or @code{long
-double} type.
-
-@comment math.h
-@comment ISO
-@deftypefn {Macro} int isgreater (@emph{real-floating} @var{x}, @emph{real-floating} @var{y})
-This macro determines whether the argument @var{x} is greater than
-@var{y}.  This is equivalent to @code{(@var{x}) > (@var{y})} but no
-exception is raised if @var{x} or @var{y} are unordered.
-@end deftypefn
-
-@comment math.h
-@comment ISO
-@deftypefn {Macro} int isgreaterequal (@emph{real-floating} @var{x}, @emph{real-floating} @var{y})
-This macro determines whether the argument @var{x} is greater than or
-equal to @var{y}.  This is equivalent to @code{(@var{x}) >= (@var{y})} but no
-exception is raised if @var{x} or @var{y} are unordered.
-@end deftypefn
-
-@comment math.h
-@comment ISO
-@deftypefn {Macro} int isless (@emph{real-floating} @var{x}, @emph{real-floating} @var{y})
-This macro determines whether the argument @var{x} is less than @var{y}.
-This is equivalent @code{(@var{x}) < (@var{y})} but no exception is raised if
-@var{x} or @var{y} are unordered.
-@end deftypefn
-
-@comment math.h
-@comment ISO
-@deftypefn {Macro} int islessequal (@emph{real-floating} @var{x}, @emph{real-floating} @var{y})
-This macro determines whether the argument @var{x} is less than or equal
-to @var{y}.  This is equivalent to @code{(@var{x}) <= (@var{y})} but no
-exception is raised if @var{x} or @var{y} are unordered.
-@end deftypefn
-
-@comment math.h
-@comment ISO
-@deftypefn {Macro} int islessgreater (@emph{real-floating} @var{x}, @emph{real-floating} @var{y})
-This macro determines whether the argument @var{x} is less or greater
-than @var{y}.  This is equivalent to @code{(@var{x}) < (@var{y}) ||
-(@var{x}) > (@var{y})} (except that @var{x} and @var{y} are only
-evaluated once) but no exception is raised if @var{x} or @var{y} are
-unordered.
-@end deftypefn
-
-@comment math.h
-@comment ISO
-@deftypefn {Macro} int isunordered (@emph{real-floating} @var{x}, @emph{real-floating} @var{y})
-This macro determines whether its arguments are unordered.
-@end deftypefn
-
-All the macros are defined in a way to ensure that both arguments are
-evaluated exactly once and so they can be used exactly like the builtin
-operators.
-
-On several platform these macros are mapped to efficient instructions
-the processor understands.  But on machines missing these functions, the
-macros above might be rather slow.  So it is best to use the builtin
-operators unless it is necessary to use unordered comparisons.
-
-@strong{Note:} There are no macros @code{isequal} or @code{isunequal}.
-These macros are not necessary since the @w{IEEE 754} standard requires
-that the comparison for equality and unequality do @emph{not} throw an
-exception if one of the arguments is an unordered value.
-
-
-@node FP Function Optimizations
-@section Is Fast Code or Small Code preferred?
-@cindex Optimization
-
-If an application uses many floating point function it is often the case
-that the costs for the function calls itselfs are not neglectable.
-Modern processor implementation often can execute the operation itself
-very fast but the call means a disturbance of the control flow.
-
-For this reason the GNU C Library provides optimizations for many of the
-frequently used math functions.  When the GNU CC is used and the user
-activates the optimizer several new inline functions and macros get
-defined.  These new functions and macros have the same names as the
-library function and so get used instead of the later.  In case of
-inline functions the compiler will decide whether it is reasonable to
-use the inline function and this decision is usually correct.
-
-For the generated code this means that no calls to the library functions
-are necessary.  This increases the speed significantly.  But the
-drawback is that the code size increases and this increase is not always
-neglectable.
-
-In cases where the inline functions and macros are not wanted the symbol
-@code{__NO_MATH_INLINES} should be defined before any system header is
-included.  This will make sure only library functions are used.  Of
-course it can be determined for each single file in the project whether
-giving this option is preferred or not.
-
+same value as @code{M_PI}.  This constant is not standard; it may have
+appeared in some old AT&T headers, and is mentioned in Stroustrup's book
+on C++.  It infringes on the user's name space, so the GNU C library
+does not define it.  Fixing programs written to expect it is simple:
+replace @code{PI} with @code{M_PI} throughout, or put @samp{-DPI=M_PI}
+on the compiler command line.
 
 @node Trig Functions
 @section Trigonometric Functions
@@ -744,10 +134,10 @@ 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 does define a symbolic constant for pi in @file{math.h}
-(@pxref{Mathematical Constants}) when BSD compliance is required
-(@pxref{Feature Test Macros}).  In case it is not possible to use this
-predefined macro one easily can define it:
+The math library normally defines @code{M_PI} to a @code{double}
+approximation of pi.  If strict ISO and/or POSIX compliance
+are requested this constant is not defined, but you can easily define it
+yourself:
 
 @smallexample
 #define M_PI 3.14159265358979323846264338327
@@ -757,7 +147,6 @@ predefined macro one easily can define it:
 You can also compute the value of pi with the expression @code{acos
 (-1.0)}.
 
-
 @comment math.h
 @comment ISO
 @deftypefun double sin (double @var{x})
@@ -784,22 +173,15 @@ radians.  The return value is in the range @code{-1} to @code{1}.
 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:
-
-@table @code
-@item ERANGE
 Mathematically, the tangent function has singularities at odd multiples
 of pi/2.  If the argument @var{x} is too close to one of these
-singularities, @code{tan} sets @code{errno} to @code{ERANGE} and returns
-either positive or negative @code{HUGE_VAL}.
-@end table
+singularities, @code{tan} will signal overflow.
 @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 which computes both values
-at the same time.
+In many applications where @code{sin} and @code{cos} are used, the sine
+and cosine of the same angle are needed at the same time.  It is more
+efficient to compute them simultaneously, so the library provides a
+function to do that.
 
 @comment math.h
 @comment GNU
@@ -811,33 +193,34 @@ 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}.
 
-This function is a GNU extension.  It should be used whenever both sine
-and cosine are needed but in portable applications there should be a
-fallback method for systems without this function.
+This function is a GNU extension.  Portable programs should be prepared
+to cope with its absence.
 @end deftypefun
 
 @cindex complex trigonometric functions
 
-The trigonometric functions are in mathematics not only defined 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.
+@w{ISO C 9x} defines variants of the trig functions which work on
+complex numbers.  The GNU C library provides these functions, but they
+are only useful if your compiler supports the new complex types defined
+by the standard.
+@c Change this when gcc is fixed. -zw
+(As of this writing GCC supports complex numbers, but there are bugs in
+the implementation.)
 
 @comment complex.h
 @comment ISO
 @deftypefun {complex double} csin (complex double @var{z})
 @deftypefunx {complex float} csinf (complex float @var{z})
 @deftypefunx {complex long double} csinl (complex long double @var{z})
-These functions return the complex sine of the complex value in @var{z}.
+These functions return the complex sine of @var{z}.
 The mathematical definition of the complex sine is
 
 @ifinfo
 @math{sin (z) = 1/(2*i) * (exp (z*i) - exp (-z*i))}.
 @end ifinfo
-@iftex
 @tex
 $$\sin(z) = {1\over 2i} (e^{zi} - e^{-zi})$$
 @end tex
-@end iftex
 @end deftypefun
 
 @comment complex.h
@@ -845,17 +228,15 @@ $$\sin(z) = {1\over 2i} (e^{zi} - e^{-zi})$$
 @deftypefun {complex double} ccos (complex double @var{z})
 @deftypefunx {complex float} ccosf (complex float @var{z})
 @deftypefunx {complex long double} ccosl (complex long double @var{z})
-These functions return the complex cosine of the complex value in @var{z}.
+These functions return the complex cosine of @var{z}.
 The mathematical definition of the complex cosine is
 
 @ifinfo
 @math{cos (z) = 1/2 * (exp (z*i) + exp (-z*i))}
 @end ifinfo
-@iftex
 @tex
 $$\cos(z) = {1\over 2} (e^{zi} + e^{-zi})$$
 @end tex
-@end iftex
 @end deftypefun
 
 @comment complex.h
@@ -863,17 +244,20 @@ $$\cos(z) = {1\over 2} (e^{zi} + e^{-zi})$$
 @deftypefun {complex double} ctan (complex double @var{z})
 @deftypefunx {complex float} ctanf (complex float @var{z})
 @deftypefunx {complex long double} ctanl (complex long double @var{z})
-These functions return the complex tangent of the complex value in @var{z}.
+These functions return the complex tangent of @var{z}.
 The mathematical definition of the complex tangent is
 
 @ifinfo
-@math{tan (z) = 1/i * (exp (z*i) - exp (-z*i)) / (exp (z*i) + exp (-z*i))}
+@math{tan (z) = -i * (exp (z*i) - exp (-z*i)) / (exp (z*i) + exp (-z*i))}
 @end ifinfo
-@iftex
 @tex
-$$\tan(z) = {1\over i} {e^{zi} - e^{-zi}\over e^{zi} + e^{-zi}}$$
+$$\tan(z) = -i \cdot {e^{zi} - e^{-zi}\over e^{zi} + e^{-zi}}$$
 @end tex
-@end iftex
+
+@noindent
+The complex tangent has poles at @math{pi/2 + 2n}, where @math{n} is an
+integer.  @code{ctan} may signal overflow if @var{z} is too close to a
+pole.
 @end deftypefun
 
 
@@ -895,9 +279,9 @@ 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).
 
-@code{asin} fails, and sets @code{errno} to @code{EDOM}, if @var{x} is
-out of range.  The arc sine function is defined mathematically only
-over the domain @code{-1} to @code{1}.
+The arc sine function is defined mathematically only
+over the domain @code{-1} to @code{1}.  If @var{x} is outside the
+domain, @code{asin} signals a domain error.
 @end deftypefun
 
 @comment math.h
@@ -910,12 +294,11 @@ 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).
 
-@code{acos} fails, and sets @code{errno} to @code{EDOM}, if @var{x} is
-out of range.  The arc cosine function is defined mathematically only
-over the domain @code{-1} to @code{1}.
+The arc cosine function is defined mathematically only
+over the domain @code{-1} to @code{1}.  If @var{x} is outside the
+domain, @code{acos} signals a domain error.
 @end deftypefun
 
-
 @comment math.h
 @comment ISO
 @deftypefun double atan (double @var{x})
@@ -924,8 +307,7 @@ over the domain @code{-1} to @code{1}.
 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}
-(inclusive).
+returned is the one between @code{-pi/2} and @code{pi/2} (inclusive).
 @end deftypefun
 
 @comment math.h
@@ -933,11 +315,10 @@ returned is the one between @code{-pi/2} and @code{pi/2}
 @deftypefun double atan2 (double @var{y}, double @var{x})
 @deftypefunx float atan2f (float @var{y}, float @var{x})
 @deftypefunx {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
-permitted to be zero.  The return value is given in radians and is in
-the range @code{-pi} to @code{pi}, inclusive.
+This function computes the arc tangent of @var{y}/@var{x}, but the signs
+of both arguments are used to determine the quadrant of the result, and
+@var{x} is permitted to be zero.  The return value is given in radians
+and is in the range @code{-pi} to @code{pi}, inclusive.
 
 If @var{x} and @var{y} are coordinates of a point in the plane,
 @code{atan2} returns the signed angle between the line from the origin
@@ -946,15 +327,12 @@ converting Cartesian coordinates to polar coordinates.  (To compute the
 radial coordinate, use @code{hypot}; see @ref{Exponents and
 Logarithms}.)
 
-The function @code{atan2} sets @code{errno} to @code{EDOM} if both
-@var{x} and @var{y} are zero; the return value is not defined in this
-case.
+@c This is experimentally true.  Should it be so? -zw
+If both @var{x} and @var{y} are zero, @code{atan2} returns zero.
 @end deftypefun
 
 @cindex inverse complex trigonometric functions
-
-The inverse trigonometric functions also exist is separate versions
-which are usable with complex numbers.
+@w{ISO C 9x} defines complex versions of the inverse trig functions.
 
 @comment complex.h
 @comment ISO
@@ -962,10 +340,10 @@ which are usable with complex numbers.
 @deftypefunx {complex float} casinf (complex float @var{z})
 @deftypefunx {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.
+value whose sine is @var{z}.  The value returned is in radians.
 
-Unlike the real version of the arc sine function @code{casin} has no
-limitation on the argument @var{z}.
+Unlike the real-valued functions, @code{casin} is defined for all
+values of @var{z}.
 @end deftypefun
 
 @comment complex.h
@@ -974,10 +352,10 @@ limitation on the argument @var{z}.
 @deftypefunx {complex float} cacosf (complex float @var{z})
 @deftypefunx {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.
+value whose cosine is @var{z}.  The value returned is in radians.
 
-Unlike the real version of the arc cosine function @code{cacos} has no
-limitation on the argument @var{z}.
+Unlike the real-valued functions, @code{cacos} is defined for all
+values of @var{z}.
 @end deftypefun
 
 
@@ -1002,11 +380,11 @@ the value whose tangent is @var{z}.  The value is in units of radians.
 @deftypefun double exp (double @var{x})
 @deftypefunx float expf (float @var{x})
 @deftypefunx {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}.
+These functions compute @code{e} (the base of natural logarithms) raised
+to the power @var{x}.
 
-The function fails, and sets @code{errno} to @code{ERANGE}, if the
-magnitude of the result is too large to be representable.
+If the magnitude of the result is too large to be representable,
+@code{exp} signals overflow.
 @end deftypefun
 
 @comment math.h
@@ -1014,11 +392,8 @@ magnitude of the result is too large to be representable.
 @deftypefun double exp2 (double @var{x})
 @deftypefunx float exp2f (float @var{x})
 @deftypefunx {long double} exp2l (long double @var{x})
-These functions return the value of @code{2} raised to the power @var{x}.
+These functions compute @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
@@ -1029,15 +404,11 @@ magnitude of the result is too large to be representable.
 @deftypefunx double pow10 (double @var{x})
 @deftypefunx float pow10f (float @var{x})
 @deftypefunx {long double} pow10l (long double @var{x})
-These functions return the value of @code{10} raised to the power @var{x}.
-Mathematically, @code{exp2 (x)} is the same as @code{exp (x * log (2))}.
+These functions compute @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.
-
-All these functions are GNU extensions.  The name @code{pow10} is used
-in some old code but the name @code{exp10} clearly is more in the sense
-of the ISO library designers and therefore should probably be preferred.
+These functions are GNU extensions.  The name @code{exp10} is
+preferred, since it is analogous to @code{exp} and @code{exp2}.
 @end deftypefun
 
 
@@ -1046,20 +417,13 @@ of the ISO library designers and therefore should probably be preferred.
 @deftypefun double log (double @var{x})
 @deftypefunx float logf (float @var{x})
 @deftypefunx {long double} logl (long double @var{x})
-These functions return the natural logarithm of @var{x}.  @code{exp (log
+These functions compute the natural logarithm of @var{x}.  @code{exp (log
 (@var{x}))} equals @var{x}, exactly in mathematics and approximately in
 C.
 
-The following @code{errno} error conditions are defined for this function:
-
-@table @code
-@item EDOM
-The argument @var{x} is negative.  The log function is defined
-mathematically to return a real result only on positive arguments.
-
-@item ERANGE
-The argument is zero.  The log of zero is not defined.
-@end table
+If @var{x} is negative, @code{log} signals a domain error.  If @var{x}
+is zero, it returns negative infinity; if @var{x} is too close to zero,
+it may signal overflow.
 @end deftypefun
 
 @comment math.h
@@ -1067,9 +431,9 @@ The argument is zero.  The log of zero is not defined.
 @deftypefun double log10 (double @var{x})
 @deftypefunx float log10f (float @var{x})
 @deftypefunx {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,
+These functions return the base-10 logarithm of @var{x}.
 @code{log10 (@var{x})} equals @code{log (@var{x}) / log (10)}.
+
 @end deftypefun
 
 @comment math.h
@@ -1077,8 +441,7 @@ different base, it is similar to the @code{log} function.  In fact,
 @deftypefun double log2 (double @var{x})
 @deftypefunx float log2f (float @var{x})
 @deftypefunx {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,
+These functions return the base-2 logarithm of @var{x}.
 @code{log2 (@var{x})} equals @code{log (@var{x}) / log (2)}.
 @end deftypefun
 
@@ -1088,12 +451,13 @@ different base, it is similar to the @code{log} function.  In fact,
 @deftypefunx float logbf (float @var{x})
 @deftypefunx {long double} logbl (long double @var{x})
 These functions extract the exponent of @var{x} and return it as a
-signed integer value.  If @var{x} is zero, a range error may occur.
+floating-point value.  If @code{FLT_RADIX} is two, @code{logb} is equal
+to @code{floor (log2 (x))}, except it's probably faster.
 
-A special case are subnormal numbers (if supported by the floating-point
-format).  The exponent returned is not the actual value from @var{x}.
-Instead the number is first normalized as if the range of the exponent
-field is large enough.
+If @var{x} is denormalized, @code{logb} returns the exponent @var{x}
+would have if it were normalized.  If @var{x} is infinity (positive or
+negative), @code{logb} returns @math{@infinity{}}.  If @var{x} is zero,
+@code{logb} returns @math{@infinity{}}.  It does not signal.
 @end deftypefun
 
 @comment math.h
@@ -1102,17 +466,34 @@ field is large enough.
 @deftypefunx int ilogbf (float @var{x})
 @deftypefunx int ilogbl (long double @var{x})
 These functions are equivalent to the corresponding @code{logb}
-functions except that the values are returned as signed integer values.
-Since integer values cannot represent infinity and NaN, there are some
-special symbols defined to help detect these situations.
-
-@vindex FP_ILOGB0
-@vindex FP_ILOGBNAN
-@code{ilogb} returns @code{FP_ILOGB0} if @var{x} is @code{0} and it
-returns @code{FP_ILOGBNAN} if @var{x} is @code{NaN}.  These values are
-system specific and no fixed value is assigned.  More concrete, these
-values might even have the same value.  So a piece of code handling the
-result of @code{ilogb} could look like this:
+functions except that they return signed integer values.
+@end deftypefun
+
+@noindent
+Since integers cannot represent infinity and NaN, @code{ilogb} instead
+returns an integer that can't be the exponent of a normal floating-point
+number.  @file{math.h} defines constants so you can check for this.
+
+@comment math.h
+@comment ISO
+@deftypevr Macro int FP_ILOGB0
+@code{ilogb} returns this value if its argument is @code{0}.  The
+numeric value is either @code{INT_MIN} or @code{-INT_MAX}.
+
+This macro is defined in @w{ISO C 9X}.
+@end deftypevr
+
+@comment math.h
+@comment ISO
+@deftypevr Macro int FP_ILOGBNAN
+@code{ilogb} returns this value if its argument is @code{NaN}.  The
+numeric value is either @code{INT_MIN} or @code{INT_MAX}.
+
+This macro is defined in @w{ISO C 9X}.
+@end deftypevr
+
+These values are system specific.  They might even be the same.  The
+proper way to test the result of @code{ilogb} is as follows:
 
 @smallexample
 i = ilogb (f);
@@ -1134,8 +515,6 @@ if (i == FP_ILOGB0 || i == FP_ILOGBNAN)
   @}
 @end smallexample
 
-@end deftypefun
-
 @comment math.h
 @comment ISO
 @deftypefun double pow (double @var{base}, double @var{power})
@@ -1144,17 +523,10 @@ if (i == FP_ILOGB0 || i == FP_ILOGBNAN)
 These are general exponentiation functions, returning @var{base} raised
 to @var{power}.
 
-@need 250
-The following @code{errno} error conditions are defined for this function:
-
-@table @code
-@item EDOM
-The argument @var{base} is negative and @var{power} is not an integral
-value.  Mathematically, the result would be a complex number in this case.
-
-@item ERANGE
-An underflow or overflow condition was detected in the result.
-@end table
+Mathematically, @code{pow} would return a complex number when @var{base}
+is negative and @var{power} is not an integral value.  @code{pow} can't
+do that, so instead it signals a domain error. @code{pow} may also
+underflow or overflow the destination type.
 @end deftypefun
 
 @cindex square root function
@@ -1165,10 +537,8 @@ An underflow or overflow condition was detected in the result.
 @deftypefunx {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})
+If @var{x} is negative, @code{sqrt} signals a domain error.
+Mathematically, it should return a complex number.
 @end deftypefun
 
 @cindex cube root function
@@ -1187,10 +557,10 @@ fail; every representable real value has a representable real cube root.
 @deftypefunx float hypotf (float @var{x}, float @var{y})
 @deftypefunx {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
+@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.)  Using this function
-instead of the direct formula is highly appreciated since the error is
+of the point (@var{x}, @var{y}) from the origin.  Using this function
+instead of the direct formula is wise, since the error is
 much smaller.  See also the function @code{cabs} in @ref{Absolute Value}.
 @end deftypefun
 
@@ -1200,7 +570,7 @@ much smaller.  See also the function @code{cabs} in @ref{Absolute Value}.
 @deftypefunx float expm1f (float @var{x})
 @deftypefunx {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
+They are computed in a way that is accurate even if @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
@@ -1210,39 +580,32 @@ to subtraction of two numbers that are nearly equal.
 @deftypefun double log1p (double @var{x})
 @deftypefunx float log1pf (float @var{x})
 @deftypefunx {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
+These functions returns a value equivalent to @w{@code{log (1 + @var{x})}}.
+They are computed in a way that is accurate even if @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 handling complex
-numbers these functions are perhaps better optimized and provide better
-error checking than a direct use of the formulas of the mathematical
-definition.
+@w{ISO C 9X} defines complex variants of some of the exponentiation and
+logarithm functions.
 
 @comment complex.h
 @comment ISO
 @deftypefun {complex double} cexp (complex double @var{z})
 @deftypefunx {complex float} cexpf (complex float @var{z})
 @deftypefunx {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}.
-
-@noindent
+These functions return @code{e} (the base of natural
+logarithms) raised to the power of @var{z}.
 Mathematically this corresponds to the value
 
 @ifinfo
 @math{exp (z) = exp (creal (z)) * (cos (cimag (z)) + I * sin (cimag (z)))}
 @end ifinfo
-@iftex
 @tex
-$$\exp(z) = e^z = e^{{\rm Re} z} (\cos ({\rm Im} z) + i \sin ({\rm Im} z))$$
+$$\exp(z) = e^z = e^{{\rm Re}\,z} (\cos ({\rm Im}\,z) + i \sin ({\rm Im}\,z))$$
 @end tex
-@end iftex
 @end deftypefun
 
 @comment complex.h
@@ -1250,21 +613,20 @@ $$\exp(z) = e^z = e^{{\rm Re} z} (\cos ({\rm Im} z) + i \sin ({\rm Im} z))$$
 @deftypefun {complex double} clog (complex double @var{z})
 @deftypefunx {complex float} clogf (complex float @var{z})
 @deftypefunx {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}.
-
-@noindent
+These functions return the natural logarithm of @var{z}.
 Mathematically this corresponds to the value
 
 @ifinfo
 @math{log (z) = log (cabs (z)) + I * carg (z)}
 @end ifinfo
-@iftex
 @tex
-$$\log(z) = \log(|z|) + i \arg(z)$$
+$$\log(z) = \log |z| + i \arg z$$
 @end tex
-@end iftex
+
+@noindent
+@code{clog} has a pole at 0, and will signal overflow if @var{z} equals
+or is very close to 0.  It is well-defined for all other values of
+@var{z}.
 @end deftypefun
 
 
@@ -1274,22 +636,16 @@ $$\log(z) = \log(|z|) + i \arg(z)$$
 @deftypefunx {complex float} clog10f (complex float @var{z})
 @deftypefunx {complex long double} clog10l (complex long double @var{z})
 These functions return the base 10 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}.
-
-@noindent
-Mathematically this corresponds to the value
+@var{z}. Mathematically this corresponds to the value
 
 @ifinfo
 @math{log (z) = log10 (cabs (z)) + I * carg (z)}
 @end ifinfo
-@iftex
 @tex
-$$\log_{10}(z) = \log_{10}(|z|) + i \arg(z)$$
+$$\log_{10}(z) = \log_{10}|z| + i \arg z$$
 @end tex
-@end iftex
 
-This function is a GNU extension.
+These functions are GNU extensions.
 @end deftypefun
 
 @comment complex.h
@@ -1297,9 +653,8 @@ This function is a GNU extension.
 @deftypefun {complex double} csqrt (complex double @var{z})
 @deftypefunx {complex float} csqrtf (complex float @var{z})
 @deftypefunx {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.
+These functions return the complex square root of the argument @var{z}.  Unlike
+the real-valued functions, they are defined for all values of @var{z}.
 @end deftypefun
 
 @comment complex.h
@@ -1307,20 +662,10 @@ the value of the argument.
 @deftypefun {complex double} cpow (complex double @var{base}, complex double @var{power})
 @deftypefunx {complex float} cpowf (complex float @var{base}, complex float @var{power})
 @deftypefunx {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
-
-@ifinfo
-@math{cpow (x, y) = cexp (y * clog (x))}
-@end ifinfo
-@iftex
-@tex
-$${\rm cpow}(x, y) = e^{y \log(x)}$$
-@end tex
-@end iftex
+These functions return @var{base} raised to the power of
+@var{power}.  This is equivalent to @w{@code{cexp (y * clog (x))}}
 @end deftypefun
 
-
 @node Hyperbolic Functions
 @section Hyperbolic Functions
 @cindex hyperbolic functions
@@ -1334,9 +679,8 @@ see @ref{Exponents and Logarithms}.
 @deftypefunx float sinhf (float @var{x})
 @deftypefunx {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.
+mathematically as @w{@code{(exp (@var{x}) - exp (-@var{x})) / 2}}.  They
+may signal overflow if @var{x} is too large.
 @end deftypefun
 
 @comment math.h
@@ -1346,8 +690,7 @@ function fails, and sets @code{errno} to @code{ERANGE}, if the value of
 @deftypefunx {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.
+They may signal overflow if @var{x} is too large.
 @end deftypefun
 
 @comment math.h
@@ -1355,16 +698,15 @@ of @var{x} is too large; that is, if overflow occurs.
 @deftypefun double tanh (double @var{x})
 @deftypefunx float tanhf (float @var{x})
 @deftypefunx {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})}}.
+These functions return the hyperbolic tangent of @var{x},
+defined mathematically as @w{@code{sinh (@var{x}) / cosh (@var{x})}}.
+They may signal overflow if @var{x} is too large.
 @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.
+There are counterparts for the hyperbolic functions which take
+complex arguments.
 
 @comment complex.h
 @comment ISO
@@ -1372,9 +714,7 @@ library are optimized for accuracy and speed.
 @deftypefunx {complex float} csinhf (complex float @var{z})
 @deftypefunx {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.
+mathematically as @w{@code{(exp (@var{z}) - exp (-@var{z})) / 2}}.
 @end deftypefun
 
 @comment complex.h
@@ -1383,9 +723,7 @@ result is too large.
 @deftypefunx {complex float} ccoshf (complex float @var{z})
 @deftypefunx {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.
+mathematically as @w{@code{(exp (@var{z}) + exp (-@var{z})) / 2}}.
 @end deftypefun
 
 @comment complex.h
@@ -1393,8 +731,8 @@ result is too large.
 @deftypefun {complex double} ctanh (complex double @var{z})
 @deftypefunx {complex float} ctanhf (complex float @var{z})
 @deftypefunx {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})}}.
+These functions return the complex hyperbolic tangent of @var{z},
+defined mathematically as @w{@code{csinh (@var{z}) / ccosh (@var{z})}}.
 @end deftypefun
 
 
@@ -1416,7 +754,7 @@ value whose hyperbolic sine is @var{x}.
 @deftypefunx {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}.
+@code{1}, @code{acosh} signals a domain error.
 @end deftypefun
 
 @comment math.h
@@ -1426,8 +764,8 @@ value whose hyperbolic cosine is @var{x}.  If @var{x} is less than
 @deftypefunx {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}.
+@var{x} is greater than @code{1}, @code{atanh} signals a domain error;
+if it is equal to 1, @code{atanh} returns infinity.
 @end deftypefun
 
 @cindex inverse complex hyperbolic functions
@@ -1448,8 +786,7 @@ These functions return the inverse complex hyperbolic sine of
 @deftypefunx {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.
+the real-valued functions, there are no restrictions on the value of @var{z}.
 @end deftypefun
 
 @comment complex.h
@@ -1459,10 +796,157 @@ of the argument.
 @deftypefunx {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.
+the real-valued functions, there are no restrictions on the value of
+@var{z}.
 @end deftypefun
 
+@node Special Functions
+@section Special Functions
+@cindex special functions
+@cindex Bessel functions
+@cindex gamma function
+
+These are some more exotic mathematical functions, which are sometimes
+useful.  Currently they only have real-valued versions.
+
+@comment math.h
+@comment SVID
+@deftypefun double erf (double @var{x})
+@deftypefunx float erff (float @var{x})
+@deftypefunx {long double} erfl (long double @var{x})
+@code{erf} returns the error function of @var{x}.  The error
+function is defined as
+@tex
+$$\hbox{erf}(x) = {2\over\sqrt{\pi}}\cdot\int_0^x e^{-t^2} \hbox{d}t$$
+@end tex
+@ifnottex
+@smallexample
+erf (x) = 2/sqrt(pi) * integral from 0 to x of exp(-t^2) dt
+@end smallexample
+@end ifnottex
+@end deftypefun
+
+@comment math.h
+@comment SVID
+@deftypefun double erfc (double @var{x})
+@deftypefunx float erfcf (float @var{x})
+@deftypefunx {long double} erfcl (long double @var{x})
+@code{erfc} returns @code{1.0 - erf(@var{x})}, but computed in a
+fashion that avoids round-off error when @var{x} is large.
+@end deftypefun
+
+@comment math.h
+@comment SVID
+@deftypefun double lgamma (double @var{x})
+@deftypefunx float lgammaf (float @var{x})
+@deftypefunx {long double} lgammal (long double @var{x})
+@code{lgamma} returns the natural logarithm of the absolute value of
+the gamma function of @var{x}.  The gamma function is defined as
+@tex
+$$\Gamma(x) = \int_0^\infty t^{x-1} e^{-t} \hbox{d}t$$
+@end tex
+@ifnottex
+@smallexample
+gamma (x) = integral from 0 to @infinity{} of t^(x-1) e^-t dt
+@end smallexample
+@end ifnottex
+
+@vindex signgam
+The sign of the gamma function is stored in the global variable
+@var{signgam}, which is declared in @file{math.h}.  It is @code{1} if
+the intermediate result was positive or zero, and, @code{-1} if it was
+negative.
+
+You can compute the actual gamma function as follows:
+@smallexample
+lgam = lgamma(x);
+gam  = signgam*exp(lgam);
+@end smallexample
+
+The gamma function has singularities at the nonpositive integers.
+@code{lgamma} will raise the zero divide exception if evaluated at a
+singularity.
+@end deftypefun
+
+@comment math.h
+@comment XPG
+@deftypefun double lgamma_r (double @var{x})
+@deftypefunx float lgammaf_r (float @var{x})
+@deftypefunx {long double} lgammal_r (long double @var{x})
+@code{lgamma_r} is just like @code{lgamma}, but it stores the sign of
+the intermediate result in the variable pointed to by @var{signp}
+instead of in the @var{signgam} global.
+@end deftypefun
+
+@ignore
+@comment math.h
+@comment SVID
+@deftypefun double gamma (double @var{x})
+@deftypefunx float gammaf (float @var{x})
+@deftypefunx {long double} gammal (long double @var{x})
+??? _not_ exp(lgamma())*signgam - historical?
+@end deftypefun
+@end ignore
+
+@comment math.h
+@comment SVID
+@deftypefun double j0 (double @var{x})
+@deftypefunx float j0f (float @var{x})
+@deftypefunx {long double} j0l (long double @var{x})
+@code{j0} returns the Bessel function of the first kind of order 0 of
+@var{x}.  It may signal underflow if @var{x} is too large.
+@end deftypefun
+
+@comment math.h
+@comment SVID
+@deftypefun double j1 (double @var{x})
+@deftypefunx float j1f (float @var{x})
+@deftypefunx {long double} j1l (long double @var{x})
+@code{j1} returns the Bessel function of the first kind of order 1 of
+@var{x}.  It may signal underflow if @var{x} is too large.
+@end deftypefun
+
+@comment math.h
+@comment SVID
+@deftypefun double jn (int n, double @var{x})
+@deftypefunx float jnf (int n, float @var{x})
+@deftypefunx {long double} jnl (int n, long double @var{x})
+@code{jn} returns the Bessel function of the first kind of order
+@var{n} of @var{x}.  It may signal underflow if @var{x} is too large.
+@end deftypefun
+
+@comment math.h
+@comment SVID
+@deftypefun double y0 (double @var{x})
+@deftypefunx float y0f (float @var{x})
+@deftypefunx {long double} y0l (long double @var{x})
+@code{y0} returns the Bessel function of the second kind of order 0 of
+@var{x}.  It may signal underflow if @var{x} is too large.  If @var{x}
+is negative, @code{y0} signals a domain error; if it is zero,
+@code{y0} signals overflow and returns @math{-@infinity}.
+@end deftypefun
+
+@comment math.h
+@comment SVID
+@deftypefun double y1 (double @var{x})
+@deftypefunx float y1f (float @var{x})
+@deftypefunx {long double} y1l (long double @var{x})
+@code{y1} returns the Bessel function of the second kind of order 1 of
+@var{x}.  It may signal underflow if @var{x} is too large.  If @var{x}
+is negative, @code{y1} signals a domain error; if it is zero,
+@code{y1} signals overflow and returns @math{-@infinity}.
+@end deftypefun
+
+@comment math.h
+@comment SVID
+@deftypefun double yn (int n, double @var{x})
+@deftypefunx float ynf (int n, float @var{x})
+@deftypefunx {long double} ynl (int n, long double @var{x})
+@code{yn} returns the Bessel function of the second kind of order @var{n} of
+@var{x}.  It may signal underflow if @var{x} is too large.  If @var{x}
+is negative, @code{yn} signals a domain error; if it is zero,
+@code{yn} signals overflow and returns @math{-@infinity}.
+@end deftypefun
 
 @node Pseudo-Random Numbers
 @section Pseudo-Random Numbers
@@ -1472,19 +956,19 @@ of the argument.
 
 This section describes the GNU facilities for generating a series of
 pseudo-random numbers.  The numbers generated are not truly random;
-typically, they form a sequence that repeats periodically, with a
-period so large that you can ignore it for ordinary purposes.  The
-random number generator works by remembering at all times a @dfn{seed}
-value which it uses to compute the next random number and also to
-compute a new seed.
+typically, they form a sequence that repeats periodically, with a period
+so large that you can ignore it for ordinary purposes.  The random
+number generator works by remembering a @dfn{seed} value which it uses
+to compute the next random number and also to compute a new seed.
 
 Although the generated numbers look unpredictable within one run of a
 program, the sequence of numbers is @emph{exactly the same} from one run
 to the next.  This is because the initial seed is always the same.  This
 is convenient when you are debugging a program, but it is unhelpful if
-you want the program to behave unpredictably.  If you want truly random
-numbers, not just pseudo-random, specify a seed based on the current
-time.
+you want the program to behave unpredictably.  If you want a different
+pseudo-random series each time your program runs, you must specify a
+different seed each time.  For ordinary purposes, basing the seed on the
+current time works well.
 
 You can get repeatable sequences of numbers on a particular machine type
 by specifying the same initial seed value for the random number
@@ -1493,19 +977,20 @@ the same seed, used in different C libraries or on different CPU types,
 will give you different random numbers.
 
 The GNU library supports the standard @w{ISO C} random number functions
-plus two other sets derived from BSD and SVID.  We recommend you use the
-standard ones, @code{rand} and @code{srand} if only a small number of
-random bits are required.  The SVID functions provide an interface which
-allows better random number generator algorithms and they return up to
-48 random bits in one calls and they also return random floating-point
-numbers if wanted.  The SVID function might not be available on some BSD
-derived systems but since they are required in the XPG they are
-available on all Unix-conformant systems.
+plus two other sets derived from BSD and SVID.  The BSD and @w{ISO C}
+functions provide identical, somewhat limited functionality.  If only a
+small number of random bits are required, we recommend you use the
+@w{ISO C} interface, @code{rand} and @code{srand}.  The SVID functions
+provide a more flexible interface, which allows better random number
+generator algorithms, provides more random bits (up to 48) per call, and
+can provide random floating-point numbers.  These functions are required
+by the XPG standard and therefore will be present in all modern Unix
+systems.
 
 @menu
-* ISO Random::       @code{rand} and friends.
-* BSD Random::       @code{random} and friends.
-* SVID Random::      @code{drand48} and friends.
+* ISO Random::                  @code{rand} and friends.
+* BSD Random::                  @code{random} and friends.
+* SVID Random::                 @code{drand48} and friends.
 @end menu
 
 @node ISO Random
@@ -1521,18 +1006,17 @@ To use these facilities, you should include the header file
 @comment stdlib.h
 @comment ISO
 @deftypevr Macro int RAND_MAX
-The value of this macro is an integer constant expression that
-represents the maximum possible value returned by the @code{rand}
-function.  In the GNU library, it is @code{037777777}, which is the
-largest signed integer representable in 32 bits.  In other libraries, it
-may be as low as @code{32767}.
+The value of this macro is an integer constant representing the largest
+value the @code{rand} function can return.  In the GNU library, it is
+@code{2147483647}, which is the largest signed integer representable in
+32 bits.  In other libraries, it may be as low as @code{32767}.
 @end deftypevr
 
 @comment stdlib.h
 @comment ISO
 @deftypefun int rand (void)
 The @code{rand} function returns the next pseudo-random number in the
-series.  The value is in the range from @code{0} to @code{RAND_MAX}.
+series.  The value ranges from @code{0} to @code{RAND_MAX}.
 @end deftypefun
 
 @comment stdlib.h
@@ -1543,31 +1027,27 @@ pseudo-random numbers.  If you call @code{rand} before a seed has been
 established with @code{srand}, it uses the value @code{1} as a default
 seed.
 
-To produce truly random numbers (not just pseudo-random), do @code{srand
-(time (0))}.
+To produce a different pseudo-random series each time your program is
+run, do @code{srand (time (0))}.
 @end deftypefun
 
-A completely broken interface was designed by the POSIX.1 committee to
-support reproducible random numbers in multi-threaded programs.
+POSIX.1 extended the C standard functions to support reproducible random
+numbers in multi-threaded programs.  However, the extension is badly
+designed and unsuitable for serious work.
 
 @comment stdlib.h
 @comment POSIX.1
 @deftypefun int rand_r (unsigned int *@var{seed})
 This function returns a random number in the range 0 to @code{RAND_MAX}
-just as @code{rand} does.  But this function does not keep an internal
-state for the RNG.  Instead the @code{unsigned int} variable pointed to
-by the argument @var{seed} is the only state.  Before the value is
-returned the state will be updated so that the next call will return a
-new number.
-
-I.e., the state of the RNG can only have as much bits as the type
-@code{unsigned int} has.  This is far too few to provide a good RNG.
-This interface is broken by design.
+just as @code{rand} does.  However, all its state is stored in the
+@var{seed} argument.  This means the RNG's state can only have as many
+bits as the type @code{unsigned int} has.  This is far too few to
+provide a good RNG.
 
-If the program requires reproducible random numbers in multi-threaded
-programs the reentrant SVID functions are probably a better choice.  But
-these functions are GNU extensions and therefore @code{rand_r}, as being
-standardized in POSIX.1, should always be kept as a default method.
+If your program requires a reentrant RNG, we recommend you use the
+reentrant GNU extensions to the SVID random number generator.  The
+POSIX.1 interface should only be used when the GNU extensions are not
+available.
 @end deftypefun
 
 
@@ -1585,24 +1065,24 @@ The prototypes for these functions are in @file{stdlib.h}.
 @comment BSD
 @deftypefun {int32_t} random (void)
 This function returns the next pseudo-random number in the sequence.
-The range of values returned is from @code{0} to @code{RAND_MAX}.
+The value returned ranges from @code{0} to @code{RAND_MAX}.
 
-@strong{Please note:} Historically this function returned a @code{long
-int} value.  But with the appearance of 64bit machines this could lead
-to severe compatibility problems and therefore the type now explicitly
-limits the return value to 32bit.
+@strong{Note:} Historically this function returned a @code{long
+int} value.  On 64bit systems @code{long int} would have been larger
+than programs expected, so @code{random} is now defined to return
+exactly 32 bits.
 @end deftypefun
 
 @comment stdlib.h
 @comment BSD
 @deftypefun void srandom (unsigned int @var{seed})
-The @code{srandom} function sets the seed for the current random number
-state based on the integer @var{seed}.  If you supply a @var{seed} value
+The @code{srandom} function sets the state of the random number
+generator based on the integer @var{seed}.  If you supply a @var{seed} value
 of @code{1}, this will cause @code{random} to reproduce the default set
 of random numbers.
 
-To produce truly random numbers (not just pseudo-random), do
-@code{srandom (time (0))}.
+To produce a different set of pseudo-random numbers each time your
+program runs, do @code{srandom (time (0))}.
 @end deftypefun
 
 @comment stdlib.h
@@ -1610,9 +1090,9 @@ To produce truly random numbers (not just pseudo-random), do
 @deftypefun {void *} initstate (unsigned int @var{seed}, void *@var{state}, size_t @var{size})
 The @code{initstate} function is used to initialize the random number
 generator state.  The argument @var{state} is an array of @var{size}
-bytes, used to hold the state information.  The size must be at least 8
-bytes, and optimal sizes are 8, 16, 32, 64, 128, and 256.  The bigger
-the @var{state} array, the better.
+bytes, used to hold the state information.  It is initialized based on
+@var{seed}.  The size must be between 8 and 256 bytes, and should be a
+power of two.  The bigger the @var{state} array, the better.
 
 The return value is the previous value of the state information array.
 You can use this value later as an argument to @code{setstate} to
@@ -1631,13 +1111,12 @@ You can use this 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
+choose among a collection of functions which return the random bits
 in different forms.
 
 Generally there are two kinds of functions: those which use a state of
@@ -1973,3 +1452,37 @@ 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
+
+@node FP Function Optimizations
+@section Is Fast Code or Small Code preferred?
+@cindex Optimization
+
+If an application uses many floating point function it is often the case
+that the costs for the function calls itselfs are not neglectable.
+Modern processor implementation often can execute the operation itself
+very fast but the call means a disturbance of the control flow.
+
+For this reason the GNU C Library provides optimizations for many of the
+frequently used math functions.  When the GNU CC is used and the user
+activates the optimizer several new inline functions and macros get
+defined.  These new functions and macros have the same names as the
+library function and so get used instead of the later.  In case of
+inline functions the compiler will decide whether it is reasonable to
+use the inline function and this decision is usually correct.
+
+For the generated code this means that no calls to the library functions
+are necessary.  This increases the speed significantly.  But the
+drawback is that the code size increases and this increase is not always
+neglectable.
+
+In cases where the inline functions and macros are not wanted the symbol
+@code{__NO_MATH_INLINES} should be defined before any system header is
+included.  This will make sure only library functions are used.  Of
+course it can be determined for each single file in the project whether
+giving this option is preferred or not.
+
+Not all hardware implements the entire @w{IEEE 754} standard, or if it
+does, there may be a substantial performance penalty for using some of
+its features.  For example, enabling traps on some processors forces
+the FPU to run unpipelined, which more than doubles calculation time.
+@c ***Add explanation of -lieee, -mieee.
diff --git a/manual/mbyte.texi b/manual/mbyte.texi
index 4ff9a1b974..8f3c1924fa 100644
--- a/manual/mbyte.texi
+++ b/manual/mbyte.texi
@@ -1,4 +1,5 @@
 @node Extended Characters, Locales, String and Array Utilities, Top
+@c %MENU% Support for extended character sets
 @chapter Extended Characters
 
 A number of languages use character sets that are larger than the range
diff --git a/manual/memory.texi b/manual/memory.texi
index 49c2fdac2a..b87bc3f160 100644
--- a/manual/memory.texi
+++ b/manual/memory.texi
@@ -3,6 +3,7 @@
 
 @node Memory Allocation, Character Handling, Error Reporting, Top
 @chapter Memory Allocation
+@c %MENU% Allocating memory dynamically and manipulating it via pointers
 @cindex memory allocation
 @cindex storage allocation
 
diff --git a/manual/message.texi b/manual/message.texi
index fb6126215a..c0ab28161c 100644
--- a/manual/message.texi
+++ b/manual/message.texi
@@ -1,4 +1,5 @@
-@node Message Translation
+@node Message Translation, Searching and Sorting, Locales, Top
+@c %MENU% How to make the program speak the user's language
 @chapter Message Translation
 
 The program's interface with the human should be designed in a way to
diff --git a/manual/nss.texi b/manual/nss.texi
index a5dd635fd5..f6293c0a2f 100644
--- a/manual/nss.texi
+++ b/manual/nss.texi
@@ -1,11 +1,10 @@
-@c each section should have index entries corresponding to the section title
-
-@node Name Service Switch
+@node Name Service Switch, Users and Groups, Job Control, Top
 @chapter System Databases and Name Service Switch
-
+@c %MENU% Accessing system databases
 @cindex Name Service Switch
 @cindex NSS
 @cindex databases
+
 Various functions in the C Library need to be configured to work
 correctly in the local environment.  Traditionally, this was done by
 using files (e.g., @file{/etc/passwd}), but other nameservices (like the
diff --git a/manual/pattern.texi b/manual/pattern.texi
index 90529bace6..24e8e4c612 100644
--- a/manual/pattern.texi
+++ b/manual/pattern.texi
@@ -1,4 +1,5 @@
 @node Pattern Matching, I/O Overview, Searching and Sorting, Top
+@c %MENU% Matching shell ``globs'' and regular expressions
 @chapter Pattern Matching
 
 The GNU C Library provides pattern matching facilities for two kinds of
diff --git a/manual/pipe.texi b/manual/pipe.texi
index 274b93d427..9050ec8cba 100644
--- a/manual/pipe.texi
+++ b/manual/pipe.texi
@@ -1,4 +1,5 @@
 @node Pipes and FIFOs, Sockets, File System Interface, Top
+@c %MENU% A simple interprocess communication mechanism
 @chapter Pipes and FIFOs
 
 @cindex pipe
diff --git a/manual/process.texi b/manual/process.texi
index e10534212c..46aeff6009 100644
--- a/manual/process.texi
+++ b/manual/process.texi
@@ -1,4 +1,5 @@
-@node Processes
+@node Processes, Job Control, Process Startup, Top
+@c %MENU% How to create processes and run other programs
 @chapter Processes
 
 @cindex process
diff --git a/manual/search.texi b/manual/search.texi
index 013c584914..ae6d5ef409 100644
--- a/manual/search.texi
+++ b/manual/search.texi
@@ -1,4 +1,5 @@
 @node Searching and Sorting, Pattern Matching, Message Translation, Top
+@c %MENU% General searching and sorting functions
 @chapter Searching and Sorting
 
 This chapter describes functions for searching and sorting arrays of
diff --git a/manual/setjmp.texi b/manual/setjmp.texi
index b8e7a45d8f..6e3408c8c1 100644
--- a/manual/setjmp.texi
+++ b/manual/setjmp.texi
@@ -1,4 +1,5 @@
 @node Non-Local Exits, Signal Handling, Date and Time, Top
+@c %MENU% Jumping out of nested function calls
 @chapter Non-Local Exits
 @cindex non-local exits
 @cindex long jumps
diff --git a/manual/signal.texi b/manual/signal.texi
index fc05d222c8..029485c8e0 100644
--- a/manual/signal.texi
+++ b/manual/signal.texi
@@ -1,4 +1,5 @@
 @node Signal Handling, Process Startup, Non-Local Exits, Top
+@c %MENU% How to send, block, and handle signals
 @chapter Signal Handling
 
 @cindex signal
diff --git a/manual/socket.texi b/manual/socket.texi
index 8ac5fa5b84..4de5b9cd56 100644
--- a/manual/socket.texi
+++ b/manual/socket.texi
@@ -1,4 +1,5 @@
 @node Sockets, Low-Level Terminal Interface, Pipes and FIFOs, Top
+@c %MENU% A more complicated IPC mechanism, with networking support
 @chapter Sockets
 
 This chapter describes the GNU facilities for interprocess
diff --git a/manual/startup.texi b/manual/startup.texi
index 2a55e3934e..dd21c89e6f 100644
--- a/manual/startup.texi
+++ b/manual/startup.texi
@@ -1,4 +1,5 @@
-@node Process Startup
+@node Process Startup, Processes, Signal Handling, Top
+@c %MENU% Writing the beginning and end of your program
 @chapter Process Startup and Termination
 
 @cindex process
diff --git a/manual/stdio.texi b/manual/stdio.texi
index 4d054c02ef..c930471220 100644
--- a/manual/stdio.texi
+++ b/manual/stdio.texi
@@ -1,4 +1,5 @@
 @node I/O on Streams, Low-Level I/O, I/O Overview, Top
+@c %MENU% Hign-level, portable I/O facilities
 @chapter Input/Output on Streams
 @c fix an overfull:
 @tex
diff --git a/manual/string.texi b/manual/string.texi
index dd3c68d294..2bbc238bed 100644
--- a/manual/string.texi
+++ b/manual/string.texi
@@ -1,4 +1,5 @@
 @node String and Array Utilities, Extended Characters, Character Handling, Top
+@c %MENU% Utilities for copying and comparing strings and arrays
 @chapter String and Array Utilities
 
 Operations on strings (or arrays of characters) are an important part of
diff --git a/manual/sysinfo.texi b/manual/sysinfo.texi
index f35aa8b0c6..5f599c44e5 100644
--- a/manual/sysinfo.texi
+++ b/manual/sysinfo.texi
@@ -1,4 +1,5 @@
 @node System Information, System Configuration, Users and Groups, Top
+@c %MENU% Getting information about the hardware and operating system
 @chapter System Information
 
 This chapter describes functions that return information about the
diff --git a/manual/terminal.texi b/manual/terminal.texi
index 217cfc5053..85600b0190 100644
--- a/manual/terminal.texi
+++ b/manual/terminal.texi
@@ -1,4 +1,5 @@
-@node Low-Level Terminal Interface
+@node Low-Level Terminal Interface, Mathematics, Sockets, Top
+@c %MENU% How to change the characteristics of a terminal device
 @chapter Low-Level Terminal Interface
 
 This chapter describes functions that are specific to terminal devices.
diff --git a/manual/texis b/manual/texis
new file mode 100644
index 0000000000..4459561a61
--- /dev/null
+++ b/manual/texis
@@ -0,0 +1,78 @@
+texis = \
+intro.texi \
+creature.texi \
+errno.texi \
+memory.texi \
+ctype.texi \
+string.texi \
+stpcpy.c.texi \
+strdupa.c.texi \
+strncat.c.texi \
+mbyte.texi \
+locale.texi \
+message.texi \
+search.texi \
+search.c.texi \
+pattern.texi \
+io.texi \
+stdio.texi \
+rprintf.c.texi \
+memopen.c.texi \
+memstrm.c.texi \
+fmtmsgexpl.c.texi \
+llio.texi \
+select.c.texi \
+filesys.texi \
+dir.c.texi \
+dir2.c.texi \
+pipe.texi \
+pipe.c.texi \
+popen.c.texi \
+socket.texi \
+mkfsock.c.texi \
+mkisock.c.texi \
+isockad.c.texi \
+inetcli.c.texi \
+inetsrv.c.texi \
+filesrv.c.texi \
+filecli.c.texi \
+terminal.texi \
+termios.c.texi \
+math.texi \
+arith.texi \
+time.texi \
+strftim.c.texi \
+setjmp.texi \
+setjmp.c.texi \
+signal.texi \
+sigh1.c.texi \
+sigusr.c.texi \
+startup.texi \
+getopt.texi \
+testopt.c.texi \
+longopt.c.texi \
+argp.texi \
+argp-ex1.c.texi \
+argp-ex2.c.texi \
+argp-ex3.c.texi \
+argp-ex4.c.texi \
+subopt.c.texi \
+atexit.c.texi \
+process.texi \
+job.texi \
+nss.texi \
+nsswitch.texi \
+users.texi \
+db.c.texi \
+sysinfo.texi \
+conf.texi \
+../linuxthreads/linuxthreads.texi \
+lang.texi \
+add.c.texi \
+header.texi \
+summary.texi \
+install.texi \
+maint.texi \
+contrib.texi \
+lgpl.texinfo \
+
diff --git a/manual/texis.awk b/manual/texis.awk
new file mode 100644
index 0000000000..a2a8dbfe09
--- /dev/null
+++ b/manual/texis.awk
@@ -0,0 +1,21 @@
+BEGIN {
+    print "texis = \\";
+    for(x = 1; x < ARGC; x++)
+    {
+	input[0] = ARGV[x];
+	print ARGV[x], "\\";
+	for (s = 0; s >= 0; s--)
+	{
+	    while ((getline < input[s]) > 0)
+	    {
+		if ($1 == "@include") 
+		{
+		    input[++s] = $2;
+		    print $2, "\\";
+		}
+	    }
+	    close(input[stackptr]);
+	}
+    }
+    print "";
+}
diff --git a/manual/time.texi b/manual/time.texi
index 540bca1632..09c3a9fd2e 100644
--- a/manual/time.texi
+++ b/manual/time.texi
@@ -1,4 +1,5 @@
 @node Date and Time, Non-Local Exits, Arithmetic, Top
+@c %MENU% Functions for getting the date and time and formatting them nicely
 @chapter Date and Time
 
 This chapter describes functions for manipulating dates and times,
diff --git a/manual/top-menu.texi b/manual/top-menu.texi
new file mode 100644
index 0000000000..2ad64aeec1
--- /dev/null
+++ b/manual/top-menu.texi
@@ -0,0 +1,499 @@
+@menu
+* Introduction::                 Purpose of the GNU C Library.
+* Error Reporting::              How library functions report errors.
+* Memory Allocation::            Allocating memory dynamically and
+                                   manipulating it via pointers.
+* Character Handling::           Character testing and conversion functions.
+* String and Array Utilities::   Utilities for copying and comparing strings
+                                   and arrays.
+* Extended Characters::          Support for extended character sets.
+* Locales::                      The country and language can affect the
+                                   behavior of library functions.
+* Message Translation::          How to make the program speak the user's
+                                   language.
+* Searching and Sorting::        General searching and sorting functions.
+* Pattern Matching::             Matching shell ``globs'' and regular
+                                   expressions.
+* I/O Overview::                 Introduction to the I/O facilities.
+* I/O on Streams::               Hign-level, portable I/O facilities.
+* Low-Level I/O::                Low-level, less portable I/O.
+* File System Interface::        Functions for manipulating files.
+* Pipes and FIFOs::              A simple interprocess communication
+                                   mechanism.
+* Sockets::                      A more complicated IPC mechanism, with
+                                   networking support.
+* Low-Level Terminal Interface:: How to change the characteristics of a
+                                   terminal device.
+* Mathematics::                  Math functions, useful constants, random
+                                   numbers.
+* Arithmetic::                   Low level arithmetic functions.
+* Date and Time::                Functions for getting the date and time and
+                                   formatting them nicely.
+* Non-Local Exits::              Jumping out of nested function calls.
+* Signal Handling::              How to send, block, and handle signals.
+* Process Startup::              Writing the beginning and end of your
+                                   program.
+* Processes::                    How to create processes and run other
+                                   programs.
+* Job Control::                  All about process groups and sessions.
+* Name Service Switch::          Accessing system databases.
+* Users and Groups::             How users are identified and classified.
+* System Information::           Getting information about the hardware and
+                                   operating system.
+* System Configuration::         Parameters describing operating system
+                                   limits.
+
+Add-ons
+
+* POSIX Threads::                The standard threads library.
+
+Appendices
+
+* Language Features::            C language features provided by the library.
+* Library Summary::              A summary showing the syntax, header file,
+                                   and derivation of each library feature.
+* Installation::                 How to install the GNU C library.
+* Maintenance::                  How to enhance and port the GNU C Library.
+* Contributors::                 Who wrote what parts of the GNU C library.
+* Copying::                      The GNU Library General Public License says
+                                  how you can copy and share the GNU C Library.
+
+Indices
+
+* Concept Index::                Index of concepts and names.
+* Type Index::                   Index of types and type qualifiers.
+* Function Index::               Index of functions and function-like macros.
+* Variable Index::               Index of variables and variable-like macros.
+* File Index::                   Index of programs and files.
+
+ --- The Detailed Node Listing ---
+
+Introduction
+
+* Getting Started::             What this manual is for and how to use it.
+* Standards and Portability::   Standards and sources upon which the GNU
+                                 C library is based.
+* Using the Library::           Some practical uses for the library.
+* Roadmap to the Manual::       Overview of the remaining chapters in
+                                 this manual.
+
+Error Reporting
+
+* Checking for Errors::         How errors are reported by library functions.
+* Error Codes::                 Error code macros; all of these expand
+                                 into integer constant values.
+* Error Messages::              Mapping error codes onto error messages.
+
+Memory Allocation
+
+* Memory Concepts::             An introduction to concepts and terminology.
+* Dynamic Allocation and C::    How to get different kinds of allocation in C.
+* Unconstrained Allocation::    The @code{malloc} facility allows fully general
+		 		 dynamic allocation.
+* Allocation Debugging::        Finding memory leaks and not freed memory.
+* Obstacks::                    Obstacks are less general than malloc
+				 but more efficient and convenient.
+* Variable Size Automatic::     Allocation of variable-sized blocks
+				 of automatic storage that are freed when the
+				 calling function returns.
+* Relocating Allocator::        Waste less memory, if you can tolerate
+				 automatic relocation of the blocks you get.
+
+Character Handling
+
+* Classification of Characters::   Testing whether characters are
+			            letters, digits, punctuation, etc.
+
+* Case Conversion::                Case mapping, and the like.
+
+String and Array Utilities
+
+* Representation of Strings::   Introduction to basic concepts.
+* String/Array Conventions::    Whether to use a string function or an
+				 arbitrary array function.
+* String Length::               Determining the length of a string.
+* Copying and Concatenation::   Functions to copy the contents of strings
+				 and arrays.
+* String/Array Comparison::     Functions for byte-wise and character-wise
+				 comparison.
+* Collation Functions::         Functions for collating strings.
+* 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.
+* Argz and Envz Vectors::       Null-separated string vectors.
+
+Extended Characters
+
+* Extended Char Intro::         Multibyte codes versus wide characters.
+* Locales and Extended Chars::  The locale selects the character codes.
+* Multibyte Char Intro::        How multibyte codes are represented.
+* Wide Char Intro::             How wide characters are represented.
+* Wide String Conversion::      Converting wide strings to multibyte code
+                                 and vice versa.
+* Length of Char::              how many bytes make up one multibyte char.
+* Converting One Char::         Converting a string character by character.
+* Example of Conversion::       Example showing why converting
+				 one character at a time may be useful.
+* Shift State::                 Multibyte codes with "shift characters".
+
+Locales
+
+* Effects of Locale::           Actions affected by the choice of
+                                 locale.
+* Choosing Locale::             How the user specifies a locale.
+* Locale Categories::           Different purposes for which you can
+                                 select a locale.
+* Setting the Locale::          How a program specifies the locale
+                                 with library functions.
+* Standard Locales::            Locale names available on all systems.
+* Numeric Formatting::          How to format numbers according to the
+                                 chosen locale.
+
+Message Translation
+
+* Message catalogs a la X/Open::  The @code{catgets} family of functions.
+* The Uniforum approach::         The @code{gettext} family of functions.
+
+Searching and Sorting
+
+* Comparison Functions::        Defining how to compare two objects.
+				 Since the sort and search facilities
+                                 are general, you have to specify the
+                                 ordering.
+* Array Search Function::       The @code{bsearch} function.
+* Array Sort Function::         The @code{qsort} function.
+* Search/Sort Example::         An example program.
+* Hash Search Function::        The @code{hsearch} function.
+* Tree Search Function::        The @code{tsearch} function.
+
+Pattern Matching
+
+* Wildcard Matching::    Matching a wildcard pattern against a single string.
+* Globbing::             Finding the files that match a wildcard pattern.
+* Regular Expressions::  Matching regular expressions against strings.
+* Word Expansion::       Expanding shell variables, nested commands,
+			    arithmetic, and wildcards.
+			    This is what the shell does with shell commands.
+
+I/O Overview
+
+* I/O Concepts::       Some basic information and terminology.
+* File Names::         How to refer to a file.
+
+I/O on Streams
+
+* Streams::                     About the data type representing a stream.
+* Standard Streams::            Streams to the standard input and output
+                                 devices are created for you.
+* Opening Streams::             How to create a stream to talk to a file.
+* Closing Streams::             Close a stream when you are finished with it.
+* Simple Output::               Unformatted output by characters and lines.
+* Character Input::             Unformatted input by characters and words.
+* Line Input::                  Reading a line or a record from a stream.
+* Unreading::                   Peeking ahead/pushing back input just read.
+* Block Input/Output::          Input and output operations on blocks of data.
+* Formatted Output::            @code{printf} and related functions.
+* Customizing Printf::          You can define new conversion specifiers for
+                                 @code{printf} and friends.
+* Formatted Input::             @code{scanf} and related functions.
+* EOF and Errors::              How you can tell if an I/O error happens.
+* Binary Streams::              Some systems distinguish between text files
+                                 and binary files.
+* File Positioning::            About random-access streams.
+* Portable Positioning::        Random access on peculiar ISO C systems.
+* Stream Buffering::            How to control buffering of streams.
+* Other Kinds of Streams::      Streams that do not necessarily correspond
+                                 to an open file.
+* Formatted Messages::          Print strictly formatted messages.
+
+Low-Level I/O
+
+* Opening and Closing Files::           How to open and close file
+                                         descriptors.
+* Truncating Files::                    Change the size of a file.
+* I/O Primitives::                      Reading and writing data.
+* File Position Primitive::             Setting a descriptor's file
+                                         position.
+* Descriptors and Streams::             Converting descriptor to stream
+                                         or vice-versa.
+* Stream/Descriptor Precautions::       Precautions needed if you use both
+                                         descriptors and streams.
+* Waiting for I/O::                     How to check for input or output
+					 on multiple file descriptors.
+* Synchronizing I/O::                   Making sure all I/O actions completed.
+* Asynchronous I/O::                    Perform I/O in parallel.
+* Control Operations::                  Various other operations on file
+					 descriptors.
+* Duplicating Descriptors::             Fcntl commands for duplicating
+                                         file descriptors.
+* Descriptor Flags::                    Fcntl commands for manipulating
+                                         flags associated with file
+                                         descriptors.
+* File Status Flags::                   Fcntl commands for manipulating
+                                         flags associated with open files.
+* File Locks::                          Fcntl commands for implementing
+                                         file locking.
+* Interrupt Input::                     Getting an asynchronous signal when
+                                         input arrives.
+
+File System Interface
+
+* Working Directory::           This is used to resolve relative
+				 file names.
+* Accessing Directories::       Finding out what files a directory
+				 contains.
+* Working on Directory Trees::  Apply actions to all files or a selectable
+                                 subset of a directory hierarchy.
+* Hard Links::                  Adding alternate names to a file.
+* Symbolic Links::              A file that ``points to'' a file name.
+* Deleting Files::              How to delete a file, and what that means.
+* Renaming Files::              Changing a file's name.
+* Creating Directories::        A system call just for creating a directory.
+* File Attributes::             Attributes of individual files.
+* Making Special Files::        How to create special files.
+* Temporary Files::             Naming and creating temporary files.
+
+Pipes and FIFOs
+
+* Creating a Pipe::             Making a pipe with the @code{pipe} function.
+* Pipe to a Subprocess::        Using a pipe to communicate with a
+				 child process.
+* FIFO Special Files::          Making a FIFO special file.
+* Pipe Atomicity::		When pipe (or FIFO) I/O is atomic.
+
+Sockets
+
+* Socket Concepts::	Basic concepts you need to know about.
+* Communication Styles::Stream communication, datagrams, and other styles.
+* Socket Addresses::	How socket names (``addresses'') work.
+* Interface Naming::	Identifying specific network interfaces.
+* Local Namespace::	Details about the local namespace.
+* Internet Namespace::	Details about the Internet namespace.
+* Misc Namespaces::	Other namespaces not documented fully here.
+* Open/Close Sockets::  Creating sockets and destroying them.
+* Connections::		Operations on sockets with connection state.
+* Datagrams::		Operations on datagram sockets.
+* Inetd::		Inetd is a daemon that starts servers on request.
+			   The most convenient way to write a server
+			   is to make it work with Inetd.
+* Socket Options::	Miscellaneous low-level socket options.
+* Networks Database::   Accessing the database of network names.
+
+Low-Level Terminal Interface
+
+* Is It a Terminal::            How to determine if a file is a terminal
+			         device, and what its name is.
+* I/O Queues::                  About flow control and typeahead.
+* Canonical or Not::            Two basic styles of input processing.
+* Terminal Modes::              How to examine and modify flags controlling
+			         details of terminal I/O: echoing,
+                                 signals, editing.
+* Line Control::                Sending break sequences, clearing
+                                 terminal buffers @dots{}
+* Noncanon Example::            How to read single characters without echo.
+* Pseudo-Terminals::            How to open a pseudo-terminal.
+
+Mathematics
+
+* Mathematical Constants::      Precise numeric values for often-used
+                                 constants.
+* Trig Functions::              Sine, cosine, tangent, and friends.
+* Inverse Trig Functions::      Arcsine, arccosine, etc.
+* Exponents and Logarithms::    Also pow and sqrt.
+* Hyperbolic Functions::        sinh, cosh, tanh, etc.
+* Special Functions::           Bessel, gamma, erf.
+* Pseudo-Random Numbers::       Functions for generating pseudo-random
+				 numbers.
+* FP Function Optimizations::   Fast code or small code.
+
+Arithmetic
+
+* Floating Point Numbers::      Basic concepts.  IEEE 754.
+* Floating Point Classes::      The five kinds of floating-point number.
+* Floating Point Errors::       When something goes wrong in a calculation.
+* Rounding::                    Controlling how results are rounded.
+* Control Functions::           Saving and restoring the FPU's state.
+* Arithmetic Functions::        Fundamental operations provided by the library.
+* Complex Numbers::             The types.  Writing complex constants.
+* Operations on Complex::       Projection, conjugation, decomposition.
+* Integer Division::            Integer division with guaranteed rounding.
+* Parsing of Numbers::          Converting strings to numbers.
+* System V Number Conversion::  An archaic way to convert numbers to strings.
+
+Date and Time
+
+* Processor Time::              Measures processor time used by a program.
+* Calendar Time::               Manipulation of ``real'' dates and times.
+* Setting an Alarm::            Sending a signal after a specified time.
+* Sleeping::                    Waiting for a period of time.
+* Resource Usage::		Measuring various resources used.
+* Limits on Resources::		Specifying limits on resource usage.
+* Priority::			Reading or setting process run priority.
+
+Non-Local Exits
+
+* Intro: Non-Local Intro.        When and how to use these facilities.
+* Details: Non-Local Details.   Functions for nonlocal exits.
+* Non-Local Exits and Signals::  Portability issues.
+
+Signal Handling
+
+* Concepts of Signals::         Introduction to the signal facilities.
+* Standard Signals::            Particular kinds of signals with
+                                 standard names and meanings.
+* Signal Actions::              Specifying what happens when a
+                                 particular signal is delivered.
+* Defining Handlers::           How to write a signal handler function.
+* Interrupted Primitives::	Signal handlers affect use of @code{open},
+				 @code{read}, @code{write} and other functions.
+* Generating Signals::          How to send a signal to a process.
+* Blocking Signals::            Making the system hold signals temporarily.
+* Waiting for a Signal::        Suspending your program until a signal
+                                 arrives.
+* Signal Stack::                Using a Separate Signal Stack.
+* BSD Signal Handling::         Additional functions for backward
+			         compatibility with BSD.
+
+Process Startup
+
+* Program Arguments::           Parsing your program's command-line arguments.
+* Environment Variables::       How to access parameters inherited from
+				 a parent process.
+* Program Termination::         How to cause a process to terminate and
+				 return status information to its parent.
+
+Processes
+
+* Running a Command::           The easy way to run another program.
+* Process Creation Concepts::   An overview of the hard way to do it.
+* Process Identification::      How to get the process ID of a process.
+* Creating a Process::          How to fork a child process.
+* Executing a File::            How to make a process execute another program.
+* Process Completion::          How to tell when a child process has completed.
+* Process Completion Status::   How to interpret the status value
+                                 returned from a child process.
+* BSD Wait Functions::  	More functions, for backward compatibility.
+* Process Creation Example::    A complete example program.
+
+Job Control
+
+* Concepts of Job Control::     Jobs can be controlled by a shell.
+* Job Control is Optional::     Not all POSIX systems support job control.
+* Controlling Terminal::        How a process gets its controlling terminal.
+* Access to the Terminal::      How processes share the controlling terminal.
+* Orphaned Process Groups::     Jobs left after the user logs out.
+* Implementing a Shell::        What a shell must do to implement job control.
+* Functions for Job Control::   Functions to control process groups.
+
+Name Service Switch
+
+* NSS Basics::                  What is this NSS good for.
+* NSS Configuration File::      Configuring NSS.
+* NSS Module Internals::        How does it work internally.
+* Extending NSS::               What to do to add services or databases.
+
+Users and Groups
+
+* User and Group IDs::          Each user has a unique numeric ID;
+				 likewise for groups.
+* Process Persona::             The user IDs and group IDs of a process.
+* Why Change Persona::          Why a program might need to change
+				 its user and/or group IDs.
+* How Change Persona::          Changing the user and group IDs.
+* Reading Persona::             How to examine the user and group IDs.
+
+* Setting User ID::             Functions for setting the user ID.
+* Setting Groups::              Functions for setting the group IDs.
+
+* Enable/Disable Setuid::       Turning setuid access on and off.
+* Setuid Program Example::      The pertinent parts of one sample program.
+* Tips for Setuid::             How to avoid granting unlimited access.
+
+* Who Logged In::               Getting the name of the user who logged in,
+				 or of the real user ID of the current process.
+
+* User Accounting Database::    Keeping information about users and various
+                                 actions in databases.
+
+* User Database::               Functions and data structures for
+                        	 accessing the user database.
+* Group Database::              Functions and data structures for
+                        	 accessing the group database.
+* Database Example::            Example program showing the use of database
+				 inquiry functions.
+* Netgroup Database::           Functions for accessing the netgroup database.
+
+System Information
+
+* Host Identification::         Determining the name of the machine.
+* Hardware/Software Type ID::   Determining the hardware type of the
+                                 machine and what operating system it is
+                                 running.
+* Filesystem handling::         Which is mounted and/or available?
+
+System Configuration
+
+* General Limits::           Constants and functions that describe
+				various process-related limits that have
+				one uniform value for any given machine.
+* System Options::           Optional POSIX features.
+* Version Supported::        Version numbers of POSIX.1 and POSIX.2.
+* Sysconf::                  Getting specific configuration values
+                                of general limits and system options.
+* Minimums::                 Minimum values for general limits.
+
+* Limits for Files::         Size limitations that pertain to individual files.
+                                These can vary between file systems
+                                or even from file to file.
+* Options for Files::        Optional features that some files may support.
+* File Minimums::            Minimum values for file limits.
+* Pathconf::                 Getting the limit values for a particular file.
+
+* Utility Limits::           Capacity limits of some POSIX.2 utility programs.
+* Utility Minimums::         Minimum allowable values of those limits.
+
+* String Parameters::        Getting the default search path.
+
+POSIX Threads
+
+* Basic Thread Operations::     Creating, terminating, and waiting for threads.
+* Thread Attributes::           Tuning thread scheduling.
+* Cancellation::                Stopping a thread before it's done.
+* Cleanup Handlers::            Deallocating resources when a thread is
+                                  cancelled.
+* Mutexes::                     One way to synchronize threads.
+* Condition Variables::         Another way.
+* POSIX Semaphores::            And a third way.
+* Thread-Specific Data::        Variables with different values in
+                                  different threads.
+* Threads and Signal Handling:: Why you should avoid mixing the two, and
+                                  how to do it if you must.
+* Miscellaneous Thread Functions:: A grab bag of utility routines.
+
+Language Features
+
+* Consistency Checking::        Using @code{assert} to abort if
+				 something ``impossible'' happens.
+* Variadic Functions::          Defining functions with varying numbers
+                                 of args.
+* Null Pointer Constant::       The macro @code{NULL}.
+* Important Data Types::        Data types for object sizes.
+* Data Type Measurements::      Parameters of data type representations.
+
+Installation
+
+* Tools for Installation::      We recommend using these tools to build.
+* Supported Configurations::    What systems the GNU C library runs on.
+* Tips for Installation::       Useful hints for the installation.
+* Reporting Bugs::              How to report bugs (if you want to
+                                get them fixed) and other troubles
+                                you may have with the GNU C library.
+
+Maintenance
+
+* Source Layout::         How to add new functions or header files
+                             to the GNU C library.
+* Porting::               How to port the GNU C library to
+                             a new machine or operating system.
+@end menu
diff --git a/manual/users.texi b/manual/users.texi
index 5ffd5fd990..562390c355 100644
--- a/manual/users.texi
+++ b/manual/users.texi
@@ -1,4 +1,5 @@
-@node Users and Groups
+@node Users and Groups, System Information, Name Service Switch, Top
+@c %MENU% How users are identified and classified
 @chapter Users and Groups
 
 Every user who can log in on the system is identified by a unique number