InfoMagic Source Code 1993 July/THE_SOURCE_CODE_CD_ROM.iso/gnu/glibc-1.06/manual/libc.cp

Text File | 1993-05-17 | 44.8 KB | 782 lines

\entry {library}{1}{library}
\entry {standards}{2}{standards}
\entry {ANSI C}{2}{ANSI C}
\entry {POSIX}{3}{POSIX}
\entry {POSIX.1}{3}{POSIX.1}
\entry {IEEE Std 1003.1}{3}{IEEE Std 1003.1}
\entry {POSIX.2}{3}{POSIX.2}
\entry {IEEE Std 1003.2}{3}{IEEE Std 1003.2}
\entry {BSD Unix}{3}{BSD Unix}
\entry {4.x BSD Unix}{3}{4.x BSD Unix}
\entry {Berkeley Unix}{3}{Berkeley Unix}
\entry {SunOS}{3}{SunOS}
\entry {Unix, Berkeley}{3}{Unix, Berkeley}
\entry {SVID}{4}{SVID}
\entry {System V Unix}{4}{System V Unix}
\entry {Unix, System V}{4}{Unix, System V}
\entry {header files}{4}{header files}
\entry {definition (compared to declaration)}{4}{definition (compared to declaration)}
\entry {declaration (compared to definition)}{4}{declaration (compared to definition)}
\entry {shadowing functions with macros}{6}{shadowing functions with macros}
\entry {removing macros that shadow functions}{6}{removing macros that shadow functions}
\entry {undefining macros that shadow functions}{6}{undefining macros that shadow functions}
\entry {reserved names}{7}{reserved names}
\entry {name space}{7}{name space}
\entry {feature test macros}{9}{feature test macros}
\entry {error reporting}{13}{error reporting}
\entry {reporting errors}{13}{reporting errors}
\entry {error codes}{13}{error codes}
\entry {status codes}{13}{status codes}
\entry {program name}{24}{program name}
\entry {name of running program}{24}{name of running program}
\entry {memory allocation}{27}{memory allocation}
\entry {storage allocation}{27}{storage allocation}
\entry {dynamic allocation}{27}{dynamic allocation}
\entry {static allocation}{27}{static allocation}
\entry {automatic allocation}{27}{automatic allocation}
\entry {unconstrained storage allocation}{28}{unconstrained storage allocation}
\entry {malloc function}{28}{\code {malloc} function}
\entry {heap, dynamic allocation from}{28}{heap, dynamic allocation from}
\entry {allocation of memory with malloc}{29}{allocation of memory with \code {malloc}}
\entry {freeing memory allocated with malloc}{30}{freeing memory allocated with \code {malloc}}
\entry {heap, freeing memory from}{30}{heap, freeing memory from}
\entry {changing the size of a block (malloc)}{31}{changing the size of a block (\code {malloc})}
\entry {efficiency and malloc}{33}{efficiency and \code {malloc}}
\entry {page boundary}{34}{page boundary}
\entry {alignment (with malloc)}{34}{alignment (with \code {malloc})}
\entry {heap consistency checking}{34}{heap consistency checking}
\entry {consistency checking, of heap}{34}{consistency checking, of heap}
\entry {allocation hooks, for malloc}{35}{allocation hooks, for \code {malloc}}
\entry {allocation statistics}{36}{allocation statistics}
\entry {obstacks}{38}{obstacks}
\entry {allocation (obstacks)}{40}{allocation (obstacks)}
\entry {freeing (obstacks)}{41}{freeing (obstacks)}
\entry {macros}{42}{macros}
\entry {growing objects (in obstacks)}{43}{growing objects (in obstacks)}
\entry {changing the size of a block (obstacks)}{43}{changing the size of a block (obstacks)}
\entry {shrinking objects}{45}{shrinking objects}
\entry {efficiency and obstacks}{45}{efficiency and obstacks}
\entry {obstack status}{47}{obstack status}
\entry {status of obstack}{47}{status of obstack}
\entry {alignment (in obstacks)}{47}{alignment (in obstacks)}
\entry {efficiency of chunks}{48}{efficiency of chunks}
\entry {chunks}{48}{chunks}
\entry {automatic freeing}{51}{automatic freeing}
\entry {alloca function}{51}{\code {alloca} function}
\entry {automatic storage with variable size}{51}{automatic storage with variable size}
\entry {longjmp}{52}{longjmp}
\entry {alloca disadvantages}{53}{\code {alloca} disadvantages}
\entry {disadvantages of alloca}{53}{disadvantages of \code {alloca}}
\entry {variable-sized arrays}{53}{variable-sized arrays}
\entry {relocating memory allocator}{54}{relocating memory allocator}
\entry {handle}{54}{handle}
\entry {memory usage warnings}{55}{memory usage warnings}
\entry {warnings of memory almost full}{55}{warnings of memory almost full}
\entry {character testing}{57}{character testing}
\entry {classification of characters}{57}{classification of characters}
\entry {predicates on characters}{57}{predicates on characters}
\entry {character predicates}{57}{character predicates}
\entry {lower-case character}{57}{lower-case character}
\entry {upper-case character}{57}{upper-case character}
\entry {alphabetic character}{58}{alphabetic character}
\entry {digit character}{58}{digit character}
\entry {decimal digit character}{58}{decimal digit character}
\entry {alphanumeric character}{58}{alphanumeric character}
\entry {hexadecimal digit character}{58}{hexadecimal digit character}
\entry {punctuation character}{58}{punctuation character}
\entry {whitespace character}{58}{whitespace character}
\entry {blank character}{58}{blank character}
\entry {graphic character}{59}{graphic character}
\entry {printing character}{59}{printing character}
\entry {control character}{59}{control character}
\entry {ASCII character}{59}{ASCII character}
\entry {character case conversion}{59}{character case conversion}
\entry {case conversion of characters}{59}{case conversion of characters}
\entry {converting case of characters}{59}{converting case of characters}
\entry {string, representation of}{61}{string, representation of}
\entry {string}{61}{string}
\entry {null character}{61}{null character}
\entry {string literal}{61}{string literal}
\entry {length of string}{62}{length of string}
\entry {allocation size of string}{62}{allocation size of string}
\entry {size of string}{62}{size of string}
\entry {string length}{62}{string length}
\entry {string allocation}{62}{string allocation}
\entry {copying strings and arrays}{63}{copying strings and arrays}
\entry {string copy functions}{63}{string copy functions}
\entry {array copy functions}{63}{array copy functions}
\entry {concatenating strings}{63}{concatenating strings}
\entry {string concatenation functions}{63}{string concatenation functions}
\entry {comparing strings and arrays}{68}{comparing strings and arrays}
\entry {string comparison functions}{68}{string comparison functions}
\entry {array comparison functions}{68}{array comparison functions}
\entry {predicates on strings}{68}{predicates on strings}
\entry {predicates on arrays}{68}{predicates on arrays}
\entry {collating strings}{70}{collating strings}
\entry {string collation functions}{70}{string collation functions}
\entry {converting string to collation order}{71}{converting string to collation order}
\entry {search functions (for strings)}{73}{search functions (for strings)}
\entry {string search functions}{73}{string search functions}
\entry {tokenizing strings}{76}{tokenizing strings}
\entry {breaking a string into tokens}{76}{breaking a string into tokens}
\entry {parsing tokens from a string}{76}{parsing tokens from a string}
\entry {extended character sets}{79}{extended character sets}
\entry {wide characters}{79}{wide characters}
\entry {multibyte characters}{80}{multibyte characters}
\entry {basic byte sequence}{80}{basic byte sequence}
\entry {code, character}{84}{code, character}
\entry {character code}{84}{character code}
\entry {extended strings, converting representations}{84}{extended strings, converting representations}
\entry {converting extended strings}{84}{converting extended strings}
\entry {multibyte character, length of}{86}{multibyte character, length of}
\entry {length of multibyte character}{86}{length of multibyte character}
\entry {extended characters, converting}{86}{extended characters, converting}
\entry {converting extended characters}{86}{converting extended characters}
\entry {internationalization}{93}{internationalization}
\entry {locales}{93}{locales}
\entry {combining locales}{94}{combining locales}
\entry {categories for locales}{94}{categories for locales}
\entry {locale categories}{94}{locale categories}
\entry {changing the locale}{95}{changing the locale}
\entry {locale, changing}{95}{locale, changing}
\entry {monetary value formatting}{98}{monetary value formatting}
\entry {numeric value formatting}{98}{numeric value formatting}
\entry {decimal-point separator}{98}{decimal-point separator}
\entry {grouping of digits}{99}{grouping of digits}
\entry {currency symbols}{99}{currency symbols}
\entry {Comparison Function}{103}{Comparison Function}
\entry {search function (for arrays)}{104}{search function (for arrays)}
\entry {binary search function (for arrays)}{104}{binary search function (for arrays)}
\entry {array search function}{104}{array search function}
\entry {sort function (for arrays)}{104}{sort function (for arrays)}
\entry {quick sort function (for arrays)}{104}{quick sort function (for arrays)}
\entry {array sort function}{104}{array sort function}
\entry {stable sorting}{104}{stable sorting}
\entry {Kermit the frog}{107}{Kermit the frog}
\entry {globbing}{110}{globbing}
\entry {word expansion}{120}{word expansion}
\entry {expansion of shell words}{120}{expansion of shell words}
\entry {tilde expansion}{121}{tilde expansion}
\entry {variable substitution}{121}{variable substitution}
\entry {substitution of variables and commands}{121}{substitution of variables and commands}
\entry {command substitution}{121}{command substitution}
\entry {arithmetic expansion}{121}{arithmetic expansion}
\entry {field splitting}{121}{field splitting}
\entry {wildcard expansion}{121}{wildcard expansion}
\entry {quote removal}{121}{quote removal}
\entry {removal of quotes}{121}{removal of quotes}
\entry {opening a file}{127}{opening a file}
\entry {file position}{129}{file position}
\entry {sequential-access files}{129}{sequential-access files}
\entry {random-access files}{129}{random-access files}
\entry {append-access files}{129}{append-access files}
\entry {file name}{130}{file name}
\entry {directory}{130}{directory}
\entry {link}{130}{link}
\entry {directory entry}{130}{directory entry}
\entry {file name component}{130}{file name component}
\entry {file name resolution}{131}{file name resolution}
\entry {root directory}{131}{root directory}
\entry {absolute file name}{131}{absolute file name}
\entry {relative file name}{131}{relative file name}
\entry {parent directory}{131}{parent directory}
\entry {file name syntax errors}{132}{file name syntax errors}
\entry {usual file name syntax errors}{132}{usual file name syntax errors}
\entry {file pointer}{135}{file pointer}
\entry {standard streams}{135}{standard streams}
\entry {streams, standard}{135}{streams, standard}
\entry {standard input stream}{136}{standard input stream}
\entry {standard output stream}{136}{standard output stream}
\entry {standard error stream}{136}{standard error stream}
\entry {opening a stream}{136}{opening a stream}
\entry {closing a stream}{138}{closing a stream}
\entry {writing to a stream, by characters}{139}{writing to a stream, by characters}
\entry {reading from a stream, by characters}{140}{reading from a stream, by characters}
\entry {peeking at input}{144}{peeking at input}
\entry {unreading characters}{144}{unreading characters}
\entry {pushing input back}{144}{pushing input back}
\entry {format string, for printf}{146}{format string, for \code {printf}}
\entry {template, for printf}{146}{template, for \code {printf}}
\entry {formatted output to a stream}{146}{formatted output to a stream}
\entry {writing to a stream, formatted}{146}{writing to a stream, formatted}
\entry {conversion specifications (printf)}{146}{conversion specifications (\code {printf})}
\entry {flag character (printf)}{148}{flag character (\code {printf})}
\entry {minimum field width (printf)}{148}{minimum field width (\code {printf})}
\entry {precision (printf)}{148}{precision (\code {printf})}
\entry {type modifier character (printf)}{148}{type modifier character (\code {printf})}
\entry {output conversions, for printf}{148}{output conversions, for \code {printf}}
\entry {parsing a template string}{160}{parsing a template string}
\entry {customizing printf}{163}{customizing \code {printf}}
\entry {defining new printf conversions}{163}{defining new \code {printf} conversions}
\entry {extending printf}{163}{extending \code {printf}}
\entry {formatted input from a stream}{169}{formatted input from a stream}
\entry {reading from a stream, formatted}{169}{reading from a stream, formatted}
\entry {format string, for scanf}{169}{format string, for \code {scanf}}
\entry {template, for scanf}{169}{template, for \code {scanf}}
\entry {conversion specifications (scanf)}{169}{conversion specifications (\code {scanf})}
\entry {matching failure, in scanf}{169}{matching failure, in \code {scanf}}
\entry {flag character (scanf)}{170}{flag character (\code {scanf})}
\entry {maximum field width (scanf)}{171}{maximum field width (\code {scanf})}
\entry {type modifier character (scanf)}{171}{type modifier character (\code {scanf})}
\entry {input conversions, for scanf}{171}{input conversions, for \code {scanf}}
\entry {binary I/O to a stream}{178}{binary I/O to a stream}
\entry {block I/O to a stream}{178}{block I/O to a stream}
\entry {reading from a stream, by blocks}{178}{reading from a stream, by blocks}
\entry {writing to a stream, by blocks}{178}{writing to a stream, by blocks}
\entry {end of file, on a stream}{179}{end of file, on a stream}
\entry {text stream}{180}{text stream}
\entry {binary stream}{180}{binary stream}
\entry {lines (in a text file)}{180}{lines (in a text file)}
\entry {file positioning on a stream}{181}{file positioning on a stream}
\entry {positioning a stream}{181}{positioning a stream}
\entry {seeking on a stream}{181}{seeking on a stream}
\entry {buffering of streams}{184}{buffering of streams}
\entry {unbuffered stream}{185}{unbuffered stream}
\entry {line buffered stream}{185}{line buffered stream}
\entry {fully buffered stream}{185}{fully buffered stream}
\entry {flushing a stream}{186}{flushing a stream}
\entry {buffering, controlling}{186}{buffering, controlling}
\entry {TMPDIR environment variable}{190}{TMPDIR environment variable}
\entry {stream, for I/O to a string}{191}{stream, for I/O to a string}
\entry {string stream}{191}{string stream}
\entry {custom streams}{194}{custom streams}
\entry {programming your own streams}{194}{programming your own streams}
\entry {cookie, for custom stream}{194}{cookie, for custom stream}
\entry {hook functions (of custom streams)}{196}{hook functions (of custom streams)}
\entry {opening a file descriptor}{199}{opening a file descriptor}
\entry {closing a file descriptor}{199}{closing a file descriptor}
\entry {append mode (file status flag)}{200}{append mode (file status flag)}
\entry {create on open (file status flag)}{200}{create on open (file status flag)}
\entry {non-blocking mode (file status flag)}{200}{non-blocking mode (file status flag)}
\entry {reading from a file descriptor}{202}{reading from a file descriptor}
\entry {end-of-file, on a file descriptor}{202}{end-of-file, on a file descriptor}
\entry {writing to a file descriptor}{203}{writing to a file descriptor}
\entry {file positioning on a file descriptor}{205}{file positioning on a file descriptor}
\entry {positioning a file descriptor}{205}{positioning a file descriptor}
\entry {seeking on a file descriptor}{205}{seeking on a file descriptor}
\entry {streams, and file descriptors}{207}{streams, and file descriptors}
\entry {converting file descriptor to stream}{207}{converting file descriptor to stream}
\entry {extracting file descriptor from stream}{207}{extracting file descriptor from stream}
\entry {standard file descriptors}{208}{standard file descriptors}
\entry {file descriptors, standard}{208}{file descriptors, standard}
\entry {standard input file descriptor}{208}{standard input file descriptor}
\entry {standard output file descriptor}{208}{standard output file descriptor}
\entry {standard error file descriptor}{208}{standard error file descriptor}
\entry {channels}{208}{channels}
\entry {streams and descriptors}{208}{streams and descriptors}
\entry {descriptors and streams}{208}{descriptors and streams}
\entry {mixing descriptors and streams}{208}{mixing descriptors and streams}
\entry {linked channels}{209}{linked channels}
\entry {cleaning up a stream}{209}{cleaning up a stream}
\entry {independent channels}{209}{independent channels}
\entry {waiting for input or output}{211}{waiting for input or output}
\entry {multiplexing input}{211}{multiplexing input}
\entry {input from multiple files}{211}{input from multiple files}
\entry {file descriptor sets, for select}{211}{file descriptor sets, for \code {select}}
\entry {control operations on files}{214}{control operations on files}
\entry {fcntl function}{214}{\code {fcntl} function}
\entry {duplicating file descriptors}{215}{duplicating file descriptors}
\entry {redirecting input and output}{215}{redirecting input and output}
\entry {file descriptor flags}{218}{file descriptor flags}
\entry {close-on-exec (file descriptor flag)}{219}{close-on-exec (file descriptor flag)}
\entry {file status flags}{219}{file status flags}
\entry {file locks}{222}{file locks}
\entry {record locking}{222}{record locking}
\entry {exclusive lock}{222}{exclusive lock}
\entry {write lock}{222}{write lock}
\entry {shared lock}{222}{shared lock}
\entry {read lock}{222}{read lock}
\entry {interrupt-driven input}{226}{interrupt-driven input}
\entry {current working directory}{229}{current working directory}
\entry {working directory}{229}{working directory}
\entry {change working directory}{229}{change working directory}
\entry {accessing directories}{231}{accessing directories}
\entry {reading from a directory}{231}{reading from a directory}
\entry {directories, accessing}{231}{directories, accessing}
\entry {directory stream}{231}{directory stream}
\entry {hard link}{235}{hard link}
\entry {link, hard}{235}{link, hard}
\entry {multiple names for one file}{235}{multiple names for one file}
\entry {file names, multiple}{235}{file names, multiple}
\entry {soft link}{236}{soft link}
\entry {link, soft}{236}{link, soft}
\entry {symbolic link}{236}{symbolic link}
\entry {link, symbolic}{236}{link, symbolic}
\entry {deleting a file}{238}{deleting a file}
\entry {removing a file}{238}{removing a file}
\entry {unlinking a file}{238}{unlinking a file}
\entry {directories, deleting}{239}{directories, deleting}
\entry {deleting a directory}{239}{deleting a directory}
\entry {renaming a file}{239}{renaming a file}
\entry {creating a directory}{241}{creating a directory}
\entry {directories, creating}{241}{directories, creating}
\entry {status of a file}{242}{status of a file}
\entry {attributes of a file}{242}{attributes of a file}
\entry {file attributes}{242}{file attributes}
\entry {inode number}{244}{inode number}
\entry {file owner}{247}{file owner}
\entry {owner of a file}{247}{owner of a file}
\entry {group owner of a file}{247}{group owner of a file}
\entry {file permission bits}{249}{file permission bits}
\entry {sticky bit}{250}{sticky bit}
\entry {permission to access a file}{251}{permission to access a file}
\entry {access permission for a file}{251}{access permission for a file}
\entry {file access permission}{251}{file access permission}
\entry {file creation mask}{251}{file creation mask}
\entry {umask}{251}{umask}
\entry {testing access permission}{253}{testing access permission}
\entry {access, testing for}{253}{access, testing for}
\entry {setuid programs and file access}{253}{setuid programs and file access}
\entry {file access time}{255}{file access time}
\entry {file modification time}{255}{file modification time}
\entry {file attribute modification time}{255}{file attribute modification time}
\entry {creating special files}{257}{creating special files}
\entry {special files}{257}{special files}
\entry {pipe}{259}{pipe}
\entry {FIFO special file}{259}{FIFO special file}
\entry {creating a pipe}{259}{creating a pipe}
\entry {opening a pipe}{259}{opening a pipe}
\entry {interprocess communication, with pipes}{259}{interprocess communication, with pipes}
\entry {creating a pipe to a subprocess}{261}{creating a pipe to a subprocess}
\entry {pipe to a subprocess}{261}{pipe to a subprocess}
\entry {filtering i/o through subprocess}{261}{filtering i/o through subprocess}
\entry {creating a FIFO special file}{263}{creating a FIFO special file}
\entry {interprocess communication, with FIFO}{263}{interprocess communication, with FIFO}
\entry {socket}{265}{socket}
\entry {interprocess communication, with sockets}{265}{interprocess communication, with sockets}
\entry {communication style (of a socket)}{265}{communication style (of a socket)}
\entry {style of communication (of a socket)}{265}{style of communication (of a socket)}
\entry {packet}{265}{packet}
\entry {byte stream}{265}{byte stream}
\entry {stream (sockets)}{265}{stream (sockets)}
\entry {loss of data on sockets}{265}{loss of data on sockets}
\entry {data loss on sockets}{265}{data loss on sockets}
\entry {namespace (of socket)}{266}{namespace (of socket)}
\entry {domain (of socket)}{266}{domain (of socket)}
\entry {socket namespace}{266}{socket namespace}
\entry {socket domain}{266}{socket domain}
\entry {network protocol}{266}{network protocol}
\entry {protocol (of socket)}{266}{protocol (of socket)}
\entry {socket protocol}{266}{socket protocol}
\entry {protocol family}{266}{protocol family}
\entry {address of socket}{267}{address of socket}
\entry {name of socket}{267}{name of socket}
\entry {binding a socket address}{267}{binding a socket address}
\entry {socket address (name) binding}{267}{socket address (name) binding}
\entry {file namespace, for sockets}{271}{file namespace, for sockets}
\entry {Internet namespace, for sockets}{274}{Internet namespace, for sockets}
\entry {host address, Internet}{276}{host address, Internet}
\entry {Internet host address}{276}{Internet host address}
\entry {network number}{276}{network number}
\entry {local network address number}{276}{local network address number}
\entry {standard dot notation, for Internet addresses}{276}{standard dot notation, for Internet addresses}
\entry {dot notation, for Internet addresses}{276}{dot notation, for Internet addresses}
\entry {hosts database}{278}{hosts database}
\entry {converting host name to address}{278}{converting host name to address}
\entry {converting host address to name}{278}{converting host address to name}
\entry {port number}{281}{port number}
\entry {services database}{282}{services database}
\entry {converting service name to port number}{282}{converting service name to port number}
\entry {converting port number to service name}{282}{converting port number to service name}
\entry {byte order conversion, for socket}{283}{byte order conversion, for socket}
\entry {converting byte order}{283}{converting byte order}
\entry {big-endian}{283}{big-endian}
\entry {little-endian}{283}{little-endian}
\entry {network byte order}{283}{network byte order}
\entry {protocols database}{284}{protocols database}
\entry {TCP (Internet protocol)}{284}{TCP (Internet protocol)}
\entry {creating a socket}{288}{creating a socket}
\entry {socket, creating}{288}{socket, creating}
\entry {opening a socket}{288}{opening a socket}
\entry {socket, closing}{289}{socket, closing}
\entry {closing a socket}{289}{closing a socket}
\entry {shutting down a socket}{289}{shutting down a socket}
\entry {socket shutdown}{289}{socket shutdown}
\entry {creating a socket pair}{290}{creating a socket pair}
\entry {socket pair}{290}{socket pair}
\entry {opening a socket pair}{290}{opening a socket pair}
\entry {connection}{291}{connection}
\entry {client}{291}{client}
\entry {server}{291}{server}
\entry {connecting a socket}{291}{connecting a socket}
\entry {socket, connecting}{291}{socket, connecting}
\entry {socket, initiating a connection}{291}{socket, initiating a connection}
\entry {socket, client actions}{291}{socket, client actions}
\entry {listening (sockets)}{292}{listening (sockets)}
\entry {sockets, server actions}{292}{sockets, server actions}
\entry {sockets, listening}{292}{sockets, listening}
\entry {sockets, accepting connections}{293}{sockets, accepting connections}
\entry {accepting connections}{293}{accepting connections}
\entry {reading from a socket}{295}{reading from a socket}
\entry {writing to a socket}{295}{writing to a socket}
\entry {out-of-band data}{301}{out-of-band data}
\entry {high-priority data}{301}{high-priority data}
\entry {urgent socket condition}{301}{urgent socket condition}
\entry {datagram socket}{305}{datagram socket}
\entry {sending a datagram}{305}{sending a datagram}
\entry {transmitting datagrams}{305}{transmitting datagrams}
\entry {datagrams, transmitting}{305}{datagrams, transmitting}
\entry {receiving datagrams}{306}{receiving datagrams}
\entry {socket options}{311}{socket options}
\entry {level, for socket options}{311}{level, for socket options}
\entry {socket option level}{311}{socket option level}
\entry {networks database}{314}{networks database}
\entry {converting network number to network name}{314}{converting network number to network name}
\entry {converting network name to network number}{314}{converting network name to network number}
\entry {terminal identification}{317}{terminal identification}
\entry {identifying terminals}{317}{identifying terminals}
\entry {terminal input queue}{318}{terminal input queue}
\entry {typeahead buffer}{318}{typeahead buffer}
\entry {terminal output queue}{318}{terminal output queue}
\entry {canonical input processing}{318}{canonical input processing}
\entry {noncanonical input processing}{319}{noncanonical input processing}
\entry {terminal mode data types}{319}{terminal mode data types}
\entry {terminal mode functions}{320}{terminal mode functions}
\entry {parity checking}{323}{parity checking}
\entry {break condition, detecting}{324}{break condition, detecting}
\entry {modem status lines}{326}{modem status lines}
\entry {carrier detect}{326}{carrier detect}
\entry {modem disconnect}{326}{modem disconnect}
\entry {echo of terminal input}{327}{echo of terminal input}
\entry {interactive signals, from terminal}{328}{interactive signals, from terminal}
\entry {line speed}{329}{line speed}
\entry {baud rate}{329}{baud rate}
\entry {terminal line speed}{329}{terminal line speed}
\entry {terminal line speed}{329}{terminal line speed}
\entry {EOF character}{332}{EOF character}
\entry {EOL character}{332}{EOL character}
\entry {ERASE character}{332}{ERASE character}
\entry {KILL character}{333}{KILL character}
\entry {EOL2 character}{333}{EOL2 character}
\entry {WERASE character}{333}{WERASE character}
\entry {REPRINT character}{334}{REPRINT character}
\entry {LNEXT character}{334}{LNEXT character}
\entry {INTR character}{334}{INTR character}
\entry {interrupt character}{334}{interrupt character}
\entry {QUIT character}{335}{QUIT character}
\entry {SUSP character}{335}{SUSP character}
\entry {suspend character}{335}{suspend character}
\entry {DSUSP character}{335}{DSUSP character}
\entry {delayed suspend character}{335}{delayed suspend character}
\entry {START character}{336}{START character}
\entry {STOP character}{336}{STOP character}
\entry {DISCARD character}{337}{DISCARD character}
\entry {STATUS character}{337}{STATUS character}
\entry {MIN termios slot}{338}{MIN termios slot}
\entry {TIME termios slot}{338}{TIME termios slot}
\entry {terminal line control functions}{339}{terminal line control functions}
\entry {break condition, generating}{339}{break condition, generating}
\entry {flushing terminal output queue}{339}{flushing terminal output queue}
\entry {terminal output queue, flushing}{339}{terminal output queue, flushing}
\entry {clearing terminal input queue}{340}{clearing terminal input queue}
\entry {terminal input queue, clearing}{340}{terminal input queue, clearing}
\entry {flow control, terminal}{340}{flow control, terminal}
\entry {terminal flow control}{340}{terminal flow control}
\entry {domain error}{345}{domain error}
\entry {range error}{345}{range error}
\entry {trigonometric functions}{346}{trigonometric functions}
\entry {pi (trigonometric constant)}{346}{pi (trigonometric constant)}
\entry {inverse trigonmetric functions}{347}{inverse trigonmetric functions}
\entry {exponentiation functions}{348}{exponentiation functions}
\entry {power functions}{348}{power functions}
\entry {logarithm functions}{348}{logarithm functions}
\entry {square root function}{349}{square root function}
\entry {cube root function}{349}{cube root function}
\entry {hyperbolic functions}{350}{hyperbolic functions}
\entry {inverse hyperbolic functions}{350}{inverse hyperbolic functions}
\entry {random numbers}{350}{random numbers}
\entry {pseudo-random numbers}{350}{pseudo-random numbers}
\entry {seed (for random numbers)}{350}{seed (for random numbers)}
\entry {NaN}{355}{NaN}
\entry {not a number}{355}{not a number}
\entry {IEEE floating point}{355}{IEEE floating point}
\entry {absolute value functions}{356}{absolute value functions}
\entry {normalization functions (floating-point)}{357}{normalization functions (floating-point)}
\entry {rounding functions}{359}{rounding functions}
\entry {remainder functions}{359}{remainder functions}
\entry {converting floats to integers}{359}{converting floats to integers}
\entry {integer division functions}{360}{integer division functions}
\entry {parsing numbers (in formatted input)}{361}{parsing numbers (in formatted input)}
\entry {converting strings to numbers}{361}{converting strings to numbers}
\entry {number syntax, parsing}{361}{number syntax, parsing}
\entry {syntax, for reading numbers}{361}{syntax, for reading numbers}
\entry {CPU time}{367}{CPU time}
\entry {processor time}{367}{processor time}
\entry {clock ticks}{367}{clock ticks}
\entry {ticks, clock}{367}{ticks, clock}
\entry {time, elapsed CPU}{367}{time, elapsed CPU}
\entry {Gregorian calendar}{370}{Gregorian calendar}
\entry {time, calendar}{370}{time, calendar}
\entry {date and time}{370}{date and time}
\entry {calendar time}{370}{calendar time}
\entry {high-resolution time}{370}{high-resolution time}
\entry {local time}{370}{local time}
\entry {broken-down time}{370}{broken-down time}
\entry {epoch}{370}{epoch}
\entry {broken-down time}{374}{broken-down time}
\entry {calendar time and broken-down time}{374}{calendar time and broken-down time}
\entry {leap second}{374}{leap second}
\entry {Daylight Saving Time}{375}{Daylight Saving Time}
\entry {summer time}{375}{summer time}
\entry {time zone}{378}{time zone}
\entry {setting an alarm}{382}{setting an alarm}
\entry {interval timer, setting}{382}{interval timer, setting}
\entry {alarms, setting}{382}{alarms, setting}
\entry {timers, setting}{382}{timers, setting}
\entry {real-time timer}{382}{real-time timer}
\entry {virtual timer}{382}{virtual timer}
\entry {profiling timer}{382}{profiling timer}
\entry {resource limits}{387}{resource limits}
\entry {limits on resource usage}{387}{limits on resource usage}
\entry {usage limits}{387}{usage limits}
\entry {process priority}{389}{process priority}
\entry {priority of a process}{389}{priority of a process}
\entry {non-local exits}{393}{non-local exits}
\entry {long jumps}{393}{long jumps}
\entry {signal}{399}{signal}
\entry {generation of signals}{400}{generation of signals}
\entry {delivery of signals}{401}{delivery of signals}
\entry {pending signals}{401}{pending signals}
\entry {blocked signals}{401}{blocked signals}
\entry {specified action (for a signal)}{401}{specified action (for a signal)}
\entry {default action (for a signal)}{401}{default action (for a signal)}
\entry {signal action}{401}{signal action}
\entry {catching signals}{401}{catching signals}
\entry {signal names}{402}{signal names}
\entry {names of signals}{402}{names of signals}
\entry {signal number}{402}{signal number}
\entry {program error signals}{402}{program error signals}
\entry {exception}{403}{exception}
\entry {floating-point exception}{403}{floating-point exception}
\entry {illegal instruction}{404}{illegal instruction}
\entry {segmentation violation}{404}{segmentation violation}
\entry {bus error}{405}{bus error}
\entry {abort signal}{405}{abort signal}
\entry {program termination signals}{405}{program termination signals}
\entry {hangup signal}{405}{hangup signal}
\entry {interrupt signal}{406}{interrupt signal}
\entry {quit signal}{406}{quit signal}
\entry {quit signal}{406}{quit signal}
\entry {termination signal}{406}{termination signal}
\entry {kill signal}{406}{kill signal}
\entry {alarm signal}{407}{alarm signal}
\entry {virtual time alarm signal}{407}{virtual time alarm signal}
\entry {profiling alarm signal}{407}{profiling alarm signal}
\entry {input available signal}{407}{input available signal}
\entry {output possible signal}{407}{output possible signal}
\entry {urgent data signal}{408}{urgent data signal}
\entry {job control signals}{408}{job control signals}
\entry {child process signal}{408}{child process signal}
\entry {continue signal}{408}{continue signal}
\entry {stop signal}{408}{stop signal}
\entry {interactive stop signal}{409}{interactive stop signal}
\entry {terminal input signal}{409}{terminal input signal}
\entry {terminal output signal}{409}{terminal output signal}
\entry {pipe signal}{410}{pipe signal}
\entry {broken pipe signal}{410}{broken pipe signal}
\entry {user signals}{410}{user signals}
\entry {signal messages}{411}{signal messages}
\entry {signal actions}{412}{signal actions}
\entry {establishing a handler}{412}{establishing a handler}
\entry {signal function}{412}{\code {signal} function}
\entry {default action for a signal}{413}{default action for a signal}
\entry {ignore action for a signal}{413}{ignore action for a signal}
\entry {sigaction function}{415}{\code {sigaction} function}
\entry {signal flags}{418}{signal flags}
\entry {flags for sigaction}{418}{flags for \code {sigaction}}
\entry {sigaction flags}{418}{\code {sigaction} flags}
\entry {initial signal actions}{419}{initial signal actions}
\entry {signal handler function}{420}{signal handler function}
\entry {non-local exit, from signal handler}{423}{non-local exit, from signal handler}
\entry {race conditions, relating to signals}{425}{race conditions, relating to signals}
\entry {handling multiple signals}{425}{handling multiple signals}
\entry {successive signals}{425}{successive signals}
\entry {merging of signals}{425}{merging of signals}
\entry {restrictions on signal handler functions}{428}{restrictions on signal handler functions}
\entry {volatile declarations}{429}{\code {volatile} declarations}
\entry {reentrant functions}{429}{reentrant functions}
\entry {sending signals}{434}{sending signals}
\entry {raising signals}{434}{raising signals}
\entry {signals, generating}{434}{signals, generating}
\entry {killing a process}{436}{killing a process}
\entry {interprocess communication, with signals}{438}{interprocess communication, with signals}
\entry {blocking signals}{440}{blocking signals}
\entry {signal set}{441}{signal set}
\entry {signal mask}{442}{signal mask}
\entry {process signal mask}{442}{process signal mask}
\entry {blocking signals, in a handler}{445}{blocking signals, in a handler}
\entry {pending signals, checking for}{446}{pending signals, checking for}
\entry {blocked signals, checking for}{446}{blocked signals, checking for}
\entry {checking for pending signals}{446}{checking for pending signals}
\entry {timing error in signal handling}{448}{timing error in signal handling}
\entry {waiting for a signal}{449}{waiting for a signal}
\entry {pause function}{449}{\code {pause} function}
\entry {signal stack}{452}{signal stack}
\entry {process}{457}{process}
\entry {program arguments}{457}{program arguments}
\entry {command line arguments}{457}{command line arguments}
\entry {main function}{457}{\code {main} function}
\entry {argc (program argument count)}{457}{argc (program argument count)}
\entry {argv (program argument vector)}{457}{argv (program argument vector)}
\entry {program argument syntax}{458}{program argument syntax}
\entry {syntax, for program arguments}{458}{syntax, for program arguments}
\entry {command argument syntax}{458}{command argument syntax}
\entry {long-named options}{458}{long-named options}
\entry {program arguments, parsing}{459}{program arguments, parsing}
\entry {command arguments, parsing}{459}{command arguments, parsing}
\entry {parsing program arguments}{459}{parsing program arguments}
\entry {environment variable}{466}{environment variable}
\entry {environment}{467}{environment}
\entry {environment access}{467}{environment access}
\entry {environment representation}{467}{environment representation}
\entry {standard environment variables}{468}{standard environment variables}
\entry {HOME environment variable}{468}{HOME environment variable}
\entry {home directory}{468}{home directory}
\entry {LOGNAME environment variable}{468}{LOGNAME environment variable}
\entry {PATH environment variable}{468}{PATH environment variable}
\entry {TERM environment variable}{469}{TERM environment variable}
\entry {TZ environment variable}{469}{TZ environment variable}
\entry {LANG environment variable}{469}{LANG environment variable}
\entry {LC{\_}COLLATE environment variable}{469}{LC{\_}COLLATE environment variable}
\entry {LC{\_}CTYPE environment variable}{469}{LC{\_}CTYPE environment variable}
\entry {LC{\_}MONETARY environment variable}{469}{LC{\_}MONETARY environment variable}
\entry {LC{\_}NUMERIC environment variable}{469}{LC{\_}NUMERIC environment variable}
\entry {LC{\_}TIME environment variable}{469}{LC{\_}TIME environment variable}
\entry {{\_}POSIX{\_}OPTION{\_}ORDER environment variable.}{469}{{\_}POSIX{\_}OPTION{\_}ORDER environment variable.}
\entry {program termination}{470}{program termination}
\entry {process termination}{470}{process termination}
\entry {exit status value}{470}{exit status value}
\entry {exit status}{470}{exit status}
\entry {aborting a program}{473}{aborting a program}
\entry {process}{475}{process}
\entry {child process}{475}{child process}
\entry {parent process}{475}{parent process}
\entry {running a command}{475}{running a command}
\entry {process ID}{476}{process ID}
\entry {process lifetime}{476}{process lifetime}
\entry {creating a process}{476}{creating a process}
\entry {forking a process}{476}{forking a process}
\entry {child process}{476}{child process}
\entry {parent process}{476}{parent process}
\entry {process image}{476}{process image}
\entry {executing a file}{479}{executing a file}
\entry {exec functions}{479}{\code {exec} functions}
\entry {process completion}{482}{process completion}
\entry {waiting for completion of child process}{482}{waiting for completion of child process}
\entry {testing exit status of child process}{482}{testing exit status of child process}
\entry {process groups}{489}{process groups}
\entry {job control}{489}{job control}
\entry {job}{489}{job}
\entry {session}{489}{session}
\entry {shell}{489}{shell}
\entry {session}{489}{session}
\entry {session leader}{489}{session leader}
\entry {controlling terminal}{490}{controlling terminal}
\entry {foreground job}{490}{foreground job}
\entry {background job}{490}{background job}
\entry {stopped job}{490}{stopped job}
\entry {job control is optional}{490}{job control is optional}
\entry {controlling process}{491}{controlling process}
\entry {controlling terminal, access to}{491}{controlling terminal, access to}
\entry {SIGTTIN, from background job}{491}{\code {SIGTTIN}, from background job}
\entry {SIGTTOU, from background job}{491}{\code {SIGTTOU}, from background job}
\entry {orphaned process group}{492}{orphaned process group}
\entry {job control, enabling}{495}{job control, enabling}
\entry {subshell}{495}{subshell}
\entry {job control, enabling}{495}{job control, enabling}
\entry {launching jobs}{497}{launching jobs}
\entry {process group leader}{497}{process group leader}
\entry {process group ID}{497}{process group ID}
\entry {race conditions, relating to job control}{497}{race conditions, relating to job control}
\entry {foreground job, launching}{501}{foreground job, launching}
\entry {background job, launching}{502}{background job, launching}
\entry {stopped jobs, detecting}{502}{stopped jobs, detecting}
\entry {terminated jobs, detecting}{502}{terminated jobs, detecting}
\entry {SIGCHLD, handling of}{503}{\code {SIGCHLD}, handling of}
\entry {stopped jobs, continuing}{507}{stopped jobs, continuing}
\entry {process group functions}{508}{process group functions}
\entry {job control functions}{508}{job control functions}
\entry {controlling terminal, determining}{509}{controlling terminal, determining}
\entry {BSD compatibility library}{510}{BSD compatibility library}
\entry {login name}{513}{login name}
\entry {user name}{513}{user name}
\entry {user ID}{513}{user ID}
\entry {group name}{513}{group name}
\entry {group ID}{513}{group ID}
\entry {persona}{513}{persona}
\entry {effective user ID}{513}{effective user ID}
\entry {effective group ID}{513}{effective group ID}
\entry {real user ID}{514}{real user ID}
\entry {real group ID}{514}{real group ID}
\entry {supplementary group IDs}{514}{supplementary group IDs}
\entry {setuid programs}{515}{\code {setuid} programs}
\entry {login name, determining}{524}{login name, determining}
\entry {user ID, determining}{524}{user ID, determining}
\entry {user database}{525}{user database}
\entry {password database}{525}{password database}
\entry {converting user ID to user name}{526}{converting user ID to user name}
\entry {converting user name to user ID}{526}{converting user name to user ID}
\entry {scanning the user list}{526}{scanning the user list}
\entry {group database}{528}{group database}
\entry {converting group name to group ID}{528}{converting group name to group ID}
\entry {converting group ID to group name}{528}{converting group ID to group name}
\entry {scanning the group list}{529}{scanning the group list}
\entry {POSIX capacity limits}{537}{POSIX capacity limits}
\entry {limits, POSIX}{537}{limits, POSIX}
\entry {capacity limits, POSIX}{537}{capacity limits, POSIX}
\entry {limits, program argument size}{537}{limits, program argument size}
\entry {limits, number of processes}{537}{limits, number of processes}
\entry {limits, number of open files}{537}{limits, number of open files}
\entry {limits, time zone name length}{538}{limits, time zone name length}
\entry {limits, number of supplementary group IDs}{538}{limits, number of supplementary group IDs}
\entry {POSIX optional features}{539}{POSIX optional features}
\entry {optional POSIX features}{539}{optional POSIX features}
\entry {limits, link count of files}{546}{limits, link count of files}
\entry {limits, terminal input queue}{546}{limits, terminal input queue}
\entry {limits, file name length}{546}{limits, file name length}
\entry {limits, pipe buffer size}{546}{limits, pipe buffer size}
\entry {consistency checking}{555}{consistency checking}
\entry {impossible events}{555}{impossible events}
\entry {assertions}{555}{assertions}
\entry {variable number of arguments}{556}{variable number of arguments}
\entry {variadic functions}{556}{variadic functions}
\entry {optional arguments}{556}{optional arguments}
\entry {function prototypes (variadic)}{558}{function prototypes (variadic)}
\entry {prototypes for variadic functions}{558}{prototypes for variadic functions}
\entry {variadic function prototypes}{558}{variadic function prototypes}
\entry {variadic function argument access}{558}{variadic function argument access}
\entry {arguments (variadic functions)}{558}{arguments (variadic functions)}
\entry {number of arguments passed}{559}{number of arguments passed}
\entry {how many arguments}{559}{how many arguments}
\entry {arguments, how many}{559}{arguments, how many}
\entry {variadic functions, calling}{560}{variadic functions, calling}
\entry {calling variadic functions}{560}{calling variadic functions}
\entry {declaring variadic functions}{560}{declaring variadic functions}
\entry {default argument promotions}{560}{default argument promotions}
\entry {argument promotion}{560}{argument promotion}
\entry {null pointer constant}{564}{null pointer constant}
\entry {integer type width}{565}{integer type width}
\entry {width of integer type}{565}{width of integer type}
\entry {type measurements, integer}{565}{type measurements, integer}
\entry {integer type range}{566}{integer type range}
\entry {range of integer type}{566}{range of integer type}
\entry {limits, integer types}{566}{limits, integer types}
\entry {floating type measurements}{568}{floating type measurements}
\entry {measurements of floating types}{568}{measurements of floating types}
\entry {type measurements, floating}{568}{type measurements, floating}
\entry {limits, floating types}{568}{limits, floating types}
\entry {sign (of floating point number)}{568}{sign (of floating point number)}
\entry {base (of floating point number)}{568}{base (of floating point number)}
\entry {radix (of floating point number)}{568}{radix (of floating point number)}
\entry {exponent (of floating point number)}{568}{exponent (of floating point number)}
\entry {bias (of floating point number exponent)}{568}{bias (of floating point number exponent)}
\entry {mantissa (of floating point number)}{569}{mantissa (of floating point number)}
\entry {significand (of floating point number)}{569}{significand (of floating point number)}
\entry {precision (of floating point number)}{569}{precision (of floating point number)}
\entry {hidden bit (of floating point number mantissa)}{569}{hidden bit (of floating point number mantissa)}
\entry {normalized floating point number}{569}{normalized floating point number}
\entry {IEEE floating point representation}{572}{IEEE floating point representation}
\entry {floating point, IEEE}{572}{floating point, IEEE}
\entry {installing the library}{631}{installing the library}
\entry {reporting bugs}{634}{reporting bugs}