about summary refs log tree commit diff
diff options
context:
space:
mode:
-rw-r--r--ChangeLog118
-rw-r--r--Makeconfig4
-rw-r--r--Makerules27
-rw-r--r--elf/dl-close.c4
-rw-r--r--elf/dl-open.c82
-rw-r--r--elf/dlfcn.h10
-rw-r--r--iconv/gconv_db.c6
-rw-r--r--iconv/gconv_dl.c7
-rw-r--r--linuxthreads/linuxthreads.texi1427
-rw-r--r--manual/.cvsignore2
-rw-r--r--manual/Makefile88
-rw-r--r--manual/arith.texi1967
-rw-r--r--manual/chapters.texi35
-rw-r--r--manual/conf.texi4
-rw-r--r--manual/contrib.texi1
-rw-r--r--manual/ctype.texi1
-rw-r--r--manual/errno.texi1
-rw-r--r--manual/filesys.texi1
-rw-r--r--manual/header.texi1
-rw-r--r--manual/install.texi1
-rw-r--r--manual/intro.texi1
-rw-r--r--manual/io.texi1
-rw-r--r--manual/job.texi3
-rw-r--r--manual/lang.texi4
-rw-r--r--manual/libc-texinfo.sh115
-rw-r--r--manual/libc.texinfo892
-rw-r--r--manual/llio.texi1
-rw-r--r--manual/locale.texi1
-rw-r--r--manual/maint.texi1
-rw-r--r--manual/math.texi1395
-rw-r--r--manual/mbyte.texi1
-rw-r--r--manual/memory.texi1
-rw-r--r--manual/message.texi3
-rw-r--r--manual/nss.texi7
-rw-r--r--manual/pattern.texi1
-rw-r--r--manual/pipe.texi1
-rw-r--r--manual/process.texi3
-rw-r--r--manual/search.texi1
-rw-r--r--manual/setjmp.texi1
-rw-r--r--manual/signal.texi1
-rw-r--r--manual/socket.texi1
-rw-r--r--manual/startup.texi3
-rw-r--r--manual/stdio.texi1
-rw-r--r--manual/string.texi1
-rw-r--r--manual/sysinfo.texi1
-rw-r--r--manual/terminal.texi3
-rw-r--r--manual/texis78
-rw-r--r--manual/texis.awk21
-rw-r--r--manual/time.texi1
-rw-r--r--manual/top-menu.texi499
-rw-r--r--manual/users.texi3
-rw-r--r--sysdeps/unix/sysv/linux/i386/dl-procinfo.h4
-rw-r--r--sysdeps/unix/sysv/linux/recvmsg.c5
-rw-r--r--sysdeps/unix/sysv/linux/sendmsg.c5
54 files changed, 4231 insertions, 2616 deletions
diff --git a/ChangeLog b/ChangeLog
index a94494be34..d21c1f2aa9 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,4 +1,116 @@
-Mon Jul 13 10:28:28 1998  Andreas Schwab  <schwab@issan.informatik.uni-dortmund.de>
+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>
 
 	* sysdeps/unix/sysv/linux/m68k/dl-envvars.h: New file.
 
@@ -857,6 +969,10 @@ Mon Jul 13 10:28:28 1998  Andreas Schwab  <schwab@issan.informatik.uni-dortmund.
 
 1998-06-23  Mark Kettenis  <kettenis@phys.uva.nl>
 
+	* elf/rtld.c (process_dl_debug): Add missing continue.
+
+1998-06-23  Mark Kettenis  <kettenis@phys.uva.nl>
+
 	* elf/dl-load.c (_dl_map_object_from_fd): Add missing cast.
 
 1998-06-23  Andreas Jaeger  <aj@arthur.rhein-neckar.de>
diff --git a/Makeconfig b/Makeconfig
index ee1cc6e79b..43b44c9e87 100644
--- a/Makeconfig
+++ b/Makeconfig
@@ -777,7 +777,9 @@ all-Subdirs-files = $(wildcard $(addsuffix /Subdirs, $(config-sysdirs)))
 $(common-objpfx)sysd-dirs: $(common-objpfx)config.make $(all-Subdirs-files)
 	(echo define sysdep-subdirs;				\
 	 sed 's/#.*$$//' $(all-Subdirs-files) /dev/null;	\
-	 echo endef) > $@-tmp
+	 echo endef;						\
+	 echo 'sysd-dirs-done = t';				\
+	) > $@-tmp
 	mv -f $@-tmp $@
 
 endif # Makeconfig not yet included
diff --git a/Makerules b/Makerules
index dc5f25ead0..9bf62c6cf6 100644
--- a/Makerules
+++ b/Makerules
@@ -276,22 +276,31 @@ ifndef sysd-rules-done
 no_deps=t
 endif
 
-# Generate version maps.
+# Generate version maps, but wait until sysdep-subdirs is known
+ifdef sysd-dirs-done
 ifeq ($(versioning),yes)
-ifndef no_deps
 -include $(common-objpfx)sysd-versions
 $(addprefix $(common-objpfx),$(version-maps)): $(common-objpfx)sysd-versions
-generated += $(version-maps)
+common-generated += $(version-maps) sysd-versions
 
+ifndef avoid-generated
+ifneq ($(sysd-versions-subdirs),$(all-subdirs) $(config-sysdirs))
+sysd-versions-force = FORCE
+FORCE:
+endif
 $(common-objpfx)sysd-versions: $(..)Versions.def $(..)scripts/versions.awk \
 			       $(wildcard $(all-subdirs:%=$(..)%/Versions)) \
-			       $(wildcard $(+sysdep_dirs:%=%/Versions))
-	$(AWK) -v buildroot=$(common-objpfx) -v defsfile=$< \
-	       -v move_if_change='$(move-if-change)' \
-	       -f $(filter-out $<,$^) > $@T
+			       $(wildcard $(sysdirs:%=%/Versions)) \
+			       $(sysd-versions-force)
+	{ echo 'sysd-versions-subdirs = $(all-subdirs) $(config-sysdirs)' ; \
+	  $(AWK) -v buildroot=$(common-objpfx) -v defsfile=$< \
+		 -v move_if_change='$(move-if-change)' \
+		 -f $(filter-out $< $(sysd-versions-force),$^); \
+	} > $@T
 	mv -f $@T $@
-endif
-endif
+endif # avoid-generated
+endif # $(versioning) = yes
+endif # sysd-dirs-done
 
 ifndef compile-command.S
 compile-command.S = $(compile.S) $(OUTPUT_OPTION)
diff --git a/elf/dl-close.c b/elf/dl-close.c
index 8b352d0f47..e1ca142a69 100644
--- a/elf/dl-close.c
+++ b/elf/dl-close.c
@@ -62,7 +62,9 @@ _dl_close (struct link_map *map)
     {
       struct link_map *imap = list[i];
       if (imap->l_opencount == 1 && imap->l_type == lt_loaded
-	  && imap->l_info[DT_FINI])
+	  && imap->l_info[DT_FINI]
+	  /* Skip any half-cooked objects that were never initialized.  */
+	  && imap->l_init_called)
 	{
 	  /* When debugging print a message first.  */
 	  if (_dl_debug_impcalls)
diff --git a/elf/dl-open.c b/elf/dl-open.c
index 2b9590913f..b595f2df73 100644
--- a/elf/dl-open.c
+++ b/elf/dl-open.c
@@ -20,6 +20,7 @@
 #include <dlfcn.h>
 #include <errno.h>
 #include <stdlib.h>
+#include <string.h>
 #include <bits/libc-lock.h>
 #include <elf/ldsodefs.h>
 
@@ -50,25 +51,31 @@ static size_t _dl_global_scope_alloc;
 __libc_lock_define_initialized_recursive (, _dl_load_lock)
 
 
-struct link_map *
-internal_function
-_dl_open (const char *file, int mode)
+/* We must be carefull not to leave us in an inconsistent state.  Thus we
+   catch any error and re-raise it after cleaning up.  */
+
+struct dl_open_args
 {
+  const char *file;
+  int mode;
+  struct link_map *map;
+};
+
+static void
+dl_open_worker (void *a)
+{
+  struct dl_open_args *args = a;
+  const char *file = args->file;
+  int mode = args->mode;
   struct link_map *new, *l;
   ElfW(Addr) init;
   struct r_debug *r;
 
-  /* Make sure we are alone.  */
-  __libc_lock_lock (_dl_load_lock);
-
   /* Load the named object.  */
-  new = _dl_map_object (NULL, file, 0, lt_loaded, 0);
+  args->map = new = _dl_map_object (NULL, file, 0, lt_loaded, 0);
   if (new->l_searchlist)
-    {
-      /* It was already open.  */
-      __libc_lock_unlock (_dl_load_lock);
-      return new;
-    }
+    /* It was already open.  */
+    return;
 
   /* Load that object's dependencies.  */
   _dl_map_object_deps (new, NULL, 0, 0);
@@ -147,7 +154,7 @@ _dl_open (const char *file, int mode)
 	    {
 	      _dl_global_scope = _dl_default_scope;
 	    nomem:
-	      _dl_close (new);
+	      new->l_global = 0;
 	      _dl_signal_error (ENOMEM, file, "cannot extend global scope");
 	    }
 	  _dl_global_scope[2] = _dl_default_scope[2];
@@ -158,8 +165,8 @@ _dl_open (const char *file, int mode)
 	}
       else
 	{
-	  if (_dl_global_scope_alloc <
-	      (size_t) (_dl_global_scope_end - _dl_global_scope + 2))
+	  if (_dl_global_scope_end + 2
+	      == _dl_global_scope + _dl_global_scope_alloc)
 	    {
 	      /* Must extend the list.  */
 	      struct link_map **new = realloc (_dl_global_scope,
@@ -167,9 +174,8 @@ _dl_open (const char *file, int mode)
 					       * sizeof (struct link_map *));
 	      if (! new)
 		goto nomem;
-	      _dl_global_scope_end = new + (_dl_global_scope_end -
-					    _dl_global_scope);
 	      _dl_global_scope = new;
+	      _dl_global_scope_end = new + _dl_global_scope_alloc - 2;
 	      _dl_global_scope_alloc *= 2;
 	    }
 
@@ -199,9 +205,49 @@ _dl_open (const char *file, int mode)
     /* We must be the static _dl_open in libc.a.  A static program that
        has loaded a dynamic object now has competition.  */
     __libc_multiple_libcs = 1;
+}
+
+
+struct link_map *
+internal_function
+_dl_open (const char *file, int mode)
+{
+  struct dl_open_args args;
+  char *errstring;
+  int errcode;
+
+  /* Make sure we are alone.  */
+  __libc_lock_lock (_dl_load_lock);
+
+  args.file = file;
+  args.mode = mode;
+  args.map = NULL;
+  errcode = _dl_catch_error (&errstring, dl_open_worker, &args);
 
   /* Release the lock.  */
   __libc_lock_unlock (_dl_load_lock);
 
-  return new;
+  if (errstring)
+    {
+      /* Some error occured during loading.  */
+      char *local_errstring;
+
+      /* Reset the global scope.  */
+      *_dl_global_scope_end = NULL;
+
+      /* Remove the object from memory.  It may be in an inconsistent
+	 state if relocation failed, for example.  */
+      if (args.map)
+	_dl_close (args.map);
+
+      /* Make a local copy of the error string so that we can release the
+	 memory allocated for it.  */
+      local_errstring = strdupa (errstring);
+      free (errstring);
+
+      /* Reraise the error.  */
+      _dl_signal_error (errcode, NULL, local_errstring);
+    }
+
+  return args.map;
 }
diff --git a/elf/dlfcn.h b/elf/dlfcn.h
index 2f890bfe24..aa2e32ffd3 100644
--- a/elf/dlfcn.h
+++ b/elf/dlfcn.h
@@ -81,14 +81,8 @@ extern int dladdr __P ((const void *__address, Dl_info *__info));
    into
         foo = DL_CALL_FCT (fctp, (arg1, arg2));
 */
-# if __GNUC__ >= 2
-#  define DL_CALL_FCT(fctp, args) \
-  (__extension__ ({ _dl_mcount_wrapper_check (fctp);			      \
-		    (*fctp) args; }))
-# else
-/* This feature is not available without GCC.  */
-#  define DL_CALL_FCT(fctp, args) (*fctp) args
-# endif
+# define DL_CALL_FCT(fctp, args) \
+  (_dl_mcount_wrapper_check (fctp), (*(fctp)) args)
 
 /* This function calls the profiling functions.  */
 extern void _dl_mcount_wrapper_check __P ((void *__selfpc));
diff --git a/iconv/gconv_db.c b/iconv/gconv_db.c
index 2c66249cc5..d5d075df88 100644
--- a/iconv/gconv_db.c
+++ b/iconv/gconv_db.c
@@ -239,6 +239,7 @@ gen_steps (struct derivation_step *best, const char *toset,
 	    }
 	  free (result);
 	  *nsteps = 0;
+	  *handle = NULL;
 	  status = GCONV_NOCONV;
 	}
       else
@@ -247,6 +248,11 @@ gen_steps (struct derivation_step *best, const char *toset,
 	  status = GCONV_OK;
 	}
     }
+  else
+    {
+      *nsteps = 0;
+      *handle = NULL;
+    }
 
   return status;
 }
diff --git a/iconv/gconv_dl.c b/iconv/gconv_dl.c
index 8375040d84..e0471b0de6 100644
--- a/iconv/gconv_dl.c
+++ b/iconv/gconv_dl.c
@@ -129,6 +129,7 @@ internal_function
 __gconv_find_shlib (const char *name)
 {
   struct gconv_loaded_object *found;
+  void *keyp;
 
   /* Search the tree of shared objects previously requested.  Data in
      the tree are `loaded_object' structures, whose first member is a
@@ -139,8 +140,8 @@ __gconv_find_shlib (const char *name)
      enough to a pointer to our structure to use as a lookup key that
      will be passed to `known_compare' (above).  */
 
-  found = __tfind (&name, &loaded, known_compare);
-  if (found == NULL)
+  keyp = __tfind (&name, &loaded, known_compare);
+  if (keyp == NULL)
     {
       /* This name was not known before.  */
       found = malloc (sizeof (struct gconv_loaded_object));
@@ -159,6 +160,8 @@ __gconv_find_shlib (const char *name)
 	    }
 	}
     }
+  else
+    found = *(struct gconv_loaded_object **) keyp;
 
   /* Try to load the shared object if the usage count is 0.  This
      implies that if the shared object is not loadable, the handle is
diff --git a/linuxthreads/linuxthreads.texi b/linuxthreads/linuxthreads.texi
new file mode 100644
index 0000000000..dc1b14649a
--- /dev/null
+++ b/linuxthreads/linuxthreads.texi
@@ -0,0 +1,1427 @@
+@node POSIX Threads, , Top, Top
+@chapter POSIX Threads
+@c %MENU% The standard threads library
+
+@c This chapter needs more work bigtime. -zw
+
+This chapter describes the pthreads (POSIX threads) library.  This
+library provides support functions for multithreaded programs: thread
+primitives, synchronization objects, and so forth.  It also implements
+POSIX 1003.1b semaphores (not to be confused with System V semaphores).
+
+The threads operations (@samp{pthread_*}) do not use @var{errno}.
+Instead they return an error code directly.  The semaphore operations do
+use @var{errno}.
+
+@menu
+* 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.
+@end menu
+
+@node Basic Thread Operations
+@section Basic Thread Operations
+
+These functions are the thread equivalents of @code{fork}, @code{exit},
+and @code{wait}.
+
+@comment pthread.h
+@comment POSIX
+@deftypefun int pthread_create (pthread_t * @var{thread}, pthread_attr_t * @var{attr}, void * (*@var{start_routine})(void *), void * @var{arg})
+@code{pthread_create} creates a new thread of control that executes
+concurrently with the calling thread. The new thread calls the
+function @var{start_routine}, passing it @var{arg} as first argument. The
+new thread terminates either explicitly, by calling @code{pthread_exit},
+or implicitly, by returning from the @var{start_routine} function. The
+latter case is equivalent to calling @code{pthread_exit} with the result
+returned by @var{start_routine} as exit code.
+
+The @var{attr} argument specifies thread attributes to be applied to the
+new thread. @xref{Thread Attributes} for details. The @var{attr}
+argument can also be @code{NULL}, in which case default attributes are
+used: the created thread is joinable (not detached) and has an ordinary
+(not realtime) scheduling policy.
+
+On success, the identifier of the newly created thread is stored in the
+location pointed by the @var{thread} argument, and a 0 is returned. On
+error, a non-zero error code is returned.
+
+This function may return the following errors:
+@table @code
+@item EAGAIN
+Not enough system resources to create a process for the new thread,
+or more than @code{PTHREAD_THREADS_MAX} threads are already active.
+@end table
+@end deftypefun
+
+@comment pthread.h
+@comment POSIX
+@deftypefun void pthread_exit (void *@var{retval})
+@code{pthread_exit} terminates the execution of the calling thread.  All
+cleanup handlers (@pxref{Cleanup Handlers}) that have been set for the
+calling thread with @code{pthread_cleanup_push} are executed in reverse
+order (the most recently pushed handler is executed first). Finalization
+functions for thread-specific data are then called for all keys that
+have non-@code{NULL} values associated with them in the calling thread
+(@pxref{Thread-Specific Data}).  Finally, execution of the calling
+thread is stopped.
+
+The @var{retval} argument is the return value of the thread. It can be
+retrieved from another thread using @code{pthread_join}.
+
+The @code{pthread_exit} function never returns.
+@end deftypefun
+
+@comment pthread.h
+@comment POSIX
+@deftypefun int pthread_cancel (pthread_t @var{thread})
+
+@code{pthread_cancel} sends a cancellation request to the thread denoted
+by the @var{thread} argument.  If there is no such thread,
+@code{pthread_cancel} fails and returns @code{ESRCH}.  Otherwise it
+returns 0. @xref{Cancellation}, for details.
+@end deftypefun
+
+@comment pthread.h
+@comment POSIX
+@deftypefun int pthread_join (pthread_t @var{th}, void **thread_@var{return})
+@code{pthread_join} suspends the execution of the calling thread until
+the thread identified by @var{th} terminates, either by calling
+@code{pthread_exit} or by being cancelled.
+
+If @var{thread_return} is not @code{NULL}, the return value of @var{th}
+is stored in the location pointed to by @var{thread_return}.  The return
+value of @var{th} is either the argument it gave to @code{pthread_exit},
+or @code{PTHREAD_CANCELED} if @var{th} was cancelled.
+
+The joined thread @code{th} must be in the joinable state: it must not
+have been detached using @code{pthread_detach} or the
+@code{PTHREAD_CREATE_DETACHED} attribute to @code{pthread_create}.
+
+When a joinable thread terminates, its memory resources (thread
+descriptor and stack) are not deallocated until another thread performs
+@code{pthread_join} on it. Therefore, @code{pthread_join} must be called
+once for each joinable thread created to avoid memory leaks.
+
+At most one thread can wait for the termination of a given
+thread. Calling @code{pthread_join} on a thread @var{th} on which
+another thread is already waiting for termination returns an error.
+
+@code{pthread_join} is a cancellation point. If a thread is canceled
+while suspended in @code{pthread_join}, the thread execution resumes
+immediately and the cancellation is executed without waiting for the
+@var{th} thread to terminate. If cancellation occurs during
+@code{pthread_join}, the @var{th} thread remains not joined.
+
+On success, the return value of @var{th} is stored in the location
+pointed to by @var{thread_return}, and 0 is returned. On error, one of
+the following values is returned:
+@table @code
+@item ESRCH
+No thread could be found corresponding to that specified by @var{th}.
+@item EINVAL
+The @var{th} thread has been detached, or another thread is already
+waiting on termination of @var{th}.
+@item EDEADLK
+The @var{th} argument refers to the calling thread.
+@end table
+@end deftypefun
+
+@node Thread Attributes
+@section Thread Attributes
+
+@comment pthread.h
+@comment POSIX
+
+Threads have a number of attributes that may be set at creation time.
+This is done by filling a thread attribute object @var{attr} of type
+@code{pthread_attr_t}, then passing it as second argument to
+@code{pthread_create}. Passing @code{NULL} is equivalent to passing a
+thread attribute object with all attributes set to their default values.
+
+Attribute objects are consulted only when creating a new thread.  The
+same attribute object can be used for creating several threads.
+Modifying an attribute object after a call to @code{pthread_create} does
+not change the attributes of the thread previously created.
+
+@comment pthread.h
+@comment POSIX
+@deftypefun int pthread_attr_init (pthread_attr_t *@var{attr})
+@code{pthread_attr_init} initializes the thread attribute object
+@var{attr} and fills it with default values for the attributes. (The
+default values are listed below for each attribute.)
+
+Each attribute @var{attrname} (see below for a list of all attributes)
+can be individually set using the function
+@code{pthread_attr_set@var{attrname}} and retrieved using the function
+@code{pthread_attr_get@var{attrname}}.
+@end deftypefun
+
+@comment pthread.h
+@comment POSIX
+@deftypefun int pthread_attr_destroy (pthread_attr_t *@var{attr})
+@code{pthread_attr_destroy} destroys the attribute object pointed to by
+@var{attr} releasing any resources associated with it.  @var{attr} is
+left in an undefined state, and you must not use it again in a call to
+any pthreads function until it has been reinitialized.
+@end deftypefun
+
+@findex pthread_attr_setinheritsched
+@findex pthread_attr_setschedparam
+@findex pthread_attr_setschedpolicy
+@findex pthread_attr_setscope
+@comment pthread.h
+@comment POSIX
+@deftypefun int pthread_attr_set@var{attr} (pthread_attr_t *@var{obj}, int @var{value})
+Set attribute @var{attr} to @var{value} in the attribute object pointed
+to by @var{obj}.  See below for a list of possible attributes and the
+values they can take.
+
+On success, these functions return 0.  If @var{value} is not meaningful
+for the @var{attr} being modified, they will return the error code
+@code{EINVAL}.  Some of the functions have other failure modes; see
+below.
+@end deftypefun
+
+@findex pthread_attr_getinheritsched
+@findex pthread_attr_getschedparam
+@findex pthread_attr_getschedpolicy
+@findex pthread_attr_getscope
+@comment pthread.h
+@comment POSIX
+@deftypefun int pthread_attr_get@var{attr} (const pthread_attr_t *@var{obj}, int *@var{value})
+Store the current setting of @var{attr} in @var{obj} into the variable
+pointed to by @var{value}.
+
+These functions always return 0.
+@end deftypefun
+
+The following thread attributes are supported:
+@table @samp
+@item detachstate
+Choose whether the thread is created in the joinable state (value
+@code{PTHREAD_CREATE_JOINABLE}) or in the detached state
+(@code{PTHREAD_CREATE_DETACHED}).  The default is
+@code{PTHREAD_CREATE_JOINABLE}.
+
+In the joinable state, another thread can synchronize on the thread
+termination and recover its termination code using @code{pthread_join},
+but some of the thread resources are kept allocated after the thread
+terminates, and reclaimed only when another thread performs
+@code{pthread_join} on that thread.
+
+In the detached state, the thread resources are immediately freed when
+it terminates, but @code{pthread_join} cannot be used to synchronize on
+the thread termination.
+
+A thread created in the joinable state can later be put in the detached
+thread using @code{pthread_detach}.
+
+@item schedpolicy
+Select the scheduling policy for the thread: one of @code{SCHED_OTHER}
+(regular, non-realtime scheduling), @code{SCHED_RR} (realtime,
+round-robin) or @code{SCHED_FIFO} (realtime, first-in first-out).
+The default is @code{SCHED_OTHER}.
+@c Not doc'd in our manual: FIXME.
+@c See @code{sched_setpolicy} for more information on scheduling policies.
+
+The realtime scheduling policies @code{SCHED_RR} and @code{SCHED_FIFO}
+are available only to processes with superuser privileges.
+@code{pthread_attr_setschedparam} will fail and return @code{ENOTSUP} if
+you try to set a realtime policy when you are unprivileged.
+
+The scheduling policy of a thread can be changed after creation with
+@code{pthread_setschedparam}.
+
+@item schedparam
+Change the scheduling parameter (the scheduling priority)
+for the thread.  The default is 0.
+
+This attribute is not significant if the scheduling policy is
+@code{SCHED_OTHER}; it only matters for the realtime policies
+@code{SCHED_RR} and @code{SCHED_FIFO}.
+
+The scheduling priority of a thread can be changed after creation with
+@code{pthread_setschedparam}.
+
+@item inheritsched
+Choose whether the scheduling policy and scheduling parameter for the
+newly created thread are determined by the values of the
+@var{schedpolicy} and @var{schedparam} attributes (value
+@code{PTHREAD_EXPLICIT_SCHED}) or are inherited from the parent thread
+(value @code{PTHREAD_INHERIT_SCHED}).  The default is
+@code{PTHREAD_EXPLICIT_SCHED}.
+
+@item scope
+Choose the scheduling contention scope for the created thread.  The
+default is @code{PTHREAD_SCOPE_SYSTEM}, meaning that the threads contend
+for CPU time with all processes running on the machine. In particular,
+thread priorities are interpreted relative to the priorities of all
+other processes on the machine. The other possibility,
+@code{PTHREAD_SCOPE_PROCESS}, means that scheduling contention occurs
+only between the threads of the running process: thread priorities are
+interpreted relative to the priorities of the other threads of the
+process, regardless of the priorities of other processes.
+
+@code{PTHREAD_SCOPE_PROCESS} is not supported in LinuxThreads.  If you
+try to set the scope to this value @code{pthread_attr_setscope} will
+fail and return @code{ENOTSUP}.
+@end table
+
+@node Cancellation
+@section Cancellation
+
+Cancellation is the mechanism by which a thread can terminate the
+execution of another thread. More precisely, a thread can send a
+cancellation request to another thread. Depending on its settings, the
+target thread can then either ignore the request, honor it immediately,
+or defer it till it reaches a cancellation point.  When threads are
+first created by @code{pthread_create}, they always defer cancellation
+requests.
+
+When a thread eventually honors a cancellation request, it behaves as if
+@code{pthread_exit(PTHREAD_CANCELED)} was called.  All cleanup handlers
+are executed in reverse order, finalization functions for
+thread-specific data are called, and finally the thread stops executing.
+If the cancelled thread was joinable, the return value
+@code{PTHREAD_CANCELED} is provided to whichever thread calls
+@var{pthread_join} on it. See @code{pthread_exit} for more information.
+
+Cancellation points are the points where the thread checks for pending
+cancellation requests and performs them.  The POSIX threads functions
+@code{pthread_join}, @code{pthread_cond_wait},
+@code{pthread_cond_timedwait}, @code{pthread_testcancel},
+@code{sem_wait}, and @code{sigwait} are cancellation points.  In
+addition, these system calls are cancellation points:
+
+@multitable @columnfractions .33 .33 .33
+@item @t{accept}	@tab @t{open}		@tab @t{sendmsg}
+@item @t{close}		@tab @t{pause}		@tab @t{sendto}
+@item @t{connect}	@tab @t{read}		@tab @t{system}
+@item @t{fcntl}		@tab @t{recv}		@tab @t{tcdrain}
+@item @t{fsync}		@tab @t{recvfrom}	@tab @t{wait}
+@item @t{lseek}		@tab @t{recvmsg}	@tab @t{waitpid}
+@item @t{msync}		@tab @t{send}		@tab @t{write}
+@item @t{nanosleep}
+@end multitable
+
+@noindent
+All library functions that call these functions (such as
+@code{printf}) are also cancellation points.
+
+@comment pthread.h
+@comment POSIX
+@deftypefun int pthread_setcancelstate (int @var{state}, int *@var{oldstate})
+@code{pthread_setcancelstate} changes the cancellation state for the
+calling thread -- that is, whether cancellation requests are ignored or
+not. The @var{state} argument is the new cancellation state: either
+@code{PTHREAD_CANCEL_ENABLE} to enable cancellation, or
+@code{PTHREAD_CANCEL_DISABLE} to disable cancellation (cancellation
+requests are ignored).
+
+If @var{oldstate} is not @code{NULL}, the previous cancellation state is
+stored in the location pointed to by @var{oldstate}, and can thus be
+restored later by another call to @code{pthread_setcancelstate}.
+
+If the @var{state} argument is not @code{PTHREAD_CANCEL_ENABLE} or
+@code{PTHREAD_CANCEL_DISABLE}, @code{pthread_setcancelstate} fails and
+returns @code{EINVAL}.  Otherwise it returns 0.
+@end deftypefun
+
+@comment pthread.h
+@comment POSIX
+@deftypefun int pthread_setcanceltype (int @var{type}, int *@var{oldtype})
+@code{pthread_setcanceltype} changes the type of responses to
+cancellation requests for the calling thread: asynchronous (immediate)
+or deferred.  The @var{type} argument is the new cancellation type:
+either @code{PTHREAD_CANCEL_ASYNCHRONOUS} to cancel the calling thread
+as soon as the cancellation request is received, or
+@code{PTHREAD_CANCEL_DEFERRED} to keep the cancellation request pending
+until the next cancellation point. If @var{oldtype} is not @code{NULL},
+the previous cancellation state is stored in the location pointed to by
+@var{oldtype}, and can thus be restored later by another call to
+@code{pthread_setcanceltype}.
+
+If the @var{type} argument is not @code{PTHREAD_CANCEL_DEFERRED} or
+@code{PTHREAD_CANCEL_ASYNCHRONOUS}, @code{pthread_setcanceltype} fails
+and returns @code{EINVAL}.  Otherwise it returns 0.
+@end deftypefun
+
+@comment pthread.h
+@comment POSIX
+@deftypefun void pthread_testcancel (@var{void})
+@code{pthread_testcancel} does nothing except testing for pending
+cancellation and executing it. Its purpose is to introduce explicit
+checks for cancellation in long sequences of code that do not call
+cancellation point functions otherwise.
+@end deftypefun
+
+@node Cleanup Handlers
+@section Cleanup Handlers
+
+Cleanup handlers are functions that get called when a thread terminates,
+either by calling @code{pthread_exit} or because of
+cancellation. Cleanup handlers are installed and removed following a
+stack-like discipline.
+
+The purpose of cleanup handlers is to free the resources that a thread
+may hold at the time it terminates. In particular, if a thread exits or
+is cancelled while it owns a locked mutex, the mutex will remain locked
+forever and prevent other threads from executing normally. The best way
+to avoid this is, just before locking the mutex, to install a cleanup
+handler whose effect is to unlock the mutex. Cleanup handlers can be
+used similarly to free blocks allocated with @code{malloc} or close file
+descriptors on thread termination.
+
+Here is how to lock a mutex @var{mut} in such a way that it will be
+unlocked if the thread is canceled while @var{mut} is locked:
+
+@smallexample
+pthread_cleanup_push(pthread_mutex_unlock, (void *) &mut);
+pthread_mutex_lock(&mut);
+/* do some work */
+pthread_mutex_unlock(&mut);
+pthread_cleanup_pop(0);
+@end smallexample
+
+Equivalently, the last two lines can be replaced by
+
+@smallexample
+pthread_cleanup_pop(1);
+@end smallexample
+
+Notice that the code above is safe only in deferred cancellation mode
+(see @code{pthread_setcanceltype}). In asynchronous cancellation mode, a
+cancellation can occur between @code{pthread_cleanup_push} and
+@code{pthread_mutex_lock}, or between @code{pthread_mutex_unlock} and
+@code{pthread_cleanup_pop}, resulting in both cases in the thread trying
+to unlock a mutex not locked by the current thread. This is the main
+reason why asynchronous cancellation is difficult to use.
+
+If the code above must also work in asynchronous cancellation mode,
+then it must switch to deferred mode for locking and unlocking the
+mutex:
+
+@smallexample
+pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED, &oldtype);
+pthread_cleanup_push(pthread_mutex_unlock, (void *) &mut);
+pthread_mutex_lock(&mut);
+/* do some work */
+pthread_cleanup_pop(1);
+pthread_setcanceltype(oldtype, NULL);
+@end smallexample
+
+The code above can be rewritten in a more compact and efficient way,
+using the non-portable functions @code{pthread_cleanup_push_defer_np}
+and @code{pthread_cleanup_pop_restore_np}:
+
+@smallexample
+pthread_cleanup_push_defer_np(pthread_mutex_unlock, (void *) &mut);
+pthread_mutex_lock(&mut);
+/* do some work */
+pthread_cleanup_pop_restore_np(1);
+@end smallexample
+
+@comment pthread.h
+@comment POSIX
+@deftypefun void pthread_cleanup_push (void (*@var{routine}) (void *), void *@var{arg})
+
+@code{pthread_cleanup_push} installs the @var{routine} function with
+argument @var{arg} as a cleanup handler. From this point on to the
+matching @code{pthread_cleanup_pop}, the function @var{routine} will be
+called with arguments @var{arg} when the thread terminates, either
+through @code{pthread_exit} or by cancellation. If several cleanup
+handlers are active at that point, they are called in LIFO order: the
+most recently installed handler is called first.
+@end deftypefun
+
+@comment pthread.h
+@comment POSIX
+@deftypefun void pthread_cleanup_pop (int @var{execute})
+@code{pthread_cleanup_pop} removes the most recently installed cleanup
+handler. If the @var{execute} argument is not 0, it also executes the
+handler, by calling the @var{routine} function with arguments
+@var{arg}. If the @var{execute} argument is 0, the handler is only
+removed but not executed.
+@end deftypefun
+
+Matching pairs of @code{pthread_cleanup_push} and
+@code{pthread_cleanup_pop} must occur in the same function, at the same
+level of block nesting.  Actually, @code{pthread_cleanup_push} and
+@code{pthread_cleanup_pop} are macros, and the expansion of
+@code{pthread_cleanup_push} introduces an open brace @code{@{} with the
+matching closing brace @code{@}} being introduced by the expansion of the
+matching @code{pthread_cleanup_pop}.
+
+@comment pthread.h
+@comment GNU
+@deftypefun void pthread_cleanup_push_defer_np (void (*@var{routine}) (void *), void *@var{arg})
+@code{pthread_cleanup_push_defer_np} is a non-portable extension that
+combines @code{pthread_cleanup_push} and @code{pthread_setcanceltype}.
+It pushes a cleanup handler just as @code{pthread_cleanup_push} does,
+but also saves the current cancellation type and sets it to deferred
+cancellation. This ensures that the cleanup mechanism is effective even
+if the thread was initially in asynchronous cancellation mode.
+@end deftypefun
+
+@comment pthread.h
+@comment GNU
+@deftypefun void pthread_cleanup_pop_restore_np (int @var{execute})
+@code{pthread_cleanup_pop_restore_np} pops a cleanup handler introduced
+by @code{pthread_cleanup_push_defer_np}, and restores the cancellation
+type to its value at the time @code{pthread_cleanup_push_defer_np} was
+called.
+@end deftypefun
+
+@code{pthread_cleanup_push_defer_np} and
+@code{pthread_cleanup_pop_restore_np} must occur in matching pairs, at
+the same level of block nesting.
+
+The sequence
+
+@smallexample
+pthread_cleanup_push_defer_np(routine, arg);
+...
+pthread_cleanup_pop_defer_np(execute);
+@end smallexample
+
+@noindent
+is functionally equivalent to (but more compact and efficient than)
+
+@smallexample
+@{
+  int oldtype;
+  pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED, &oldtype);
+  pthread_cleanup_push(routine, arg);
+  ...
+  pthread_cleanup_pop(execute);
+  pthread_setcanceltype(oldtype, NULL);
+@}
+@end smallexample
+
+
+@node Mutexes
+@section Mutexes
+
+A mutex is a MUTual EXclusion device, and is useful for protecting
+shared data structures from concurrent modifications, and implementing
+critical sections and monitors.
+
+A mutex has two possible states: unlocked (not owned by any thread),
+and locked (owned by one thread). A mutex can never be owned by two
+different threads simultaneously. A thread attempting to lock a mutex
+that is already locked by another thread is suspended until the owning
+thread unlocks the mutex first.
+
+None of the mutex functions is a cancellation point, not even
+@code{pthread_mutex_lock}, in spite of the fact that it can suspend a
+thread for arbitrary durations. This way, the status of mutexes at
+cancellation points is predictable, allowing cancellation handlers to
+unlock precisely those mutexes that need to be unlocked before the
+thread stops executing. Consequently, threads using deferred
+cancellation should never hold a mutex for extended periods of time.
+
+It is not safe to call mutex functions from a signal handler.  In
+particular, calling @code{pthread_mutex_lock} or
+@code{pthread_mutex_unlock} from a signal handler may deadlock the
+calling thread.
+
+@comment pthread.h
+@comment POSIX
+@deftypefun int pthread_mutex_init (pthread_mutex_t *@var{mutex}, const pthread_mutexattr_t *@var{mutexattr})
+
+@code{pthread_mutex_init} initializes the mutex object pointed to by
+@var{mutex} according to the mutex attributes specified in @var{mutexattr}.
+If @var{mutexattr} is @code{NULL}, default attributes are used instead.
+
+The LinuxThreads implementation supports only one mutex attribute,
+the @var{mutex kind}, which is either ``fast'', ``recursive'', or
+``error checking''. The kind of a mutex determines whether
+it can be locked again by a thread that already owns it.
+The default kind is ``fast''.
+
+Variables of type @code{pthread_mutex_t} can also be initialized
+statically, using the constants @code{PTHREAD_MUTEX_INITIALIZER} (for
+fast mutexes), @code{PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP} (for
+recursive mutexes), and @code{PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP}
+(for error checking mutexes).
+
+@code{pthread_mutex_init} always returns 0.
+@end deftypefun
+
+@comment pthread.h
+@comment POSIX
+@deftypefun int pthread_mutex_lock (pthread_mutex_t *mutex))
+@code{pthread_mutex_lock} locks the given mutex. If the mutex is
+currently unlocked, it becomes locked and owned by the calling thread,
+and @code{pthread_mutex_lock} returns immediately. If the mutex is
+already locked by another thread, @code{pthread_mutex_lock} suspends the
+calling thread until the mutex is unlocked.
+
+If the mutex is already locked by the calling thread, the behavior of
+@code{pthread_mutex_lock} depends on the kind of the mutex. If the mutex
+is of the ``fast'' kind, the calling thread is suspended.  It will
+remain suspended forever, because no other thread can unlock the mutex.
+If  the mutex is of the ``error checking'' kind, @code{pthread_mutex_lock}
+returns immediately with the error code @code{EDEADLK}.  If the mutex is
+of the ``recursive'' kind, @code{pthread_mutex_lock} succeeds and
+returns immediately, recording the number of times the calling thread
+has locked the mutex. An equal number of @code{pthread_mutex_unlock}
+operations must be performed before the mutex returns to the unlocked
+state.
+@end deftypefun
+
+@comment pthread.h
+@comment POSIX
+@deftypefun int pthread_mutex_trylock (pthread_mutex_t *@var{mutex})
+@code{pthread_mutex_trylock} behaves identically to
+@code{pthread_mutex_lock}, except that it does not block the calling
+thread if the mutex is already locked by another thread (or by the
+calling thread in the case of a ``fast'' mutex). Instead,
+@code{pthread_mutex_trylock} returns immediately with the error code
+@code{EBUSY}.
+@end deftypefun
+
+@comment pthread.h
+@comment POSIX
+@deftypefun int pthread_mutex_unlock (pthread_mutex_t *@var{mutex})
+@code{pthread_mutex_unlock} unlocks the given mutex. The mutex is
+assumed to be locked and owned by the calling thread on entrance to
+@code{pthread_mutex_unlock}. If the mutex is of the ``fast'' kind,
+@code{pthread_mutex_unlock} always returns it to the unlocked state. If
+it is of the ``recursive'' kind, it decrements the locking count of the
+mutex (number of @code{pthread_mutex_lock} operations performed on it by
+the calling thread), and only when this count reaches zero is the mutex
+actually unlocked.
+
+On ``error checking'' mutexes, @code{pthread_mutex_unlock} actually
+checks at run-time that the mutex is locked on entrance, and that it was
+locked by the same thread that is now calling
+@code{pthread_mutex_unlock}.  If these conditions are not met,
+@code{pthread_mutex_unlock} returns @code{EPERM}, and the mutex remains
+unchanged.  ``Fast'' and ``recursive'' mutexes perform no such checks,
+thus allowing a locked mutex to be unlocked by a thread other than its
+owner. This is non-portable behavior and must not be relied upon.
+@end deftypefun
+
+@comment pthread.h
+@comment POSIX
+@deftypefun int pthread_mutex_destroy (pthread_mutex_t *@var{mutex})
+@code{pthread_mutex_destroy} destroys a mutex object, freeing the
+resources it might hold. The mutex must be unlocked on entrance. In the
+LinuxThreads implementation, no resources are associated with mutex
+objects, thus @code{pthread_mutex_destroy} actually does nothing except
+checking that the mutex is unlocked.
+
+If the mutex is locked by some thread, @code{pthread_mutex_destroy}
+returns @code{EBUSY}.  Otherwise it returns 0.
+@end deftypefun
+
+If any of the above functions (except @code{pthread_mutex_init})
+is applied to an uninitialized mutex, they will simply return
+@code{EINVAL} and do nothing.
+
+A shared global variable @var{x} can be protected by a mutex as follows:
+
+@smallexample
+int x;
+pthread_mutex_t mut = PTHREAD_MUTEX_INITIALIZER;
+@end smallexample
+
+All accesses and modifications to @var{x} should be bracketed by calls to
+@code{pthread_mutex_lock} and @code{pthread_mutex_unlock} as follows:
+
+@smallexample
+pthread_mutex_lock(&mut);
+/* operate on x */
+pthread_mutex_unlock(&mut);
+@end smallexample
+
+Mutex attributes can be specified at mutex creation time, by passing a
+mutex attribute object as second argument to @code{pthread_mutex_init}.
+Passing @code{NULL} is equivalent to passing a mutex attribute object
+with all attributes set to their default values.
+
+@comment pthread.h
+@comment POSIX
+@deftypefun int pthread_mutexattr_init (pthread_mutexattr_t *@var{attr})
+@code{pthread_mutexattr_init} initializes the mutex attribute object
+@var{attr} and fills it with default values for the attributes.
+
+This function always returns 0.
+@end deftypefun
+
+@comment pthread.h
+@comment POSIX
+@deftypefun int pthread_mutexattr_destroy (pthread_mutexattr_t *@var{attr})
+@code{pthread_mutexattr_destroy} destroys a mutex attribute object,
+which must not be reused until it is
+reinitialized. @code{pthread_mutexattr_destroy} does nothing in the
+LinuxThreads implementation.
+
+This function always returns 0.
+@end deftypefun
+
+LinuxThreads supports only one mutex attribute: the mutex kind, which is
+either @code{PTHREAD_MUTEX_FAST_NP} for ``fast'' mutexes,
+@code{PTHREAD_MUTEX_RECURSIVE_NP} for ``recursive'' mutexes, or
+@code{PTHREAD_MUTEX_ERRORCHECK_NP} for ``error checking'' mutexes.  As
+the @code{NP} suffix indicates, this is a non-portable extension to the
+POSIX standard and should not be employed in portable programs.
+
+The mutex kind determines what happens if a thread attempts to lock a
+mutex it already owns with @code{pthread_mutex_lock}. If the mutex is of
+the ``fast'' kind, @code{pthread_mutex_lock} simply suspends the calling
+thread forever.  If the mutex is of the ``error checking'' kind,
+@code{pthread_mutex_lock} returns immediately with the error code
+@code{EDEADLK}.  If the mutex is of the ``recursive'' kind, the call to
+@code{pthread_mutex_lock} returns immediately with a success return
+code. The number of times the thread owning the mutex has locked it is
+recorded in the mutex. The owning thread must call
+@code{pthread_mutex_unlock} the same number of times before the mutex
+returns to the unlocked state.
+
+The default mutex kind is ``fast'', that is, @code{PTHREAD_MUTEX_FAST_NP}.
+
+@comment pthread.h
+@comment GNU
+@deftypefun int pthread_mutexattr_setkind_np (pthread_mutexattr_t *@var{attr}, int @var{kind})
+@code{pthread_mutexattr_setkind_np} sets the mutex kind attribute in
+@var{attr} to the value specified by @var{kind}.
+
+If @var{kind} is not @code{PTHREAD_MUTEX_FAST_NP},
+@code{PTHREAD_MUTEX_RECURSIVE_NP}, or
+@code{PTHREAD_MUTEX_ERRORCHECK_NP}, this function will return
+@code{EINVAL} and leave @var{attr} unchanged.
+@end deftypefun
+
+@comment pthread.h
+@comment GNU
+@deftypefun int pthread_mutexattr_getkind_np (const pthread_mutexattr_t *@var{attr}, int *@var{kind})
+@code{pthread_mutexattr_getkind_np} retrieves the current value of the
+mutex kind attribute in @var{attr} and stores it in the location pointed
+to by @var{kind}.
+
+This function always returns 0.
+@end deftypefun
+
+@node Condition Variables
+@section Condition Variables
+
+A condition (short for ``condition variable'') is a synchronization
+device that allows threads to suspend execution until some predicate on
+shared data is satisfied. The basic operations on conditions are: signal
+the condition (when the predicate becomes true), and wait for the
+condition, suspending the thread execution until another thread signals
+the condition.
+
+A condition variable must always be associated with a mutex, to avoid
+the race condition where a thread prepares to wait on a condition
+variable and another thread signals the condition just before the first
+thread actually waits on it.
+
+@comment pthread.h
+@comment POSIX
+@deftypefun int pthread_cond_init (pthread_cond_t *@var{cond}, pthread_condattr_t *cond_@var{attr})
+
+@code{pthread_cond_init} initializes the condition variable @var{cond},
+using the condition attributes specified in @var{cond_attr}, or default
+attributes if @var{cond_attr} is @code{NULL}. The LinuxThreads
+implementation supports no attributes for conditions, hence the
+@var{cond_attr} parameter is actually ignored.
+
+Variables of type @code{pthread_cond_t} can also be initialized
+statically, using the constant @code{PTHREAD_COND_INITIALIZER}.
+
+This function always returns 0.
+@end deftypefun
+
+@comment pthread.h
+@comment POSIX
+@deftypefun int pthread_cond_signal (pthread_cond_t *@var{cond})
+@code{pthread_cond_signal} restarts one of the threads that are waiting
+on the condition variable @var{cond}. If no threads are waiting on
+@var{cond}, nothing happens. If several threads are waiting on
+@var{cond}, exactly one is restarted, but it is not specified which.
+
+This function always returns 0.
+@end deftypefun
+
+@comment pthread.h
+@comment POSIX
+@deftypefun int pthread_cond_broadcast (pthread_cond_t *@var{cond})
+@code{pthread_cond_broadcast} restarts all the threads that are waiting
+on the condition variable @var{cond}. Nothing happens if no threads are
+waiting on @var{cond}.
+
+This function always returns 0.
+@end deftypefun
+
+@comment pthread.h
+@comment POSIX
+@deftypefun int pthread_cond_wait (pthread_cond_t *@var{cond}, pthread_mutex_t *@var{mutex})
+@code{pthread_cond_wait} atomically unlocks the @var{mutex} (as per
+@code{pthread_unlock_mutex}) and waits for the condition variable
+@var{cond} to be signaled. The thread execution is suspended and does
+not consume any CPU time until the condition variable is signaled. The
+@var{mutex} must be locked by the calling thread on entrance to
+@code{pthread_cond_wait}. Before returning to the calling thread,
+@code{pthread_cond_wait} re-acquires @var{mutex} (as per
+@code{pthread_lock_mutex}).
+
+Unlocking the mutex and suspending on the condition variable is done
+atomically. Thus, if all threads always acquire the mutex before
+signaling the condition, this guarantees that the condition cannot be
+signaled (and thus ignored) between the time a thread locks the mutex
+and the time it waits on the condition variable.
+
+This function always returns 0.
+@end deftypefun
+
+@comment pthread.h
+@comment POSIX
+@deftypefun int pthread_cond_timedwait (pthread_cond_t *@var{cond}, pthread_mutex_t *@var{mutex}, const struct timespec *@var{abstime})
+@code{pthread_cond_timedwait} atomically unlocks @var{mutex} and waits
+on @var{cond}, as @code{pthread_cond_wait} does, but it also bounds the
+duration of the wait. If @var{cond} has not been signaled before time
+@var{abstime}, the mutex @var{mutex} is re-acquired and
+@code{pthread_cond_timedwait} returns the error code @code{ETIMEDOUT}.
+The wait can also be interrupted by a signal; in that case
+@code{pthread_cond_timedwait} returns @code{EINTR}.
+
+The @var{abstime} parameter specifies an absolute time, with the same
+origin as @code{time} and @code{gettimeofday}: an @var{abstime} of 0
+corresponds to 00:00:00 GMT, January 1, 1970.
+@end deftypefun
+
+@comment pthread.h
+@comment POSIX
+@deftypefun int pthread_cond_destroy (pthread_cond_t *@var{cond})
+@code{pthread_cond_destroy} destroys the condition variable @var{cond},
+freeing the resources it might hold.  If any threads are waiting on the
+condition variable, @code{pthread_cond_destroy} leaves @var{cond}
+untouched and returns @code{EBUSY}.  Otherwise it returns 0, and
+@var{cond} must not be used again until it is reinitialized.
+
+In the LinuxThreads implementation, no resources are associated with
+condition variables, so @code{pthread_cond_destroy} actually does
+nothing.
+@end deftypefun
+
+@code{pthread_cond_wait} and @code{pthread_cond_timedwait} are
+cancellation points. If a thread is cancelled while suspended in one of
+these functions, the thread immediately resumes execution, relocks the
+mutex specified by  @var{mutex}, and finally executes the cancellation.
+Consequently, cleanup handlers are assured that @var{mutex} is locked
+when they are called.
+
+It is not safe to call the condition variable functions from a signal
+handler. In particular, calling @code{pthread_cond_signal} or
+@code{pthread_cond_broadcast} from a signal handler may deadlock the
+calling thread.
+
+Consider two shared variables @var{x} and @var{y}, protected by the
+mutex @var{mut}, and a condition variable @var{cond} that is to be
+signaled whenever @var{x} becomes greater than @var{y}.
+
+@smallexample
+int x,y;
+pthread_mutex_t mut = PTHREAD_MUTEX_INITIALIZER;
+pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
+@end smallexample
+
+Waiting until @var{x} is greater than @var{y} is performed as follows:
+
+@smallexample
+pthread_mutex_lock(&mut);
+while (x <= y) @{
+        pthread_cond_wait(&cond, &mut);
+@}
+/* operate on x and y */
+pthread_mutex_unlock(&mut);
+@end smallexample
+
+Modifications on @var{x} and @var{y} that may cause @var{x} to become greater than
+@var{y} should signal the condition if needed:
+
+@smallexample
+pthread_mutex_lock(&mut);
+/* modify x and y */
+if (x > y) pthread_mutex_broadcast(&cond);
+pthread_mutex_unlock(&mut);
+@end smallexample
+
+If it can be proved that at most one waiting thread needs to be waken
+up (for instance, if there are only two threads communicating through
+@var{x} and @var{y}), @code{pthread_cond_signal} can be used as a slightly more
+efficient alternative to @code{pthread_cond_broadcast}. In doubt, use
+@code{pthread_cond_broadcast}.
+
+To wait for @var{x} to becomes greater than @var{y} with a timeout of 5
+seconds, do:
+
+@smallexample
+struct timeval now;
+struct timespec timeout;
+int retcode;
+
+pthread_mutex_lock(&mut);
+gettimeofday(&now);
+timeout.tv_sec = now.tv_sec + 5;
+timeout.tv_nsec = now.tv_usec * 1000;
+retcode = 0;
+while (x <= y && retcode != ETIMEDOUT) @{
+        retcode = pthread_cond_timedwait(&cond, &mut, &timeout);
+@}
+if (retcode == ETIMEDOUT) @{
+        /* timeout occurred */
+@} else @{
+        /* operate on x and y */
+@}
+pthread_mutex_unlock(&mut);
+@end smallexample
+
+Condition attributes can be specified at condition creation time, by
+passing a condition attribute object as second argument to
+@code{pthread_cond_init}.  Passing @code{NULL} is equivalent to passing
+a condition attribute object with all attributes set to their default
+values.
+
+The LinuxThreads implementation supports no attributes for
+conditions. The functions on condition attributes are included only for
+compliance with the POSIX standard.
+
+@comment pthread.h
+@comment POSIX
+@deftypefun int pthread_condattr_init (pthread_condattr_t *@var{attr})
+@deftypefunx int pthread_condattr_destroy (pthread_condattr_t *@var{attr})
+@code{pthread_condattr_init} initializes the condition attribute object
+@var{attr} and fills it with default values for the attributes.
+@code{pthread_condattr_destroy} destroys the condition attribute object
+@var{attr}.
+
+Both functions do nothing in the LinuxThreads implementation.
+
+@code{pthread_condattr_init} and @code{pthread_condattr_destroy} always
+return 0.
+@end deftypefun
+
+@node POSIX Semaphores
+@section POSIX Semaphores
+
+@vindex SEM_VALUE_MAX
+Semaphores are counters for resources shared between threads. The
+basic operations on semaphores are: increment the counter atomically,
+and wait until the counter is non-null and decrement it atomically.
+
+Semaphores have a maximum value past which they cannot be incremented.
+The macro @code{SEM_VALUE_MAX} is defined to be this maximum value.  In
+the GNU C library, @code{SEM_VALUE_MAX} is equal to @code{INT_MAX}
+(@pxref{Range of Type}), but it may be much smaller on other systems.
+
+The pthreads library implements POSIX 1003.1b semaphores.  These should
+not be confused with System V semaphores (@code{ipc}, @code{semctl} and
+@code{semop}).
+@c !!! SysV IPC is not doc'd at all in our manual
+
+All the semaphore functions and macros are defined in @file{semaphore.h}.
+
+@comment semaphore.h
+@comment POSIX
+@deftypefun int sem_init (sem_t *@var{sem}, int @var{pshared}, unsigned int @var{value})
+@code{sem_init} initializes the semaphore object pointed to by
+@var{sem}. The count associated with the semaphore is set initially to
+@var{value}. The @var{pshared} argument indicates whether the semaphore
+is local to the current process (@var{pshared} is zero) or is to be
+shared between several processes (@var{pshared} is not zero).
+
+On success @code{sem_init} returns 0.  On failure it returns -1 and sets
+@var{errno} to one of the following values:
+
+@table @code
+@item EINVAL
+@var{value} exceeds the maximal counter value @code{SEM_VALUE_MAX}
+
+@item ENOSYS
+@var{pshared} is not zero.  LinuxThreads currently does not support
+process-shared semaphores.  (This will eventually change.)
+@end table
+@end deftypefun
+
+@comment semaphore.h
+@comment POSIX
+@deftypefun int sem_destroy (sem_t * @var{sem})
+@code{sem_destroy} destroys a semaphore object, freeing the resources it
+might hold.  If any threads are waiting on the semaphore when
+@code{sem_destroy} is called, it fails and sets @var{errno} to
+@code{EBUSY}.
+
+In the LinuxThreads implementation, no resources are associated with
+semaphore objects, thus @code{sem_destroy} actually does nothing except
+checking that no thread is waiting on the semaphore.  This will change
+when process-shared semaphores are implemented.
+@end deftypefun
+
+@comment semaphore.h
+@comment POSIX
+@deftypefun int sem_wait (sem_t * @var{sem})
+@code{sem_wait} suspends the calling thread until the semaphore pointed
+to by @var{sem} has non-zero count. It then atomically decreases the
+semaphore count.
+
+@code{sem_wait} is a cancellation point.  It always returns 0.
+@end deftypefun
+
+@comment semaphore.h
+@comment POSIX
+@deftypefun int sem_trywait (sem_t * @var{sem})
+@code{sem_trywait} is a non-blocking variant of @code{sem_wait}. If the
+semaphore pointed to by @var{sem} has non-zero count, the count is
+atomically decreased and @code{sem_trywait} immediately returns 0.  If
+the semaphore count is zero, @code{sem_trywait} immediately returns -1
+and sets errno to @code{EAGAIN}.
+@end deftypefun
+
+@comment semaphore.h
+@comment POSIX
+@deftypefun int sem_post (sem_t * @var{sem})
+@code{sem_post} atomically increases the count of the semaphore pointed to
+by @var{sem}. This function never blocks.
+
+@c !!! This para appears not to agree with the code.
+On processors supporting atomic compare-and-swap (Intel 486, Pentium and
+later, Alpha, PowerPC, MIPS II, Motorola 68k, Ultrasparc), the
+@code{sem_post} function is can safely be called from signal handlers.
+This is the only thread synchronization function provided by POSIX
+threads that is async-signal safe.  On the Intel 386 and earlier Sparc
+chips, the current LinuxThreads implementation of @code{sem_post} is not
+async-signal safe, because the hardware does not support the required
+atomic operations.
+
+@code{sem_post} always succeeds and returns 0, unless the semaphore
+count would exceed @code{SEM_VALUE_MAX} after being incremented.  In
+that case @code{sem_post} returns -1 and sets @var{errno} to
+@code{EINVAL}.  The semaphore count is left unchanged.
+@end deftypefun
+
+@comment semaphore.h
+@comment POSIX
+@deftypefun int sem_getvalue (sem_t * @var{sem}, int * @var{sval})
+@code{sem_getvalue} stores in the location pointed to by @var{sval} the
+current count of the semaphore @var{sem}.  It always returns 0.
+@end deftypefun
+
+@node Thread-Specific Data
+@section Thread-Specific Data
+
+Programs often need global or static variables that have different
+values in different threads. Since threads share one memory space, this
+cannot be achieved with regular variables. Thread-specific data is the
+POSIX threads answer to this need.
+
+Each thread possesses a private memory block, the thread-specific data
+area, or TSD area for short. This area is indexed by TSD keys. The TSD
+area associates values of type @code{void *} to TSD keys. TSD keys are
+common to all threads, but the value associated with a given TSD key can
+be different in each thread.
+
+For concreteness, the TSD areas can be viewed as arrays of @code{void *}
+pointers, TSD keys as integer indices into these arrays, and the value
+of a TSD key as the value of the corresponding array element in the
+calling thread.
+
+When a thread is created, its TSD area initially associates @code{NULL}
+with all keys.
+
+@comment pthread.h
+@comment POSIX
+@deftypefun int pthread_key_create (pthread_key_t *@var{key}, void (*destr_function) (void *))
+@code{pthread_key_create} allocates a new TSD key. The key is stored in
+the location pointed to by @var{key}. There is a limit of
+@code{PTHREAD_KEYS_MAX} on the number of keys allocated at a given
+time. The value initially associated with the returned key is
+@code{NULL} in all currently executing threads.
+
+The @var{destr_function} argument, if not @code{NULL}, specifies a
+destructor function associated with the key. When a thread terminates
+via @code{pthread_exit} or by cancellation, @var{destr_function} is
+called on the value associated with the key in that thread. The
+@var{destr_function} is not called if a key is deleted with
+@code{pthread_key_delete} or a value is changed with
+@code{pthread_setspecific}.  The order in which destructor functions are
+called at thread termination time is unspecified.
+
+Before the destructor function is called, the @code{NULL} value is
+associated with the key in the current thread.  A destructor function
+might, however, re-associate non-@code{NULL} values to that key or some
+other key.  To deal with this, if after all the destructors have been
+called for all non-@code{NULL} values, there are still some
+non-@code{NULL} values with associated destructors, then the process is
+repeated.  The LinuxThreads implementation stops the process after
+@code{PTHREAD_DESTRUCTOR_ITERATIONS} iterations, even if some
+non-@code{NULL} values with associated descriptors remain.  Other
+implementations may loop indefinitely.
+
+@code{pthread_key_create} returns 0 unless @code{PTHREAD_KEYS_MAX} keys
+have already been allocated, in which case it fails and returns
+@code{EAGAIN}.
+@end deftypefun
+
+
+@comment pthread.h
+@comment POSIX
+@deftypefun int pthread_key_delete (pthread_key_t @var{key})
+@code{pthread_key_delete} deallocates a TSD key. It does not check
+whether non-@code{NULL} values are associated with that key in the
+currently executing threads, nor call the destructor function associated
+with the key.
+
+If there is no such key @var{key}, it returns @code{EINVAL}.  Otherwise
+it returns 0.
+@end deftypefun
+
+@comment pthread.h
+@comment POSIX
+@deftypefun int pthread_setspecific (pthread_key_t @var{key}, const void *@var{pointer})
+@code{pthread_setspecific} changes the value associated with @var{key}
+in the calling thread, storing the given @var{pointer} instead.
+
+If there is no such key @var{key}, it returns @code{EINVAL}.  Otherwise
+it returns 0.
+@end deftypefun
+
+@comment pthread.h
+@comment POSIX
+@deftypefun {void *} pthread_getspecific (pthread_key_t @var{key})
+@code{pthread_getspecific} returns the value currently associated with
+@var{key} in the calling thread.
+
+If there is no such key @var{key}, it returns @code{NULL}.
+@end deftypefun
+
+The following code fragment allocates a thread-specific array of 100
+characters, with automatic reclaimation at thread exit:
+
+@smallexample
+/* Key for the thread-specific buffer */
+static pthread_key_t buffer_key;
+
+/* Once-only initialisation of the key */
+static pthread_once_t buffer_key_once = PTHREAD_ONCE_INIT;
+
+/* Allocate the thread-specific buffer */
+void buffer_alloc(void)
+@{
+  pthread_once(&buffer_key_once, buffer_key_alloc);
+  pthread_setspecific(buffer_key, malloc(100));
+@}
+
+/* Return the thread-specific buffer */
+char * get_buffer(void)
+@{
+  return (char *) pthread_getspecific(buffer_key);
+@}
+
+/* Allocate the key */
+static void buffer_key_alloc()
+@{
+  pthread_key_create(&buffer_key, buffer_destroy);
+@}
+
+/* Free the thread-specific buffer */
+static void buffer_destroy(void * buf)
+@{
+  free(buf);
+@}
+@end smallexample
+
+@node Threads and Signal Handling
+@section Threads and Signal Handling
+
+@comment pthread.h
+@comment POSIX
+@deftypefun int pthread_sigmask (int @var{how}, const sigset_t *@var{newmask}, sigset_t *@var{oldmask})
+@code{pthread_sigmask} changes the signal mask for the calling thread as
+described by the @var{how} and @var{newmask} arguments. If @var{oldmask}
+is not @code{NULL}, the previous signal mask is stored in the location
+pointed to by @var{oldmask}.
+
+The meaning of the @var{how} and @var{newmask} arguments is the same as
+for @code{sigprocmask}. If @var{how} is @code{SIG_SETMASK}, the signal
+mask is set to @var{newmask}. If @var{how} is @code{SIG_BLOCK}, the
+signals specified to @var{newmask} are added to the current signal mask.
+If @var{how} is @code{SIG_UNBLOCK}, the signals specified to
+@var{newmask} are removed from the current signal mask.
+
+Recall that signal masks are set on a per-thread basis, but signal
+actions and signal handlers, as set with @code{sigaction}, are shared
+between all threads.
+
+The @code{pthread_sigmask} function returns 0 on success, and one of the
+following error codes on error:
+@table @code
+@item EINVAL
+@var{how} is not one of @code{SIG_SETMASK}, @code{SIG_BLOCK}, or @code{SIG_UNBLOCK}
+
+@item EFAULT
+@var{newmask} or @var{oldmask} point to invalid addresses
+@end table
+@end deftypefun
+
+@comment pthread.h
+@comment POSIX
+@deftypefun int pthread_kill (pthread_t @var{thread}, int @var{signo})
+@code{pthread_kill} sends signal number @var{signo} to the thread
+@var{thread}.  The signal is delivered and handled as described in
+@ref{Signal Handling}.
+
+@code{pthread_kill} returns 0 on success, one of the following error codes
+on error:
+@table @code
+@item EINVAL
+@var{signo} is not a valid signal number
+
+@item ESRCH
+The thread @var{thread} does not exist (e.g. it has already terminated)
+@end table
+@end deftypefun
+
+@comment pthread.h
+@comment POSIX
+@deftypefun int sigwait (const sigset_t *@var{set}, int *@var{sig})
+@code{sigwait} suspends the calling thread until one of the signals in
+@var{set} is delivered to the calling thread. It then stores the number
+of the signal received in the location pointed to by @var{sig} and
+returns. The signals in @var{set} must be blocked and not ignored on
+entrance to @code{sigwait}. If the delivered signal has a signal handler
+function attached, that function is @emph{not} called.
+
+@code{sigwait} is a cancellation point.  It always returns 0.
+@end deftypefun
+
+For @code{sigwait} to work reliably, the signals being waited for must be
+blocked in all threads, not only in the calling thread, since
+otherwise the POSIX semantics for signal delivery do not guarantee
+that it's the thread doing the @code{sigwait} that will receive the signal.
+The best way to achieve this is block those signals before any threads
+are created, and never unblock them in the program other than by
+calling @code{sigwait}.
+
+Signal handling in LinuxThreads departs significantly from the POSIX
+standard. According to the standard, ``asynchronous'' (external) signals
+are addressed to the whole process (the collection of all threads),
+which then delivers them to one particular thread. The thread that
+actually receives the signal is any thread that does not currently block
+the signal.
+
+In LinuxThreads, each thread is actually a kernel process with its own
+PID, so external signals are always directed to one particular thread.
+If, for instance, another thread is blocked in @code{sigwait} on that
+signal, it will not be restarted.
+
+The LinuxThreads implementation of @code{sigwait} installs dummy signal
+handlers for the signals in @var{set} for the duration of the
+wait. Since signal handlers are shared between all threads, other
+threads must not attach their own signal handlers to these signals, or
+alternatively they should all block these signals (which is recommended
+anyway).
+
+@node Miscellaneous Thread Functions
+@section Miscellaneous Thread Functions
+
+@comment pthread.h
+@comment POSIX
+@deftypefun {pthread_t} pthread_self (@var{void})
+@code{pthread_self} returns the thread identifier for the calling thread.
+@end deftypefun
+
+@comment pthread.h
+@comment POSIX
+@deftypefun int pthread_equal (pthread_t thread1, pthread_t thread2)
+@code{pthread_equal} determines if two thread identifiers refer to the same
+thread.
+
+A non-zero value is returned if @var{thread1} and @var{thread2} refer to
+the same thread. Otherwise, 0 is returned.
+@end deftypefun
+
+@comment pthread.h
+@comment POSIX
+@deftypefun int pthread_detach (pthread_t @var{th})
+@code{pthread_detach} puts the thread @var{th} in the detached
+state. This guarantees that the memory resources consumed by @var{th}
+will be freed immediately when @var{th} terminates. However, this
+prevents other threads from synchronizing on the termination of @var{th}
+using @code{pthread_join}.
+
+A thread can be created initially in the detached state, using the
+@code{detachstate} attribute to @code{pthread_create}. In contrast,
+@code{pthread_detach} applies to threads created in the joinable state,
+and which need to be put in the detached state later.
+
+After @code{pthread_detach} completes, subsequent attempts to perform
+@code{pthread_join} on @var{th} will fail. If another thread is already
+joining the thread @var{th} at the time @code{pthread_detach} is called,
+@code{pthread_detach} does nothing and leaves @var{th} in the joinable
+state.
+
+On success, 0 is returned. On error, one of the following codes is
+returned:
+@table @code
+@item ESRCH
+No thread could be found corresponding to that specified by @var{th}
+@item EINVAL
+The thread @var{th} is already in the detached state
+@end table
+@end deftypefun
+
+@comment pthread.h
+@comment POSIX
+@deftypefun int pthread_atfork (void (*@var{prepare})(void), void (*@var{parent})(void), void (*@var{child})(void))
+
+@code{pthread_atfork} registers handler functions to be called just
+before and just after a new process is created with @code{fork}. The
+@var{prepare} handler will be called from the parent process, just
+before the new process is created. The @var{parent} handler will be
+called from the parent process, just before @code{fork} returns. The
+@var{child} handler will be called from the child process, just before
+@code{fork} returns.
+
+@code{pthread_atfork} returns 0 on success and a non-zero error code on
+error.
+
+One or more of the three handlers @var{prepare}, @var{parent} and
+@var{child} can be given as @code{NULL}, meaning that no handler needs
+to be called at the corresponding point.
+
+@code{pthread_atfork} can be called several times to install several
+sets of handlers. At @code{fork} time, the @var{prepare} handlers are
+called in LIFO order (last added with @code{pthread_atfork}, first
+called before @code{fork}), while the @var{parent} and @var{child}
+handlers are called in FIFO order (first added, first called).
+
+If there is insufficient memory available to register the handlers,
+@code{pthread_atfork} fails and returns @code{ENOMEM}.  Otherwise it
+returns 0.
+@end deftypefun
+
+To understand the purpose of @code{pthread_atfork}, recall that
+@code{fork} duplicates the whole memory space, including mutexes in
+their current locking state, but only the calling thread: other threads
+are not running in the child process. Thus, if a mutex is locked by a
+thread other than the thread calling @code{fork}, that mutex will remain
+locked forever in the child process, possibly blocking the execution of
+the child process. To avoid this, install handlers with
+@code{pthread_atfork} as follows: the @var{prepare} handler locks the
+global mutexes (in locking order), and the @var{parent} and @var{child}
+handlers unlock them (in reverse order). Alternatively, @var{prepare}
+and @var{parent} can be set to @code{NULL} and @var{child} to a function
+that calls @code{pthread_mutex_init} on the global mutexes.
+
+@comment pthread.h
+@comment GNU
+@deftypefun void pthread_kill_other_threads_np (@var{void})
+@code{pthread_kill_other_threads_np} is a non-portable LinuxThreads extension.
+It causes all threads in the program to terminate immediately, except
+the calling thread which proceeds normally. It is intended to be
+called just before a thread calls one of the @code{exec} functions,
+e.g. @code{execve}.
+
+Termination of the other threads is not performed through
+@code{pthread_cancel} and completely bypasses the cancellation
+mechanism. Hence, the current settings for cancellation state and
+cancellation type are ignored, and the cleanup handlers are not
+executed in the terminated threads.
+
+According to POSIX 1003.1c, a successful @code{exec*} in one of the
+threads should automatically terminate all other threads in the program.
+This behavior is not yet implemented in LinuxThreads.  Calling
+@code{pthread_kill_other_threads_np} before @code{exec*} achieves much
+of the same behavior, except that if @code{exec*} ultimately fails, then
+all other threads are already killed.
+@end deftypefun
+
+@comment pthread.h
+@comment POSIX
+@deftypefun int pthread_once (pthread_once_t *once_@var{control}, void (*@var{init_routine}) (void))
+
+The purpose of @code{pthread_once} is to ensure that a piece of
+initialization code is executed at most once. The @var{once_control}
+argument points to a static or extern variable statically initialized
+to @code{PTHREAD_ONCE_INIT}.
+
+The first time @code{pthread_once} is called with a given
+@var{once_control} argument, it calls @var{init_routine} with no
+argument and changes the value of the @var{once_control} variable to
+record that initialization has been performed. Subsequent calls to
+@code{pthread_once} with the same @code{once_control} argument do
+nothing.
+
+@code{pthread_once} always returns 0.
+@end deftypefun
+
+@comment pthread.h
+@comment POSIX
+@deftypefun int pthread_setschedparam (pthread_t target_@var{thread}, int @var{policy}, const struct sched_param *@var{param})
+
+@code{pthread_setschedparam} sets the scheduling parameters for the
+thread @var{target_thread} as indicated by @var{policy} and
+@var{param}. @var{policy} can be either @code{SCHED_OTHER} (regular,
+non-realtime scheduling), @code{SCHED_RR} (realtime, round-robin) or
+@code{SCHED_FIFO} (realtime, first-in first-out). @var{param} specifies
+the scheduling priority for the two realtime policies.  See
+@code{sched_setpolicy} for more information on scheduling policies.
+
+The realtime scheduling policies @code{SCHED_RR} and @code{SCHED_FIFO}
+are available only to processes with superuser privileges.
+
+On success, @code{pthread_setschedparam} returns 0.  On error it returns
+one of the following codes:
+@table @code
+@item EINVAL
+@var{policy} is not one of @code{SCHED_OTHER}, @code{SCHED_RR},
+@code{SCHED_FIFO}, or the priority value specified by @var{param} is not
+valid for the specified policy
+
+@item EPERM
+Realtime scheduling was requested but the calling process does not have
+sufficient privileges.
+
+@item ESRCH
+The @var{target_thread} is invalid or has already terminated
+
+@item EFAULT
+@var{param} points outside the process memory space
+@end table
+@end deftypefun
+
+@comment pthread.h
+@comment POSIX
+@deftypefun int pthread_getschedparam (pthread_t target_@var{thread}, int *@var{policy}, struct sched_param *@var{param})
+
+@code{pthread_getschedparam} retrieves the scheduling policy and
+scheduling parameters for the thread @var{target_thread} and stores them
+in the locations pointed to by @var{policy} and @var{param},
+respectively.
+
+@code{pthread_getschedparam} returns 0 on success, or one of the
+following error codes on failure:
+@table @code
+@item ESRCH
+The @var{target_thread} is invalid or has already terminated.
+
+@item EFAULT
+@var{policy} or @var{param} point outside the process memory space.
+
+@end table
+@end deftypefun
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
diff --git a/sysdeps/unix/sysv/linux/i386/dl-procinfo.h b/sysdeps/unix/sysv/linux/i386/dl-procinfo.h
index 4520e6cfe0..77c859ba53 100644
--- a/sysdeps/unix/sysv/linux/i386/dl-procinfo.h
+++ b/sysdeps/unix/sysv/linux/i386/dl-procinfo.h
@@ -27,8 +27,8 @@ static const char x86_cap_flags[][7] =
   {
     "fpu", "vme", "de", "pse", "tsc", "msr", "pae", "mce",
     "cx8", "apic", "10", "sep", "mtrr", "pge", "mca", "cmov",
-    "fcmov", "17", "18", "19", "20", "21", "22", "mmx",
-    "osfxsr", "25", "26", "27", "28", "29", "30", "amd3d"
+    "pat", "pse36", "18", "19", "20", "21", "22", "mmx",
+    "fxsr", "25", "26", "27", "28", "29", "30", "amd3d"
   };
 
 static inline int
diff --git a/sysdeps/unix/sysv/linux/recvmsg.c b/sysdeps/unix/sysv/linux/recvmsg.c
index 14a3417da8..3795d91b90 100644
--- a/sysdeps/unix/sysv/linux/recvmsg.c
+++ b/sysdeps/unix/sysv/linux/recvmsg.c
@@ -35,10 +35,7 @@ struct __kernel_ucred
 extern int __syscall_recvmsg (int, struct msghdr *, int);
 
 int
-__libc_recvmsg (fd, message, flags)
-     int fd;
-     struct msghdr *message;
-     int flags;
+__libc_recvmsg (int fd, struct msghdr *message, int flags)
 {
   struct cmsghdr *cm;
   int ret;
diff --git a/sysdeps/unix/sysv/linux/sendmsg.c b/sysdeps/unix/sysv/linux/sendmsg.c
index bc12b051e7..273add903e 100644
--- a/sysdeps/unix/sysv/linux/sendmsg.c
+++ b/sysdeps/unix/sysv/linux/sendmsg.c
@@ -37,10 +37,7 @@ extern int __syscall_sendmsg (int, const struct msghdr *, int);
 /* Send a message described by MESSAGE on socket FD.
    Returns the number of bytes sent, or -1 for errors.  */
 int
-__libc_sendmsg (fd, message, flags)
-     int fd;
-     const struct msghdr *message;
-     int flags;
+__libc_sendmsg (int fd, const struct msghdr *message, int flags)
 {
   struct cmsghdr *cm;
   struct cmsgcred *cc;