\entry {library}{1}{library}
\entry {standards}{1}{standards}
\entry {ANSI C}{2}{ANSI C}
\entry {POSIX}{2}{POSIX}
\entry {POSIX.1}{2}{POSIX.1}
\entry {IEEE Std 1003.1}{2}{IEEE Std 1003.1}
\entry {POSIX.2}{2}{POSIX.2}
\entry {IEEE Std 1003.2}{2}{IEEE Std 1003.2}
\entry {BSD Unix}{3}{BSD Unix}
\entry {4.n BSD Unix}{3}{4.\var {n} BSD Unix}
\entry {Berkeley Unix}{3}{Berkeley Unix}
\entry {SunOS}{3}{SunOS}
\entry {Unix, Berkeley}{3}{Unix, Berkeley}
\entry {SVID}{3}{SVID}
\entry {System V Unix}{3}{System V Unix}
\entry {Unix, System V}{3}{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}{5}{shadowing functions with macros}
\entry {removing macros that shadow functions}{5}{removing macros that shadow functions}
\entry {undefining macros that shadow functions}{5}{undefining macros that shadow functions}
\entry {reserved names}{6}{reserved names}
\entry {name space}{6}{name space}
\entry {feature test macros}{8}{feature test macros}
\entry {BSD compatibility library.}{9}{BSD compatibility library.}
\entry {error reporting}{15}{error reporting}
\entry {reporting errors}{15}{reporting errors}
\entry {error codes}{15}{error codes}
\entry {status codes}{15}{status codes}
\entry {program name}{28}{program name}
\entry {name of running program}{28}{name of running program}
\entry {memory allocation}{31}{memory allocation}
\entry {storage allocation}{31}{storage allocation}
\entry {dynamic allocation}{31}{dynamic allocation}
\entry {static allocation}{31}{static allocation}
\entry {automatic allocation}{31}{automatic allocation}
\entry {unconstrained storage allocation}{32}{unconstrained storage allocation}
\entry {malloc function}{32}{\code {malloc} function}
\entry {heap, dynamic allocation from}{32}{heap, dynamic allocation from}
\entry {allocation of memory with malloc}{32}{allocation of memory with \code {malloc}}
\entry {freeing memory allocated with malloc}{34}{freeing memory allocated with \code {malloc}}
\entry {heap, freeing memory from}{34}{heap, freeing memory from}
\entry {changing the size of a block (malloc)}{35}{changing the size of a block (\code {malloc})}
\entry {efficiency and malloc}{36}{efficiency and \code {malloc}}
\entry {page boundary}{37}{page boundary}
\entry {alignment (with malloc)}{37}{alignment (with \code {malloc})}
\entry {heap consistency checking}{37}{heap consistency checking}
\entry {consistency checking, of heap}{37}{consistency checking, of heap}
\entry {allocation hooks, for malloc}{39}{allocation hooks, for \code {malloc}}
\entry {allocation statistics}{40}{allocation statistics}
\entry {obstacks}{42}{obstacks}
\entry {allocation (obstacks)}{44}{allocation (obstacks)}
\entry {freeing (obstacks)}{45}{freeing (obstacks)}
\entry {macros}{45}{macros}
\entry {growing objects (in obstacks)}{46}{growing objects (in obstacks)}
\entry {changing the size of a block (obstacks)}{46}{changing the size of a block (obstacks)}
\entry {shrinking objects}{48}{shrinking objects}
\entry {efficiency and obstacks}{48}{efficiency and obstacks}
\entry {obstack status}{49}{obstack status}
\entry {status of obstack}{49}{status of obstack}
\entry {alignment (in obstacks)}{50}{alignment (in obstacks)}
\entry {efficiency of chunks}{50}{efficiency of chunks}
\entry {chunks}{50}{chunks}
\entry {automatic freeing}{53}{automatic freeing}
\entry {alloca function}{53}{\code {alloca} function}
\entry {automatic storage with variable size}{53}{automatic storage with variable size}
\entry {longjmp}{54}{longjmp}
\entry {alloca disadvantages}{55}{\code {alloca} disadvantages}
\entry {disadvantages of alloca}{55}{disadvantages of \code {alloca}}
\entry {variable-sized arrays}{55}{variable-sized arrays}
\entry {relocating memory allocator}{56}{relocating memory allocator}
\entry {handle}{56}{handle}
\entry {memory usage warnings}{57}{memory usage warnings}
\entry {warnings of memory almost full}{57}{warnings of memory almost full}
\entry {character testing}{59}{character testing}
\entry {classification of characters}{59}{classification of characters}
\entry {predicates on characters}{59}{predicates on characters}
\entry {character predicates}{59}{character predicates}
\entry {lower-case character}{59}{lower-case character}
\entry {upper-case character}{59}{upper-case character}
\entry {alphabetic character}{59}{alphabetic character}
\entry {digit character}{59}{digit character}
\entry {decimal digit character}{59}{decimal digit character}
\entry {alphanumeric character}{60}{alphanumeric character}
\entry {hexadecimal digit character}{60}{hexadecimal digit character}
\entry {punctuation character}{60}{punctuation character}
\entry {whitespace character}{60}{whitespace character}
\entry {blank character}{60}{blank character}
\entry {graphic character}{60}{graphic character}
\entry {printing character}{60}{printing character}
\entry {control character}{60}{control character}
\entry {ASCII character}{61}{ASCII character}
\entry {character case conversion}{61}{character case conversion}
\entry {case conversion of characters}{61}{case conversion of characters}
\entry {converting case of characters}{61}{converting case of characters}
\entry {string, representation of}{63}{string, representation of}
\entry {string}{63}{string}
\entry {null character}{63}{null character}
\entry {string literal}{63}{string literal}
\entry {length of string}{64}{length of string}
\entry {allocation size of string}{64}{allocation size of string}
\entry {size of string}{64}{size of string}
\entry {string length}{64}{string length}
\entry {string allocation}{64}{string allocation}
\entry {copying strings and arrays}{65}{copying strings and arrays}
\entry {string copy functions}{65}{string copy functions}
\entry {array copy functions}{65}{array copy functions}
\entry {concatenating strings}{65}{concatenating strings}
\entry {string concatenation functions}{65}{string concatenation functions}
\entry {comparing strings and arrays}{70}{comparing strings and arrays}
\entry {string comparison functions}{70}{string comparison functions}
\entry {array comparison functions}{70}{array comparison functions}
\entry {predicates on strings}{70}{predicates on strings}
\entry {predicates on arrays}{70}{predicates on arrays}
\entry {collating strings}{72}{collating strings}
\entry {string collation functions}{72}{string collation functions}
\entry {converting string to collation order}{73}{converting string to collation order}
\entry {search functions (for strings)}{76}{search functions (for strings)}
\entry {string search functions}{76}{string search functions}
\entry {tokenizing strings}{78}{tokenizing strings}
\entry {breaking a string into tokens}{78}{breaking a string into tokens}
\entry {parsing tokens from a string}{78}{parsing tokens from a string}
\entry {opening a file}{81}{opening a file}
\entry {file position}{83}{file position}
\entry {sequential-access files}{83}{sequential-access files}
\entry {random-access files}{83}{random-access files}
\entry {append-access files}{83}{append-access files}
\entry {file name}{83}{file name}
\entry {directory}{84}{directory}
\entry {link}{84}{link}
\entry {directory entry}{84}{directory entry}
\entry {file name component}{84}{file name component}
\entry {file name resolution}{84}{file name resolution}
\entry {root directory}{84}{root directory}
\entry {absolute file name}{84}{absolute file name}
\entry {relative file name}{84}{relative file name}
\entry {parent directory}{85}{parent directory}
\entry {file name errors}{85}{file name errors}
\entry {usual file name errors}{85}{usual file name errors}
\entry {file pointer}{89}{file pointer}
\entry {standard streams}{89}{standard streams}
\entry {streams, standard}{89}{streams, standard}
\entry {standard input stream}{89}{standard input stream}
\entry {standard output stream}{90}{standard output stream}
\entry {standard error stream}{90}{standard error stream}
\entry {opening a stream}{90}{opening a stream}
\entry {closing a stream}{92}{closing a stream}
\entry {writing to a stream, by characters}{93}{writing to a stream, by characters}
\entry {reading from a stream, by characters}{94}{reading from a stream, by characters}
\entry {peeking at input}{97}{peeking at input}
\entry {unreading characters}{97}{unreading characters}
\entry {pushing input back}{97}{pushing input back}
\entry {binary I/O to a stream}{99}{binary I/O to a stream}
\entry {block I/O to a stream}{99}{block I/O to a stream}
\entry {reading from a stream, by blocks}{99}{reading from a stream, by blocks}
\entry {writing to a stream, by blocks}{99}{writing to a stream, by blocks}
\entry {format string, for printf}{100}{format string, for \code {printf}}
\entry {template, for printf}{100}{template, for \code {printf}}
\entry {formatted output to a stream}{100}{formatted output to a stream}
\entry {writing to a stream, formatted}{100}{writing to a stream, formatted}
\entry {conversion specifications (printf)}{100}{conversion specifications (\code {printf})}
\entry {flag character (printf)}{102}{flag character (\code {printf})}
\entry {minimum field width (printf)}{102}{minimum field width (\code {printf})}
\entry {precision (printf)}{102}{precision (\code {printf})}
\entry {type modifier character (printf)}{102}{type modifier character (\code {printf})}
\entry {output conversions, for printf}{103}{output conversions, for \code {printf}}
\entry {parsing a template string}{113}{parsing a template string}
\entry {customizing printf}{116}{customizing \code {printf}}
\entry {defining new printf conversions}{116}{defining new \code {printf} conversions}
\entry {extending printf}{116}{extending \code {printf}}
\entry {formatted input from a stream}{121}{formatted input from a stream}
\entry {reading from a stream, formatted}{121}{reading from a stream, formatted}
\entry {format string, for scanf}{121}{format string, for \code {scanf}}
\entry {template, for scanf}{121}{template, for \code {scanf}}
\entry {conversion specifications (scanf)}{121}{conversion specifications (\code {scanf})}
\entry {matching failure, in scanf}{122}{matching failure, in \code {scanf}}
\entry {flag character (scanf)}{123}{flag character (\code {scanf})}
\entry {maximum field width (scanf)}{123}{maximum field width (\code {scanf})}
\entry {type modifier character (scanf)}{123}{type modifier character (\code {scanf})}
\entry {input conversions, for scanf}{123}{input conversions, for \code {scanf}}
\entry {end of file, on a stream}{130}{end of file, on a stream}
\entry {text stream}{131}{text stream}
\entry {binary stream}{131}{binary stream}
\entry {lines (in a text file)}{131}{lines (in a text file)}
\entry {file positioning on a stream}{132}{file positioning on a stream}
\entry {positioning a stream}{132}{positioning a stream}
\entry {seeking on a stream}{132}{seeking on a stream}
\entry {buffering of streams}{135}{buffering of streams}
\entry {unbuffered stream}{135}{unbuffered stream}
\entry {line buffered stream}{135}{line buffered stream}
\entry {fully buffered stream}{135}{fully buffered stream}
\entry {flushing a stream}{136}{flushing a stream}
\entry {buffering, controlling}{136}{buffering, controlling}
\entry {stream, for I/O to a string}{139}{stream, for I/O to a string}
\entry {string stream}{139}{string stream}
\entry {custom streams}{142}{custom streams}
\entry {programming your own streams}{142}{programming your own streams}
\entry {cookie, for custom stream}{142}{cookie, for custom stream}
\entry {hook functions (of custom streams)}{143}{hook functions (of custom streams)}
\entry {opening a file descriptor}{145}{opening a file descriptor}
\entry {closing a file descriptor}{145}{closing a file descriptor}
\entry {reading from a file descriptor}{147}{reading from a file descriptor}
\entry {end-of-file, on a file descriptor}{147}{end-of-file, on a file descriptor}
\entry {writing to a file descriptor}{149}{writing to a file descriptor}
\entry {file positioning on a file descriptor}{151}{file positioning on a file descriptor}
\entry {positioning a file descriptor}{151}{positioning a file descriptor}
\entry {seeking on a file descriptor}{151}{seeking on a file descriptor}
\entry {sparse files}{151}{sparse files}
\entry {holes in files}{151}{holes in files}
\entry {streams, and file descriptors}{153}{streams, and file descriptors}
\entry {converting file descriptor to stream}{153}{converting file descriptor to stream}
\entry {extracting file descriptor from stream}{153}{extracting file descriptor from stream}
\entry {standard file descriptors}{153}{standard file descriptors}
\entry {file descriptors, standard}{153}{file descriptors, standard}
\entry {standard input file descriptor}{154}{standard input file descriptor}
\entry {standard output file descriptor}{154}{standard output file descriptor}
\entry {standard error file descriptor}{154}{standard error file descriptor}
\entry {channels}{154}{channels}
\entry {streams and descriptors}{154}{streams and descriptors}
\entry {descriptors and streams}{154}{descriptors and streams}
\entry {mixing descriptors and streams}{154}{mixing descriptors and streams}
\entry {linked channels}{154}{linked channels}
\entry {cleaning up a stream}{154}{cleaning up a stream}
\entry {independent channels}{155}{independent channels}
\entry {waiting for input or output}{156}{waiting for input or output}
\entry {multiplexing input}{156}{multiplexing input}
\entry {input from multiple files}{156}{input from multiple files}
\entry {file descriptor sets, for select}{156}{file descriptor sets, for \code {select}}
\entry {control operations on files}{159}{control operations on files}
\entry {fcntl function}{159}{\code {fcntl} function}
\entry {duplicating file descriptors}{160}{duplicating file descriptors}
\entry {redirecting input and output}{160}{redirecting input and output}
\entry {file descriptor flags}{162}{file descriptor flags}
\entry {close-on-exec (file descriptor flag)}{163}{close-on-exec (file descriptor flag)}
\entry {file status flags}{164}{file status flags}
\entry {file name translation flags}{165}{file name translation flags}
\entry {flags, file name translation}{165}{flags, file name translation}
\entry {open-time action flags}{165}{open-time action flags}
\entry {flags, open-time action}{165}{flags, open-time action}
\entry {create on open (file status flag)}{166}{create on open (file status flag)}
\entry {non-blocking open}{166}{non-blocking open}
\entry {controlling terminal, setting}{166}{controlling terminal, setting}
\entry {symbolic link, opening}{166}{symbolic link, opening}
\entry {file locks}{170}{file locks}
\entry {record locking}{170}{record locking}
\entry {exclusive lock}{170}{exclusive lock}
\entry {write lock}{170}{write lock}
\entry {shared lock}{170}{shared lock}
\entry {read lock}{170}{read lock}
\entry {interrupt-driven input}{173}{interrupt-driven input}
\entry {current working directory}{175}{current working directory}
\entry {working directory}{175}{working directory}
\entry {change working directory}{175}{change working directory}
\entry {accessing directories}{177}{accessing directories}
\entry {reading from a directory}{177}{reading from a directory}
\entry {directories, accessing}{177}{directories, accessing}
\entry {directory stream}{177}{directory stream}
\entry {hard link}{181}{hard link}
\entry {link, hard}{181}{link, hard}
\entry {multiple names for one file}{181}{multiple names for one file}
\entry {file names, multiple}{181}{file names, multiple}
\entry {soft link}{183}{soft link}
\entry {link, soft}{183}{link, soft}
\entry {symbolic link}{183}{symbolic link}
\entry {link, symbolic}{183}{link, symbolic}
\entry {deleting a file}{184}{deleting a file}
\entry {removing a file}{184}{removing a file}
\entry {unlinking a file}{184}{unlinking a file}
\entry {directories, deleting}{185}{directories, deleting}
\entry {deleting a directory}{185}{deleting a directory}
\entry {renaming a file}{185}{renaming a file}
\entry {creating a directory}{187}{creating a directory}
\entry {directories, creating}{187}{directories, creating}
\entry {status of a file}{188}{status of a file}
\entry {attributes of a file}{188}{attributes of a file}
\entry {file attributes}{188}{file attributes}
\entry {inode number}{190}{inode number}
\entry {file owner}{193}{file owner}
\entry {owner of a file}{193}{owner of a file}
\entry {group owner of a file}{193}{group owner of a file}
\entry {file permission bits}{194}{file permission bits}
\entry {sticky bit}{195}{sticky bit}
\entry {permission to access a file}{196}{permission to access a file}
\entry {access permission for a file}{196}{access permission for a file}
\entry {file access permission}{196}{file access permission}
\entry {file creation mask}{197}{file creation mask}
\entry {umask}{197}{umask}
\entry {testing access permission}{199}{testing access permission}
\entry {access, testing for}{199}{access, testing for}
\entry {setuid programs and file access}{199}{setuid programs and file access}
\entry {file access time}{200}{file access time}
\entry {file modification time}{200}{file modification time}
\entry {file attribute modification time}{200}{file attribute modification time}
\entry {creating special files}{202}{creating special files}
\entry {special files}{202}{special files}
\entry {TMPDIR environment variable}{205}{TMPDIR environment variable}
\entry {pipe}{207}{pipe}
\entry {FIFO special file}{207}{FIFO special file}
\entry {creating a pipe}{207}{creating a pipe}
\entry {opening a pipe}{207}{opening a pipe}
\entry {interprocess communication, with pipes}{207}{interprocess communication, with pipes}
\entry {creating a pipe to a subprocess}{209}{creating a pipe to a subprocess}
\entry {pipe to a subprocess}{209}{pipe to a subprocess}
\entry {filtering i/o through subprocess}{209}{filtering i/o through subprocess}
\entry {creating a FIFO special file}{210}{creating a FIFO special file}
\entry {interprocess communication, with FIFO}{210}{interprocess communication, with FIFO}
\entry {socket}{213}{socket}
\entry {interprocess communication, with sockets}{213}{interprocess communication, with sockets}
\entry {communication style (of a socket)}{213}{communication style (of a socket)}
\entry {style of communication (of a socket)}{213}{style of communication (of a socket)}
\entry {packet}{213}{packet}
\entry {byte stream}{213}{byte stream}
\entry {stream (sockets)}{213}{stream (sockets)}
\entry {loss of data on sockets}{213}{loss of data on sockets}
\entry {data loss on sockets}{213}{data loss on sockets}
\entry {namespace (of socket)}{213}{namespace (of socket)}
\entry {domain (of socket)}{213}{domain (of socket)}
\entry {socket namespace}{213}{socket namespace}
\entry {socket domain}{213}{socket domain}
\entry {network protocol}{214}{network protocol}
\entry {protocol (of socket)}{214}{protocol (of socket)}
\entry {socket protocol}{214}{socket protocol}
\entry {protocol family}{214}{protocol family}
\entry {address of socket}{215}{address of socket}
\entry {name of socket}{215}{name of socket}
\entry {binding a socket address}{215}{binding a socket address}
\entry {socket address (name) binding}{215}{socket address (name) binding}
\entry {file namespace, for sockets}{218}{file namespace, for sockets}
\entry {Internet namespace, for sockets}{221}{Internet namespace, for sockets}
\entry {host address, Internet}{222}{host address, Internet}
\entry {Internet host address}{222}{Internet host address}
\entry {network number}{222}{network number}
\entry {local network address number}{222}{local network address number}
\entry {standard dot notation, for Internet addresses}{223}{standard dot notation, for Internet addresses}
\entry {dot notation, for Internet addresses}{223}{dot notation, for Internet addresses}
\entry {hosts database}{225}{hosts database}
\entry {converting host name to address}{225}{converting host name to address}
\entry {converting host address to name}{225}{converting host address to name}
\entry {port number}{228}{port number}
\entry {services database}{228}{services database}
\entry {converting service name to port number}{228}{converting service name to port number}
\entry {converting port number to service name}{228}{converting port number to service name}
\entry {byte order conversion, for socket}{230}{byte order conversion, for socket}
\entry {converting byte order}{230}{converting byte order}
\entry {big-endian}{230}{big-endian}
\entry {little-endian}{230}{little-endian}
\entry {network byte order}{230}{network byte order}
\entry {protocols database}{231}{protocols database}
\entry {TCP (Internet protocol)}{231}{TCP (Internet protocol)}
\entry {creating a socket}{234}{creating a socket}
\entry {socket, creating}{234}{socket, creating}
\entry {opening a socket}{234}{opening a socket}
\entry {socket, closing}{235}{socket, closing}
\entry {closing a socket}{235}{closing a socket}
\entry {shutting down a socket}{235}{shutting down a socket}
\entry {socket shutdown}{235}{socket shutdown}
\entry {creating a socket pair}{235}{creating a socket pair}
\entry {socket pair}{235}{socket pair}
\entry {opening a socket pair}{235}{opening a socket pair}
\entry {connection}{236}{connection}
\entry {client}{236}{client}
\entry {server}{236}{server}
\entry {connecting a socket}{237}{connecting a socket}
\entry {socket, connecting}{237}{socket, connecting}
\entry {socket, initiating a connection}{237}{socket, initiating a connection}
\entry {socket, client actions}{237}{socket, client actions}
\entry {listening (sockets)}{238}{listening (sockets)}
\entry {sockets, server actions}{238}{sockets, server actions}
\entry {sockets, listening}{238}{sockets, listening}
\entry {sockets, accepting connections}{239}{sockets, accepting connections}
\entry {accepting connections}{239}{accepting connections}
\entry {reading from a socket}{240}{reading from a socket}
\entry {writing to a socket}{240}{writing to a socket}
\entry {out-of-band data}{246}{out-of-band data}
\entry {high-priority data}{246}{high-priority data}
\entry {urgent socket condition}{247}{urgent socket condition}
\entry {datagram socket}{249}{datagram socket}
\entry {sending a datagram}{250}{sending a datagram}
\entry {transmitting datagrams}{250}{transmitting datagrams}
\entry {datagrams, transmitting}{250}{datagrams, transmitting}
\entry {receiving datagrams}{250}{receiving datagrams}
\entry {socket options}{255}{socket options}
\entry {level, for socket options}{255}{level, for socket options}
\entry {socket option level}{255}{socket option level}
\entry {networks database}{258}{networks database}
\entry {converting network number to network name}{258}{converting network number to network name}
\entry {converting network name to network number}{258}{converting network name to network number}
\entry {terminal identification}{261}{terminal identification}
\entry {identifying terminals}{261}{identifying terminals}
\entry {terminal input queue}{261}{terminal input queue}
\entry {typeahead buffer}{261}{typeahead buffer}
\entry {terminal output queue}{262}{terminal output queue}
\entry {canonical input processing}{262}{canonical input processing}
\entry {noncanonical input processing}{262}{noncanonical input processing}
\entry {terminal mode data types}{263}{terminal mode data types}
\entry {terminal mode functions}{264}{terminal mode functions}
\entry {parity checking}{267}{parity checking}
\entry {break condition, detecting}{268}{break condition, detecting}
\entry {modem status lines}{270}{modem status lines}
\entry {carrier detect}{270}{carrier detect}
\entry {modem disconnect}{270}{modem disconnect}
\entry {echo of terminal input}{272}{echo of terminal input}
\entry {interactive signals, from terminal}{273}{interactive signals, from terminal}
\entry {line speed}{274}{line speed}
\entry {baud rate}{274}{baud rate}
\entry {terminal line speed}{274}{terminal line speed}
\entry {terminal line speed}{274}{terminal line speed}
\entry {EOF character}{277}{EOF character}
\entry {EOL character}{277}{EOL character}
\entry {EOL2 character}{277}{EOL2 character}
\entry {ERASE character}{277}{ERASE character}
\entry {WERASE character}{278}{WERASE character}
\entry {KILL character}{278}{KILL character}
\entry {REPRINT character}{278}{REPRINT character}
\entry {INTR character}{278}{INTR character}
\entry {interrupt character}{278}{interrupt character}
\entry {QUIT character}{279}{QUIT character}
\entry {SUSP character}{279}{SUSP character}
\entry {suspend character}{279}{suspend character}
\entry {DSUSP character}{279}{DSUSP character}
\entry {delayed suspend character}{279}{delayed suspend character}
\entry {START character}{280}{START character}
\entry {STOP character}{280}{STOP character}
\entry {LNEXT character}{280}{LNEXT character}
\entry {DISCARD character}{281}{DISCARD character}
\entry {STATUS character}{281}{STATUS character}
\entry {MIN termios slot}{281}{MIN termios slot}
\entry {TIME termios slot}{282}{TIME termios slot}
\entry {terminal line control functions}{283}{terminal line control functions}
\entry {break condition, generating}{283}{break condition, generating}
\entry {flushing terminal output queue}{283}{flushing terminal output queue}
\entry {terminal output queue, flushing}{283}{terminal output queue, flushing}
\entry {clearing terminal input queue}{284}{clearing terminal input queue}
\entry {terminal input queue, clearing}{284}{terminal input queue, clearing}
\entry {flow control, terminal}{284}{flow control, terminal}
\entry {terminal flow control}{284}{terminal flow control}
\entry {domain error}{287}{domain error}
\entry {range error}{287}{range error}
\entry {trigonometric functions}{288}{trigonometric functions}
\entry {pi (trigonometric constant)}{288}{pi (trigonometric constant)}
\entry {inverse trigonmetric functions}{289}{inverse trigonmetric functions}
\entry {exponentiation functions}{290}{exponentiation functions}
\entry {power functions}{290}{power functions}
\entry {logarithm functions}{290}{logarithm functions}
\entry {square root function}{290}{square root function}
\entry {cube root function}{290}{cube root function}
\entry {hyperbolic functions}{291}{hyperbolic functions}
\entry {inverse hyperbolic functions}{291}{inverse hyperbolic functions}
\entry {random numbers}{292}{random numbers}
\entry {pseudo-random numbers}{292}{pseudo-random numbers}
\entry {seed (for random numbers)}{292}{seed (for random numbers)}
\entry {NaN}{295}{NaN}
\entry {not a number}{295}{not a number}
\entry {IEEE floating point}{295}{IEEE floating point}
\entry {absolute value functions}{296}{absolute value functions}
\entry {normalization functions (floating-point)}{297}{normalization functions (floating-point)}
\entry {rounding functions}{298}{rounding functions}
\entry {remainder functions}{298}{remainder functions}
\entry {converting floats to integers}{298}{converting floats to integers}
\entry {integer division functions}{299}{integer division functions}
\entry {parsing numbers (in formatted input)}{300}{parsing numbers (in formatted input)}
\entry {converting strings to numbers}{300}{converting strings to numbers}
\entry {number syntax, parsing}{300}{number syntax, parsing}
\entry {syntax, for reading numbers}{300}{syntax, for reading numbers}
\entry {Comparison Function}{307}{Comparison Function}
\entry {search function (for arrays)}{307}{search function (for arrays)}
\entry {binary search function (for arrays)}{307}{binary search function (for arrays)}
\entry {array search function}{307}{array search function}
\entry {sort function (for arrays)}{308}{sort function (for arrays)}
\entry {quick sort function (for arrays)}{308}{quick sort function (for arrays)}
\entry {array sort function}{308}{array sort function}
\entry {stable sorting}{308}{stable sorting}
\entry {Kermit the frog}{310}{Kermit the frog}
\entry {globbing}{314}{globbing}
\entry {word expansion}{323}{word expansion}
\entry {expansion of shell words}{323}{expansion of shell words}
\entry {tilde expansion}{324}{tilde expansion}
\entry {variable substitution}{324}{variable substitution}
\entry {substitution of variables and commands}{324}{substitution of variables and commands}
\entry {command substitution}{324}{command substitution}
\entry {arithmetic expansion}{324}{arithmetic expansion}
\entry {field splitting}{324}{field splitting}
\entry {wildcard expansion}{324}{wildcard expansion}
\entry {quote removal}{324}{quote removal}
\entry {removal of quotes}{324}{removal of quotes}
\entry {CPU time}{329}{CPU time}
\entry {processor time}{329}{processor time}
\entry {clock ticks}{329}{clock ticks}
\entry {ticks, clock}{329}{ticks, clock}
\entry {time, elapsed CPU}{329}{time, elapsed CPU}
\entry {Gregorian calendar}{331}{Gregorian calendar}
\entry {time, calendar}{331}{time, calendar}
\entry {date and time}{331}{date and time}
\entry {calendar time}{331}{calendar time}
\entry {high-resolution time}{331}{high-resolution time}
\entry {local time}{331}{local time}
\entry {broken-down time}{331}{broken-down time}
\entry {epoch}{332}{epoch}
\entry {broken-down time}{335}{broken-down time}
\entry {calendar time and broken-down time}{335}{calendar time and broken-down time}
\entry {leap second}{335}{leap second}
\entry {Daylight Saving Time}{336}{Daylight Saving Time}
\entry {summer time}{336}{summer time}
\entry {time zone}{342}{time zone}
\entry {time zone database}{344}{time zone database}
\entry {setting an alarm}{346}{setting an alarm}
\entry {interval timer, setting}{346}{interval timer, setting}
\entry {alarms, setting}{346}{alarms, setting}
\entry {timers, setting}{346}{timers, setting}
\entry {real-time timer}{346}{real-time timer}
\entry {timer, real-time}{346}{timer, real-time}
\entry {virtual timer}{346}{virtual timer}
\entry {timer, virtual}{346}{timer, virtual}
\entry {profiling timer}{346}{profiling timer}
\entry {timer, profiling}{346}{timer, profiling}
\entry {resource limits}{351}{resource limits}
\entry {limits on resource usage}{351}{limits on resource usage}
\entry {usage limits}{351}{usage limits}
\entry {soft limit}{352}{soft limit}
\entry {hard limit}{352}{hard limit}
\entry {process priority}{354}{process priority}
\entry {priority of a process}{354}{priority of a process}
\entry {extended character sets}{357}{extended character sets}
\entry {wide characters}{357}{wide characters}
\entry {multibyte characters}{358}{multibyte characters}
\entry {basic byte sequence}{358}{basic byte sequence}
\entry {code, character}{361}{code, character}
\entry {character code}{361}{character code}
\entry {extended strings, converting representations}{362}{extended strings, converting representations}
\entry {converting extended strings}{362}{converting extended strings}
\entry {multibyte character, length of}{363}{multibyte character, length of}
\entry {length of multibyte character}{363}{length of multibyte character}
\entry {extended characters, converting}{364}{extended characters, converting}
\entry {converting extended characters}{364}{converting extended characters}
\entry {internationalization}{369}{internationalization}
\entry {locales}{369}{locales}
\entry {combining locales}{370}{combining locales}
\entry {categories for locales}{370}{categories for locales}
\entry {locale categories}{370}{locale categories}
\entry {changing the locale}{371}{changing the locale}
\entry {locale, changing}{371}{locale, changing}
\entry {monetary value formatting}{373}{monetary value formatting}
\entry {numeric value formatting}{373}{numeric value formatting}
\entry {decimal-point separator}{374}{decimal-point separator}
\entry {grouping of digits}{374}{grouping of digits}
\entry {currency symbols}{375}{currency symbols}
\entry {non-local exits}{379}{non-local exits}
\entry {long jumps}{379}{long jumps}
\entry {signal}{383}{signal}
\entry {generation of signals}{384}{generation of signals}
\entry {delivery of signals}{384}{delivery of signals}
\entry {pending signals}{384}{pending signals}
\entry {blocked signals}{384}{blocked signals}
\entry {specified action (for a signal)}{385}{specified action (for a signal)}
\entry {default action (for a signal)}{385}{default action (for a signal)}
\entry {signal action}{385}{signal action}
\entry {catching signals}{385}{catching signals}
\entry {signal names}{385}{signal names}
\entry {names of signals}{385}{names of signals}
\entry {signal number}{385}{signal number}
\entry {program error signals}{386}{program error signals}
\entry {exception}{387}{exception}
\entry {floating-point exception}{387}{floating-point exception}
\entry {illegal instruction}{388}{illegal instruction}
\entry {segmentation violation}{388}{segmentation violation}
\entry {bus error}{388}{bus error}
\entry {abort signal}{388}{abort signal}
\entry {program termination signals}{389}{program termination signals}
\entry {termination signal}{389}{termination signal}
\entry {interrupt signal}{389}{interrupt signal}
\entry {quit signal}{390}{quit signal}
\entry {quit signal}{390}{quit signal}
\entry {kill signal}{390}{kill signal}
\entry {hangup signal}{390}{hangup signal}
\entry {alarm signal}{391}{alarm signal}
\entry {virtual time alarm signal}{391}{virtual time alarm signal}
\entry {profiling alarm signal}{391}{profiling alarm signal}
\entry {input available signal}{391}{input available signal}
\entry {output possible signal}{391}{output possible signal}
\entry {urgent data signal}{391}{urgent data signal}
\entry {job control signals}{392}{job control signals}
\entry {child process signal}{392}{child process signal}
\entry {continue signal}{392}{continue signal}
\entry {stop signal}{392}{stop signal}
\entry {interactive stop signal}{393}{interactive stop signal}
\entry {terminal input signal}{393}{terminal input signal}
\entry {terminal output signal}{393}{terminal output signal}
\entry {pipe signal}{394}{pipe signal}
\entry {broken pipe signal}{394}{broken pipe signal}
\entry {lost resource signal}{394}{lost resource signal}
\entry {user signals}{394}{user signals}
\entry {signal messages}{395}{signal messages}
\entry {signal actions}{396}{signal actions}
\entry {establishing a handler}{396}{establishing a handler}
\entry {signal function}{396}{\code {signal} function}
\entry {default action for a signal}{397}{default action for a signal}
\entry {ignore action for a signal}{397}{ignore action for a signal}
\entry {sigaction function}{398}{\code {sigaction} function}
\entry {signal flags}{401}{signal flags}
\entry {flags for sigaction}{401}{flags for \code {sigaction}}
\entry {sigaction flags}{401}{\code {sigaction} flags}
\entry {initial signal actions}{402}{initial signal actions}
\entry {signal handler function}{403}{signal handler function}
\entry {non-local exit, from signal handler}{405}{non-local exit, from signal handler}
\entry {race conditions, relating to signals}{406}{race conditions, relating to signals}
\entry {handling multiple signals}{407}{handling multiple signals}
\entry {successive signals}{407}{successive signals}
\entry {merging of signals}{407}{merging of signals}
\entry {restrictions on signal handler functions}{410}{restrictions on signal handler functions}
\entry {volatile declarations}{410}{\code {volatile} declarations}
\entry {reentrant functions}{410}{reentrant functions}
\entry {EINTR, and restarting interrupted primitives}{415}{EINTR, and restarting interrupted primitives}
\entry {restarting interrupted primitives}{415}{restarting interrupted primitives}
\entry {interrupting primitives}{415}{interrupting primitives}
\entry {primitives, interrupting}{415}{primitives, interrupting}
\entry {sending signals}{415}{sending signals}
\entry {raising signals}{415}{raising signals}
\entry {signals, generating}{415}{signals, generating}
\entry {killing a process}{417}{killing a process}
\entry {interprocess communication, with signals}{419}{interprocess communication, with signals}
\entry {blocking signals}{420}{blocking signals}
\entry {signal set}{421}{signal set}
\entry {signal mask}{422}{signal mask}
\entry {process signal mask}{422}{process signal mask}
\entry {blocking signals, in a handler}{424}{blocking signals, in a handler}
\entry {pending signals, checking for}{425}{pending signals, checking for}
\entry {blocked signals, checking for}{425}{blocked signals, checking for}
\entry {checking for pending signals}{425}{checking for pending signals}
\entry {timing error in signal handling}{427}{timing error in signal handling}
\entry {waiting for a signal}{428}{waiting for a signal}
\entry {pause function}{428}{\code {pause} function}
\entry {process}{437}{process}
\entry {program arguments}{437}{program arguments}
\entry {command line arguments}{437}{command line arguments}
\entry {arguments, to program}{437}{arguments, to program}
\entry {program startup}{437}{program startup}
\entry {startup of program}{437}{startup of program}
\entry {invocation of program}{437}{invocation of program}
\entry {main function}{437}{\code {main} function}
\entry {argc (program argument count)}{437}{argc (program argument count)}
\entry {argv (program argument vector)}{437}{argv (program argument vector)}
\entry {program argument syntax}{438}{program argument syntax}
\entry {syntax, for program arguments}{438}{syntax, for program arguments}
\entry {command argument syntax}{438}{command argument syntax}
\entry {long-named options}{438}{long-named options}
\entry {program arguments, parsing}{439}{program arguments, parsing}
\entry {command arguments, parsing}{439}{command arguments, parsing}
\entry {parsing program arguments}{439}{parsing program arguments}
\entry {environment variable}{447}{environment variable}
\entry {environment}{448}{environment}
\entry {environment access}{448}{environment access}
\entry {environment representation}{448}{environment representation}
\entry {standard environment variables}{449}{standard environment variables}
\entry {HOME environment variable}{449}{HOME environment variable}
\entry {home directory}{449}{home directory}
\entry {LOGNAME environment variable}{449}{LOGNAME environment variable}
\entry {PATH environment variable}{450}{PATH environment variable}
\entry {TERM environment variable}{450}{TERM environment variable}
\entry {TZ environment variable}{450}{TZ environment variable}
\entry {LANG environment variable}{450}{LANG environment variable}
\entry {LC{\_}COLLATE environment variable}{450}{LC{\_}COLLATE environment variable}
\entry {LC{\_}CTYPE environment variable}{450}{LC{\_}CTYPE environment variable}
\entry {LC{\_}MONETARY environment variable}{451}{LC{\_}MONETARY environment variable}
\entry {LC{\_}NUMERIC environment variable}{451}{LC{\_}NUMERIC environment variable}
\entry {LC{\_}TIME environment variable}{451}{LC{\_}TIME environment variable}
\entry {{\_}POSIX{\_}OPTION{\_}ORDER environment variable.}{451}{{\_}POSIX{\_}OPTION{\_}ORDER environment variable.}
\entry {program termination}{451}{program termination}
\entry {process termination}{451}{process termination}
\entry {exit status value}{451}{exit status value}
\entry {exit status}{452}{exit status}
\entry {aborting a program}{454}{aborting a program}
\entry {process}{457}{process}
\entry {child process}{457}{child process}
\entry {parent process}{457}{parent process}
\entry {running a command}{457}{running a command}
\entry {process ID}{458}{process ID}
\entry {process lifetime}{458}{process lifetime}
\entry {creating a process}{458}{creating a process}
\entry {forking a process}{458}{forking a process}
\entry {child process}{458}{child process}
\entry {parent process}{458}{parent process}
\entry {process image}{458}{process image}
\entry {executing a file}{460}{executing a file}
\entry {exec functions}{460}{\code {exec} functions}
\entry {process completion}{463}{process completion}
\entry {waiting for completion of child process}{463}{waiting for completion of child process}
\entry {testing exit status of child process}{463}{testing exit status of child process}
\entry {process groups}{471}{process groups}
\entry {job control}{471}{job control}
\entry {job}{471}{job}
\entry {session}{471}{session}
\entry {shell}{471}{shell}
\entry {session}{471}{session}
\entry {session leader}{471}{session leader}
\entry {controlling terminal}{472}{controlling terminal}
\entry {foreground job}{472}{foreground job}
\entry {background job}{472}{background job}
\entry {stopped job}{472}{stopped job}
\entry {job control is optional}{472}{job control is optional}
\entry {controlling process}{473}{controlling process}
\entry {controlling terminal, access to}{473}{controlling terminal, access to}
\entry {SIGTTIN, from background job}{473}{\code {SIGTTIN}, from background job}
\entry {SIGTTOU, from background job}{473}{\code {SIGTTOU}, from background job}
\entry {orphaned process group}{473}{orphaned process group}
\entry {job control, enabling}{476}{job control, enabling}
\entry {subshell}{476}{subshell}
\entry {job control, enabling}{476}{job control, enabling}
\entry {launching jobs}{478}{launching jobs}
\entry {process group leader}{478}{process group leader}
\entry {process group ID}{478}{process group ID}
\entry {race conditions, relating to job control}{478}{race conditions, relating to job control}
\entry {foreground job, launching}{481}{foreground job, launching}
\entry {background job, launching}{482}{background job, launching}
\entry {stopped jobs, detecting}{483}{stopped jobs, detecting}
\entry {terminated jobs, detecting}{483}{terminated jobs, detecting}
\entry {SIGCHLD, handling of}{483}{\code {SIGCHLD}, handling of}
\entry {stopped jobs, continuing}{486}{stopped jobs, continuing}
\entry {process group functions}{488}{process group functions}
\entry {job control functions}{488}{job control functions}
\entry {controlling terminal, determining}{488}{controlling terminal, determining}
\entry {BSD compatibility library}{489}{BSD compatibility library}
\entry {Name Service Switch}{493}{Name Service Switch}
\entry {NSS}{493}{NSS}
\entry {databses}{493}{databses}
\entry {ethers}{493}{ethers}
\entry {group}{493}{group}
\entry {hosts}{493}{hosts}
\entry {netgroup}{493}{netgroup}
\entry {network}{493}{network}
\entry {protocols}{493}{protocols}
\entry {passwd}{493}{passwd}
\entry {rpc}{493}{rpc}
\entry {services}{493}{services}
\entry {shadow}{493}{shadow}
\entry {/etc/nsswitch.conf}{494}{\file {/etc/nsswitch.conf}}
\entry {nsswitch.conf}{494}{\file {nsswitch.conf}}
\entry {DNS server unavailable}{495}{DNS server unavailable}
\entry {nisplus, and completeness}{496}{nisplus, and completeness}
\entry {nisplus, and booting}{496}{nisplus, and booting}
\entry {bootstrapping, and services}{496}{bootstrapping, and services}
\entry {default value, and NSS}{496}{default value, and NSS}
\entry {optimizing NSS}{497}{optimizing NSS}
\entry {reentrant NSS functions}{497}{reentrant NSS functions}
\entry {NSS{\_}STATUS{\_}TRYAGAIN}{498}{NSS{\_}STATUS{\_}TRYAGAIN}
\entry {NSS{\_}STATUS{\_}UNAVAIL}{498}{NSS{\_}STATUS{\_}UNAVAIL}
\entry {NSS{\_}STATUS{\_}NOTFOUND}{498}{NSS{\_}STATUS{\_}NOTFOUND}
\entry {NSS{\_}STATUS{\_}SUCCESS}{498}{NSS{\_}STATUS{\_}SUCCESS}
\entry {login name}{503}{login name}
\entry {user name}{503}{user name}
\entry {user ID}{503}{user ID}
\entry {group name}{503}{group name}
\entry {group ID}{503}{group ID}
\entry {persona}{503}{persona}
\entry {effective user ID}{503}{effective user ID}
\entry {effective group ID}{503}{effective group ID}
\entry {real user ID}{504}{real user ID}
\entry {real group ID}{504}{real group ID}
\entry {supplementary group IDs}{504}{supplementary group IDs}
\entry {setuid programs}{505}{\code {setuid} programs}
\entry {login name, determining}{512}{login name, determining}
\entry {user ID, determining}{512}{user ID, determining}
\entry {user database}{513}{user database}
\entry {password database}{513}{password database}
\entry {converting user ID to user name}{514}{converting user ID to user name}
\entry {converting user name to user ID}{514}{converting user name to user ID}
\entry {scanning the user list}{515}{scanning the user list}
\entry {group database}{517}{group database}
\entry {converting group name to group ID}{517}{converting group name to group ID}
\entry {converting group ID to group name}{517}{converting group ID to group name}
\entry {scanning the group list}{519}{scanning the group list}
\entry {Netgroup}{520}{Netgroup}
\entry {POSIX capacity limits}{529}{POSIX capacity limits}
\entry {limits, POSIX}{529}{limits, POSIX}
\entry {capacity limits, POSIX}{529}{capacity limits, POSIX}
\entry {limits, program argument size}{529}{limits, program argument size}
\entry {limits, number of processes}{529}{limits, number of processes}
\entry {limits, number of open files}{529}{limits, number of open files}
\entry {limits, time zone name length}{530}{limits, time zone name length}
\entry {limits, number of supplementary group IDs}{530}{limits, number of supplementary group IDs}
\entry {POSIX optional features}{530}{POSIX optional features}
\entry {optional POSIX features}{530}{optional POSIX features}
\entry {limits, link count of files}{537}{limits, link count of files}
\entry {limits, terminal input queue}{537}{limits, terminal input queue}
\entry {limits, file name length}{537}{limits, file name length}
\entry {limits, pipe buffer size}{538}{limits, pipe buffer size}
\entry {consistency checking}{545}{consistency checking}
\entry {impossible events}{545}{impossible events}
\entry {assertions}{545}{assertions}
\entry {variable number of arguments}{547}{variable number of arguments}
\entry {variadic functions}{547}{variadic functions}
\entry {optional arguments}{547}{optional arguments}
\entry {function prototypes (variadic)}{548}{function prototypes (variadic)}
\entry {prototypes for variadic functions}{548}{prototypes for variadic functions}
\entry {variadic function prototypes}{548}{variadic function prototypes}
\entry {variadic function argument access}{548}{variadic function argument access}
\entry {arguments (variadic functions)}{548}{arguments (variadic functions)}
\entry {number of arguments passed}{549}{number of arguments passed}
\entry {how many arguments}{549}{how many arguments}
\entry {arguments, how many}{549}{arguments, how many}
\entry {variadic functions, calling}{550}{variadic functions, calling}
\entry {calling variadic functions}{550}{calling variadic functions}
\entry {declaring variadic functions}{550}{declaring variadic functions}
\entry {default argument promotions}{550}{default argument promotions}
\entry {argument promotion}{550}{argument promotion}
\entry {null pointer constant}{553}{null pointer constant}
\entry {integer type width}{555}{integer type width}
\entry {width of integer type}{555}{width of integer type}
\entry {type measurements, integer}{555}{type measurements, integer}
\entry {integer type range}{555}{integer type range}
\entry {range of integer type}{555}{range of integer type}
\entry {limits, integer types}{555}{limits, integer types}
\entry {floating type measurements}{557}{floating type measurements}
\entry {measurements of floating types}{557}{measurements of floating types}
\entry {type measurements, floating}{557}{type measurements, floating}
\entry {limits, floating types}{557}{limits, floating types}
\entry {sign (of floating point number)}{557}{sign (of floating point number)}
\entry {base (of floating point number)}{557}{base (of floating point number)}
\entry {radix (of floating point number)}{557}{radix (of floating point number)}
\entry {exponent (of floating point number)}{557}{exponent (of floating point number)}
\entry {bias (of floating point number exponent)}{557}{bias (of floating point number exponent)}
\entry {mantissa (of floating point number)}{558}{mantissa (of floating point number)}
\entry {significand (of floating point number)}{558}{significand (of floating point number)}
\entry {precision (of floating point number)}{558}{precision (of floating point number)}
\entry {hidden bit (of floating point number mantissa)}{558}{hidden bit (of floating point number mantissa)}
\entry {normalized floating point number}{558}{normalized floating point number}
\entry {IEEE floating point representation}{562}{IEEE floating point representation}
\entry {floating point, IEEE}{562}{floating point, IEEE}
\entry {installing the library}{659}{installing the library}
\entry {installation tools}{661}{installation tools}
\entry {tools, for installing library}{661}{tools, for installing library}
\entry {configurations, all supported}{662}{configurations, all supported}
\entry {reporting bugs}{663}{reporting bugs}
\entry {bugs, reporting}{663}{bugs, reporting}
