Added copying permission info to copyright page.
[kopensolaris-gnu/glibc.git] / manual / libc.texinfo
index 53dd9e8..e720f85 100644 (file)
@@ -1,20 +1,52 @@
 \input texinfo                  @c -*- Texinfo -*-
 @comment %**start of header (This is for running Texinfo on a region.)
-@setfilename library.info
+@setfilename libc.info
 @settitle The GNU C Library
 @setchapternewpage odd
 @comment %**end of header (This is for running Texinfo on a region.)
 
+@smallbook
+
+@set EDITION 0.04 (Preliminary)
+@set VERSION 1.07 Beta
+@set UPDATED 20 June 1993
+
 @ifinfo
 This file documents the GNU C library.
 
-Copyright (C) 1992 Free Software Foundation, Inc.
-
-This will be free information when it is finished, but isn't finished yet.
+This is Edition @value{EDITION}, last updated @value{UPDATED},
+of @cite{The GNU C Library Reference Manual}, for Version @value{VERSION}.
+
+Copyright (C) 1993 Free Software Foundation, Inc.
+
+Permission is granted to make and distribute verbatim copies of
+this manual provided the copyright notice and this permission notice
+are preserved on all copies.
+
+@ignore
+Permission is granted to process this file through TeX and print the
+results, provided the printed document carries copying permission
+notice identical to this one except for the removal of this paragraph
+(this paragraph not being relevant to the printed manual).
+
+@end ignore
+Permission is granted to copy and distribute modified versions of this
+manual under the conditions for verbatim copying, provided also that the
+section entitled ``GNU Library General Public License'' is included
+exactly as in the original, and provided that the entire resulting
+derived work is distributed under the terms of a permission notice
+identical to this one.
+
+Permission is granted to copy and distribute translations of this manual
+into another language, under the above conditions for modified versions,
+except that the text of the translations of the section entitled ``GNU
+Library General Public License'' must be approved for accuracy by the
+Foundation.
 @end ifinfo
 
-@setchapternewpage odd
-
+@iftex
+@shorttitlepage The GNU C Library Reference Manual
+@end iftex
 @titlepage
 @center @titlefont{The GNU C Library}
 @sp 1
@@ -24,81 +56,97 @@ This will be free information when it is finished, but isn't finished yet.
 @center with
 @center Roland McGrath, Andrew Oram, and Richard M. Stallman
 @sp 3
-@center last updated January 10, 1992
+@center last updated @value{UPDATED}
 @sp 1
-@center for version 0.00
+@center for version @value{VERSION}
 @page
 @vskip 0pt plus 1filll
-Copyright @copyright{} 1992 Free Software Foundation, Inc.
+Copyright @copyright{} 1993 Free Software Foundation, Inc.
+@sp 2
+Published by the Free Software Foundation @*
+675 Massachusetts Avenue, @*
+Cambridge, MA 02139 USA @*
+Printed copies are available for $50 each.
+
+Permission is granted to make and distribute verbatim copies of
+this manual provided the copyright notice and this permission notice
+are preserved on all copies.
+
+Permission is granted to copy and distribute modified versions of this
+manual under the conditions for verbatim copying, provided also that the
+section entitled ``GNU Library General Public License'' is included
+exactly as in the original, and provided that the entire resulting
+derived work is distributed under the terms of a permission notice
+identical to this one.
+
+Permission is granted to copy and distribute translations of this manual
+into another language, under the above conditions for modified versions,
+except that the text of the translation of the section entitled ``GNU
+Library General Public License'' must be approved for accuracy by the
+Foundation.
 @end titlepage
 @page
 
 @ifinfo
 @node Top, Introduction, (dir), (dir)
 @top Main Menu
-This is the reference manual for version 0.00 of the GNU C Library.
+This is the reference manual for version @value{VERSION} 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.
+                                 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.
+                                 strings and arrays.
 * Extended Characters::         Support for extended character sets.
 * Locales::                     The country and language can affect
-                                         the behavior of library functions.
-* Searching and Sorting::       General searching and sorting
-                                        functions.
-* I/O Overview::       Introduction to the i/o facilities.
-* I/O on Streams::     High-level, portable i/o facilities.
-* Low-Level I/O::      Low-level, less portable i/o.
+                                 the behavior of library functions.
+* 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,
-                                         random numbers, abs value).
+* 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 conversion between formats.
-* Non-Local Exits::             The @code{setjmp} and @code{longjmp}
-                                        facilities.
+* 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.
-* Processes::                   How to create processes and run other
-                                        programs.
+                                 block them, and handle them.
+* Process Startup::             Writing the beginning and end of your program.
+* Child Processes::             How to create processes and run other programs.
 * Job Control::                 All about process groups and sessions.
-* Users and Groups::            
+* 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 Limits::  Parameters describing operating
-                                        system limits.
+                                 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. 
 
-* Summary of Library Facilities::  A summary showing the syntax, header
-                                         file, and derivation of each library
-                                         feature.
-* Maintenance::                 How to install and maintain the
-                                         GNU C Library.
-* Copying::                     The GNU Library General Public License
-                                         says how you can copy and share the
-                                         GNU C Library.
+* Library Summary::             A summary showing the syntax, header file,
+                                 and derivation of each library feature.
+* Maintenance::                 How to install and maintain 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.
@@ -117,24 +165,24 @@ Introduction
 Standards and Portability
 
 * ANSI C::                      The American National Standard for the
-                                C programming language.  
+                                 C programming language.  
 * POSIX::                       The IEEE 1003 standards for operating systems.
 * Berkeley Unix::               BSD and SunOS.
 * SVID::                        The System V Interface Description.  
 
 Using the Library
 
-* Header Files::                How to include 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.
+* 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::                 Error Codes
+* Error Codes::                 What all the error codes are.
 * Error Messages::              Mapping error codes onto error messages.
 
 Memory Allocation
@@ -142,28 +190,30 @@ 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.
+                                 dynamic allocation.
 * Obstacks::                    Obstacks are less general than malloc
-                                but more efficient and convenient.
+                                 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::        
+                                 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.
+* Memory Warnings::             Getting warnings when memory is nearly full.
 
 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}.
+                                 got with @code{malloc}.
 * Changing Block Size::         Use @code{realloc} to make a block
-                                bigger or smaller.
+                                 bigger or smaller.
 * Allocating Cleared Space::    Use @code{calloc} to allocate a
-                                block and clear it.
+                                 block and clear it.
 * Efficiency and Malloc::       Efficiency considerations in use of
-                                these functions.
+                                 these functions.
 * Aligned Memory Blocks::       Allocating specially aligned memory:
-                                @code{memalign} and @code{valloc}.
+                                 @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}.
@@ -173,25 +223,20 @@ Unconstrained Allocation
 
 Obstacks
 
-* Representation of Obstacks::  How to declare an obstack in your
-                                        program.
-* Preparing to Use Obstacks::   Preparations needed before you can
-                                        use 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 and Macros::  The obstack functions are both
-                                        functions and macros.
+* 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 Objects::  Extra-high-efficiency (though more
-                                        complicated) growing.
-* 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.
-* Obstacks and Signal Handling::  Don't try to use obstack functions
-                                        in a signal handler.
+* 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
@@ -200,13 +245,17 @@ Automatic Storage with Variable Size
 * 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.
+                                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.
+* Classification of Characters::Testing whether characters are
+                                 letters, digits, punctuation, etc.
 * Case Conversion::             Case mapping, and the like.
 
 String and Array Utilities
@@ -242,16 +291,11 @@ 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 library functions.
+* 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 according to the chosen locale.
-
-Numeric Formatting
-
-* General Numeric::             
-* Currency Symbol::             
-* Sign of Money Amount::        
+* Numeric Formatting::          How to format numbers for the chosen locale.
 
 Searching and Sorting 
 
@@ -262,29 +306,39 @@ Searching and Sorting
 * 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.
+* 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::               
+* 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::       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.
+                                 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.
@@ -293,12 +347,12 @@ I/O on Streams
 * 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.
+                                 @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.
+                                 and binary files.
 * File Positioning::            About random-access streams.
 * Portable Positioning::        Random access on peculiar ANSI C systems.
 * Stream Buffering::            How to control buffering of streams.
@@ -313,19 +367,16 @@ 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 and
-                                         what they do.
-* Integer Conversions::         Details about formatting of integers.
-* Floating-Point Conversions::  Details about formatting of
-                                         floating-point numbers.
+* 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.
+                                 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 args
-                                         does a given template call for?
+* Variable Arguments Output::   @code{vprintf} and friends.
+* Parsing a Template String::   What kinds of arguments does
+                                 a given template call for?
 
 Customizing Printf
 
@@ -343,7 +394,7 @@ Formatted Input
 * 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.
+* Variable Arguments Input::    @code{vscanf} and friends.
 
 Stream Buffering
 
@@ -366,31 +417,24 @@ 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.
+* Descriptors and Streams::     Converting descriptor to stream or vice-versa.
 * Stream/Descriptor Precautions::  Precautions needed if you use both
-                                         descriptors and streams.
+                                    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 file
-                                        descriptors.
+                                 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.
+                                 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.
+                                 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.
+* 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.
@@ -410,76 +454,98 @@ Accessing Directories
 
 File Attributes
 
-* Attribute Meanings::          The names of the file attributes, 
-                           and what their values mean.
+* 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...
+* 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.
+                                 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.
+                                 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 process.
+* Pipe to a Subprocess::        Using a pipe to communicate with a child.
 * FIFO Special Files::          Making a FIFO special file.
 
 Sockets
 
-* Socket Creation and Naming::  Functions for creating and
-                                         initializing sockets.
-* Domains and Protocols::       How to specify the communications
-                                        protocol for a socket.
-* Local Domain::            Details about the local (Unix) domain.
-* Internet Domain::         Details about the Internet domain.
-* Types of Sockets::            Different socket types have different
-                                        semantics for data transmission.
-* Byte Stream Sockets::  Operations on sockets with connection
-                                        state.
-* Datagram Socket Operations::  Operations on datagram sockets.
+* Socket Concepts::             Basic concepts you need to know about.
+* Communication Styles::        Stream communication, datagrams, and others.
+* Socket Addresses::            How socket names (``addresses'') work.
+* File Namespace::              Details about the file 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
 
-Socket Creation and Naming
+* Internet Address Format::     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 Naming::               You must associate a name with a socket
-                                        before it can receive data.
 * Socket Pairs::                These are created like pipes.
 
-Internet Domain
+Connections
 
-* Protocols Database::          Selecting a communications protocol.
-* Internet Socket Naming::      How socket names are specified in the Internet
-                                 domain.
-* Internet Host Addresses::     Hosts are assigned addresses that are numbers.
-* Hosts Database::              A host may also have a symbolic host name.
-* Services Database::           Ports may also have symbolic names.
-* Networks Database::           There is also a database for network names.
-* Byte Order Conversion::       Different hosts may use different byte
-                                 ordering conventions; you need to canonicalize
-                                 host address and port numbers.
-* Internet Socket Example::     Putting it all together.
-
-Byte Stream Sockets
-
-* Establishing a Connection::   The socket must be connected before it
-                                 can transmit data.
+* 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 Socket Example::  An example program.
+* 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.
 
-Datagram Socket Operations
+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}.
 
-* Transmitting Datagrams::      Functions for sending and receiving messages
-                                 on a datagram socket.
-* Datagram Socket Example::     An example program.
+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 file namespace.
+* Example Receiver::            Another program, that receives those packets.
 
 Socket Options
 
@@ -490,26 +556,26 @@ Socket Options
 Low-Level Terminal Interface
 
 * Is It a Terminal::            How to determine if a file is a terminal
-                         device, and what its name is.
+                                 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...
+                                 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 the terminal attributes.
-* Setting Modes::               The right way to set terminal attributes reliably.
+* 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.
+                                 and how to change them.
 * Noncanonical Input::          Controlling how long to wait for input.
 
 Special Characters
@@ -520,38 +586,34 @@ Special Characters
 
 Mathematics
 
-* Domain and Range Errors::     How overflow conditions and the like
-                                        are reported.
+* 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.
+* 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.
+* Pseudo-Random Numbers::       Functions for generating pseudo-random numbers.
 * Absolute Value::              Absolute value functions.
 
 Pseudo-Random Numbers
 
-* ANSI C Random Number Functions::  @code{rand} and friends.
-* BSD Random Number Functions::  @code{random} and friends.
+* ANSI 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::  Determinining the integer and
-                                        fractional parts of a float.
-* Integer Division::            Functions for performing integer
-                                        division.
-* Parsing of Numbers::          Functions for ``reading'' numbers
-                                        from strings.
+* Rounding and Remainders::     Determinining 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
-                                values.
+* Parsing of Floats::           Functions for conversion of floating-point.
 
 Date and Time
 
@@ -572,30 +634,23 @@ Calendar Time
 * Broken-down Time::            Facilities for manipulating local time.
 * Formatting Date and Time::    Converting times to strings.
 * TZ Variable::                 How users specify the time zone.
-* TZ Functions::         Functions to examine or 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.
-
-Non-Local Exits
-
-* Intro to Non-Local Exits::  An overview of how and when to use
-                                        these facilities.
-* Functions for Non-Local Exits::  Details of the interface.
-* Non-Local Exits and Signals::  Portability issues.
+                                 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.
+                                 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.
 * BSD Signal Handling::         Additional functions for backward
-                            compatibility with BSD.
+                                 compatibility with BSD.
 * BSD Handler::                 BSD Function to Establish a Handler
 
 Basic Concepts of Signals
@@ -612,7 +667,7 @@ Standard Signals
 * Asynchronous I/O Signals::    Used to indicate input is available.
 * Job Control Signals::         Signals used to support job control.
 * Miscellaneous Signals::       Miscellaneous Signals
-* Other Signals::               Implementations can support other signals.
+* Nonstandard Signals::         Implementations can support other signals.
 * Signal Messages::             Printing a message describing a signal.
 
 Specifying Signal Actions
@@ -629,7 +684,7 @@ Defining Signal Handlers
 * Handler Returns::             
 * Termination in Handler::      
 * Longjmp in Handler::          
-* Signals in Succession::       
+* Signals in Handler::       
 * Nonreentrancy::               
 * Atomic Data Access::          
 
@@ -645,14 +700,14 @@ 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.
+                                 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
+                                 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.
+                                 as blocking a signal, by handling it
+                                 and setting a flag to be tested later.
 
 Waiting for a Signal
 
@@ -662,60 +717,61 @@ Waiting for a Signal
 
 BSD Signal Handling
 
-* POSIX vs BSD::                Overview comparing BSD and POSIX signal functions.
+* POSIX vs BSD::                Comparison of BSD and POSIX signal functions.
 
 BSD Function to Establish a Handler
 
 * Blocking in BSD::             BSD Functions for Blocking Signals 
 * Signal Stack::                Using a Separate Signal Stack
 
-Processes
+Process Startup and Termination
 
-* Program Arguments::           Parsing the command-line arguments to
-                                a program.
+* Program Arguments::           Parsing your program's command-line arguments.
 * Environment Variables::       How to access parameters inherited from
-                                a parent process.
+                                 a parent process.
 * Program Termination::         How to cause a process to terminate and
-                                return status information to its parent.
-* Creating New Processes::      Running other programs.
+                                 return status information to its parent.
 
 Program Arguments
 
-* Argument Syntax Conventions::  By convention, program
-                                                 options are specified by a
-                                                 leading hyphen.
-* Parsing Program Arguments::   The @code{getopt} function.
-* Example Using getopt::  An example of @code{getopt}.
+* Argument Syntax::             By convention, options start with a hyphen.
+* Parsing Options::             The @code{getopt} function.
+* Example of Getopt::           An example of parsing options with @code{getopt}.
+* Long Options::                GNU utilities should accept long-named options.
+                                 Here is how to do that.
+* Long Option Example::         An example of using @code{getopt_long}.
 
 Environment Variables
 
 * Environment Access::          How to get and set the values of
-                                        environment variables.
-* Standard Environment Variables::  These environment variables have
-                                        standard interpretations.
+                                 environment variables.
+* Standard Environment::        These environment variables have
+                                 standard interpretations.
 
 Program Termination
 
-* Normal Program Termination::  
-* Exit Status::                 Exit Status
-* Cleanups on Exit::            Cleanups on Exit
-* Aborting a Program::          
-* Termination Internals::       Termination Internals
+* 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.
 
-Creating New Processes
+
+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 get a process to execute another
-                                        program.
-* Process Completion::          How to tell when a child process has
-                                        completed.
+* 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.
+                                 returned from a child process.
+* BSD Wait Functions::          More functions, for backward compatibility.
 * Process Creation Example::    A complete example program.
 
 Job Control
@@ -732,13 +788,13 @@ 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.
+                                 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.
+* 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.
+                                 the foreground or background.
+* Missing Pieces::              Other parts of the shell.
 
 Functions for Job Control
 
@@ -748,26 +804,26 @@ Functions for Job Control
 
 Users and Groups
 
-* User and Group IDs::          Each user has a unique numeric ID; likewise for 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 the user and group IDs.
-* Reading Persona::             How to examine the process's user and group IDs.
+                                 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.
+                                 or of the real user ID of the current process.
 
 * User Database::               Functions and data structures for
-                         accessing the user database.
+                                 accessing the user database.
 * Group Database::              Functions and data structures for
-                         accessing the group database.
+                                 accessing the group database.
 * Database Example::            Example program showing use of database
-                        inquiry functions.
+                                 inquiry functions.
 
 User Database
 
@@ -784,75 +840,88 @@ Group 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.
+* Host Identification::         Determining the name of the machine.
+* Hardware/Software Type ID::   Determining the hardware type and
+                                 operating system type.
 
 System Configuration Limits
 
-* File System Parameters::      Constants and functions that describe
-                                various file system limits.
-
-* System Parameters::           Constants and functions that describe
-                                various process-related limits.
-
-* String-Valued Parameters::    Constants and functions that describe
-                                string-valued 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 args.
+                                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.
+* 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.
+                                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 Argument Values::   Steps you must follow to access the
-                                  optional argument values.
+                                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 Variadic Functions::  Things you need to know about calling
-                                  variable arguments functions.
+* Calling Variadics::          Things you need to know about calling
+                                variable arguments functions.
 
 Data Type Measurements
 
-* Integer Type Macros::         Parameters that measure the integer types.
-* Floating Type Macros::        Parameters that measure the floating point types.
+* 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::   Floating-Point Parameters
+* 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.
+                                 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.
+                                 get them fixed) and other troubles
+                                 you may have with the GNU C library.
 * Porting::                     How to port the GNU C library to
-                                         a new machine or operating system.
-* Traditional C Compatibility::  Using the GNU C library with non-ANSI
-                                         C compilers.
-* GNU C Library Contributors::  Contributors to the GNU C Library.
+                                 a new machine or operating system.
+@c * Traditional C Compatibility::  Using the GNU C library with non-ANSI
+@c                                          C compilers.
+* Contributors::               Who wrote what parts of the GNU C Library.
 
 Porting the GNU C Library
 
@@ -863,51 +932,71 @@ Porting the GNU C Library
 @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 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 child.texi
+@include job.texi
+@include users.texi
+@include sysinfo.texi
+@include conf.texi
 
-@include intro.texinfo
-@include errno.texinfo
-@include memory.texinfo
-@include ctype.texinfo
-@include string.texinfo
-@include mbyte.texinfo
-@include locale.texinfo
-@include search.texinfo
-@include io.texinfo
-@include stdio.texinfo
-@include llio.texinfo
-@include filesys.texinfo
-@include pipe.texinfo
-@include socket.texinfo
-@include terminal.texinfo
-@include math.texinfo
-@include arith.texinfo
-@include time.texinfo
-@include setjmp.texinfo
-@include signal.texinfo
-@include process.texinfo
-@include job.texinfo
-@include users.texinfo
-@include sysinfo.texinfo
-@include conf.texinfo
-@include lang.texinfo
-
-@include header.texinfo
-@include maint.texinfo
-
-@c @set lgpl-appendix
-@c node Copying, Concept Index, Maintenance, Top
-@c @include lgpl.texinfo
-@include copying.texinfo
-
-@include index-cp.texi
-
-@include index-tp.texi
-   
-@include index-fn.texi
+@comment Includes of the appendices.
+@include lang.texi
+@include header.texi
+@include maint.texi
+
+
+@set lgpl-appendix
+@node Copying, Concept Index, Maintenance, Top
+@include lgpl.texinfo
+
+
+@node Concept Index, Type Index, Copying, Top
+@unnumbered Concept Index
+
+@printindex cp
+
+@node Type Index, Function Index, Concept Index, Top
+@unnumbered Type Index
+
+@printindex tp
+
+@node Function Index, Variable Index, Type Index, Top
+@unnumbered Function and Macro Index
+
+@printindex fn
+
+@node Variable Index, File Index, Function Index, Top
+@unnumbered Variable and Constant Macro Index
+
+@printindex vr
+
+@node File Index, , Variable Index, Top
+@unnumbered Program and File Index
 
-@include index-vr.texi
+@printindex pg
 
-@include index-pg.texi
 
 @shortcontents
 @contents