Regenerated.
[kopensolaris-gnu/glibc.git] / manual / top-menu.texi
index 2ad64ae..6ff8bd6 100644 (file)
@@ -77,6 +77,26 @@ Introduction
 * Roadmap to the Manual::       Overview of the remaining chapters in
                                  this manual.
 
+Standards and Portability
+
+* ISO C::                       The international 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.
+* XPG::                         The X/Open Portability Guide.
+
+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.
+* Feature Test Macros::         How to control what names are defined.
+
 Error Reporting
 
 * Checking for Errors::         How errors are reported by library functions.
@@ -99,6 +119,68 @@ Memory Allocation
 * 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}.
+* Malloc Tunable Parameters::   Use @code{mallopt} to adjust allocation
+                                 parameters.
+* 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.
+
+Allocation Debugging
+
+* Tracing malloc::               How to install the tracing functionality.
+* Using the Memory Debugger::    Example programs excerpts.
+* Tips for the Memory Debugger:: Some more or less clever ideas.
+* Interpreting the traces::      What do all these lines mean?
+
+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::
+
+Variable Size Automatic
+
+* 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
@@ -123,6 +205,11 @@ String and Array Utilities
 * Encode Binary Data::          Encoding and Decoding of Binary Data.
 * Argz and Envz Vectors::       Null-separated string vectors.
 
+Argz and Envz Vectors
+
+* Argz Functions::              Operations on argz vectors.
+* Envz Functions::              Additional operations on environment vectors.
+
 Extended Characters
 
 * Extended Char Intro::         Multibyte codes versus wide characters.
@@ -150,11 +237,41 @@ Locales
 * Numeric Formatting::          How to format numbers according to the
                                  chosen locale.
 
+Numeric Formatting
+
+* General Numeric::             Parameters for formatting numbers and
+                                 currency amounts.
+* Currency Symbol::             How to print the symbol that identifies an
+                                 amount of money (e.g. @samp{$}).
+* Sign of Money Amount::        How to print the (positive or negative) sign
+                                 for a monetary amount, if one exists.
+
 Message Translation
 
 * Message catalogs a la X/Open::  The @code{catgets} family of functions.
 * The Uniforum approach::         The @code{gettext} family of functions.
 
+Message catalogs a la X/Open
+
+* The catgets Functions::      The @code{catgets} function family.
+* The message catalog files::  Format of the message catalog files.
+* The gencat program::         How to generate message catalogs files which
+                                can be used by the functions.
+* Common Usage::               How to use the @code{catgets} interface.
+
+The Uniforum approach
+
+* Message catalogs with gettext::  The @code{gettext} family of functions.
+* Helper programs for gettext::    Programs to handle message catalogs
+                                    for @code{gettext}.
+
+Message catalogs with gettext
+
+* Translation with gettext::    What has to be done to translate a message.
+* Locating gettext catalog::    How to determine which catalog to be used.
+* Using gettextized software::  The possibilities of the user to influence
+                                 the way @code{gettext} works.
+
 Searching and Sorting
 
 * Comparison Functions::        Defining how to compare two objects.
@@ -176,11 +293,48 @@ Pattern Matching
                            arithmetic, and wildcards.
                            This is what the shell does with shell commands.
 
+Globbing
+
+* Calling Glob::             Basic use of @code{glob}.
+* Flags for Globbing::       Flags that enable various options in @code{glob}.
+* More Flags for Globbing::  GNU specific extensions to @code{glob}.
+
+Regular Expressions
+
+* POSIX Regexp Compilation::    Using @code{regcomp} to prepare to match.
+* Flags for POSIX Regexps::     Syntax variations for @code{regcomp}.
+* Matching POSIX Regexps::      Using @code{regexec} to match the compiled
+                                  pattern that you get from @code{regcomp}.
+* Regexp Subexpressions::       Finding which parts of the string were matched.
+* Subexpression Complications:: Find points of which parts were matched.
+* Regexp Cleanup::             Freeing storage; reporting errors.
+
+Word Expansion
+
+* Expansion Stages::   What word expansion does to a string.
+* Calling Wordexp::    How to call @code{wordexp}.
+* Flags for Wordexp::   Options you can enable in @code{wordexp}.
+* Wordexp Example::    A sample program that does word expansion.
+
 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.
@@ -207,6 +361,83 @@ I/O on Streams
                                  to an open file.
 * Formatted Messages::          Print strictly formatted messages.
 
+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 and
+                                 what they do.
+* Integer Conversions::         Details about formatting of integers.
+* Floating-Point Conversions::  Details about formatting of
+                                 floating-point numbers.
+* Other Output Conversions::    Details about formatting of strings,
+                                 characters, pointers, and the like.
+* Formatted Output Functions::  Descriptions of the actual functions.
+* Dynamic Output::             Functions that allocate memory for the output.
+* Variable Arguments Output::   @code{vprintf} and friends.
+* Parsing a Template String::   What kinds of args does a given template
+                                 call for?
+* Example of Parsing::          Sample program using @code{parse_printf_format}.
+
+Customizing Printf
+
+* Registering New Conversions::         Using @code{register_printf_function}
+                                         to register a new output conversion.
+* Conversion Specifier Options::        The handler must be able to get
+                                         the options specified in the
+                                         template when it is called.
+* Defining the Output Handler::         Defining the handler and arginfo
+                                         functions that are passed as arguments
+                                         to @code{register_printf_function}.
+* Printf Extension Example::            How to define a @code{printf}
+                                         handler function.
+* Predefined Printf Handlers::          Predefined @code{printf} handlers.
+
+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.
+* Dynamic String Input::       String conversions that @code{malloc} the buffer.
+* 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::              Streams that get data from or put data in
+                                 a string or memory buffer.
+* Obstack Streams::            Streams that store data in an obstack.
+* Custom Streams::              Defining your own streams with an arbitrary
+                                 input data source and/or output data sink.
+
+Custom Streams
+
+* Streams and Cookies::         The @dfn{cookie} records where to fetch or
+                                 store data that is read or written.
+* Hook Functions::              How you should define the four @dfn{hook
+                                 functions} that a custom stream needs.
+
+Formatted Messages
+
+* Printing Formatted Messages::   The @code{fmtmsg} function.
+* Adding Severity Classes::       Add more severity classes.
+* Example::                       How to use @code{fmtmsg} and @code{addseverity}.
+
 Low-Level I/O
 
 * Opening and Closing Files::           How to open and close file
@@ -219,6 +450,8 @@ Low-Level I/O
                                          or vice-versa.
 * Stream/Descriptor Precautions::       Precautions needed if you use both
                                          descriptors and streams.
+* Scatter-Gather::                      Fast I/O to discontinous buffers.
+* Memory-mapped I/O::                   Using files like memory.
 * 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.
@@ -236,6 +469,29 @@ Low-Level I/O
                                          file locking.
 * Interrupt Input::                     Getting an asynchronous signal when
                                          input arrives.
+* IOCTLs::                              Generic I/O Control operations.
+
+Stream/Descriptor Precautions
+
+* Linked Channels::       Dealing with channels sharing a file position.
+* Independent Channels::   Dealing with separately opened, unlinked channels.
+* Cleaning Streams::      Cleaning a stream makes it safe to use
+                            another channel.
+
+Asynchronous I/O
+
+* Asynchronous Reads/Writes::    Asynchronous Read and Write Operations.
+* Status of AIO Operations::     Getting the Status of AIO Operations.
+* Synchronizing AIO Operations:: Getting into a consistent state.
+* Cancel AIO Operations::        Cancelation of AIO Operations.
+* Configuration of AIO::         How to optimize the AIO implementation.
+
+File Status Flags
+
+* Access Modes::                Whether the descriptor can read or write.
+* Open-time Flags::             Details of @code{open}.
+* Operating Modes::             Special modes to control I/O operations.
+* Getting File Status Flags::   Fetching and changing these flags.
 
 File System Interface
 
@@ -254,6 +510,36 @@ File System Interface
 * Making Special Files::        How to create special files.
 * Temporary Files::             Naming and creating temporary 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.
+* Scanning Directory Content::  Get entries for user selected subset of
+                                 contents in given directory.
+* Simple Directory Lister Mark II::  Revised version of the program.
+
+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.
@@ -280,6 +566,82 @@ 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.
+
+Local Namespace
+
+* Concepts: Local Namespace Concepts. What you need to understand.
+* Details: Local Namespace Details.   Address format, symbolic names, etc.
+* Example: Local Socket Example.      Example of creating a socket.
+
+Internet Namespace
+
+* Internet Address Formats::    How socket addresses are specified in the
+                                 Internet namespace.
+* Host Addresses::             All about host addresses of internet host.
+* Protocols Database::         Referring to protocols by name.
+* Ports::                      Internet port numbers.
+* 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 program: a 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{send}.
+* Receiving Data::             Reading data with @code{recv}.
+* 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 socket in the local namespace.
+* Example Receiver::    Another program, that receives those packets.
+
+Inetd
+
+* Inetd Servers::
+* Configuring Inetd::
+
+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
@@ -294,6 +656,40 @@ Low-Level Terminal Interface
 * Noncanon Example::            How to read single characters without echo.
 * Pseudo-Terminals::            How to open a pseudo-terminal.
 
+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.
+* 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::          Special characters that terminate lines and
+                                  delete text, and other editing functions.
+* Signal Characters::           Special characters that send or raise signals
+                                  to or for certain classes of processes.
+* Start/Stop Characters::       Special characters that suspend or resume
+                                  suspended output.
+* Other Special::              Other special characters for BSD systems:
+                                 they can discard output, and print status.
+
+Pseudo-Terminals
+
+* Allocation::             Allocating a pseudo terminal.
+* Pseudo-Terminal Pairs::  How to open both sides of a
+                            pseudo-terminal in a single operation.
+
 Mathematics
 
 * Mathematical Constants::      Precise numeric values for often-used
@@ -307,6 +703,12 @@ Mathematics
                                 numbers.
 * FP Function Optimizations::   Fast code or small code.
 
+Pseudo-Random Numbers
+
+* ISO Random::                  @code{rand} and friends.
+* BSD Random::                  @code{random} and friends.
+* SVID Random::                 @code{drand48} and friends.
+
 Arithmetic
 
 * Floating Point Numbers::      Basic concepts.  IEEE 754.
@@ -321,6 +723,29 @@ Arithmetic
 * Parsing of Numbers::          Converting strings to numbers.
 * System V Number Conversion::  An archaic way to convert numbers to strings.
 
+Floating Point Errors
+
+* 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.
+
+Arithmetic Functions
+
+* 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.
+
+Parsing of Numbers
+
+* Parsing of Integers::         Functions for conversion of integer values.
+* Parsing of Floats::           Functions for conversion of floating-point
+                                values.
+
 Date and Time
 
 * Processor Time::              Measures processor time used by a program.
@@ -331,6 +756,22 @@ Date and Time
 * Limits on Resources::                Specifying limits on resource usage.
 * Priority::                   Reading or setting process run priority.
 
+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.
+
 Non-Local Exits
 
 * Intro: Non-Local Intro.        When and how to use these facilities.
@@ -355,6 +796,91 @@ Signal Handling
 * BSD Signal Handling::         Additional functions for backward
                                 compatibility with BSD.
 
+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.
+
+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 Handlers
+
+* Handler Returns::             Handlers that return normally, and what
+                                 this means.
+* Termination in Handler::      How handler functions terminate a program.
+* Longjmp in Handler::          Nonlocal transfer of control out of a
+                                 signal handler.
+* Signals in Handler::          What happens when signals arrive while
+                                 the handler is already occupied.
+* Merged Signals::             When a second signal arrives before the
+                                first is handled.
+* Nonreentrancy::               Do not call any functions unless you know they
+                                 are reentrant with respect to signals.
+* Atomic Data Access::          A single handler can run in the middle of
+                                 reading or writing a single object.
+
+Atomic Data Access
+
+* Non-atomic Example::         A program illustrating interrupted access.
+* Types: Atomic Types.         Data types that guarantee no interruption.
+* Usage: Atomic Usage.         Proving that interruption is harmless.
+
+Generating Signals
+
+* Signaling Yourself::          A process can send a signal to itself.
+* 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
 
 * Program Arguments::           Parsing your program's command-line arguments.
@@ -363,6 +889,37 @@ Process Startup
 * 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.
+
 Processes
 
 * Running a Command::           The easy way to run another program.
@@ -386,6 +943,24 @@ Job Control
 * Implementing a Shell::        What a shell must do to implement job control.
 * Functions for Job Control::   Functions to control process groups.
 
+Implementing a 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.
@@ -393,6 +968,26 @@ Name Service Switch
 * NSS Module Internals::        How does it work internally.
 * Extending NSS::               What to do to add services or databases.
 
+NSS Configuration File
+
+* Services in the NSS configuration::  Service names in the NSS configuration.
+* Actions in the NSS configuration::  React appropriately to the lookup result.
+* Notes on NSS Configuration File::  Things to take care about while
+                                     configuring NSS.
+
+NSS Module Internals
+
+* NSS Module Names::            Construction of the interface function of
+                                the NSS modules.
+* NSS Modules Interface::       Programming interface in the NSS module
+                                functions.
+
+Extending NSS
+
+* Adding another Service to NSS::  What is to do to add a new service.
+* NSS Module Function Internals::  Guidelines for writing new NSS
+                                        service functions.
+
 Users and Groups
 
 * User and Group IDs::          Each user has a unique numeric ID;
@@ -424,6 +1019,34 @@ Users and Groups
                                 inquiry functions.
 * Netgroup Database::           Functions for accessing the netgroup database.
 
+User Accounting Database
+
+* Manipulating the Database::   Scanning and modifying the user
+                                 accounting database.
+* XPG Functions::               A standardized way for doing the same thing.
+* Logging In and Out::          Functions from BSD that modify the user
+                                 accounting database.
+
+User Database
+
+* User Data Structure::         What each user record contains.
+* Lookup User::                 How to look for a particular user.
+* Scanning All Users::          Scanning the list of all users, one by one.
+* Writing a User Entry::        How a program can rewrite a user's record.
+
+Group Database
+
+* Group Data Structure::        What each group record contains.
+* Lookup Group::                How to look for a particular group.
+* Scanning All Groups::         Scanning the list of all groups.
+
+Netgroup Database
+
+* Netgroup Data::                  Data in the Netgroup database and where
+                                   it comes from.
+* Lookup Netgroup::                How to look for a particular netgroup.
+* Netgroup Membership::            How to test for netgroup membership.
+
 System Information
 
 * Host Identification::         Determining the name of the machine.
@@ -455,6 +1078,13 @@ System Configuration
 
 * String Parameters::        Getting the default search path.
 
+Sysconf
+
+* Sysconf Definition::        Detailed specifications of @code{sysconf}.
+* Constants for Sysconf::     The list of parameters @code{sysconf} can read.
+* Examples of Sysconf::       How to use @code{sysconf} and the parameter
+                                macros properly together.
+
 POSIX Threads
 
 * Basic Thread Operations::     Creating, terminating, and waiting for threads.
@@ -481,6 +1111,41 @@ Language Features
 * 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.
+* Variadic Example::            A complete example.
+
+How Variadic
+
+* 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.
+* Argument Macros::      Detailed specification of the macros
+                         for accessing variable arguments.
+* Old Varargs::                 The pre-ISO way of defining variadic 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 the floating point types.
+* Structure Measurement::   Getting measurements on structure types.
+
+Floating Type Macros
+
+* Floating Point Concepts::     Definitions of terminology.
+* Floating Point Parameters::   Details of specific macros.
+* IEEE Floating Point::         The measurements for one common
+                                 representation.
+
 Installation
 
 * Tools for Installation::      We recommend using these tools to build.
@@ -496,4 +1161,10 @@ Maintenance
                              to the GNU C library.
 * Porting::               How to port the GNU C library to
                              a new machine or operating system.
+
+Porting
+
+* Hierarchy Conventions::       The layout of the @file{sysdeps} hierarchy.
+* Porting to Unix::             Porting the library to an average
+                                   Unix-like system.
 @end menu