This is Info file libc.info, produced by Makeinfo version 1.67 from the
input file libc.texinfo.

   This file documents the GNU C library.

   This is Edition 0.07 DRAFT, last updated 4 Oct 1996, of `The GNU C
Library Reference Manual', for Version 2.00 Beta.

   Copyright (C) 1993, '94, '95, '96 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.

   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.


File: libc.info,  Node: Concept Index,  Next: Type Index,  Prev: Copying,  Up: Top

Concept Index
*************

* Menu:

* /etc/nsswitch.conf:                    NSS Configuration File.
* 4.N BSD Unix:                          Berkeley Unix.
* _POSIX_OPTION_ORDER environment variable.: Standard Environment.
* abort signal:                          Program Error Signals.
* aborting a program:                    Aborting a Program.
* absolute file name:                    File Name Resolution.
* absolute value functions:              Absolute Value.
* accepting connections:                 Accepting Connections.
* access permission for a file:          Access Permission.
* access, testing for:                   Testing File Access.
* accessing directories:                 Accessing Directories.
* address of socket:                     Socket Addresses.
* alarm signal:                          Alarm Signals.
* alarms, setting:                       Setting an Alarm.
* alignment (in obstacks):               Obstacks Data Alignment.
* alignment (with malloc):               Aligned Memory Blocks.
* alloca disadvantages:                  Disadvantages of Alloca.
* alloca function:                       Variable Size Automatic.
* allocation (obstacks):                 Allocation in an Obstack.
* allocation hooks, for malloc:          Hooks for Malloc.
* allocation of memory with malloc:      Basic Allocation.
* allocation size of string:             Representation of Strings.
* allocation statistics:                 Statistics of Malloc.
* alphabetic character:                  Classification of Characters.
* alphanumeric character:                Classification of Characters.
* append-access files:                   File Position.
* argc (program argument count):         Program Arguments.
* argument promotion:                    Calling Variadics.
* arguments (variadic functions):        Receiving Arguments.
* arguments, how many:                   How Many Arguments.
* arguments, to program:                 Program Arguments.
* argv (program argument vector):        Program Arguments.
* arithmetic expansion:                  Expansion Stages.
* array comparison functions:            String/Array Comparison.
* array copy functions:                  Copying and Concatenation.
* array search function:                 Array Search Function.
* array sort function:                   Array Sort Function.
* ASCII character:                       Classification of Characters.
* assertions:                            Consistency Checking.
* attributes of a file:                  Attribute Meanings.
* automatic allocation:                  Memory Concepts.
* automatic freeing:                     Variable Size Automatic.
* automatic storage with variable size:  Variable Size Automatic.
* background job:                        Concepts of Job Control.
* background job, launching:             Foreground and Background.
* base (of floating point number):       Floating Point Concepts.
* basic byte sequence:                   Multibyte Char Intro.
* baud rate:                             Line Speed.
* Berkeley Unix:                         Berkeley Unix.
* bias (of floating point number exponent): Floating Point Concepts.
* big-endian:                            Byte Order.
* binary I/O to a stream:                Block Input/Output.
* binary search function (for arrays):   Array Search Function.
* binary stream:                         Binary Streams.
* binding a socket address:              Socket Addresses.
* blank character:                       Classification of Characters.
* block I/O to a stream:                 Block Input/Output.
* blocked signals:                       Delivery of Signal.
* blocked signals, checking for:         Checking for Pending Signals.
* blocking signals:                      Blocking Signals.
* blocking signals, in a handler:        Blocking for Handler.
* bootstrapping, and services:           Actions in the NSS configuration.
* break condition, detecting:            Input Modes.
* break condition, generating:           Line Control.
* breaking a string into tokens:         Finding Tokens in a String.
* broken pipe signal:                    Operation Error Signals.
* broken-down time <1>:                  Broken-down Time.
* broken-down time:                      Calendar Time.
* BSD compatibility library:             Process Group Functions.
* BSD compatibility library.:            Feature Test Macros.
* BSD Unix:                              Berkeley Unix.
* buffering of streams:                  Stream Buffering.
* buffering, controlling:                Controlling Buffering.
* bugs, reporting:                       Reporting Bugs.
* bus error:                             Program Error Signals.
* byte order conversion, for socket:     Byte Order.
* byte stream:                           Socket Concepts.
* calendar time:                         Calendar Time.
* calendar time and broken-down time:    Broken-down Time.
* calling variadic functions:            Calling Variadics.
* canonical input processing:            Canonical or Not.
* capacity limits, POSIX:                General Limits.
* carrier detect:                        Control Modes.
* case conversion of characters:         Case Conversion.
* catching signals:                      Delivery of Signal.
* categories for locales:                Locale Categories.
* change working directory:              Working Directory.
* changing the locale:                   Setting the Locale.
* changing the size of a block (malloc): Changing Block Size.
* changing the size of a block (obstacks): Growing Objects.
* channels:                              Stream/Descriptor Precautions.
* character case conversion:             Case Conversion.
* character code:                        Wide Char Intro.
* character predicates:                  Classification of Characters.
* character testing:                     Classification of Characters.
* checking for pending signals:          Checking for Pending Signals.
* child process <1>:                     Process Creation Concepts.
* child process:                         Processes.
* child process signal:                  Job Control Signals.
* chunks:                                Obstack Chunks.
* classification of characters:          Classification of Characters.
* cleaning up a stream:                  Linked Channels.
* clearing terminal input queue:         Line Control.
* client:                                Connections.
* clock ticks:                           Processor Time.
* close-on-exec (file descriptor flag):  Descriptor Flags.
* closing a file descriptor:             Opening and Closing Files.
* closing a socket:                      Closing a Socket.
* closing a stream:                      Closing Streams.
* code, character:                       Wide Char Intro.
* collating strings:                     Collation Functions.
* combining locales:                     Choosing Locale.
* command argument syntax:               Argument Syntax.
* command arguments, parsing:            Parsing Options.
* command line arguments:                Program Arguments.
* command substitution:                  Expansion Stages.
* communication style (of a socket):     Socket Concepts.
* comparing strings and arrays:          String/Array Comparison.
* Comparison Function:                   Comparison Functions.
* concatenating strings:                 Copying and Concatenation.
* configurations, all supported:         Supported Configurations.
* connecting a socket:                   Connecting.
* connection:                            Connections.
* consistency checking:                  Consistency Checking.
* consistency checking, of heap:         Heap Consistency Checking.
* continue signal:                       Job Control Signals.
* control character:                     Classification of Characters.
* control operations on files:           Control Operations.
* controlling process:                   Controlling Terminal.
* controlling terminal:                  Concepts of Job Control.
* controlling terminal, access to:       Access to the Terminal.
* controlling terminal, determining:     Identifying the Terminal.
* controlling terminal, setting:         Open-time Flags.
* conversion specifications (printf):    Formatted Output Basics.
* conversion specifications (scanf):     Formatted Input Basics.
* converting byte order:                 Byte Order.
* converting case of characters:         Case Conversion.
* converting extended characters:        Converting One Char.
* converting extended strings:           Wide String Conversion.
* converting file descriptor to stream:  Descriptors and Streams.
* converting floats to integers:         Rounding and Remainders.
* converting group ID to group name:     Lookup Group.
* converting group name to group ID:     Lookup Group.
* converting host address to name:       Host Names.
* converting host name to address:       Host Names.
* converting network name to network number: Networks Database.
* converting network number to network name: Networks Database.
* converting port number to service name: Services Database.
* converting service name to port number: Services Database.
* converting string to collation order:  Collation Functions.
* converting strings to numbers:         Parsing of Numbers.
* converting user ID to user name:       Lookup User.
* converting user name to user ID:       Lookup User.
* cookie, for custom stream:             Streams and Cookies.
* copying strings and arrays:            Copying and Concatenation.
* CPU time:                              Processor Time.
* create on open (file status flag):     Open-time Flags.
* creating a directory:                  Creating Directories.
* creating a FIFO special file:          FIFO Special Files.
* creating a pipe:                       Creating a Pipe.
* creating a pipe to a subprocess:       Pipe to a Subprocess.
* creating a process:                    Process Creation Concepts.
* creating a socket:                     Creating a Socket.
* creating a socket pair:                Socket Pairs.
* creating special files:                Making Special Files.
* cube root function:                    Exponents and Logarithms.
* currency symbols:                      Currency Symbol.
* current working directory:             Working Directory.
* custom streams:                        Custom Streams.
* customizing printf:                    Customizing Printf.
* data loss on sockets:                  Socket Concepts.
* databases:                             Name Service Switch.
* datagram socket:                       Datagrams.
* datagrams, transmitting:               Sending Datagrams.
* date and time:                         Calendar Time.
* Daylight Saving Time:                  Broken-down Time.
* decimal digit character:               Classification of Characters.
* decimal-point separator:               General Numeric.
* declaration (compared to definition):  Header Files.
* declaring variadic functions:          Calling Variadics.
* default action (for a signal):         Delivery of Signal.
* default action for a signal:           Basic Signal Handling.
* default argument promotions:           Calling Variadics.
* default value, and NSS:                Notes on NSS Configuration File.
* defining new printf conversions:       Customizing Printf.
* definition (compared to declaration):  Header Files.
* delayed suspend character:             Signal Characters.
* deleting a directory:                  Deleting Files.
* deleting a file:                       Deleting Files.
* delivery of signals:                   Delivery of Signal.
* descriptors and streams:               Stream/Descriptor Precautions.
* digit character:                       Classification of Characters.
* directories, accessing:                Accessing Directories.
* directories, creating:                 Creating Directories.
* directories, deleting:                 Deleting Files.
* directory:                             Directories.
* directory entry:                       Directories.
* directory stream:                      Accessing Directories.
* disadvantages of alloca:               Disadvantages of Alloca.
* DISCARD character:                     Other Special.
* DNS server unavailable:                Actions in the NSS configuration.
* domain (of socket):                    Socket Concepts.
* domain error:                          Domain and Range Errors.
* dot notation, for Internet addresses:  Abstract Host Addresses.
* DSUSP character:                       Signal Characters.
* duplicating file descriptors:          Duplicating Descriptors.
* dynamic allocation:                    Memory Concepts.
* echo of terminal input:                Local Modes.
* effective group ID:                    Process Persona.
* effective user ID:                     Process Persona.
* efficiency and malloc:                 Efficiency and Malloc.
* efficiency and obstacks:               Extra Fast Growing.
* efficiency of chunks:                  Obstack Chunks.
* EINTR, and restarting interrupted primitives: Interrupted Primitives.
* end of file, on a stream:              EOF and Errors.
* end-of-file, on a file descriptor:     I/O Primitives.
* environment:                           Environment Variables.
* environment access:                    Environment Access.
* environment representation:            Environment Access.
* environment variable:                  Environment Variables.
* EOF character:                         Editing Characters.
* EOL character:                         Editing Characters.
* EOL2 character:                        Editing Characters.
* epoch:                                 Simple Calendar Time.
* ERASE character:                       Editing Characters.
* error codes:                           Error Reporting.
* error reporting:                       Error Reporting.
* establishing a handler:                Signal Actions.
* ethers:                                NSS Basics.
* exception:                             Program Error Signals.
* exclusive lock:                        File Locks.
* exec functions:                        Executing a File.
* executing a file:                      Executing a File.
* exit status:                           Exit Status.
* exit status value:                     Program Termination.
* expansion of shell words:              Word Expansion.
* exponent (of floating point number):   Floating Point Concepts.
* exponentiation functions:              Exponents and Logarithms.
* extended character sets:               Extended Characters.
* extended characters, converting:       Converting One Char.
* extended strings, converting representations: Wide String Conversion.
* extending printf:                      Customizing Printf.
* extracting file descriptor from stream: Descriptors and Streams.
* fcntl function:                        Control Operations.
* feature test macros:                   Feature Test Macros.
* field splitting:                       Expansion Stages.
* FIFO special file:                     Pipes and FIFOs.
* file access permission:                Access Permission.
* file access time:                      File Times.
* file attribute modification time:      File Times.
* file attributes:                       Attribute Meanings.
* file creation mask:                    Setting Permissions.
* file descriptor flags:                 Descriptor Flags.
* file descriptor sets, for select:      Waiting for I/O.
* file descriptors, standard:            Descriptors and Streams.
* file locks:                            File Locks.
* file modification time:                File Times.
* file name:                             File Names.
* file name component:                   Directories.
* file name errors:                      File Name Errors.
* file name resolution:                  File Name Resolution.
* file name translation flags:           Open-time Flags.
* file names, multiple:                  Hard Links.
* file namespace, for sockets:           File Namespace.
* file owner:                            File Owner.
* file permission bits:                  Permission Bits.
* file pointer:                          Streams.
* file position:                         File Position.
* file positioning on a file descriptor: File Position Primitive.
* file positioning on a stream:          File Positioning.
* file status flags:                     File Status Flags.
* filtering i/o through subprocess:      Pipe to a Subprocess.
* flag character (printf):               Output Conversion Syntax.
* flag character (scanf):                Input Conversion Syntax.
* flags for sigaction:                   Flags for Sigaction.
* flags, file name translation:          Open-time Flags.
* flags, open-time action:               Open-time Flags.
* floating point, IEEE:                  IEEE Floating Point.
* floating type measurements:            Floating Type Macros.
* floating-point exception:              Program Error Signals.
* flow control, terminal:                Line Control.
* flushing a stream:                     Flushing Buffers.
* flushing terminal output queue:        Line Control.
* foreground job:                        Concepts of Job Control.
* foreground job, launching:             Foreground and Background.
* forking a process:                     Process Creation Concepts.
* format string, for printf:             Formatted Output.
* format string, for scanf:              Formatted Input.
* formatted input from a stream:         Formatted Input.
* formatted output to a stream:          Formatted Output.
* freeing (obstacks):                    Freeing Obstack Objects.
* freeing memory allocated with malloc:  Freeing after Malloc.
* fully buffered stream:                 Buffering Concepts.
* function prototypes (variadic):        Variadic Prototypes.
* generation of signals:                 Signal Generation.
* globbing:                              Globbing.
* graphic character:                     Classification of Characters.
* Gregorian calendar:                    Calendar Time.
* group:                                 NSS Basics.
* group database:                        Group Database.
* group ID:                              User and Group IDs.
* group name:                            User and Group IDs.
* group owner of a file:                 File Owner.
* grouping of digits:                    General Numeric.
* growing objects (in obstacks):         Growing Objects.
* handle:                                Relocator Concepts.
* handling multiple signals:             Merged Signals.
* hangup signal:                         Termination Signals.
* hard limit:                            Limits on Resources.
* hard link:                             Hard Links.
* header files:                          Header Files.
* heap consistency checking:             Heap Consistency Checking.
* heap, dynamic allocation from:         Unconstrained Allocation.
* heap, freeing memory from:             Freeing after Malloc.
* hexadecimal digit character:           Classification of Characters.
* hidden bit (of floating point number mantissa): Floating Point Concepts.
* high-priority data:                    Out-of-Band Data.
* high-resolution time:                  Calendar Time.
* holes in files:                        File Position Primitive.
* home directory:                        Standard Environment.
* HOME environment variable:             Standard Environment.
* hook functions (of custom streams):    Hook Functions.
* host address, Internet:                Abstract Host Addresses.
* hosts:                                 NSS Basics.
* hosts database:                        Host Names.
* how many arguments:                    How Many Arguments.
* hyperbolic functions:                  Hyperbolic Functions.
* identifying terminals:                 Is It a Terminal.
* IEEE floating point:                   Not a Number.
* IEEE floating point representation:    IEEE Floating Point.
* IEEE Std 1003.1:                       POSIX.
* IEEE Std 1003.2:                       POSIX.
* ignore action for a signal:            Basic Signal Handling.
* illegal instruction:                   Program Error Signals.
* impossible events:                     Consistency Checking.
* independent channels:                  Independent Channels.
* initial signal actions:                Initial Signal Actions.
* inode number:                          Attribute Meanings.
* input available signal:                Asynchronous I/O Signals.
* input conversions, for scanf:          Table of Input Conversions.
* input from multiple files:             Waiting for I/O.
* installation tools:                    Tools for Installation.
* installing the library:                Installation.
* integer division functions:            Integer Division.
* integer type range:                    Range of Type.
* integer type width:                    Width of Type.
* interactive signals, from terminal:    Local Modes.
* interactive stop signal:               Job Control Signals.
* internationalization:                  Locales.
* Internet host address:                 Abstract Host Addresses.
* Internet namespace, for sockets:       Internet Namespace.
* interprocess communication, with FIFO: FIFO Special Files.
* interprocess communication, with pipes: Creating a Pipe.
* interprocess communication, with signals: Kill Example.
* interprocess communication, with sockets: Sockets.
* interrupt character:                   Signal Characters.
* interrupt signal:                      Termination Signals.
* interrupt-driven input:                Interrupt Input.
* interrupting primitives:               Interrupted Primitives.
* interval timer, setting:               Setting an Alarm.
* INTR character:                        Signal Characters.
* inverse hyperbolic functions:          Hyperbolic Functions.
* inverse trigonometric functions:       Inverse Trig Functions.
* invocation of program:                 Program Arguments.
* ISO C:                                 ISO C.
* job:                                   Job Control.
* job control:                           Job Control.
* job control functions:                 Functions for Job Control.
* job control is optional:               Job Control is Optional.
* job control signals:                   Job Control Signals.
* job control, enabling:                 Initializing the Shell.
* Kermit the frog:                       Search/Sort Example.
* KILL character:                        Editing Characters.
* kill signal:                           Termination Signals.
* killing a process:                     Signaling Another Process.
* LANG environment variable:             Standard Environment.
* launching jobs:                        Launching Jobs.
* LC_COLLATE environment variable:       Standard Environment.
* LC_CTYPE environment variable:         Standard Environment.
* LC_MONETARY environment variable:      Standard Environment.
* LC_NUMERIC environment variable:       Standard Environment.
* LC_TIME environment variable:          Standard Environment.
* leap second:                           Broken-down Time.
* length of multibyte character:         Length of Char.
* length of string:                      Representation of Strings.
* level, for socket options:             Socket Options.
* library:                               Introduction.
* limits on resource usage:              Limits on Resources.
* limits, file name length:              Limits for Files.
* limits, floating types:                Floating Type Macros.
* limits, integer types:                 Range of Type.
* limits, link count of files:           Limits for Files.
* limits, number of open files:          General Limits.
* limits, number of processes:           General Limits.
* limits, number of supplementary group IDs: General Limits.
* limits, pipe buffer size:              Limits for Files.
* limits, POSIX:                         General Limits.
* limits, program argument size:         General Limits.
* limits, terminal input queue:          Limits for Files.
* limits, time zone name length:         General Limits.
* line buffered stream:                  Buffering Concepts.
* line speed:                            Line Speed.
* lines (in a text file):                Binary Streams.
* link:                                  Directories.
* link, hard:                            Hard Links.
* link, soft:                            Symbolic Links.
* link, symbolic:                        Symbolic Links.
* linked channels:                       Linked Channels.
* listening (sockets):                   Listening.
* little-endian:                         Byte Order.
* LNEXT character:                       Other Special.
* local network address number:          Abstract Host Addresses.
* local time:                            Calendar Time.
* locale categories:                     Locale Categories.
* locale, changing:                      Setting the Locale.
* locales:                               Locales.
* logarithm functions:                   Exponents and Logarithms.
* login name:                            User and Group IDs.
* login name, determining:               Who Logged In.
* LOGNAME environment variable:          Standard Environment.
* long jumps:                            Non-Local Exits.
* long-named options:                    Argument Syntax.
* longjmp:                               Advantages of Alloca.
* loss of data on sockets:               Socket Concepts.
* lost resource signal:                  Operation Error Signals.
* lower-case character:                  Classification of Characters.
* macros:                                Obstack Functions.
* main function:                         Program Arguments.
* malloc function:                       Unconstrained Allocation.
* mantissa (of floating point number):   Floating Point Concepts.
* matching failure, in scanf:            Formatted Input Basics.
* maximum field width (scanf):           Input Conversion Syntax.
* measurements of floating types:        Floating Type Macros.
* memory allocation:                     Memory Allocation.
* memory usage warnings:                 Memory Warnings.
* merging of signals:                    Merged Signals.
* MIN termios slot:                      Noncanonical Input.
* minimum field width (printf):          Output Conversion Syntax.
* mixing descriptors and streams:        Stream/Descriptor Precautions.
* modem disconnect:                      Control Modes.
* modem status lines:                    Control Modes.
* monetary value formatting:             Numeric Formatting.
* multibyte character, length of:        Length of Char.
* multibyte characters:                  Multibyte Char Intro.
* multiple names for one file:           Hard Links.
* multiplexing input:                    Waiting for I/O.
* name of running program:               Error Messages.
* name of socket:                        Socket Addresses.
* Name Service Switch:                   Name Service Switch.
* name space:                            Reserved Names.
* names of signals:                      Standard Signals.
* namespace (of socket):                 Socket Concepts.
* NaN:                                   Not a Number.
* Netgroup:                              Netgroup Data.
* netgroup:                              NSS Basics.
* network:                               NSS Basics.
* network byte order:                    Byte Order.
* network number:                        Abstract Host Addresses.
* network protocol:                      Socket Concepts.
* networks database:                     Networks Database.
* nisplus, and booting:                  Actions in the NSS configuration.
* nisplus, and completeness:             Actions in the NSS configuration.
* non-blocking open:                     Open-time Flags.
* non-local exit, from signal handler:   Longjmp in Handler.
* non-local exits:                       Non-Local Exits.
* noncanonical input processing:         Canonical or Not.
* normalization functions (floating-point): Normalization Functions.
* normalized floating point number:      Floating Point Concepts.
* not a number:                          Not a Number.
* NSS:                                   Name Service Switch.
* nsswitch.conf:                         NSS Configuration File.
* null character:                        Representation of Strings.
* null pointer constant:                 Null Pointer Constant.
* number of arguments passed:            How Many Arguments.
* number syntax, parsing:                Parsing of Numbers.
* numeric value formatting:              Numeric Formatting.
* obstack status:                        Status of an Obstack.
* obstacks:                              Obstacks.
* open-time action flags:                Open-time Flags.
* opening a file:                        I/O Concepts.
* opening a file descriptor:             Opening and Closing Files.
* opening a pipe:                        Creating a Pipe.
* opening a socket:                      Creating a Socket.
* opening a socket pair:                 Socket Pairs.
* opening a stream:                      Opening Streams.
* optimizing NSS:                        Notes on NSS Configuration File.
* optional arguments:                    Variadic Functions.
* optional POSIX features:               System Options.
* orphaned process group:                Orphaned Process Groups.
* out-of-band data:                      Out-of-Band Data.
* output conversions, for printf:        Table of Output Conversions.
* output possible signal:                Asynchronous I/O Signals.
* owner of a file:                       File Owner.
* packet:                                Socket Concepts.
* page boundary:                         Aligned Memory Blocks.
* parent directory:                      File Name Resolution.
* parent process <1>:                    Process Creation Concepts.
* parent process:                        Processes.
* parity checking:                       Input Modes.
* parsing a template string:             Parsing a Template String.
* parsing numbers (in formatted input):  Parsing of Numbers.
* parsing program arguments:             Parsing Options.
* parsing tokens from a string:          Finding Tokens in a String.
* passwd:                                NSS Basics.
* password database:                     User Database.
* PATH environment variable:             Standard Environment.
* pause function:                        Waiting for a Signal.
* peeking at input:                      Unreading.
* pending signals:                       Delivery of Signal.
* pending signals, checking for:         Checking for Pending Signals.
* permission to access a file:           Access Permission.
* persona:                               Process Persona.
* pi (trigonometric constant):           Trig Functions.
* pipe:                                  Pipes and FIFOs.
* pipe signal:                           Operation Error Signals.
* pipe to a subprocess:                  Pipe to a Subprocess.
* port number:                           Ports.
* positioning a file descriptor:         File Position Primitive.
* positioning a stream:                  File Positioning.
* POSIX:                                 POSIX.
* POSIX capacity limits:                 General Limits.
* POSIX optional features:               System Options.
* POSIX.1:                               POSIX.
* POSIX.2:                               POSIX.
* power functions:                       Exponents and Logarithms.
* precision (of floating point number):  Floating Point Concepts.
* precision (printf):                    Output Conversion Syntax.
* predicates on arrays:                  String/Array Comparison.
* predicates on characters:              Classification of Characters.
* predicates on strings:                 String/Array Comparison.
* primitives, interrupting:              Interrupted Primitives.
* printing character:                    Classification of Characters.
* priority of a process:                 Priority.
* process <1>:                           Processes.
* process:                               Process Startup.
* process completion:                    Process Completion.
* process group functions:               Functions for Job Control.
* process group ID:                      Launching Jobs.
* process group leader:                  Launching Jobs.
* process groups:                        Job Control.
* process ID:                            Process Creation Concepts.
* process image:                         Process Creation Concepts.
* process lifetime:                      Process Creation Concepts.
* process priority:                      Priority.
* process signal mask:                   Process Signal Mask.
* process termination:                   Program Termination.
* processor time:                        Processor Time.
* profiling alarm signal:                Alarm Signals.
* profiling timer:                       Setting an Alarm.
* program argument syntax:               Argument Syntax.
* program arguments:                     Program Arguments.
* program arguments, parsing:            Parsing Options.
* program error signals:                 Program Error Signals.
* program name:                          Error Messages.
* program startup:                       Program Arguments.
* program termination:                   Program Termination.
* program termination signals:           Termination Signals.
* programming your own streams:          Custom Streams.
* protocol (of socket):                  Socket Concepts.
* protocol family:                       Socket Concepts.
* protocols:                             NSS Basics.
* protocols database:                    Protocols Database.
* prototypes for variadic functions:     Variadic Prototypes.
* pseudo-random numbers:                 Pseudo-Random Numbers.
* punctuation character:                 Classification of Characters.
* pushing input back:                    Unreading.
* quick sort function (for arrays):      Array Sort Function.
* QUIT character:                        Signal Characters.
* quit signal:                           Termination Signals.
* quote removal:                         Expansion Stages.
* race conditions, relating to job control: Launching Jobs.
* race conditions, relating to signals:  Signals in Handler.
* radix (of floating point number):      Floating Point Concepts.
* raising signals:                       Generating Signals.
* random numbers:                        Pseudo-Random Numbers.
* random-access files:                   File Position.
* range error:                           Domain and Range Errors.
* range of integer type:                 Range of Type.
* read lock:                             File Locks.
* reading from a directory:              Accessing Directories.
* reading from a file descriptor:        I/O Primitives.
* reading from a socket:                 Transferring Data.
* reading from a stream, by blocks:      Block Input/Output.
* reading from a stream, by characters:  Character Input.
* reading from a stream, formatted:      Formatted Input.
* real group ID:                         Process Persona.
* real user ID:                          Process Persona.
* real-time timer:                       Setting an Alarm.
* receiving datagrams:                   Receiving Datagrams.
* record locking:                        File Locks.
* redirecting input and output:          Duplicating Descriptors.
* reentrant functions:                   Nonreentrancy.
* reentrant NSS functions:               NSS Module Names.
* relative file name:                    File Name Resolution.
* relocating memory allocator:           Relocating Allocator.
* remainder functions:                   Rounding and Remainders.
* removal of quotes:                     Expansion Stages.
* removing a file:                       Deleting Files.
* removing macros that shadow functions: Macro Definitions.
* renaming a file:                       Renaming Files.
* reporting bugs:                        Reporting Bugs.
* reporting errors:                      Error Reporting.
* REPRINT character:                     Editing Characters.
* reserved names:                        Reserved Names.
* resource limits:                       Limits on Resources.
* restarting interrupted primitives:     Interrupted Primitives.
* restrictions on signal handler functions: Nonreentrancy.
* root directory:                        File Name Resolution.
* rounding functions:                    Rounding and Remainders.
* rpc:                                   NSS Basics.
* running a command:                     Running a Command.
* scanning the group list:               Scanning All Groups.
* scanning the user list:                Scanning All Users.
* search function (for arrays):          Array Search Function.
* search functions (for strings):        Search Functions.
* seed (for random numbers):             Pseudo-Random Numbers.
* seeking on a file descriptor:          File Position Primitive.
* seeking on a stream:                   File Positioning.
* segmentation violation:                Program Error Signals.
* sending a datagram:                    Sending Datagrams.
* sending signals:                       Generating Signals.
* sequential-access files:               File Position.
* server:                                Connections.
* services:                              NSS Basics.
* services database:                     Services Database.
* session <1>:                           Concepts of Job Control.
* session:                               Job Control.
* session leader:                        Concepts of Job Control.
* setting an alarm:                      Setting an Alarm.
* setuid programs:                       How Change Persona.
* setuid programs and file access:       Testing File Access.
* shadow:                                NSS Basics.
* shadowing functions with macros:       Macro Definitions.
* shared lock:                           File Locks.
* shell:                                 Concepts of Job Control.
* shrinking objects:                     Growing Objects.
* shutting down a socket:                Closing a Socket.
* sigaction flags:                       Flags for Sigaction.
* sigaction function:                    Advanced Signal Handling.
* SIGCHLD, handling of:                  Stopped and Terminated Jobs.
* sign (of floating point number):       Floating Point Concepts.
* signal:                                Signal Handling.
* signal action:                         Delivery of Signal.
* signal actions:                        Signal Actions.
* signal flags:                          Flags for Sigaction.
* signal function:                       Basic Signal Handling.
* signal handler function:               Defining Handlers.
* signal mask:                           Process Signal Mask.
* signal messages:                       Signal Messages.
* signal names:                          Standard Signals.
* signal number:                         Standard Signals.
* signal set:                            Signal Sets.
* signals, generating:                   Generating Signals.
* significand (of floating point number): Floating Point Concepts.
* SIGTTIN, from background job:          Access to the Terminal.
* SIGTTOU, from background job:          Access to the Terminal.
* size of string:                        Representation of Strings.
* socket:                                Sockets.
* socket address (name) binding:         Socket Addresses.
* socket domain:                         Socket Concepts.
* socket namespace:                      Socket Concepts.
* socket option level:                   Socket Options.
* socket options:                        Socket Options.
* socket pair:                           Socket Pairs.
* socket protocol:                       Socket Concepts.
* socket shutdown:                       Closing a Socket.
* socket, client actions:                Connecting.
* socket, closing:                       Closing a Socket.
* socket, connecting:                    Connecting.
* socket, creating:                      Creating a Socket.
* socket, initiating a connection:       Connecting.
* sockets, accepting connections:        Accepting Connections.
* sockets, listening:                    Listening.
* sockets, server actions:               Listening.
* soft limit:                            Limits on Resources.
* soft link:                             Symbolic Links.
* sort function (for arrays):            Array Sort Function.
* sparse files:                          File Position Primitive.
* special files:                         Making Special Files.
* specified action (for a signal):       Delivery of Signal.
* square root function:                  Exponents and Logarithms.
* stable sorting:                        Array Sort Function.
* standard dot notation, for Internet addresses: Abstract Host Addresses.
* standard environment variables:        Standard Environment.
* standard error file descriptor:        Descriptors and Streams.
* standard error stream:                 Standard Streams.
* standard file descriptors:             Descriptors and Streams.
* standard input file descriptor:        Descriptors and Streams.
* standard input stream:                 Standard Streams.
* standard output file descriptor:       Descriptors and Streams.
* standard output stream:                Standard Streams.
* standard streams:                      Standard Streams.
* standards:                             Standards and Portability.
* START character:                       Start/Stop Characters.
* startup of program:                    Program Arguments.
* static allocation:                     Memory Concepts.
* STATUS character:                      Other Special.
* status codes:                          Error Reporting.
* status of a file:                      Attribute Meanings.
* status of obstack:                     Status of an Obstack.
* sticky bit:                            Permission Bits.
* STOP character:                        Start/Stop Characters.
* stop signal:                           Job Control Signals.
* stopped job:                           Concepts of Job Control.
* stopped jobs, continuing:              Continuing Stopped Jobs.
* stopped jobs, detecting:               Stopped and Terminated Jobs.
* storage allocation:                    Memory Allocation.
* stream (sockets):                      Socket Concepts.
* stream, for I/O to a string:           String Streams.
* streams and descriptors:               Stream/Descriptor Precautions.
* streams, and file descriptors:         Descriptors and Streams.
* streams, standard:                     Standard Streams.
* string:                                Representation of Strings.
* string allocation:                     Representation of Strings.
* string collation functions:            Collation Functions.
* string comparison functions:           String/Array Comparison.
* string concatenation functions:        Copying and Concatenation.
* string copy functions:                 Copying and Concatenation.
* string length:                         Representation of Strings.
* string literal:                        Representation of Strings.
* string search functions:               Search Functions.
* string stream:                         String Streams.
* string, representation of:             Representation of Strings.
* style of communication (of a socket):  Socket Concepts.
* subshell:                              Initializing the Shell.
* substitution of variables and commands: Expansion Stages.
* successive signals:                    Merged Signals.
* summer time:                           Broken-down Time.
* SunOS:                                 Berkeley Unix.
* supplementary group IDs:               Process Persona.
* SUSP character:                        Signal Characters.
* suspend character:                     Signal Characters.
* SVID:                                  SVID.
* symbolic link:                         Symbolic Links.
* symbolic link, opening:                Open-time Flags.
* syntax, for program arguments:         Argument Syntax.
* syntax, for reading numbers:           Parsing of Numbers.
* System V Unix:                         SVID.
* TCP (Internet protocol):               Protocols Database.
* template, for printf:                  Formatted Output.
* template, for scanf:                   Formatted Input.
* TERM environment variable:             Standard Environment.
* terminal flow control:                 Line Control.
* terminal identification:               Is It a Terminal.
* terminal input queue:                  I/O Queues.
* terminal input queue, clearing:        Line Control.
* terminal input signal:                 Job Control Signals.
* terminal line control functions:       Line Control.
* terminal line speed:                   Line Speed.
* terminal mode data types:              Mode Data Types.
* terminal mode functions:               Mode Functions.
* terminal output queue:                 I/O Queues.
* terminal output queue, flushing:       Line Control.
* terminal output signal:                Job Control Signals.
* terminated jobs, detecting:            Stopped and Terminated Jobs.
* termination signal:                    Termination Signals.
* testing access permission:             Testing File Access.
* testing exit status of child process:  Process Completion.
* text stream:                           Binary Streams.
* ticks, clock:                          Processor Time.
* tilde expansion:                       Expansion Stages.
* TIME termios slot:                     Noncanonical Input.
* time zone:                             TZ Variable.
* time zone database:                    TZ Variable.
* time, calendar:                        Calendar Time.
* time, elapsed CPU:                     Processor Time.
* timer, profiling:                      Setting an Alarm.
* timer, real-time:                      Setting an Alarm.
* timer, virtual:                        Setting an Alarm.
* timers, setting:                       Setting an Alarm.
* timing error in signal handling:       Remembering a Signal.
* TMPDIR environment variable:           Temporary Files.
* tokenizing strings:                    Finding Tokens in a String.
* tools, for installing library:         Tools for Installation.
* transmitting datagrams:                Sending Datagrams.
* trigonometric functions:               Trig Functions.
* type measurements, floating:           Floating Type Macros.
* type measurements, integer:            Width of Type.
* type modifier character (printf):      Output Conversion Syntax.
* type modifier character (scanf):       Input Conversion Syntax.
* typeahead buffer:                      I/O Queues.
* TZ environment variable:               Standard Environment.
* umask:                                 Setting Permissions.
* unbuffered stream:                     Buffering Concepts.
* unconstrained storage allocation:      Unconstrained Allocation.
* undefining macros that shadow functions: Macro Definitions.
* Unix, Berkeley:                        Berkeley Unix.
* Unix, System V:                        SVID.
* unlinking a file:                      Deleting Files.
* unreading characters:                  Unreading.
* upper-case character:                  Classification of Characters.
* urgent data signal:                    Asynchronous I/O Signals.
* urgent socket condition:               Out-of-Band Data.
* usage limits:                          Limits on Resources.
* user database:                         User Database.
* user ID:                               User and Group IDs.
* user ID, determining:                  Who Logged In.
* user name:                             User and Group IDs.
* user signals:                          Miscellaneous Signals.
* usual file name errors:                File Name Errors.
* variable number of arguments:          Variadic Functions.
* variable substitution:                 Expansion Stages.
* variable-sized arrays:                 GNU C Variable-Size Arrays.
* variadic function argument access:     Receiving Arguments.
* variadic function prototypes:          Variadic Prototypes.
* variadic functions:                    Variadic Functions.
* variadic functions, calling:           Calling Variadics.
* virtual time alarm signal:             Alarm Signals.
* virtual timer:                         Setting an Alarm.
* volatile declarations:                 Nonreentrancy.
* waiting for a signal:                  Waiting for a Signal.
* waiting for completion of child process: Process Completion.
* waiting for input or output:           Waiting for I/O.
* warnings of memory almost full:        Memory Warnings.
* WERASE character:                      Editing Characters.
* whitespace character:                  Classification of Characters.
* wide characters:                       Extended Char Intro.
* width of integer type:                 Width of Type.
* wildcard expansion:                    Expansion Stages.
* word expansion:                        Word Expansion.
* working directory:                     Working Directory.
* write lock:                            File Locks.
* writing to a file descriptor:          I/O Primitives.
* writing to a socket:                   Transferring Data.
* writing to a stream, by blocks:        Block Input/Output.
* writing to a stream, by characters:    Simple Output.
* writing to a stream, formatted:        Formatted Output.

