libc.cp

一个C源代码分析器

\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}{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}{28}{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}{32}{efficiency and \code {malloc}}
\entry {page boundary}{33}{page boundary}
\entry {alignment (with malloc)}{33}{alignment (with \code {malloc})}
\entry {heap consistency checking}{33}{heap consistency checking}
\entry {consistency checking, of heap}{33}{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}{41}{macros}
\entry {growing objects (in obstacks)}{42}{growing objects (in obstacks)}
\entry {changing the size of a block (obstacks)}{42}{changing the size of a block (obstacks)}
\entry {shrinking objects}{44}{shrinking objects}
\entry {efficiency and obstacks}{44}{efficiency and obstacks}
\entry {obstack status}{45}{obstack status}
\entry {status of obstack}{45}{status of obstack}
\entry {alignment (in obstacks)}{46}{alignment (in obstacks)}
\entry {efficiency of chunks}{46}{efficiency of chunks}
\entry {chunks}{46}{chunks}
\entry {automatic freeing}{49}{automatic freeing}
\entry {alloca function}{49}{\code {alloca} function}
\entry {automatic storage with variable size}{49}{automatic storage with variable size}
\entry {longjmp}{50}{longjmp}
\entry {alloca disadvantages}{51}{\code {alloca} disadvantages}
\entry {disadvantages of alloca}{51}{disadvantages of \code {alloca}}
\entry {variable-sized arrays}{51}{variable-sized arrays}
\entry {relocating memory allocator}{52}{relocating memory allocator}
\entry {handle}{52}{handle}
\entry {memory usage warnings}{53}{memory usage warnings}
\entry {warnings of memory almost full}{53}{warnings of memory almost full}
\entry {character testing}{55}{character testing}
\entry {classification of characters}{55}{classification of characters}
\entry {predicates on characters}{55}{predicates on characters}
\entry {character predicates}{55}{character predicates}
\entry {lower-case character}{55}{lower-case character}
\entry {upper-case character}{55}{upper-case character}
\entry {alphabetic character}{55}{alphabetic character}
\entry {digit character}{55}{digit character}
\entry {decimal digit character}{55}{decimal digit character}
\entry {alphanumeric character}{56}{alphanumeric character}
\entry {hexadecimal digit character}{56}{hexadecimal digit character}
\entry {punctuation character}{56}{punctuation character}
\entry {whitespace character}{56}{whitespace character}
\entry {blank character}{56}{blank character}
\entry {graphic character}{56}{graphic character}
\entry {printing character}{56}{printing character}
\entry {control character}{56}{control character}
\entry {ASCII character}{57}{ASCII character}
\entry {character case conversion}{57}{character case conversion}
\entry {case conversion of characters}{57}{case conversion of characters}
\entry {converting case of characters}{57}{converting case of characters}
\entry {string, representation of}{59}{string, representation of}
\entry {string}{59}{string}
\entry {null character}{59}{null character}
\entry {string literal}{59}{string literal}
\entry {length of string}{60}{length of string}
\entry {allocation size of string}{60}{allocation size of string}
\entry {size of string}{60}{size of string}
\entry {string length}{60}{string length}
\entry {string allocation}{60}{string allocation}
\entry {copying strings and arrays}{61}{copying strings and arrays}
\entry {string copy functions}{61}{string copy functions}
\entry {array copy functions}{61}{array copy functions}
\entry {concatenating strings}{61}{concatenating strings}
\entry {string concatenation functions}{61}{string concatenation functions}
\entry {comparing strings and arrays}{65}{comparing strings and arrays}
\entry {string comparison functions}{65}{string comparison functions}
\entry {array comparison functions}{65}{array comparison functions}
\entry {predicates on strings}{65}{predicates on strings}
\entry {predicates on arrays}{65}{predicates on arrays}
\entry {collating strings}{67}{collating strings}
\entry {string collation functions}{67}{string collation functions}
\entry {converting string to collation order}{68}{converting string to collation order}
\entry {search functions (for strings)}{70}{search functions (for strings)}
\entry {string search functions}{70}{string search functions}
\entry {tokenizing strings}{72}{tokenizing strings}
\entry {breaking a string into tokens}{72}{breaking a string into tokens}
\entry {parsing tokens from a string}{72}{parsing tokens from a string}
\entry {opening a file}{75}{opening a file}
\entry {file position}{77}{file position}
\entry {sequential-access files}{77}{sequential-access files}
\entry {random-access files}{77}{random-access files}
\entry {append-access files}{77}{append-access files}
\entry {file name}{77}{file name}
\entry {directory}{78}{directory}
\entry {link}{78}{link}
\entry {directory entry}{78}{directory entry}
\entry {file name component}{78}{file name component}
\entry {file name resolution}{78}{file name resolution}
\entry {root directory}{78}{root directory}
\entry {absolute file name}{78}{absolute file name}
\entry {relative file name}{78}{relative file name}
\entry {parent directory}{79}{parent directory}
\entry {file name syntax errors}{79}{file name syntax errors}
\entry {usual file name syntax errors}{79}{usual file name syntax errors}
\entry {file pointer}{83}{file pointer}
\entry {standard streams}{83}{standard streams}
\entry {streams, standard}{83}{streams, standard}
\entry {standard input stream}{83}{standard input stream}
\entry {standard output stream}{84}{standard output stream}
\entry {standard error stream}{84}{standard error stream}
\entry {opening a stream}{84}{opening a stream}
\entry {closing a stream}{86}{closing a stream}
\entry {writing to a stream, by characters}{87}{writing to a stream, by characters}
\entry {reading from a stream, by characters}{88}{reading from a stream, by characters}
\entry {peeking at input}{91}{peeking at input}
\entry {unreading characters}{91}{unreading characters}
\entry {pushing input back}{91}{pushing input back}
\entry {format string, for printf}{93}{format string, for \code {printf}}
\entry {template, for printf}{93}{template, for \code {printf}}
\entry {formatted output to a stream}{93}{formatted output to a stream}
\entry {writing to a stream, formatted}{93}{writing to a stream, formatted}
\entry {conversion specifications (printf)}{93}{conversion specifications (\code {printf})}
\entry {flag character (printf)}{94}{flag character (\code {printf})}
\entry {minimum field width (printf)}{94}{minimum field width (\code {printf})}
\entry {precision (printf)}{95}{precision (\code {printf})}
\entry {type modifier character (printf)}{95}{type modifier character (\code {printf})}
\entry {output conversions, for printf}{95}{output conversions, for \code {printf}}
\entry {parsing a template string}{105}{parsing a template string}
\entry {customizing printf}{109}{customizing \code {printf}}
\entry {defining new printf conversions}{109}{defining new \code {printf} conversions}
\entry {extending printf}{109}{extending \code {printf}}
\entry {formatted input from a stream}{113}{formatted input from a stream}
\entry {reading from a stream, formatted}{113}{reading from a stream, formatted}
\entry {format string, for scanf}{113}{format string, for \code {scanf}}
\entry {template, for scanf}{113}{template, for \code {scanf}}
\entry {conversion specifications (scanf)}{114}{conversion specifications (\code {scanf})}
\entry {matching failure, in scanf}{114}{matching failure, in \code {scanf}}
\entry {flag character (scanf)}{115}{flag character (\code {scanf})}
\entry {maximum field width (scanf)}{115}{maximum field width (\code {scanf})}
\entry {type modifier character (scanf)}{115}{type modifier character (\code {scanf})}
\entry {input conversions, for scanf}{116}{input conversions, for \code {scanf}}
\entry {binary I/O to a stream}{122}{binary I/O to a stream}
\entry {block I/O to a stream}{122}{block I/O to a stream}
\entry {reading from a stream, by blocks}{122}{reading from a stream, by blocks}
\entry {writing to a stream, by blocks}{122}{writing to a stream, by blocks}
\entry {end of file, on a stream}{123}{end of file, on a stream}
\entry {text stream}{124}{text stream}
\entry {binary stream}{124}{binary stream}
\entry {lines (in a text file)}{124}{lines (in a text file)}
\entry {file positioning on a stream}{125}{file positioning on a stream}
\entry {positioning a stream}{125}{positioning a stream}
\entry {seeking on a stream}{125}{seeking on a stream}
\entry {buffering of streams}{128}{buffering of streams}
\entry {unbuffered stream}{128}{unbuffered stream}
\entry {line buffered stream}{128}{line buffered stream}
\entry {fully buffered stream}{128}{fully buffered stream}
\entry {flushing a stream}{129}{flushing a stream}
\entry {buffering, controlling}{129}{buffering, controlling}
\entry {stream, for I/O to a string}{131}{stream, for I/O to a string}
\entry {string stream}{131}{string stream}
\entry {custom streams}{135}{custom streams}
\entry {programming your own streams}{135}{programming your own streams}
\entry {cookie, for custom stream}{135}{cookie, for custom stream}
\entry {hook functions (of custom streams)}{136}{hook functions (of custom streams)}
\entry {opening a file descriptor}{139}{opening a file descriptor}