\entry{awk, POSIX and, See Also POSIX awk}{3}{\command {awk}, POSIX and, See Also POSIX \command {awk}}
\entry{awk, POSIX and}{3}{\command {awk}, POSIX and}
\entry{POSIX, awk and}{3}{POSIX, \command {awk} and}
\entry{gawk, awk and}{3}{\command {gawk}, \command {awk} and}
\entry{awk, gawk and}{3}{\command {awk}, \command {gawk} and}
\entry{awk, uses for}{3}{\command {awk}, uses for}
\entry{awk, See Also gawk}{3}{\command {awk}, See Also \command {gawk}}
\entry{gawk, See Also awk}{3}{\command {gawk}, See Also \command {awk}}
\entry{gawk, uses for}{3}{\command {gawk}, uses for}
\entry{GNU awk, See gawk}{3}{GNU \command {awk}, See \command {gawk}}
\entry{recipe for a programming language}{3}{recipe for a programming language}
\entry{programming language, recipe for}{3}{programming language, recipe for}
\entry{Aho, Alfred}{4}{Aho, Alfred}
\entry{Weinberger, Peter}{4}{Weinberger, Peter}
\entry{Kernighan, Brian}{4}{Kernighan, Brian}
\entry{awk, history of}{4}{\command {awk}, history of}
\entry{Rubin, Paul}{4}{Rubin, Paul}
\entry{Fenlason, Jay}{4}{Fenlason, Jay}
\entry{Trueman, David}{4}{Trueman, David}
\entry{awk, new vs. old}{4}{\command {awk}, new vs. old}
\entry{awk, versions of}{4}{\command {awk}, versions of}
\entry{nawk utility}{4}{\command {nawk} utility}
\entry{oawk utility}{4}{\command {oawk} utility}
\entry{awk, terms describing}{5}{\command {awk}, terms describing}
\entry{gawk, awk and}{5}{\command {gawk}, \command {awk} and}
\entry{awk, gawk and}{5}{\command {awk}, \command {gawk} and}
\entry{POSIX awk}{5}{POSIX \command {awk}}
\entry{Texinfo}{6}{Texinfo}
\entry{Kernighan, Brian}{7}{Kernighan, Brian}
\entry{d.c., See dark corner}{7}{d.c., See dark corner}
\entry{dark corner}{7}{dark corner}
\entry{FSF (Free Software Foundation)}{7}{FSF (Free Software Foundation)}
\entry{Free Software Foundation (FSF)}{7}{Free Software Foundation (FSF)}
\entry{Stallman, Richard}{7}{Stallman, Richard}
\entry{GNU Project}{7}{GNU Project}
\entry{GPL (General Public License)}{7}{GPL (General Public License)}
\entry{General Public License, See GPL}{7}{General Public License, See GPL}
\entry{documentation, online}{7}{documentation, online}
\entry{Linux}{7}{Linux}
\entry{GNU/Linux}{7}{GNU/Linux}
\entry{operating systems, BSD-based}{7}{operating systems, BSD-based}
\entry{Alpha (DEC)}{7}{Alpha (DEC)}
\entry{Close, Diane}{8}{Close, Diane}
\entry{Stallman, Richard}{9}{Stallman, Richard}
\entry{Berry, Karl}{9}{Berry, Karl}
\entry{Chassell, Robert J.\spacefactor =1000 }{9}{Chassell, Robert J.\spacefactor =1000 }
\entry{Hartholz, Marshall}{9}{Hartholz, Marshall}
\entry{Hartholz, Elaine}{9}{Hartholz, Elaine}
\entry{Schreiber, Bert}{9}{Schreiber, Bert}
\entry{Schreiber, Rita}{9}{Schreiber, Rita}
\entry{Hughes, Phil}{9}{Hughes, Phil}
\entry{Trueman, David}{9}{Trueman, David}
\entry{Drepper, Ulrich}{9}{Drepper, Ulrich}
\entry{GNITS mailing list}{9}{GNITS mailing list}
\entry{mailing list, GNITS}{9}{mailing list, GNITS}
\entry{Beebe, Nelson}{9}{Beebe, Nelson}
\entry{Brown, Martin}{9}{Brown, Martin}
\entry{Buening, Andreas}{9}{Buening, Andreas}
\entry{Deifik, Scott}{9}{Deifik, Scott}
\entry{Hankerson, Darrel}{9}{Hankerson, Darrel}
\entry{Hasegawa, Isamu}{9}{Hasegawa, Isamu}
\entry{Jaegermann, Michal}{9}{Jaegermann, Michal}
\entry{Kahrs, Jurgen}{9}{Kahrs, J\"urgen}
\entry{Rankin, Pat}{9}{Rankin, Pat}
\entry{Rommel, Kai Uwe}{9}{Rommel, Kai Uwe}
\entry{Zaretskii, Eli}{9}{Zaretskii, Eli}
\entry{Kernighan, Brian}{9}{Kernighan, Brian}
\entry{Robbins, Miriam}{9}{Robbins, Miriam}
\entry{Robbins, Jean}{9}{Robbins, Jean}
\entry{Robbins, Harry}{9}{Robbins, Harry}
\entry{G-d}{9}{G-d}
\entry{awk, function of}{11}{\command {awk}, function of}
\entry{awk, uses for}{11}{\command {awk}, uses for}
\entry{programming languages, data-driven vs. procedural}{11}{programming languages, data-driven vs. procedural}
\entry{awk programs}{11}{\command {awk} programs}
\entry{program, definition of}{11}{program, definition of}
\entry{rule, definition of}{11}{rule, definition of}
\entry{awk programs, running}{11}{\command {awk} programs, running}
\entry{command line, formats}{11}{command line, formats}
\entry{single quote (')}{11}{single quote (\code {'})}
\entry{' (single quote)}{11}{\code {'} (single quote)}
\entry{shells, scripts}{12}{shells, scripts}
\entry{awk programs, running, from shell scripts}{12}{\command {awk} programs, running, from shell scripts}
\entry{standard input}{12}{standard input}
\entry{input, standard}{12}{input, standard}
\entry{input files, running awk without}{12}{input files, running \command {awk} without}
\entry{files, input, See input files}{12}{files, input, See input files}
\entry{input files, running awk without}{12}{input files, running \command {awk} without}
\entry{awk programs, running, without input files}{12}{\command {awk} programs, running, without input files}
\entry{quoting}{12}{quoting}
\entry{double quote (")}{12}{double quote (\code {"})}
\entry{" (double quote)}{12}{\code {"} (double quote)}
\entry{{\tt \indexbackslash } (backslash)}{12}{\code {{\tt \rawbackslashxx }} (backslash)}
\entry{backslash ({\tt \indexbackslash })}{12}{backslash (\code {{\tt \rawbackslashxx }})}
\entry{awk programs, running}{12}{\command {awk} programs, running}
\entry{awk programs, lengthy}{12}{\command {awk} programs, lengthy}
\entry{files, awk programs in}{12}{files, \command {awk} programs in}
\entry{-f option}{13}{\code {-f} option}
\entry{command line, options}{13}{command line, options}
\entry{options, command-line}{13}{options, command-line}
\entry{quoting}{13}{quoting}
\entry{single quote (')}{13}{single quote (\code {'})}
\entry{' (single quote)}{13}{\code {'} (single quote)}
\entry{awk programs}{13}{\command {awk} programs}
\entry{# (number sign), #! (executable scripts)}{13}{\code {#} (number sign), \code {#!} (executable scripts)}
\entry{number sign (#), #! (executable scripts)}{13}{number sign (\code {#}), \code {#!} (executable scripts)}
\entry{Unix, awk scripts and}{13}{Unix, \command {awk} scripts and}
\entry{# (number sign), #! (executable scripts), portability issues with}{13}{\code {#} (number sign), \code {#!} (executable scripts), portability issues with}
\entry{number sign (#), #! (executable scripts), portability issues with}{13}{number sign (\code {#}), \code {#!} (executable scripts), portability issues with}
\entry{portability, #! (executable scripts)}{14}{portability, \code {#!} (executable scripts)}
\entry{ARGC/ARGV variables, portability and}{14}{\code {ARGC}/\code {ARGV} variables, portability and}
\entry{portability, ARGV variable}{14}{portability, \code {ARGV} variable}
\entry{# (number sign), commenting}{14}{\code {#} (number sign), commenting}
\entry{number sign (#), commenting}{14}{number sign (\code {#}), commenting}
\entry{commenting}{14}{commenting}
\entry{awk programs, documenting}{14}{\command {awk} programs, documenting}
\entry{quoting}{14}{quoting}
\entry{single quote ('), vs. apostrophe}{14}{single quote (\code {'}), vs. apostrophe}
\entry{' (single quote), vs. apostrophe}{14}{\code {'} (single quote), vs. apostrophe}
\entry{{\tt \indexbackslash } (backslash)}{15}{\code {{\tt \rawbackslashxx }} (backslash)}
\entry{backslash ({\tt \indexbackslash })}{15}{backslash (\code {{\tt \rawbackslashxx }})}
\entry{quoting, rules for}{15}{quoting, rules for}
\entry{shells, quoting, rules for}{15}{shells, quoting, rules for}
\entry{Bourne shell, quoting rules for}{15}{Bourne shell, quoting rules for}
\entry{{\tt \indexbackslash } (backslash)}{15}{\code {{\tt \rawbackslashxx }} (backslash)}
\entry{backslash ({\tt \indexbackslash })}{15}{backslash (\code {{\tt \rawbackslashxx }})}
\entry{single quote (')}{15}{single quote (\code {'})}
\entry{' (single quote)}{15}{\code {'} (single quote)}
\entry{double quote (")}{15}{double quote (\code {"})}
\entry{" (double quote)}{15}{\code {"} (double quote)}
\entry{single quote ('), with double quotes}{15}{single quote (\code {'}), with double quotes}
\entry{' (single quote), with double quotes}{15}{\code {'} (single quote), with double quotes}
\entry{null strings, quoting and}{15}{null strings, quoting and}
\entry{quoting, tricks for}{16}{quoting, tricks for}
\entry{input files, examples}{16}{input files, examples}
\entry{BBS-list file}{16}{\code {BBS-list} file}
\entry{inventory-shipped file}{16}{\code {inventory-shipped} file}
\entry{actions, default}{17}{actions, default}
\entry{patterns, default}{17}{patterns, default}
\entry{actions, empty}{17}{actions, empty}
\entry{awk programs, one-line examples}{18}{\command {awk} programs, one-line examples}
\entry{expand utility}{18}{\command {expand} utility}
\entry{awk programs}{19}{\command {awk} programs}
\entry{csh utility, backslash continuation and}{20}{\command {csh} utility, backslash continuation and}
\entry{ls utility}{20}{\command {ls} utility}
\entry{backslash ({\tt \indexbackslash }), continuing lines and, in csh}{20}{backslash (\code {{\tt \rawbackslashxx }}), continuing lines and, in \command {csh}}
\entry{{\tt \indexbackslash } (backslash), continuing lines and, in csh}{20}{\code {{\tt \rawbackslashxx }} (backslash), continuing lines and, in \command {csh}}
\entry{line continuations, with C shell}{20}{line continuations, with C shell}
\entry{initialization, automatic}{20}{initialization, automatic}
\entry{line breaks}{21}{line breaks}
\entry{newlines}{21}{newlines}
\entry{gawk, newlines in}{21}{\command {gawk}, newlines in}
\entry{{\tt \indexbackslash } (backslash), continuing lines and}{21}{\code {{\tt \rawbackslashxx }} (backslash), continuing lines and}
\entry{backslash ({\tt \indexbackslash }), continuing lines and}{21}{backslash (\code {{\tt \rawbackslashxx }}), continuing lines and}
\entry{portability, backslash continuation and}{21}{portability, backslash continuation and}
\entry{csh utility}{21}{\command {csh} utility}
\entry{backslash ({\tt \indexbackslash }), continuing lines and, in csh}{21}{backslash (\code {{\tt \rawbackslashxx }}), continuing lines and, in \command {csh}}
\entry{{\tt \indexbackslash } (backslash), continuing lines and, in csh}{21}{\code {{\tt \rawbackslashxx }} (backslash), continuing lines and, in \command {csh}}
\entry{backslash ({\tt \indexbackslash }), continuing lines and, comments and}{22}{backslash (\code {{\tt \rawbackslashxx }}), continuing lines and, comments and}
\entry{{\tt \indexbackslash } (backslash), continuing lines and, comments and}{22}{\code {{\tt \rawbackslashxx }} (backslash), continuing lines and, comments and}
\entry{commenting, backslash continuation and}{22}{commenting, backslash continuation and}
\entry{statements, multiple}{22}{statements, multiple}
\entry{; (semicolon)}{22}{\code {;} (semicolon)}
\entry{semicolon (;)}{22}{semicolon (\code {;})}
\entry{variables}{22}{variables}
\entry{awk, uses for}{22}{\command {awk}, uses for}
\entry{awk programs, complex}{23}{\command {awk} programs, complex}
\entry{regexp, See regular expressions}{24}{regexp, See regular expressions}
\entry{regular expressions}{24}{regular expressions}
\entry{forward slash (/)}{24}{forward slash (\code {/})}
\entry{/ (forward slash)}{24}{\code {/} (forward slash)}
\entry{regular expressions, as patterns}{24}{regular expressions, as patterns}
\entry{regular expressions, operators}{24}{regular expressions, operators}
\entry{operators, string-matching}{24}{operators, string-matching}
\entry{string-matching operators}{24}{string-matching operators}
\entry{tilde (~), ~ operator}{24}{tilde (\code {~}), \code {~} operator}
\entry{! (exclamation point), !~ operator}{24}{\code {!} (exclamation point), \code {!~} operator}
\entry{exclamation point (!), !~ operator}{24}{exclamation point (\code {!}), \code {!~} operator}
\entry{if statement}{24}{\code {if} statement}
\entry{while statement}{24}{\code {while} statement}
\entry{do-while statement}{24}{\code {do}-\code {while} statement}
\entry{regexp constants}{25}{regexp constants}
\entry{regular expressions, constants, See regexp constants}{25}{regular expressions, constants, See regexp constants}
\entry{escape sequences}{25}{escape sequences}
\entry{backslash ({\tt \indexbackslash }), in escape sequences}{25}{backslash (\code {{\tt \rawbackslashxx }}), in escape sequences}
\entry{{\tt \indexbackslash } (backslash), in escape sequences}{25}{\code {{\tt \rawbackslashxx }} (backslash), in escape sequences}
\entry{{\tt \indexbackslash } (backslash), {\tt \indexbackslash }a escape sequence}{25}{\code {{\tt \rawbackslashxx }} (backslash), \code {{\tt \rawbackslashxx }a} escape sequence}
\entry{backslash ({\tt \indexbackslash }), {\tt \indexbackslash }a escape sequence}{25}{backslash (\code {{\tt \rawbackslashxx }}), \code {{\tt \rawbackslashxx }a} escape sequence}
\entry{{\tt \indexbackslash } (backslash), {\tt \indexbackslash }b escape sequence}{25}{\code {{\tt \rawbackslashxx }} (backslash), \code {{\tt \rawbackslashxx }b} escape sequence}
\entry{backslash ({\tt \indexbackslash }), {\tt \indexbackslash }b escape sequence}{25}{backslash (\code {{\tt \rawbackslashxx }}), \code {{\tt \rawbackslashxx }b} escape sequence}
\entry{{\tt \indexbackslash } (backslash), {\tt \indexbackslash }f escape sequence}{25}{\code {{\tt \rawbackslashxx }} (backslash), \code {{\tt \rawbackslashxx }f} escape sequence}
\entry{backslash ({\tt \indexbackslash }), {\tt \indexbackslash }f escape sequence}{25}{backslash (\code {{\tt \rawbackslashxx }}), \code {{\tt \rawbackslashxx }f} escape sequence}
\entry{{\tt \indexbackslash } (backslash), {\tt \indexbackslash }n escape sequence}{25}{\code {{\tt \rawbackslashxx }} (backslash), \code {{\tt \rawbackslashxx }n} escape sequence}
\entry{backslash ({\tt \indexbackslash }), {\tt \indexbackslash }n escape sequence}{25}{backslash (\code {{\tt \rawbackslashxx }}), \code {{\tt \rawbackslashxx }n} escape sequence}
\entry{{\tt \indexbackslash } (backslash), {\tt \indexbackslash }r escape sequence}{25}{\code {{\tt \rawbackslashxx }} (backslash), \code {{\tt \rawbackslashxx }r} escape sequence}
\entry{backslash ({\tt \indexbackslash }), {\tt \indexbackslash }r escape sequence}{25}{backslash (\code {{\tt \rawbackslashxx }}), \code {{\tt \rawbackslashxx }r} escape sequence}
\entry{{\tt \indexbackslash } (backslash), {\tt \indexbackslash }t escape sequence}{25}{\code {{\tt \rawbackslashxx }} (backslash), \code {{\tt \rawbackslashxx }t} escape sequence}
\entry{backslash ({\tt \indexbackslash }), {\tt \indexbackslash }t escape sequence}{25}{backslash (\code {{\tt \rawbackslashxx }}), \code {{\tt \rawbackslashxx }t} escape sequence}
\entry{{\tt \indexbackslash } (backslash), {\tt \indexbackslash }v escape sequence}{25}{\code {{\tt \rawbackslashxx }} (backslash), \code {{\tt \rawbackslashxx }v} escape sequence}
\entry{backslash ({\tt \indexbackslash }), {\tt \indexbackslash }v escape sequence}{25}{backslash (\code {{\tt \rawbackslashxx }}), \code {{\tt \rawbackslashxx }v} escape sequence}
\entry{{\tt \indexbackslash } (backslash), {\tt \indexbackslash }nnn escape sequence}{25}{\code {{\tt \rawbackslashxx }} (backslash), \code {{\tt \rawbackslashxx }}\var {nnn} escape sequence}
\entry{backslash ({\tt \indexbackslash }), {\tt \indexbackslash }nnn escape sequence}{25}{backslash (\code {{\tt \rawbackslashxx }}), \code {{\tt \rawbackslashxx }}\var {nnn} escape sequence}
\entry{{\tt \indexbackslash } (backslash), {\tt \indexbackslash }x escape sequence}{26}{\code {{\tt \rawbackslashxx }} (backslash), \code {{\tt \rawbackslashxx }x} escape sequence}
\entry{backslash ({\tt \indexbackslash }), {\tt \indexbackslash }x escape sequence}{26}{backslash (\code {{\tt \rawbackslashxx }}), \code {{\tt \rawbackslashxx }x} escape sequence}
\entry{{\tt \indexbackslash } (backslash), {\tt \indexbackslash }/ escape sequence}{26}{\code {{\tt \rawbackslashxx }} (backslash), \code {{\tt \rawbackslashxx }/} escape sequence}
\entry{backslash ({\tt \indexbackslash }), {\tt \indexbackslash }/ escape sequence}{26}{backslash (\code {{\tt \rawbackslashxx }}), \code {{\tt \rawbackslashxx }/} escape sequence}
\entry{{\tt \indexbackslash } (backslash), {\tt \indexbackslash }" escape sequence}{26}{\code {{\tt \rawbackslashxx }} (backslash), \code {{\tt \rawbackslashxx }"} escape sequence}
\entry{backslash ({\tt \indexbackslash }), {\tt \indexbackslash }" escape sequence}{26}{backslash (\code {{\tt \rawbackslashxx }}), \code {{\tt \rawbackslashxx }"} escape sequence}
\entry{backslash ({\tt \indexbackslash }), in escape sequences}{26}{backslash (\code {{\tt \rawbackslashxx }}), in escape sequences}
\entry{{\tt \indexbackslash } (backslash), in escape sequences}{26}{\code {{\tt \rawbackslashxx }} (backslash), in escape sequences}
\entry{portability}{26}{portability}
\entry{portability, backslash in escape sequences}{26}{portability, backslash in escape sequences}
\entry{POSIX awk, backslashes in string constants}{26}{POSIX \command {awk}, backslashes in string constants}
\entry{backslash ({\tt \indexbackslash }), in escape sequences, POSIX and}{26}{backslash (\code {{\tt \rawbackslashxx }}), in escape sequences, POSIX and}
\entry{{\tt \indexbackslash } (backslash), in escape sequences, POSIX and}{26}{\code {{\tt \rawbackslashxx }} (backslash), in escape sequences, POSIX and}
\entry{troubleshooting, backslash before nonspecial character}{26}{troubleshooting, backslash before nonspecial character}
\entry{gawk, escape sequences}{26}{\command {gawk}, escape sequences}
\entry{Unix awk, backslashes in escape sequences}{26}{Unix \command {awk}, backslashes in escape sequences}
\entry{metacharacters, escape sequences for}{27}{metacharacters, escape sequences for}
\entry{dark corner, escape sequences, for metacharacters}{27}{dark corner, escape sequences, for metacharacters}
\entry{regular expressions, operators}{27}{regular expressions, operators}
\entry{backslash ({\tt \indexbackslash })}{27}{backslash (\code {{\tt \rawbackslashxx }})}
\entry{{\tt \indexbackslash } (backslash)}{27}{\code {{\tt \rawbackslashxx }} (backslash)}
\entry{regular expressions, anchors in}{27}{regular expressions, anchors in}
\entry{Texinfo, chapter beginnings in files}{27}{Texinfo, chapter beginnings in files}
\entry{^ (caret)}{27}{\code {^} (caret)}
\entry{caret (^)}{27}{caret (\code {^})}
\entry{$ (dollar sign)}{27}{\code {$} (dollar sign)}
\entry{dollar sign ($)}{27}{dollar sign (\code {$})}
\entry{. (period)}{27}{\code {.} (period)}
\entry{period (.)}{27}{period (\code {.})}
\entry{POSIX awk, period (.), using}{27}{POSIX \command {awk}, period (\code {.}), using}
\entry{[] (square brackets)}{28}{\code {[]} (square brackets)}
\entry{square brackets ([])}{28}{square brackets (\code {[]})}
\entry{character lists}{28}{character lists}
\entry{character sets, See Also character lists}{28}{character sets, See Also character lists}
\entry{bracket expressions, See character lists}{28}{bracket expressions, See character lists}
\entry{character lists, complemented}{28}{character lists, complemented}
\entry{| (vertical bar)}{28}{\code {|} (vertical bar)}
\entry{vertical bar (|)}{28}{vertical bar (\code {|})}
\entry{() (parentheses)}{28}{\code {()} (parentheses)}
\entry{parentheses ()}{28}{parentheses \code {()}}
\entry{* (asterisk), * operator, as regexp operator}{28}{\code {*} (asterisk), \code {*} operator, as regexp operator}
\entry{asterisk (*), * operator, as regexp operator}{28}{asterisk (\code {*}), \code {*} operator, as regexp operator}
\entry{+ (plus sign)}{28}{\code {+} (plus sign)}
\entry{plus sign (+)}{28}{plus sign (\code {+})}
\entry{? (question mark)}{28}{\code {?} (question mark)}
\entry{question mark (?)}{28}{question mark (\code {?})}
\entry{interval expressions}{28}{interval expressions}
\entry{POSIX awk, interval expressions in}{29}{POSIX \command {awk}, interval expressions in}
\entry{gawk, interval expressions and}{29}{\command {gawk}, interval expressions and}
\entry{precedence, regexp operators}{29}{precedence, regexp operators}
\entry{regular expressions, operators, precedence of}{29}{regular expressions, operators, precedence of}
\entry{POSIX awk, regular expressions and}{29}{POSIX \command {awk}, regular expressions and}
\entry{gawk, regular expressions, precedence}{29}{\command {gawk}, regular expressions, precedence}
\entry{character lists}{29}{character lists}
\entry{character lists, range expressions}{29}{character lists, range expressions}
\entry{range expressions}{29}{range expressions}
\entry{{\tt \indexbackslash } (backslash), in character lists}{29}{\code {{\tt \rawbackslashxx }} (backslash), in character lists}
\entry{backslash ({\tt \indexbackslash }), in character lists}{29}{backslash (\code {{\tt \rawbackslashxx }}), in character lists}
\entry{^ (caret), in character lists}{29}{\code {^} (caret), in character lists}
\entry{caret (^), in character lists}{29}{caret (\code {^}), in character lists}
\entry{- (hyphen), in character lists}{29}{\code {-} (hyphen), in character lists}
\entry{hyphen (-), in character lists}{29}{hyphen (\code {-}), in character lists}
\entry{POSIX awk, character lists and}{30}{POSIX \command {awk}, character lists and}
\entry{Extended Regular Expressions (EREs)}{30}{Extended Regular Expressions (EREs)}
\entry{EREs (Extended Regular Expressions)}{30}{EREs (Extended Regular Expressions)}
\entry{egrep utility}{30}{\command {egrep} utility}
\entry{character lists, character classes}{30}{character lists, character classes}
\entry{POSIX awk, character lists and, character classes}{30}{POSIX \command {awk}, character lists and, character classes}
\entry{character lists, collating elements}{30}{character lists, collating elements}
\entry{character lists, non-ASCII}{30}{character lists, non-ASCII}
\entry{collating elements}{30}{collating elements}
\entry{character lists, collating symbols}{30}{character lists, collating symbols}
\entry{collating symbols}{30}{collating symbols}
\entry{character lists, equivalence classes}{30}{character lists, equivalence classes}
\entry{internationalization, localization, character classes}{31}{internationalization, localization, character classes}
\entry{gawk, character classes and}{31}{\command {gawk}, character classes and}
\entry{POSIX awk, character lists and, character classes}{31}{POSIX \command {awk}, character lists and, character classes}
\entry{regular expressions, operators, gawk}{31}{regular expressions, operators, \command {gawk}}
\entry{gawk, regular expressions, operators}{31}{\command {gawk}, regular expressions, operators}
\entry{operators, GNU-specific}{31}{operators, GNU-specific}
\entry{regular expressions, operators, for words}{31}{regular expressions, operators, for words}
\entry{word, regexp definition of}{31}{word, regexp definition of}
\entry{backslash ({\tt \indexbackslash }), {\tt \indexbackslash }w operator (gawk)}{31}{backslash (\code {{\tt \rawbackslashxx }}), \code {{\tt \rawbackslashxx }w} operator (\command {gawk})}
\entry{{\tt \indexbackslash } (backslash), {\tt \indexbackslash }w operator (gawk)}{31}{\code {{\tt \rawbackslashxx }} (backslash), \code {{\tt \rawbackslashxx }w} operator (\command {gawk})}
\entry{backslash ({\tt \indexbackslash }), {\tt \indexbackslash }W operator (gawk)}{31}{backslash (\code {{\tt \rawbackslashxx }}), \code {{\tt \rawbackslashxx }W} operator (\command {gawk})}
\entry{{\tt \indexbackslash } (backslash), {\tt \indexbackslash }W operator (gawk)}{31}{\code {{\tt \rawbackslashxx }} (backslash), \code {{\tt \rawbackslashxx }W} operator (\command {gawk})}
\entry{backslash ({\tt \indexbackslash }), {\tt \indexbackslash }< operator (gawk)}{31}{backslash (\code {{\tt \rawbackslashxx }}), \code {{\tt \rawbackslashxx }<} operator (\command {gawk})}
\entry{{\tt \indexbackslash } (backslash), {\tt \indexbackslash }< operator (gawk)}{31}{\code {{\tt \rawbackslashxx }} (backslash), \code {{\tt \rawbackslashxx }<} operator (\command {gawk})}
\entry{backslash ({\tt \indexbackslash }), {\tt \indexbackslash }> operator (gawk)}{31}{backslash (\code {{\tt \rawbackslashxx }}), \code {{\tt \rawbackslashxx }>} operator (\command {gawk})}
\entry{{\tt \indexbackslash } (backslash), {\tt \indexbackslash }> operator (gawk)}{31}{\code {{\tt \rawbackslashxx }} (backslash), \code {{\tt \rawbackslashxx }>} operator (\command {gawk})}
\entry{backslash ({\tt \indexbackslash }), {\tt \indexbackslash }y operator (gawk)}{31}{backslash (\code {{\tt \rawbackslashxx }}), \code {{\tt \rawbackslashxx }y} operator (\command {gawk})}
\entry{{\tt \indexbackslash } (backslash), {\tt \indexbackslash }y operator (gawk)}{31}{\code {{\tt \rawbackslashxx }} (backslash), \code {{\tt \rawbackslashxx }y} operator (\command {gawk})}
\entry{word boundaries, matching}{31}{word boundaries, matching}
\entry{backslash ({\tt \indexbackslash }), {\tt \indexbackslash }B operator (gawk)}{31}{backslash (\code {{\tt \rawbackslashxx }}), \code {{\tt \rawbackslashxx }B} operator (\command {gawk})}
\entry{{\tt \indexbackslash } (backslash), {\tt \indexbackslash }B operator (gawk)}{31}{\code {{\tt \rawbackslashxx }} (backslash), \code {{\tt \rawbackslashxx }B} operator (\command {gawk})}
\entry{buffers, operators for}{31}{buffers, operators for}
\entry{regular expressions, operators, for buffers}{31}{regular expressions, operators, for buffers}
\entry{operators, string-matching, for buffers}{31}{operators, string-matching, for buffers}
\entry{backslash ({\tt \indexbackslash }), {\tt \indexbackslash }` operator (gawk)}{31}{backslash (\code {{\tt \rawbackslashxx }}), \code {{\tt \rawbackslashxx }`} operator (\command {gawk})}
\entry{{\tt \indexbackslash } (backslash), {\tt \indexbackslash }` operator (gawk)}{31}{\code {{\tt \rawbackslashxx }} (backslash), \code {{\tt \rawbackslashxx }`} operator (\command {gawk})}
\entry{backslash ({\tt \indexbackslash }), {\tt \indexbackslash }' operator (gawk)}{31}{backslash (\code {{\tt \rawbackslashxx }}), \code {{\tt \rawbackslashxx }'} operator (\command {gawk})}
\entry{{\tt \indexbackslash } (backslash), {\tt \indexbackslash }' operator (gawk)}{31}{\code {{\tt \rawbackslashxx }} (backslash), \code {{\tt \rawbackslashxx }'} operator (\command {gawk})}
\entry{^ (caret)}{31}{\code {^} (caret)}
\entry{caret (^)}{31}{caret (\code {^})}
\entry{? (question mark)}{31}{\code {?} (question mark)}
\entry{question mark (?)}{31}{question mark (\code {?})}
\entry{gawk, word-boundary operator}{31}{\command {gawk}, word-boundary operator}
\entry{word-boundary operator (gawk)}{31}{word-boundary operator (\command {gawk})}
\entry{operators, word-boundary (gawk)}{31}{operators, word-boundary (\command {gawk})}
\entry{regular expressions, gawk, command-line options}{32}{regular expressions, \command {gawk}, command-line options}
\entry{gawk, command-line options}{32}{\command {gawk}, command-line options}
\entry{regular expressions, case sensitivity}{32}{regular expressions, case sensitivity}
\entry{case sensitivity, regexps and}{32}{case sensitivity, regexps and}
\entry{gawk, regular expressions, case sensitivity}{32}{\command {gawk}, regular expressions, case sensitivity}
\entry{case sensitivity, gawk}{32}{case sensitivity, \command {gawk}}
\entry{differences in awk and gawk, regular expressions}{32}{differences in \command {awk} and \command {gawk}, regular expressions}
\entry{~ (tilde), ~ operator}{32}{\code {~} (tilde), \code {~} operator}
\entry{tilde (~), ~ operator}{32}{tilde (\code {~}), \code {~} operator}
\entry{! (exclamation point), !~ operator}{32}{\code {!} (exclamation point), \code {!~} operator}
\entry{exclamation point (!), !~ operator}{32}{exclamation point (\code {!}), \code {!~} operator}
\entry{IGNORECASE variable}{32}{\code {IGNORECASE} variable}
\entry{regular expressions, leftmost longest match}{33}{regular expressions, leftmost longest match}
\entry{regular expressions, computed}{34}{regular expressions, computed}
\entry{regular expressions, dynamic}{34}{regular expressions, dynamic}
\entry{~ (tilde), ~ operator}{34}{\code {~} (tilde), \code {~} operator}
\entry{tilde (~), ~ operator}{34}{tilde (\code {~}), \code {~} operator}
\entry{! (exclamation point), !~ operator}{34}{\code {!} (exclamation point), \code {!~} operator}
\entry{exclamation point (!), !~ operator}{34}{exclamation point (\code {!}), \code {!~} operator}
\entry{regexp constants, slashes vs. quotes}{34}{regexp constants, slashes vs. quotes}
\entry{{\tt \indexbackslash } (backslash), regexp constants}{34}{\code {{\tt \rawbackslashxx }} (backslash), regexp constants}
\entry{backslash ({\tt \indexbackslash }), regexp constants}{34}{backslash (\code {{\tt \rawbackslashxx }}), regexp constants}
\entry{" (double quote), regexp constants}{34}{\code {"} (double quote), regexp constants}
\entry{double quote ("), regexp constants}{34}{double quote (\code {"}), regexp constants}
\entry{troubleshooting, regexp constants vs. string constants}{34}{troubleshooting, regexp constants vs. string constants}
\entry{regexp constants, vs. string constants}{34}{regexp constants, vs. string constants}
\entry{string constants, vs. regexp constants}{34}{string constants, vs. regexp constants}
\entry{regular expressions, dynamic, with embedded newlines}{34}{regular expressions, dynamic, with embedded newlines}
\entry{newlines, in dynamic regexps}{34}{newlines, in dynamic regexps}
\entry{newlines, in regexp constants}{34}{newlines, in regexp constants}
\entry{input files, reading}{36}{input files, reading}
\entry{input files}{36}{input files}
\entry{FILENAME variable}{36}{\code {FILENAME} variable}
\entry{records}{36}{records}
\entry{fields}{36}{fields}
\entry{getline command}{36}{\code {getline} command}
\entry{input, splitting into records}{36}{input, splitting into records}
\entry{records, splitting input into}{36}{records, splitting input into}
\entry{NR variable}{36}{\code {NR} variable}
\entry{FNR variable}{36}{\code {FNR} variable}
\entry{separators, for records}{36}{separators, for records}
\entry{record separators}{36}{record separators}
\entry{newlines, as record separators}{36}{newlines, as record separators}
\entry{RS variable}{36}{\code {RS} variable}
\entry{BEGIN pattern}{36}{\code {BEGIN} pattern}
\entry{record separators, changing}{37}{record separators, changing}
\entry{separators, for records}{37}{separators, for records}
\entry{dark corner, input files}{37}{dark corner, input files}
\entry{null strings}{38}{null strings}
\entry{strings, empty, See null strings}{38}{strings, empty, See null strings}
\entry{RT variable}{38}{\code {RT} variable}
\entry{records, terminating}{38}{records, terminating}
\entry{terminating records}{38}{terminating records}
\entry{differences in awk and gawk, record separators}{38}{differences in \command {awk} and \command {gawk}, record separators}
\entry{regular expressions, as record separators}{38}{regular expressions, as record separators}
\entry{record separators, regular expressions as}{38}{record separators, regular expressions as}
\entry{separators, for records, regular expressions as}{38}{separators, for records, regular expressions as}
\entry{differences in awk and gawk, RS/RT variables}{38}{differences in \command {awk} and \command {gawk}, \code {RS}/\code {RT} variables}
\entry{advanced features, data files as single record}{39}{advanced features, data files as single record}
\entry{portability, data files as single record}{39}{portability, data files as single record}
\entry{differences in awk and gawk, strings, storing}{39}{differences in \command {awk} and \command {gawk}, strings, storing}
\entry{dark corner, strings, storing}{39}{dark corner, strings, storing}
\entry{records, treating files as}{39}{records, treating files as}
\entry{files, as single records}{39}{files, as single records}
\entry{examining fields}{39}{examining fields}
\entry{fields}{39}{fields}
\entry{accessing fields}{39}{accessing fields}
\entry{fields, examining}{39}{fields, examining}
\entry{POSIX awk, field separators and}{39}{POSIX \command {awk}, field separators and}
\entry{field separators, POSIX and}{39}{field separators, POSIX and}
\entry{separators, field, POSIX and}{39}{separators, field, POSIX and}
\entry{$ field operator}{39}{\code {$} field operator}
\entry{field operator $}{39}{field operator \code {$}}
\entry{$ (dollar sign), $ field operator}{39}{\code {$} (dollar sign), \code {$} field operator}
\entry{dollar sign ($), $ field operator}{39}{dollar sign (\code {$}), \code {$} field operator}
\entry{field operators, dollar sign as}{39}{field operators, dollar sign as}
\entry{NF variable}{39}{\code {NF} variable}
\entry{fields, number of}{39}{fields, number of}
\entry{fields, numbers}{40}{fields, numbers}
\entry{field numbers}{40}{field numbers}
\entry{fields, changing contents of}{41}{fields, changing contents of}
\entry{adding, fields}{41}{adding, fields}
\entry{fields, adding}{41}{fields, adding}
\entry{OFS variable}{42}{\code {OFS} variable}
\entry{output field separator, See OFS variable}{42}{output field separator, See \code {OFS} variable}
\entry{field separators, See Also OFS}{42}{field separators, See Also \code {OFS}}
\entry{dark corner, NF variable, decrementing}{42}{dark corner, \code {NF} variable, decrementing}
\entry{NF variable, decrementing}{42}{\code {NF} variable, decrementing}
\entry{portability, NF variable, decrementing}{42}{portability, \code {NF} variable, decrementing}
\entry{FS variable}{43}{\code {FS} variable}
\entry{fields, separating}{43}{fields, separating}
\entry{field separators}{43}{field separators}
\entry{fields, separating}{43}{fields, separating}
\entry{troubleshooting, awk uses FS not IFS}{43}{troubleshooting, \command {awk} uses \code {FS} not \code {IFS}}
\entry{FS variable, changing value of}{43}{\code {FS} variable, changing value of}
\entry{BEGIN pattern}{43}{\code {BEGIN} pattern}
\entry{field separators, choice of}{43}{field separators, choice of}
\entry{regular expressions as field separators}{43}{regular expressions as field separators}
\entry{field separators, regular expressions as}{43}{field separators, regular expressions as}
\entry{newlines, as field separators}{43}{newlines, as field separators}
\entry{whitespace, as field separators}{43}{whitespace, as field separators}
\entry{regular expressions, as field separators}{44}{regular expressions, as field separators}
\entry{field separators, regular expressions as}{44}{field separators, regular expressions as}
\entry{null strings}{44}{null strings}
\entry{strings, null}{44}{strings, null}
\entry{empty strings, See null strings}{44}{empty strings, See null strings}
\entry{differences in awk and gawk, single-character fields}{45}{differences in \command {awk} and \command {gawk}, single-character fields}
\entry{single-character fields}{45}{single-character fields}
\entry{fields, single-character}{45}{fields, single-character}
\entry{dark corner, FS as null string}{45}{dark corner, \code {FS} as null string}
\entry{FS variable, as null string}{45}{FS variable, as null string}
\entry{-F option}{45}{\code {-F} option}
\entry{options, command-line}{45}{options, command-line}
\entry{command line, options}{45}{command line, options}
\entry{field separators, on command line}{45}{field separators, on command line}
\entry{command line, FS on, setting}{45}{command line, \code {FS} on, setting}
\entry{FS variable, setting from command line}{45}{\code {FS} variable, setting from command line}
\entry{{\tt \indexbackslash } (backslash), as field separators}{45}{\code {{\tt \rawbackslashxx }} (backslash), as field separators}
\entry{backslash ({\tt \indexbackslash }), as field separators}{45}{backslash (\code {{\tt \rawbackslashxx }}), as field separators}
\entry{Unix awk, password files, field separators and}{46}{Unix \command {awk}, password files, field separators and}
\entry{Robbins, Arnold}{46}{Robbins, Arnold}
\entry{POSIX awk, field separators and}{47}{POSIX \command {awk}, field separators and}
\entry{field separators, POSIX and}{47}{field separators, POSIX and}
\entry{dark corner, field separators}{47}{dark corner, field separators}
\entry{sed utility}{47}{\command {sed} utility}
\entry{stream editors}{47}{stream editors}
\entry{data, fixed-width}{48}{data, fixed-width}
\entry{fixed-width data}{48}{fixed-width data}
\entry{advanced features, fixed-width data}{48}{advanced features, fixed-width data}
\entry{troubleshooting, fatal errors, field widths, specifying}{48}{troubleshooting, fatal errors, field widths, specifying}
\entry{w utility}{48}{\command {w} utility}
\entry{FIELDWIDTHS variable}{48}{\code {FIELDWIDTHS} variable}
\entry{gawk, splitting fields and}{49}{\command {gawk}, splitting fields and}
\entry{records, multiline}{49}{records, multiline}
\entry{input, multiline records}{49}{input, multiline records}
\entry{files, reading, multiline records}{49}{files, reading, multiline records}
\entry{input, files, See input files}{49}{input, files, See input files}
\entry{record separators, with multiline records}{49}{record separators, with multiline records}
\entry{RS variable, multiline records and}{49}{\code {RS} variable, multiline records and}
\entry{leftmost longest match}{50}{leftmost longest match}
\entry{matching, leftmost longest}{50}{matching, leftmost longest}
\entry{dark corner, multiline records}{50}{dark corner, multiline records}
\entry{field separators, in multiline records}{50}{field separators, in multiline records}
\entry{RT variable}{51}{\code {RT} variable}
\entry{getline command, explicit input with}{51}{\code {getline} command, explicit input with}
\entry{input, explicit}{51}{input, explicit}
\entry{ERRNO variable}{52}{\code {ERRNO} variable}
\entry{differences in awk and gawk, getline command}{52}{differences in \command {awk} and \command {gawk}, \code {getline} command}
\entry{getline command, return values}{52}{\code {getline} command, return values}
\entry{variables, getline command into, using}{53}{variables, \code {getline} command into, using}
\entry{input redirection}{53}{input redirection}
\entry{redirection of input}{53}{redirection of input}
\entry{< (left angle bracket), < operator (I/O)}{53}{\code {<} (left angle bracket), \code {<} operator (I/O)}
\entry{left angle bracket (<), < operator (I/O)}{53}{left angle bracket (\code {<}), \code {<} operator (I/O)}
\entry{operators, input/output}{53}{operators, input/output}
\entry{POSIX awk, < operator and}{54}{POSIX \command {awk}, \code {<} operator and}
\entry{variables, getline command into, using}{54}{variables, \code {getline} command into, using}
\entry{close function}{54}{\code {close} function}
\entry{| (vertical bar), | operator (I/O)}{54}{\code {|} (vertical bar), \code {|} operator (I/O)}
\entry{vertical bar (|), | operator (I/O)}{54}{vertical bar (\code {|}), \code {|} operator (I/O)}
\entry{input pipeline}{54}{input pipeline}
\entry{pipes, input}{54}{pipes, input}
\entry{operators, input/output}{54}{operators, input/output}
\entry{close function}{55}{\code {close} function}
\entry{Robbins, Bill}{55}{Robbins, Bill}
\entry{Robbins, Miriam}{55}{Robbins, Miriam}
\entry{Robbins, Arnold}{55}{Robbins, Arnold}
\entry{POSIX awk, | I/O operator and}{55}{POSIX \command {awk}, \code {|} I/O operator and}
\entry{variables, getline command into, using}{55}{variables, \code {getline} command into, using}
\entry{coprocesses, getline from}{56}{coprocesses, \code {getline} from}
\entry{getline command, coprocesses, using from}{56}{\code {getline} command, coprocesses, using from}
\entry{| (vertical bar), |& operator (I/O)}{56}{\code {|} (vertical bar), \code {|&} operator (I/O)}
\entry{vertical bar (|), |& operator (I/O)}{56}{vertical bar (\code {|}), \code {|&} operator (I/O)}
\entry{operators, input/output}{56}{operators, input/output}
\entry{differences in awk and gawk, input/output operators}{56}{differences in \command {awk} and \command {gawk}, input/output operators}
\entry{variables, getline command into, using}{56}{variables, \code {getline} command into, using}
\entry{differences in awk and gawk, implementation limitations}{56}{differences in \command {awk} and \command {gawk}, implementation limitations}
\entry{implementation issues, gawk, limits}{56}{implementation issues, \command {gawk}, limits}
\entry{awk, implementations, limits}{56}{\command {awk}, implementations, limits}
\entry{gawk, implementation issues, limits}{56}{\command {gawk}, implementation issues, limits}
\entry{side effects, FILENAME variable}{56}{side effects, \code {FILENAME} variable}
\entry{FILENAME variable, getline, setting with}{56}{\code {FILENAME} variable, \code {getline}, setting with}
\entry{dark corner, FILENAME variable}{56}{dark corner, \code {FILENAME} variable}
\entry{getline command, FILENAME variable and}{56}{\code {getline} command, \code {FILENAME} variable and}
\entry{BEGIN pattern, getline and}{56}{\code {BEGIN} pattern, \code {getline} and}
\entry{getline command, variants}{57}{\code {getline} command, variants}
\entry{printing}{58}{printing}
\entry{output, printing, See printing}{58}{output, printing, See printing}
\entry{print statement}{58}{\code {print} statement}
\entry{printf statement}{58}{\code {printf} statement}
\entry{records, printing}{58}{records, printing}
\entry{lines, blank, printing}{58}{lines, blank, printing}
\entry{text, printing}{58}{text, printing}
\entry{newlines, printing}{58}{newlines, printing}
\entry{fields, printing}{59}{fields, printing}
\entry{print statement, commas, omitting}{59}{\code {print} statement, commas, omitting}
\entry{troubleshooting, print statement, omitting commas}{59}{troubleshooting, \code {print} statement, omitting commas}
\entry{BEGIN pattern, headings, adding}{59}{\code {BEGIN} pattern, headings, adding}
\entry{printf statement, columns, aligning}{59}{\code {printf} statement, columns, aligning}
\entry{columns, aligning}{59}{columns, aligning}
\entry{line continuations, in print statement}{59}{line continuations, in \code {print} statement}
\entry{print statement, line continuations and}{59}{\code {print} statement, line continuations and}
\entry{OFS variable}{60}{\code {OFS} variable}
\entry{output, records}{60}{output, records}
\entry{output record separator, See ORS variable}{60}{output record separator, See \code {ORS} variable}
\entry{ORS variable}{60}{\code {ORS} variable}
\entry{BEGIN pattern, OFS/ORS variables, assigning values to}{60}{\code {BEGIN} pattern, \code {OFS}/\code {ORS} variables, assigning values to}
\entry{numeric, output format}{60}{numeric, output format}
\entry{formats, numeric output}{60}{formats, numeric output}
\entry{sprintf function}{60}{\code {sprintf} function}
\entry{OFMT variable}{60}{\code {OFMT} variable}
\entry{output, format specifier, OFMT}{60}{output, format specifier, \code {OFMT}}
\entry{dark corner, OFMT variable}{61}{dark corner, \code {OFMT} variable}
\entry{POSIX awk, OFMT variable and}{61}{POSIX \command {awk}, \code {OFMT} variable and}
\entry{OFMT variable, POSIX awk and}{61}{\code {OFMT} variable, POSIX \command {awk} and}
\entry{printf statement}{61}{\code {printf} statement}
\entry{output, formatted}{61}{output, formatted}
\entry{formatting output}{61}{formatting output}
\entry{printf statement, syntax of}{61}{\code {printf} statement, syntax of}
\entry{format strings}{61}{format strings}
\entry{printf statement, format-control characters}{62}{\code {printf} statement, format-control characters}
\entry{format specifiers, printf statement}{62}{format specifiers, \code {printf} statement}
\entry{dark corner, format-control characters}{62}{dark corner, format-control characters}
\entry{gawk, format-control characters}{62}{\command {gawk}, format-control characters}
\entry{printf statement, modifiers}{62}{\code {printf} statement, modifiers}
\entry{modifiers, in format specifiers}{62}{modifiers, in format specifiers}
\entry{differences in awk and gawk, print/printf statements}{63}{differences in \command {awk} and \command {gawk}, \code {print}/\code {printf} statements}
\entry{printf statement, positional specifiers}{63}{\code {printf} statement, positional specifiers}
\entry{positional specifiers, printf statement}{63}{positional specifiers, \code {printf} statement}
\entry{dark corner}{63}{dark corner}
\entry{troubleshooting, fatal errors, printf format strings}{64}{troubleshooting, fatal errors, \code {printf} format strings}
\entry{POSIX awk, printf format strings and}{64}{POSIX \command {awk}, \code {printf} format strings and}
\entry{output redirection}{66}{output redirection}
\entry{redirection of output}{66}{redirection of output}
\entry{print statement, See Also redirection, of output}{66}{\code {print} statement, See Also redirection, of output}
\entry{printf statement, See Also redirection, of output}{66}{\code {printf} statement, See Also redirection, of output}
\entry{> (right angle bracket), > operator (I/O)}{66}{\code {>} (right angle bracket), \code {>} operator (I/O)}
\entry{right angle bracket (>), > operator (I/O)}{66}{right angle bracket (\code {>}), \code {>} operator (I/O)}
\entry{operators, input/output}{66}{operators, input/output}
\entry{> (right angle bracket), >> operator (I/O)}{66}{\code {>} (right angle bracket), \code {>>} operator (I/O)}
\entry{right angle bracket (>), >> operator (I/O)}{66}{right angle bracket (\code {>}), \code {>>} operator (I/O)}
\entry{| (vertical bar), | operator (I/O)}{66}{\code {|} (vertical bar), \code {|} operator (I/O)}
\entry{pipes, output}{66}{pipes, output}
\entry{output, pipes}{66}{output, pipes}
\entry{coprocesses}{67}{coprocesses}
\entry{| (vertical bar), |& operator (I/O)}{67}{\code {|} (vertical bar), \code {|&} operator (I/O)}
\entry{operators, input/output}{67}{operators, input/output}
\entry{differences in awk and gawk, input/output operators}{67}{differences in \command {awk} and \command {gawk}, input/output operators}
\entry{troubleshooting, printing}{67}{troubleshooting, printing}
\entry{differences in awk and gawk, implementation limitations}{68}{differences in \command {awk} and \command {gawk}, implementation limitations}
\entry{implementation issues, gawk, limits}{68}{implementation issues, \command {gawk}, limits}
\entry{awk, implementation issues, pipes}{68}{\command {awk}, implementation issues, pipes}
\entry{gawk, implementation issues, pipes}{68}{\command {gawk}, implementation issues, pipes}
\entry{advanced features, piping into sh}{68}{advanced features, piping into \command {sh}}
\entry{shells, piping commands into}{68}{shells, piping commands into}
\entry{gawk, file names in}{68}{\command {gawk}, file names in}
\entry{standard input}{68}{standard input}
\entry{input, standard}{68}{input, standard}
\entry{standard output}{68}{standard output}
\entry{output, standard}{68}{output, standard}
\entry{error output}{68}{error output}
\entry{file descriptors}{68}{file descriptors}
\entry{files, descriptors, See file descriptors}{68}{files, descriptors, See file descriptors}
\entry{differences in awk and gawk, error messages}{68}{differences in \command {awk} and \command {gawk}, error messages}
\entry{error handling}{68}{error handling}
\entry{file names, standard streams in gawk}{69}{file names, standard streams in \command {gawk}}
\entry{/dev/...{} special files (gawk)}{69}{\code {/dev/\dots {}} special files (\command {gawk})}
\entry{files, /dev/...{} special files}{69}{files, \code {/dev/\dots {}} special files}
\entry{troubleshooting, quotes with file names}{69}{troubleshooting, quotes with file names}
\entry{files, for process information}{69}{files, for process information}
\entry{process information, files for}{69}{process information, files for}
\entry{networks, support for}{70}{networks, support for}
\entry{TCP/IP, support for}{70}{TCP/IP, support for}
\entry{compatibility mode (gawk), file names}{70}{compatibility mode (\command {gawk}), file names}
\entry{file names, in compatibility mode}{70}{file names, in compatibility mode}
\entry{PROCINFO array}{70}{\code {PROCINFO} array}
\entry{files, output, See output files}{71}{files, output, See output files}
\entry{input files, closing}{71}{input files, closing}
\entry{output, files, closing}{71}{output, files, closing}
\entry{pipes, closing}{71}{pipes, closing}
\entry{coprocesses, closing}{71}{coprocesses, closing}
\entry{getline command, coprocesses, using from}{71}{\code {getline} command, coprocesses, using from}
\entry{close function}{71}{\code {close} function}
\entry{differences in awk and gawk, close function}{72}{differences in \command {awk} and \command {gawk}, \code {close} function}
\entry{portability, close function and}{72}{portability, \code {close} function and}
\entry{| (vertical bar), |& operator (I/O), pipes, closing}{73}{\code {|} (vertical bar), \code {|&} operator (I/O), pipes, closing}
\entry{advanced features, close function}{73}{advanced features, \code {close} function}
\entry{dark corner, close function}{73}{dark corner, \code {close} function}
\entry{close function, return values}{73}{\code {close} function, return values}
\entry{return values, close function}{73}{return values, \code {close} function}
\entry{differences in awk and gawk, close function}{73}{differences in \command {awk} and \command {gawk}, \code {close} function}
\entry{Unix awk, close function and}{73}{Unix \command {awk}, \code {close} function and}
\entry{pipes, closing}{73}{pipes, closing}
\entry{POSIX awk, pipes, closing}{73}{POSIX \command {awk}, pipes, closing}
\entry{expressions}{74}{expressions}
\entry{constants, types of}{74}{constants, types of}
\entry{numeric, constants}{74}{numeric, constants}
\entry{string constants}{74}{string constants}
\entry{differences in awk and gawk, strings}{74}{differences in \command {awk} and \command {gawk}, strings}
\entry{strings, length of}{74}{strings, length of}
\entry{octal numbers}{74}{octal numbers}
\entry{hexadecimal numbers}{74}{hexadecimal numbers}
\entry{numbers, octal}{74}{numbers, octal}
\entry{numbers, hexadecimal}{74}{numbers, hexadecimal}
\entry{gawk, octal numbers and}{75}{\command {gawk}, octal numbers and}
\entry{gawk, hexadecimal numbers and}{75}{\command {gawk}, hexadecimal numbers and}
\entry{compatibility mode (gawk), octal numbers}{75}{compatibility mode (\command {gawk}), octal numbers}
\entry{compatibility mode (gawk), hexadecimal numbers}{75}{compatibility mode (\command {gawk}), hexadecimal numbers}
\entry{advanced features, constants, values of}{75}{advanced features, constants, values of}
\entry{regexp constants}{75}{regexp constants}
\entry{~ (tilde), ~ operator}{75}{\code {~} (tilde), \code {~} operator}
\entry{tilde (~), ~ operator}{75}{tilde (\code {~}), \code {~} operator}
\entry{! (exclamation point), !~ operator}{75}{\code {!} (exclamation point), \code {!~} operator}
\entry{exclamation point (!), !~ operator}{75}{exclamation point (\code {!}), \code {!~} operator}
\entry{dark corner, regexp constants}{76}{dark corner, regexp constants}
\entry{gawk, regexp constants and}{76}{\command {gawk}, regexp constants and}
\entry{regexp constants, in gawk}{76}{regexp constants, in \command {gawk}}
\entry{differences in awk and gawk, regexp constants}{76}{differences in \command {awk} and \command {gawk}, regexp constants}
\entry{dark corner, regexp constants, as arguments to user-defined functions}{76}{dark corner, regexp constants, as arguments to user-defined functions}
\entry{gensub function (gawk)}{76}{\code {gensub} function (\command {gawk})}
\entry{sub function}{76}{\code {sub} function}
\entry{gsub function}{76}{\code {gsub} function}
\entry{variables, user-defined}{77}{variables, user-defined}
\entry{user-defined, variables}{77}{user-defined, variables}
\entry{variables, built-in}{77}{variables, built-in}
\entry{variables, initializing}{77}{variables, initializing}
\entry{variables, assigning on command line}{77}{variables, assigning on command line}
\entry{command line, variables, assigning on}{77}{command line, variables, assigning on}
\entry{-v option, variables, assigning}{78}{\code {-v} option, variables, assigning}
\entry{dark corner, command-line arguments}{78}{dark corner, command-line arguments}
\entry{converting, strings to numbers}{78}{converting, strings to numbers}
\entry{strings, converting}{78}{strings, converting}
\entry{numbers, converting}{78}{numbers, converting}
\entry{converting, numbers}{78}{converting, numbers}
\entry{null strings, converting numbers to strings}{78}{null strings, converting numbers to strings}
\entry{type conversion}{78}{type conversion}
\entry{CONVFMT variable}{79}{\code {CONVFMT} variable}
\entry{dark corner, CONVFMT variable}{79}{dark corner, \code {CONVFMT} variable}
\entry{POSIX awk, OFMT variable and}{79}{POSIX \command {awk}, \code {OFMT} variable and}
\entry{OFMT variable}{79}{\code {OFMT} variable}
\entry{portability, new awk vs. old awk}{79}{portability, new \command {awk} vs. old \command {awk}}
\entry{awk, new vs. old, OFMT variable}{79}{\command {awk}, new vs. old, \code {OFMT} variable}
\entry{arithmetic operators}{79}{arithmetic operators}
\entry{operators, arithmetic}{79}{operators, arithmetic}
\entry{POSIX awk, arithmetic operators and}{80}{POSIX \command {awk}, arithmetic operators and}
\entry{troubleshooting, division}{80}{troubleshooting, division}
\entry{division}{80}{division}
\entry{differences in awk and gawk, trunc-mod operation}{80}{differences in \command {awk} and \command {gawk}, trunc-mod operation}
\entry{trunc-mod operation}{80}{trunc-mod operation}
\entry{portability, ** operator and}{80}{portability, \code {**} operator and}
\entry{* (asterisk), ** operator}{80}{\code {*} (asterisk), \code {**} operator}
\entry{asterisk (*), ** operator}{80}{asterisk (\code {*}), \code {**} operator}
\entry{Kernighan, Brian}{80}{Kernighan, Brian}
\entry{string operators}{80}{string operators}
\entry{operators, string}{80}{operators, string}
\entry{concatenating}{80}{concatenating}
\entry{troubleshooting, string concatenation}{81}{troubleshooting, string concatenation}
\entry{order of evaluation, concatenation}{81}{order of evaluation, concatenation}
\entry{evaluation order, concatenation}{81}{evaluation order, concatenation}
\entry{side effects}{81}{side effects}
\entry{assignment operators}{82}{assignment operators}
\entry{operators, assignment}{82}{operators, assignment}
\entry{expressions, assignment}{82}{expressions, assignment}
\entry{= (equals sign), = operator}{82}{\code {=} (equals sign), \code {=} operator}
\entry{equals sign (=), = operator}{82}{equals sign (\code {=}), \code {=} operator}
\entry{side effects, assignment expressions}{82}{side effects, assignment expressions}
\entry{lvalues/rvalues}{82}{lvalues/rvalues}
\entry{rvalues/lvalues}{82}{rvalues/lvalues}
\entry{assignment operators, lvalues/rvalues}{82}{assignment operators, lvalues/rvalues}
\entry{operators, assignment}{82}{operators, assignment}
\entry{variables, types of}{82}{variables, types of}
\entry{+ (plus sign), += operator}{83}{\code {+} (plus sign), \code {+=} operator}
\entry{plus sign (+), += operator}{83}{plus sign (\code {+}), \code {+=} operator}
\entry{Rankin, Pat}{83}{Rankin, Pat}
\entry{operators, assignment, evaluation order}{83}{operators, assignment, evaluation order}
\entry{assignment operators, evaluation order}{83}{assignment operators, evaluation order}
\entry{- (hyphen), -= operator}{83}{\code {-} (hyphen), \code {-=} operator}
\entry{hyphen (-), -= operator}{83}{hyphen (\code {-}), \code {-=} operator}
\entry{* (asterisk), *= operator}{83}{\code {*} (asterisk), \code {*=} operator}
\entry{asterisk (*), *= operator}{83}{asterisk (\code {*}), \code {*=} operator}
\entry{/ (forward slash), /= operator}{83}{\code {/} (forward slash), \code {/=} operator}
\entry{forward slash (/), /= operator}{83}{forward slash (\code {/}), \code {/=} operator}
\entry{% (percent sign), %= operator}{83}{\code {%} (percent sign), \code {%=} operator}
\entry{percent sign (%), %= operator}{83}{percent sign (\code {%}), \code {%=} operator}
\entry{^ (caret), ^= operator}{83}{\code {^} (caret), \code {^=} operator}
\entry{caret (^), ^= operator}{83}{caret (\code {^}), \code {^=} operator}
\entry{* (asterisk), **= operator}{83}{\code {*} (asterisk), \code {**=} operator}
\entry{asterisk (*), **= operator}{83}{asterisk (\code {*}), \code {**=} operator}
\entry{awk language, POSIX version}{84}{\command {awk} language, POSIX version}
\entry{POSIX awk}{84}{POSIX \command {awk}}
\entry{POSIX awk, **= operator and}{84}{POSIX \command {awk}, \code {**=} operator and}
\entry{portability, **= operator and}{84}{portability, \code {**=} operator and}
\entry{advanced features, regexp constants}{84}{advanced features, regexp constants}
\entry{dark corner, regexp constants, /= operator and}{84}{dark corner, regexp constants, \code {/=} operator and}
\entry{/ (forward slash), /= operator, vs. /=...{}/ regexp constant}{84}{\code {/} (forward slash), \code {/=} operator, vs. \code {/=\dots {}/} regexp constant}
\entry{forward slash (/), /= operator, vs. /=...{}/ regexp constant}{84}{forward slash (\code {/}), \code {/=} operator, vs. \code {/=\dots {}/} regexp constant}
\entry{regexp constants, /=...{}/, /= operator and}{84}{regexp constants, \code {/=\dots {}/}, \code {/=} operator and}
\entry{dark corner}{84}{dark corner}
\entry{ambiguity, syntactic: /= operator vs. /=...{}/ regexp constant}{84}{ambiguity, syntactic: \code {/=} operator vs. \code {/=\dots {}/} regexp constant}
\entry{syntactic ambiguity: /= operator vs. /=...{}/ regexp constant}{84}{syntactic ambiguity: \code {/=} operator vs. \code {/=\dots {}/} regexp constant}
\entry{/= operator vs. /=...{}/ regexp constant}{84}{\code {/=} operator vs. \code {/=\dots {}/} regexp constant}
\entry{increment operators}{84}{increment operators}
\entry{operators, decrement/increment}{84}{operators, decrement/increment}
\entry{side effects}{84}{side effects}
\entry{+ (plus sign), decrement/increment operators}{84}{\code {+} (plus sign), decrement/increment operators}
\entry{plus sign (+), decrement/increment operators}{84}{plus sign (\code {+}), decrement/increment operators}
\entry{side effects, decrement/increment operators}{84}{side effects, decrement/increment operators}
\entry{$ (dollar sign), incrementing fields and arrays}{84}{\code {$} (dollar sign), incrementing fields and arrays}
\entry{dollar sign ($), incrementing fields and arrays}{84}{dollar sign (\code {$}), incrementing fields and arrays}
\entry{decrement operators}{85}{decrement operators}
\entry{+ (plus sign), ++ operator}{85}{\code {+} (plus sign), \code {++} operator}
\entry{plus sign (+), ++ operator}{85}{plus sign (\code {+}), \code {++} operator}
\entry{- (hyphen), -- operator}{85}{\code {-} (hyphen), \code {--} operator}
\entry{hyphen (-), -- operator}{85}{hyphen (\code {-}), \code {--} operator}
\entry{advanced features, operators, precedence}{85}{advanced features, operators, precedence}
\entry{precedence}{85}{precedence}
\entry{operators, precedence}{85}{operators, precedence}
\entry{portability, operators}{85}{portability, operators}
\entry{evaluation order}{85}{evaluation order}
\entry{Marx, Groucho}{85}{Marx, Groucho}
\entry{side effects}{85}{side effects}
\entry{truth values}{85}{truth values}
\entry{logical false/true}{85}{logical false/true}
\entry{false, logical}{85}{false, logical}
\entry{true, logical}{85}{true, logical}
\entry{null strings}{85}{null strings}
\entry{dark corner}{86}{dark corner}
\entry{comparison expressions}{86}{comparison expressions}
\entry{expressions, comparison}{86}{expressions, comparison}
\entry{expressions, matching, See comparison expressions}{86}{expressions, matching, See comparison expressions}
\entry{matching, expressions, See comparison expressions}{86}{matching, expressions, See comparison expressions}
\entry{relational operators, See comparison operators}{86}{relational operators, See comparison operators}
\entry{operators, relational, See operators, comparison}{86}{operators, relational, See operators, comparison}
\entry{variable typing}{86}{variable typing}
\entry{variables, types of, comparison expressions and}{86}{variables, types of, comparison expressions and}
\entry{numeric, strings}{86}{numeric, strings}
\entry{strings, numeric}{86}{strings, numeric}
\entry{POSIX awk, numeric strings and}{86}{POSIX \command {awk}, numeric strings and}
\entry{< (left angle bracket), < operator}{87}{\code {<} (left angle bracket), \code {<} operator}
\entry{left angle bracket (<), < operator}{87}{left angle bracket (\code {<}), \code {<} operator}
\entry{< (left angle bracket), <= operator}{87}{\code {<} (left angle bracket), \code {<=} operator}
\entry{left angle bracket (<), <= operator}{87}{left angle bracket (\code {<}), \code {<=} operator}
\entry{> (right angle bracket), >= operator}{87}{\code {>} (right angle bracket), \code {>=} operator}
\entry{right angle bracket (>), >= operator}{87}{right angle bracket (\code {>}), \code {>=} operator}
\entry{> (right angle bracket), > operator}{87}{\code {>} (right angle bracket), \code {>} operator}
\entry{right angle bracket (>), > operator}{87}{right angle bracket (\code {>}), \code {>} operator}
\entry{= (equals sign), == operator}{87}{\code {=} (equals sign), \code {==} operator}
\entry{equals sign (=), == operator}{87}{equals sign (\code {=}), \code {==} operator}
\entry{! (exclamation point), != operator}{87}{\code {!} (exclamation point), \code {!=} operator}
\entry{exclamation point (!), != operator}{87}{exclamation point (\code {!}), \code {!=} operator}
\entry{~ (tilde), ~ operator}{87}{\code {~} (tilde), \code {~} operator}
\entry{tilde (~), ~ operator}{87}{tilde (\code {~}), \code {~} operator}
\entry{! (exclamation point), !~ operator}{87}{\code {!} (exclamation point), \code {!~} operator}
\entry{exclamation point (!), !~ operator}{87}{exclamation point (\code {!}), \code {!~} operator}
\entry{in operator}{87}{\code {in} operator}
\entry{troubleshooting, == operator}{87}{troubleshooting, \code {==} operator}
\entry{gawk, comparison operators and}{87}{\command {gawk}, comparison operators and}
\entry{comparison expressions, string vs. regexp}{88}{comparison expressions, string vs. regexp}
\entry{~ (tilde), ~ operator}{88}{\code {~} (tilde), \code {~} operator}
\entry{tilde (~), ~ operator}{88}{tilde (\code {~}), \code {~} operator}
\entry{! (exclamation point), !~ operator}{88}{\code {!} (exclamation point), \code {!~} operator}
\entry{exclamation point (!), !~ operator}{88}{exclamation point (\code {!}), \code {!~} operator}
\entry{awk, regexp constants and}{88}{\command {awk}, regexp constants and}
\entry{regexp constants}{88}{regexp constants}
\entry{and Boolean-logic operator}{88}{and Boolean-logic operator}
\entry{or Boolean-logic operator}{88}{or Boolean-logic operator}
\entry{not Boolean-logic operator}{88}{not Boolean-logic operator}
\entry{expressions, Boolean}{88}{expressions, Boolean}
\entry{Boolean expressions}{88}{Boolean expressions}
\entry{operators, Boolean, See Boolean expressions}{88}{operators, Boolean, See Boolean expressions}
\entry{Boolean operators, See Boolean expressions}{88}{Boolean operators, See Boolean expressions}
\entry{logical operators, See Boolean expressions}{88}{logical operators, See Boolean expressions}
\entry{operators, logical, See Boolean expressions}{88}{operators, logical, See Boolean expressions}
\entry{side effects, Boolean operators}{89}{side effects, Boolean operators}
\entry{short-circuit operators}{89}{short-circuit operators}
\entry{operators, short-circuit}{89}{operators, short-circuit}
\entry{& (ampersand), && operator}{89}{\code {&} (ampersand), \code {&&} operator}
\entry{ampersand (&), && operator}{89}{ampersand (\code {&}), \code {&&} operator}
\entry{| (vertical bar), || operator}{89}{\code {|} (vertical bar), \code {||} operator}
\entry{vertical bar (|), || operator}{89}{vertical bar (\code {|}), \code {||} operator}
\entry{line continuations}{89}{line continuations}
\entry{! (exclamation point), ! operator}{89}{\code {!} (exclamation point), \code {!} operator}
\entry{exclamation point (!), ! operator}{89}{exclamation point (\code {!}), \code {!} operator}
\entry{newlines}{89}{newlines}
\entry{variables, flag}{89}{variables, flag}
\entry{flag variables}{89}{flag variables}
\entry{next statement}{90}{\code {next} statement}
\entry{conditional expressions}{90}{conditional expressions}
\entry{expressions, conditional}{90}{expressions, conditional}
\entry{expressions, selecting}{90}{expressions, selecting}
\entry{side effects, conditional expressions}{90}{side effects, conditional expressions}
\entry{differences in awk and gawk, line continuations}{90}{differences in \command {awk} and \command {gawk}, line continuations}
\entry{line continuations, gawk}{90}{line continuations, \command {gawk}}
\entry{gawk, line continuation in}{90}{\command {gawk}, line continuation in}
\entry{function calls}{90}{function calls}
\entry{functions, built-in}{90}{functions, built-in}
\entry{arguments, in function calls}{91}{arguments, in function calls}
\entry{troubleshooting, function call syntax}{91}{troubleshooting, function call syntax}
\entry{side effects, function calls}{91}{side effects, function calls}
\entry{precedence}{91}{precedence}
\entry{operators, precedence}{91}{operators, precedence}
\entry{$ (dollar sign), $ field operator}{92}{\code {$} (dollar sign), \code {$} field operator}
\entry{dollar sign ($), $ field operator}{92}{dollar sign (\code {$}), \code {$} field operator}
\entry{+ (plus sign), ++ operator}{92}{\code {+} (plus sign), \code {++} operator}
\entry{plus sign (+), ++ operator}{92}{plus sign (\code {+}), \code {++} operator}
\entry{- (hyphen), -- (decrement/increment) operator}{92}{\code {-} (hyphen), \code {--} (decrement/increment) operator}
\entry{hyphen (-), -- (decrement/increment) operators}{92}{hyphen (\code {-}), \code {--} (decrement/increment) operators}
\entry{^ (caret), ^ operator}{92}{\code {^} (caret), \code {^} operator}
\entry{caret (^), ^ operator}{92}{caret (\code {^}), \code {^} operator}
\entry{* (asterisk), ** operator}{92}{\code {*} (asterisk), \code {**} operator}
\entry{asterisk (*), ** operator}{92}{asterisk (\code {*}), \code {**} operator}
\entry{+ (plus sign), + operator}{92}{\code {+} (plus sign), \code {+} operator}
\entry{plus sign (+), + operator}{92}{plus sign (\code {+}), \code {+} operator}
\entry{- (hyphen), - operator}{92}{\code {-} (hyphen), \code {-} operator}
\entry{hyphen (-), - operator}{92}{hyphen (\code {-}), \code {-} operator}
\entry{! (exclamation point), ! operator}{92}{\code {!} (exclamation point), \code {!} operator}
\entry{exclamation point (!), ! operator}{92}{exclamation point (\code {!}), \code {!} operator}
\entry{* (asterisk), * operator, as multiplication operator}{92}{\code {*} (asterisk), \code {*} operator, as multiplication operator}
\entry{asterisk (*), * operator, as multiplication operator}{92}{asterisk (\code {*}), \code {*} operator, as multiplication operator}
\entry{/ (forward slash), / operator}{92}{\code {/} (forward slash), \code {/} operator}
\entry{forward slash (/), / operator}{92}{forward slash (\code {/}), \code {/} operator}
\entry{% (percent sign), % operator}{92}{\code {%} (percent sign), \code {%} operator}
\entry{percent sign (%), % operator}{92}{percent sign (\code {%}), \code {%} operator}
\entry{+ (plus sign), + operator}{92}{\code {+} (plus sign), \code {+} operator}
\entry{plus sign (+), + operator}{92}{plus sign (\code {+}), \code {+} operator}
\entry{- (hyphen), - operator}{92}{\code {-} (hyphen), \code {-} operator}
\entry{hyphen (-), - operator}{92}{hyphen (\code {-}), \code {-} operator}
\entry{< (left angle bracket), < operator}{92}{\code {<} (left angle bracket), \code {<} operator}
\entry{left angle bracket (<), < operator}{92}{left angle bracket (\code {<}), \code {<} operator}
\entry{< (left angle bracket), <= operator}{92}{\code {<} (left angle bracket), \code {<=} operator}
\entry{left angle bracket (<), <= operator}{92}{left angle bracket (\code {<}), \code {<=} operator}
\entry{> (right angle bracket), >= operator}{92}{\code {>} (right angle bracket), \code {>=} operator}
\entry{right angle bracket (>), >= operator}{92}{right angle bracket (\code {>}), \code {>=} operator}
\entry{> (right angle bracket), > operator}{92}{\code {>} (right angle bracket), \code {>} operator}
\entry{right angle bracket (>), > operator}{92}{right angle bracket (\code {>}), \code {>} operator}
\entry{= (equals sign), == operator}{92}{\code {=} (equals sign), \code {==} operator}
\entry{equals sign (=), == operator}{92}{equals sign (\code {=}), \code {==} operator}
\entry{! (exclamation point), != operator}{92}{\code {!} (exclamation point), \code {!=} operator}
\entry{exclamation point (!), != operator}{92}{exclamation point (\code {!}), \code {!=} operator}
\entry{> (right angle bracket), >> operator (I/O)}{92}{\code {>} (right angle bracket), \code {>>} operator (I/O)}
\entry{right angle bracket (>), >> operator (I/O)}{92}{right angle bracket (\code {>}), \code {>>} operator (I/O)}
\entry{operators, input/output}{92}{operators, input/output}
\entry{| (vertical bar), | operator (I/O)}{92}{\code {|} (vertical bar), \code {|} operator (I/O)}
\entry{vertical bar (|), | operator (I/O)}{92}{vertical bar (\code {|}), \code {|} operator (I/O)}
\entry{operators, input/output}{92}{operators, input/output}
\entry{| (vertical bar), |& operator (I/O)}{92}{\code {|} (vertical bar), \code {|&} operator (I/O)}
\entry{vertical bar (|), |& operator (I/O)}{92}{vertical bar (\code {|}), \code {|&} operator (I/O)}
\entry{operators, input/output}{92}{operators, input/output}
\entry{print statement, I/O operators in}{92}{\code {print} statement, I/O operators in}
\entry{printf statement, I/O operators in}{92}{\code {printf} statement, I/O operators in}
\entry{~ (tilde), ~ operator}{92}{\code {~} (tilde), \code {~} operator}
\entry{tilde (~), ~ operator}{92}{tilde (\code {~}), \code {~} operator}
\entry{! (exclamation point), !~ operator}{92}{\code {!} (exclamation point), \code {!~} operator}
\entry{exclamation point (!), !~ operator}{92}{exclamation point (\code {!}), \code {!~} operator}
\entry{in operator}{92}{\code {in} operator}
\entry{& (ampersand), && operator}{92}{\code {&} (ampersand), \code {&&} operator}
\entry{ampersand (&), &&operator}{92}{ampersand (\code {&}), \code {&&}operator}
\entry{| (vertical bar), || operator}{92}{\code {|} (vertical bar), \code {||} operator}
\entry{vertical bar (|), || operator}{92}{vertical bar (\code {|}), \code {||} operator}
\entry{? (question mark), ?: operator}{93}{\code {?} (question mark), \code {?:} operator}
\entry{question mark (?), ?: operator}{93}{question mark (\code {?}), \code {?:} operator}
\entry{+ (plus sign), += operator}{93}{\code {+} (plus sign), \code {+=} operator}
\entry{plus sign (+), += operator}{93}{plus sign (\code {+}), \code {+=} operator}
\entry{- (hyphen), -= operator}{93}{\code {-} (hyphen), \code {-=} operator}
\entry{hyphen (-), -= operator}{93}{hyphen (\code {-}), \code {-=} operator}
\entry{* (asterisk), *= operator}{93}{\code {*} (asterisk), \code {*=} operator}
\entry{asterisk (*), *= operator}{93}{asterisk (\code {*}), \code {*=} operator}
\entry{* (asterisk), **= operator}{93}{\code {*} (asterisk), \code {**=} operator}
\entry{asterisk (*), **= operator}{93}{asterisk (\code {*}), \code {**=} operator}
\entry{/ (forward slash), /= operator}{93}{\code {/} (forward slash), \code {/=} operator}
\entry{forward slash (/), /= operator}{93}{forward slash (\code {/}), \code {/=} operator}
\entry{% (percent sign), %= operator}{93}{\code {%} (percent sign), \code {%=} operator}
\entry{percent sign (%), %= operator}{93}{percent sign (\code {%}), \code {%=} operator}
\entry{^ (caret), ^= operator}{93}{\code {^} (caret), \code {^=} operator}
\entry{caret (^), ^= operator}{93}{caret (\code {^}), \code {^=} operator}
\entry{portability, operators, not in POSIX awk}{93}{portability, operators, not in POSIX \command {awk}}
\entry{patterns}{94}{patterns}
\entry{patterns, types of}{94}{patterns, types of}
\entry{patterns, expressions as}{94}{patterns, expressions as}
\entry{regular expressions, as patterns}{94}{regular expressions, as patterns}
\entry{expressions, as patterns}{94}{expressions, as patterns}
\entry{comparison expressions, as patterns}{95}{comparison expressions, as patterns}
\entry{patterns, comparison expressions as}{95}{patterns, comparison expressions as}
\entry{/ (forward slash), patterns and}{95}{\code {/} (forward slash), patterns and}
\entry{forward slash (/), patterns and}{95}{forward slash (\code {/}), patterns and}
\entry{~ (tilde), ~ operator}{95}{\code {~} (tilde), \code {~} operator}
\entry{tilde (~), ~ operator}{95}{tilde (\code {~}), \code {~} operator}
\entry{! (exclamation point), !~ operator}{95}{\code {!} (exclamation point), \code {!~} operator}
\entry{exclamation point (!), !~ operator}{95}{exclamation point (\code {!}), \code {!~} operator}
\entry{regexp constants, as patterns}{95}{regexp constants, as patterns}
\entry{patterns, regexp constants as}{95}{patterns, regexp constants as}
\entry{Boolean expressions, as patterns}{95}{Boolean expressions, as patterns}
\entry{BEGIN pattern, Boolean patterns and}{96}{\code {BEGIN} pattern, Boolean patterns and}
\entry{END pattern, Boolean patterns and}{96}{\code {END} pattern, Boolean patterns and}
\entry{range patterns}{96}{range patterns}
\entry{patterns, ranges in}{96}{patterns, ranges in}
\entry{lines, matching ranges of}{96}{lines, matching ranges of}
\entry{, (comma), in range patterns}{96}{\code {,} (comma), in range patterns}
\entry{comma (,), in range patterns}{96}{comma (\code {,}), in range patterns}
\entry{if statement, actions, changing}{96}{\code {if} statement, actions, changing}
\entry{lines, skipping between markers}{96}{lines, skipping between markers}
\entry{! operator}{96}{\code {!} operator}
\entry{BEGIN pattern}{97}{\code {BEGIN} pattern}
\entry{END pattern}{97}{\code {END} pattern}
\entry{BEGIN pattern, operators and}{97}{\code {BEGIN} pattern, operators and}
\entry{END pattern, operators and}{97}{\code {END} pattern, operators and}
\entry{input/output, from BEGIN and END}{98}{input/output, from \code {BEGIN} and \code {END}}
\entry{differences in awk and gawk, BEGIN/END patterns}{98}{differences in \command {awk} and \command {gawk}, \code {BEGIN}/\code {END} patterns}
\entry{POSIX awk, BEGIN/END patterns}{98}{POSIX \command {awk}, \code {BEGIN}/\code {END} patterns}
\entry{print statement, BEGIN/END patterns and}{98}{\code {print} statement, \code {BEGIN}/\code {END} patterns and}
\entry{BEGIN pattern, print statement and}{98}{\code {BEGIN} pattern, \code {print} statement and}
\entry{END pattern, print statement and}{98}{\code {END} pattern, \code {print} statement and}
\entry{next statement, BEGIN/END patterns and}{98}{\code {next} statement, \code {BEGIN}/\code {END} patterns and}
\entry{nextfile statement, BEGIN/END patterns and}{98}{\code {nextfile} statement, \code {BEGIN}/\code {END} patterns and}
\entry{BEGIN pattern, next/nextfile statements and}{98}{\code {BEGIN} pattern, \code {next}/\code {nextfile} statements and}
\entry{END pattern, next/nextfile statements and}{98}{\code {END} pattern, \code {next}/\code {nextfile} statements and}
\entry{empty pattern}{98}{empty pattern}
\entry{patterns, empty}{98}{patterns, empty}
\entry{shells, variables}{99}{shells, variables}
\entry{awk programs, shell variables in}{99}{\command {awk} programs, shell variables in}
\entry{shells, quoting}{99}{shells, quoting}
\entry{actions}{99}{actions}
\entry{{\tt \char 123}{\tt \char 125} (braces), actions and}{100}{\code {{\tt \char 123}{\tt \char 125}} (braces), actions and}
\entry{braces ({\tt \char 123}{\tt \char 125}), actions and}{100}{braces (\code {{\tt \char 123}{\tt \char 125}}), actions and}
\entry{separators, for statements in actions}{100}{separators, for statements in actions}
\entry{newlines, separating statements in actions}{100}{newlines, separating statements in actions}
\entry{; (semicolon), separating statements in actions}{100}{\code {;} (semicolon), separating statements in actions}
\entry{semicolon (;), separating statements in actions}{100}{semicolon (\code {;}), separating statements in actions}
\entry{side effects, statements}{100}{side effects, statements}
\entry{control statements}{100}{control statements}
\entry{statements, control, in actions}{100}{statements, control, in actions}
\entry{actions, control statements in}{100}{actions, control statements in}
\entry{compound statements, control statements and}{100}{compound statements, control statements and}
\entry{statements, compound, control statements and}{100}{statements, compound, control statements and}
\entry{body, in actions}{100}{body, in actions}
\entry{{\tt \char 123}{\tt \char 125} (braces), statements, grouping}{100}{\code {{\tt \char 123}{\tt \char 125}} (braces), statements, grouping}
\entry{braces ({\tt \char 123}{\tt \char 125}), statements, grouping}{100}{braces (\code {{\tt \char 123}{\tt \char 125}}), statements, grouping}
\entry{newlines, separating statements in actions}{100}{newlines, separating statements in actions}
\entry{; (semicolon), separating statements in actions}{100}{\code {;} (semicolon), separating statements in actions}
\entry{semicolon (;), separating statements in actions}{100}{semicolon (\code {;}), separating statements in actions}
\entry{if statement}{101}{\code {if} statement}
\entry{while statement}{101}{\code {while} statement}
\entry{loops}{101}{loops}
\entry{loops, See Also while statement}{101}{loops, See Also \code {while} statement}
\entry{body, in loops}{101}{body, in loops}
\entry{do-while statement}{102}{\code {do}-\code {while} statement}
\entry{for statement}{102}{\code {for} statement}
\entry{loops, continue statements and}{103}{loops, \code {continue} statements and}
\entry{break statement}{104}{\code {break} statement}
\entry{loops, exiting}{104}{loops, exiting}
\entry{POSIX awk, break statement and}{104}{POSIX \command {awk}, \code {break} statement and}
\entry{dark corner, break statement}{104}{dark corner, \code {break} statement}
\entry{gawk, break statement in}{104}{\command {gawk}, \code {break} statement in}
\entry{continue statement}{105}{\code {continue} statement}
\entry{POSIX awk, continue statement and}{105}{POSIX \command {awk}, \code {continue} statement and}
\entry{dark corner, continue statement}{105}{dark corner, \code {continue} statement}
\entry{gawk, continue statement in}{105}{\command {gawk}, \code {continue} statement in}
\entry{next statement}{105}{\code {next} statement}
\entry{awk programs, execution of}{106}{\command {awk} programs, execution of}
\entry{BEGIN pattern, next/nextfile statements and}{106}{\code {BEGIN} pattern, \code {next}/\code {nextfile} statements and}
\entry{END pattern, next/nextfile statements and}{106}{\code {END} pattern, \code {next}/\code {nextfile} statements and}
\entry{POSIX awk, next/nextfile statements and}{106}{POSIX \command {awk}, \code {next}/\code {nextfile} statements and}
\entry{next statement, user-defined functions and}{106}{\code {next} statement, user-defined functions and}
\entry{functions, user-defined, next/nextfile statements and}{106}{functions, user-defined, \code {next}/\code {nextfile} statements and}
\entry{nextfile statement}{106}{\code {nextfile} statement}
\entry{differences in awk and gawk, next/nextfile statements}{106}{differences in \command {awk} and \command {gawk}, \code {next}/\code {nextfile} statements}
\entry{functions, user-defined, next/nextfile statements and}{107}{functions, user-defined, \code {next}/\code {nextfile} statements and}
\entry{nextfile statement, user-defined functions and}{107}{\code {nextfile} statement, user-defined functions and}
\entry{next file statement, in gawk}{107}{\code {next file} statement, in \command {gawk}}
\entry{gawk, next file statement in}{107}{\command {gawk}, \code {next file} statement in}
\entry{nextfile statement, in gawk}{107}{\code {nextfile} statement, in \command {gawk}}
\entry{gawk, nextfile statement in}{107}{\command {gawk}, \code {nextfile} statement in}
\entry{exit statement}{107}{\code {exit} statement}
\entry{BEGIN pattern, exit statement and}{107}{\code {BEGIN} pattern, \code {exit} statement and}
\entry{END pattern, exit statement and}{107}{\code {END} pattern, \code {exit} statement and}
\entry{dark corner, exit statement}{107}{dark corner, \code {exit} statement}
\entry{programming conventions, exit statement}{107}{programming conventions, \code {exit} statement}
\entry{built-in variables}{108}{built-in variables}
\entry{variables, built-in}{108}{variables, built-in}
\entry{gawk, built-in variables and}{108}{\command {gawk}, built-in variables and}
\entry{built-in variables, user-modifiable}{108}{built-in variables, user-modifiable}
\entry{user-modifiable variables}{108}{user-modifiable variables}
\entry{BINMODE variable}{108}{\code {BINMODE} variable}
\entry{binary input/output}{108}{binary input/output}
\entry{input/output, binary}{108}{input/output, binary}
\entry{differences in awk and gawk, BINMODE variable}{108}{differences in \command {awk} and \command {gawk}, \code {BINMODE} variable}
\entry{CONVFMT variable}{108}{\code {CONVFMT} variable}
\entry{POSIX awk, CONVFMT variable and}{108}{POSIX \command {awk}, \code {CONVFMT} variable and}
\entry{numbers, converting, to strings}{108}{numbers, converting, to strings}
\entry{strings, converting, numbers to}{108}{strings, converting, numbers to}
\entry{FIELDWIDTHS variable}{108}{\code {FIELDWIDTHS} variable}
\entry{differences in awk and gawk, FIELDWIDTHS variable}{108}{differences in \command {awk} and \command {gawk}, \code {FIELDWIDTHS} variable}
\entry{field separators, FIELDWIDTHS variable and}{108}{field separators, \code {FIELDWIDTHS} variable and}
\entry{separators, field, FIELDWIDTHS variable and}{108}{separators, field, \code {FIELDWIDTHS} variable and}
\entry{gawk, FIELDWIDTHS variable in}{109}{\command {gawk}, \code {FIELDWIDTHS} variable in}
\entry{FS variable}{109}{\code {FS} variable}
\entry{separators, field}{109}{separators, field}
\entry{field separators}{109}{field separators}
\entry{POSIX awk, FS variable and}{109}{POSIX \command {awk}, \code {FS} variable and}
\entry{gawk, field separators and}{109}{\command {gawk}, field separators and}
\entry{IGNORECASE variable}{109}{\code {IGNORECASE} variable}
\entry{differences in awk and gawk, IGNORECASE variable}{109}{differences in \command {awk} and \command {gawk}, \code {IGNORECASE} variable}
\entry{case sensitivity, string comparisons and}{109}{case sensitivity, string comparisons and}
\entry{case sensitivity, regexps and}{109}{case sensitivity, regexps and}
\entry{regular expressions, case sensitivity}{109}{regular expressions, case sensitivity}
\entry{gawk, IGNORECASE variable in}{109}{\command {gawk}, \code {IGNORECASE} variable in}
\entry{LINT variable}{109}{\code {LINT} variable}
\entry{differences in awk and gawk, LINT variable}{109}{differences in \command {awk} and \command {gawk}, \code {LINT} variable}
\entry{lint checking}{109}{lint checking}
\entry{gawk, LINT variable in}{109}{\command {gawk}, \code {LINT} variable in}
\entry{OFMT variable}{110}{\code {OFMT} variable}
\entry{numbers, converting, to strings}{110}{numbers, converting, to strings}
\entry{strings, converting, numbers to}{110}{strings, converting, numbers to}
\entry{sprintf function, OFMT variable and}{110}{\code {sprintf} function, \code {OFMT} variable and}
\entry{print statement, OFMT variable and}{110}{\code {print} statement, \code {OFMT} variable and}
\entry{OFS variable}{110}{\code {OFS} variable}
\entry{separators, field}{110}{separators, field}
\entry{field separators}{110}{field separators}
\entry{ORS variable}{110}{\code {ORS} variable}
\entry{RS variable}{110}{\code {RS} variable}
\entry{separators, record}{110}{separators, record}
\entry{record separators}{110}{record separators}
\entry{SUBSEP variable}{110}{\code {SUBSEP} variable}
\entry{separators, subscript}{110}{separators, subscript}
\entry{subscript separators}{110}{subscript separators}
\entry{TEXTDOMAIN variable}{110}{\code {TEXTDOMAIN} variable}
\entry{differences in awk and gawk, TEXTDOMAIN variable}{110}{differences in \command {awk} and \command {gawk}, \code {TEXTDOMAIN} variable}
\entry{internationalization, localization}{110}{internationalization, localization}
\entry{built-in variables, conveying information}{110}{built-in variables, conveying information}
\entry{variables, built-in, conveying information}{110}{variables, built-in, conveying information}
\entry{ARGC/ARGV variables}{110}{\code {ARGC}/\code {ARGV} variables}
\entry{arguments, command-line}{110}{arguments, command-line}
\entry{command line, arguments}{110}{command line, arguments}
\entry{programming conventions, ARGC/ARGV variables}{111}{programming conventions, \code {ARGC}/\code {ARGV} variables}
\entry{ARGIND variable}{111}{\code {ARGIND} variable}
\entry{differences in awk and gawk, ARGIND variable}{111}{differences in \command {awk} and \command {gawk}, \code {ARGIND} variable}
\entry{files, processing, ARGIND variable and}{111}{files, processing, \code {ARGIND} variable and}
\entry{file names, distinguishing}{111}{file names, distinguishing}
\entry{ENVIRON variable}{111}{\code {ENVIRON} variable}
\entry{environment variables}{111}{environment variables}
\entry{ERRNO variable}{111}{\code {ERRNO} variable}
\entry{differences in awk and gawk, ERRNO variable}{111}{differences in \command {awk} and \command {gawk}, \code {ERRNO} variable}
\entry{error handling, ERRNO variable and}{111}{error handling, \code {ERRNO} variable and}
\entry{FILENAME variable}{112}{\code {FILENAME} variable}
\entry{dark corner, FILENAME variable}{112}{dark corner, \code {FILENAME} variable}
\entry{FNR variable}{112}{\code {FNR} variable}
\entry{NF variable}{112}{\code {NF} variable}
\entry{NR variable}{112}{\code {NR} variable}
\entry{PROCINFO array}{112}{\code {PROCINFO} array}
\entry{differences in awk and gawk, PROCINFO array}{112}{differences in \command {awk} and \command {gawk}, \code {PROCINFO} array}
\entry{RLENGTH variable}{113}{\code {RLENGTH} variable}
\entry{RSTART variable}{113}{\code {RSTART} variable}
\entry{RT variable}{113}{\code {RT} variable}
\entry{differences in awk and gawk, RT variable}{113}{differences in \command {awk} and \command {gawk}, \code {RT} variable}
\entry{NR variable, changing}{113}{\code {NR} variable, changing}
\entry{FNR variable, changing}{113}{\code {FNR} variable, changing}
\entry{advanced features, FNR/NR variables}{113}{advanced features, \code {FNR}/\code {NR} variables}
\entry{dark corner, FNR/NR variables}{113}{dark corner, \code {FNR}/\code {NR} variables}
\entry{ARGC/ARGV variables}{114}{\code {ARGC}/\code {ARGV} variables}
\entry{arguments, command-line}{114}{arguments, command-line}
\entry{command line, arguments}{114}{command line, arguments}
\entry{differences in awk and gawk, ARGC/ARGV variables}{115}{differences in \command {awk} and \command {gawk}, \code {ARGC}/\code {ARGV} variables}
\entry{arrays}{116}{arrays}
\entry{variables, names of}{116}{variables, names of}
\entry{functions, names of}{116}{functions, names of}
\entry{arrays, names of}{116}{arrays, names of}
\entry{names, arrays/variables}{116}{names, arrays/variables}
\entry{namespace issues}{116}{namespace issues}
\entry{arrays, indexing}{116}{arrays, indexing}
\entry{indexing arrays}{116}{indexing arrays}
\entry{associative arrays}{116}{associative arrays}
\entry{arrays, associative}{116}{arrays, associative}
\entry{sparse arrays}{117}{sparse arrays}
\entry{arrays, sparse}{117}{arrays, sparse}
\entry{case sensitivity, array indices and}{117}{case sensitivity, array indices and}
\entry{arrays, IGNORECASE variable and}{117}{arrays, \code {IGNORECASE} variable and}
\entry{IGNORECASE variable, array subscripts and}{117}{\code {IGNORECASE} variable, array subscripts and}
\entry{arrays, elements, referencing}{117}{arrays, elements, referencing}
\entry{elements in arrays}{117}{elements in arrays}
\entry{in operator, arrays and}{118}{\code {in} operator, arrays and}
\entry{side effects, array indexing}{118}{side effects, array indexing}
\entry{arrays, elements, assigning}{118}{arrays, elements, assigning}
\entry{elements in arrays, assigning}{118}{elements in arrays, assigning}
\entry{elements in arrays, scanning}{119}{elements in arrays, scanning}
\entry{arrays, scanning}{119}{arrays, scanning}
\entry{in operator, arrays and}{119}{\code {in} operator, arrays and}
\entry{arrays, for statement and}{119}{arrays, \code {for} statement and}
\entry{for statement, in arrays}{119}{\code {for} statement, in arrays}
\entry{arrays, elements, order of}{120}{arrays, elements, order of}
\entry{elements in arrays, order of}{120}{elements in arrays, order of}
\entry{delete statement}{120}{\code {delete} statement}
\entry{deleting elements in arrays}{120}{deleting elements in arrays}
\entry{arrays, elements, deleting}{120}{arrays, elements, deleting}
\entry{elements in arrays, deleting}{120}{elements in arrays, deleting}
\entry{null strings, array elements and}{120}{null strings, array elements and}
\entry{lint checking, array elements}{120}{lint checking, array elements}
\entry{arrays, deleting entire contents}{120}{arrays, deleting entire contents}
\entry{deleting entire arrays}{120}{deleting entire arrays}
\entry{differences in awk and gawk, array elements, deleting}{120}{differences in \command {awk} and \command {gawk}, array elements, deleting}
\entry{portability, deleting array elements}{121}{portability, deleting array elements}
\entry{Brennan, Michael}{121}{Brennan, Michael}
\entry{split function, array elements, deleting}{121}{\code {split} function, array elements, deleting}
\entry{numbers, as array subscripts}{121}{numbers, as array subscripts}
\entry{arrays, subscripts}{121}{arrays, subscripts}
\entry{subscripts in arrays, numbers as}{121}{subscripts in arrays, numbers as}
\entry{CONVFMT variable, array subscripts and}{121}{\code {CONVFMT} variable, array subscripts and}
\entry{converting, during subscripting}{121}{converting, during subscripting}
\entry{variables, uninitialized, as array subscripts}{122}{variables, uninitialized, as array subscripts}
\entry{uninitialized variables, as array subscripts}{122}{uninitialized variables, as array subscripts}
\entry{subscripts in arrays, uninitialized variables as}{122}{subscripts in arrays, uninitialized variables as}
\entry{arrays, subscripts, uninitialized variables as}{122}{arrays, subscripts, uninitialized variables as}
\entry{null strings, as array subscripts}{122}{null strings, as array subscripts}
\entry{dark corner, array subscripts}{122}{dark corner, array subscripts}
\entry{lint checking, array subscripts}{122}{lint checking, array subscripts}
\entry{subscripts in arrays, multidimensional}{123}{subscripts in arrays, multidimensional}
\entry{arrays, multidimensional}{123}{arrays, multidimensional}
\entry{SUBSEP variable, multidimensional arrays}{123}{\code {SUBSEP} variable, multidimensional arrays}
\entry{subscripts in arrays, multidimensional, scanning}{124}{subscripts in arrays, multidimensional, scanning}
\entry{arrays, multidimensional, scanning}{124}{arrays, multidimensional, scanning}
\entry{arrays, sorting}{124}{arrays, sorting}
\entry{asort function (gawk)}{124}{\code {asort} function (\command {gawk})}
\entry{asort function (gawk), arrays, sorting}{124}{\code {asort} function (\command {gawk}), arrays, sorting}
\entry{sort function, arrays, sorting}{124}{sort function, arrays, sorting}
\entry{side effects, asort function}{125}{side effects, \code {asort} function}
\entry{reference counting, sorting arrays}{125}{reference counting, sorting arrays}
\entry{arrays, sorting, IGNORECASE variable and}{126}{arrays, sorting, \code {IGNORECASE} variable and}
\entry{IGNORECASE variable, array sorting and}{126}{\code {IGNORECASE} variable, array sorting and}
\entry{functions, built-in}{127}{functions, built-in}
\entry{built-in functions}{127}{built-in functions}
\entry{programming conventions, functions, calling}{127}{programming conventions, functions, calling}
\entry{whitespace, functions, calling}{127}{whitespace, functions, calling}
\entry{troubleshooting, gawk, fatal errors, function arguments}{127}{troubleshooting, \command {gawk}, fatal errors, function arguments}
\entry{gawk, function arguments and}{127}{\command {gawk}, function arguments and}
\entry{differences in awk and gawk, function arguments (gawk)}{127}{differences in \command {awk} and \command {gawk}, function arguments (\command {gawk})}
\entry{evaluation order, functions}{127}{evaluation order, functions}
\entry{functions, built-in, evaluation order}{127}{functions, built-in, evaluation order}
\entry{built-in functions, evaluation order}{127}{built-in functions, evaluation order}
\entry{int function}{128}{\code {int} function}
\entry{sqrt function}{128}{\code {sqrt} function}
\entry{exp function}{128}{\code {exp} function}
\entry{log function}{128}{\code {log} function}
\entry{sin function}{128}{\code {sin} function}
\entry{cos function}{128}{\code {cos} function}
\entry{atan2 function}{128}{\code {atan2} function}
\entry{rand function}{128}{\code {rand} function}
\entry{random numbers, rand/srand functions}{128}{random numbers, \code {rand}/\code {srand} functions}
\entry{numbers, random}{129}{numbers, random}
\entry{random numbers, seed of}{129}{random numbers, seed of}
\entry{srand function}{129}{\code {srand} function}
\entry{arrays, elements, retrieving number of}{129}{arrays, elements, retrieving number of}
\entry{asort function (gawk)}{129}{\code {asort} function (\command {gawk})}
\entry{asorti function (gawk)}{130}{\code {asorti} function (\command {gawk})}
\entry{index function}{130}{\code {index} function}
\entry{searching}{130}{searching}
\entry{length function}{130}{\code {length} function}
\entry{portability, length function}{130}{portability, \code {length} function}
\entry{POSIX awk, functions and, length}{130}{POSIX \command {awk}, functions and, \code {length}}
\entry{match function}{130}{\code {match} function}
\entry{RSTART variable, match function and}{131}{\code {RSTART} variable, \code {match} function and}
\entry{RLENGTH variable, match function and}{131}{\code {RLENGTH} variable, \code {match} function and}
\entry{match function, RSTART/RLENGTH variables}{131}{\code {match} function, \code {RSTART}/\code {RLENGTH} variables}
\entry{differences in awk and gawk, match function}{131}{differences in \command {awk} and \command {gawk}, \code {match} function}
\entry{troubleshooting, match function}{132}{troubleshooting, \code {match} function}
\entry{split function}{132}{\code {split} function}
\entry{strings, splitting}{132}{strings, splitting}
\entry{differences in awk and gawk, split function}{132}{differences in \command {awk} and \command {gawk}, \code {split} function}
\entry{dark corner, split function}{132}{dark corner, \code {split} function}
\entry{sprintf function}{133}{\code {sprintf} function}
\entry{differences in awk and gawk, strtonum function (gawk)}{133}{differences in \command {awk} and \command {gawk}, \code {strtonum} function (\command {gawk})}
\entry{strtonum function (gawk)}{133}{\code {strtonum} function (\command {gawk})}
\entry{differences in awk and gawk, strtonum function (gawk)}{133}{differences in \command {awk} and \command {gawk}, \code {strtonum} function (\command {gawk})}
\entry{sub function}{133}{\code {sub} function}
\entry{sub function, arguments of}{134}{\code {sub} function, arguments of}
\entry{gsub function, arguments of}{134}{\code {gsub} function, arguments of}
\entry{troubleshooting, gsub/sub functions}{134}{troubleshooting, \code {gsub}/\code {sub} functions}
\entry{gsub function}{134}{\code {gsub} function}
\entry{gensub function (gawk)}{135}{\code {gensub} function (\command {gawk})}
\entry{substr function}{136}{\code {substr} function}
\entry{troubleshooting, substr function}{136}{troubleshooting, \code {substr} function}
\entry{portability, substr function}{136}{portability, \code {substr} function}
\entry{case sensitivity, converting case}{136}{case sensitivity, converting case}
\entry{converting, case}{136}{converting, case}
\entry{tolower function}{136}{\code {tolower} function}
\entry{toupper function}{136}{\code {toupper} function}
\entry{escape processing, gsub/gensub/sub functions}{136}{escape processing, \code {gsub}/\code {gensub}/\code {sub} functions}
\entry{sub function, escape processing}{136}{\code {sub} function, escape processing}
\entry{gsub function, escape processing}{136}{\code {gsub} function, escape processing}
\entry{gensub function (gawk), escape processing}{136}{\code {gensub} function (\command {gawk}), escape processing}
\entry{{\tt \indexbackslash } (backslash), gsub/gensub/sub functions and}{136}{\code {{\tt \rawbackslashxx }} (backslash), \code {gsub}/\code {gensub}/\code {sub} functions and}
\entry{backslash ({\tt \indexbackslash }), gsub/gensub/sub functions and}{136}{backslash (\code {{\tt \rawbackslashxx }}), \code {gsub}/\code {gensub}/\code {sub} functions and}
\entry{& (ampersand), gsub/gensub/sub functions and}{136}{\code {&} (ampersand), \code {gsub}/\code {gensub}/\code {sub} functions and}
\entry{ampersand (&), gsub/gensub/sub functions and}{136}{ampersand (\code {&}), \code {gsub}/\code {gensub}/\code {sub} functions and}
\entry{POSIX awk, functions and, gsub/sub}{137}{POSIX \command {awk}, functions and, \code {gsub}/\code {sub}}
\entry{advanced features, null strings, matching}{139}{advanced features, null strings, matching}
\entry{matching, null strings}{139}{matching, null strings}
\entry{null strings, matching}{139}{null strings, matching}
\entry{* (asterisk), * operator, null strings, matching}{139}{\code {*} (asterisk), \code {*} operator, null strings, matching}
\entry{asterisk (*), * operator, null strings, matching}{139}{asterisk (\code {*}), \code {*} operator, null strings, matching}
\entry{close function}{139}{\code {close} function}
\entry{files, closing}{139}{files, closing}
\entry{fflush function}{139}{\code {fflush} function}
\entry{portability, fflush function and}{139}{portability, \code {fflush} function and}
\entry{buffers, flushing}{139}{buffers, flushing}
\entry{output, buffering}{139}{output, buffering}
\entry{gawk, fflush function in}{139}{\command {gawk}, \code {fflush} function in}
\entry{troubleshooting, fflush function}{139}{troubleshooting, \code {fflush} function}
\entry{system function}{140}{\code {system} function}
\entry{interacting with other programs}{140}{interacting with other programs}
\entry{troubleshooting, system function}{140}{troubleshooting, \code {system} function}
\entry{advanced features, buffering}{140}{advanced features, buffering}
\entry{buffering, interactive vs. noninteractive}{140}{buffering, interactive vs. noninteractive}
\entry{advanced features, buffering}{141}{advanced features, buffering}
\entry{buffers, flushing}{141}{buffers, flushing}
\entry{buffering, input/output}{141}{buffering, input/output}
\entry{output, buffering}{141}{output, buffering}
\entry{timestamps}{141}{timestamps}
\entry{log files, timestamps in}{141}{log files, timestamps in}
\entry{files, log, timestamps in}{141}{files, log, timestamps in}
\entry{gawk, timestamps}{141}{\command {gawk}, timestamps}
\entry{POSIX awk, timestamps and}{141}{POSIX \command {awk}, timestamps and}
\entry{date utility, GNU}{142}{\command {date} utility, GNU}
\entry{time, retrieving}{142}{time, retrieving}
\entry{systime function (gawk)}{142}{\code {systime} function (\command {gawk})}
\entry{timestamps}{142}{timestamps}
\entry{mktime function (gawk)}{142}{\code {mktime} function (\command {gawk})}
\entry{strftime function (gawk)}{142}{\code {strftime} function (\command {gawk})}
\entry{converting, dates to timestamps}{143}{converting, dates to timestamps}
\entry{dates, converting to timestamps}{143}{dates, converting to timestamps}
\entry{timestamps, converting dates to}{143}{timestamps, converting dates to}
\entry{format specifiers, strftime function (gawk)}{143}{format specifiers, \code {strftime} function (\command {gawk})}
\entry{date utility, POSIX}{145}{\code {date} utility, POSIX}
\entry{POSIX awk, date utility and}{145}{POSIX \command {awk}, \code {date} utility and}
\entry{bitwise, operations}{146}{bitwise, operations}
\entry{AND bitwise operation}{146}{AND bitwise operation}
\entry{OR bitwise operation}{146}{OR bitwise operation}
\entry{XOR bitwise operation}{146}{XOR bitwise operation}
\entry{operations, bitwise}{146}{operations, bitwise}
\entry{bitwise, complement}{146}{bitwise, complement}
\entry{complement, bitwise}{146}{complement, bitwise}
\entry{bitwise, shift}{146}{bitwise, shift}
\entry{left shift, bitwise}{146}{left shift, bitwise}
\entry{right shift, bitwise}{146}{right shift, bitwise}
\entry{shift, bitwise}{146}{shift, bitwise}
\entry{gawk, bitwise operations in}{146}{\command {gawk}, bitwise operations in}
\entry{and function (gawk)}{146}{\code {and} function (\command {gawk})}
\entry{or function (gawk)}{146}{\code {or} function (\command {gawk})}
\entry{xor function (gawk)}{147}{\code {xor} function (\command {gawk})}
\entry{compl function (gawk)}{147}{\code {compl} function (\command {gawk})}
\entry{lshift function (gawk)}{147}{\code {lshift} function (\command {gawk})}
\entry{rshift function (gawk)}{147}{\code {rshift} function (\command {gawk})}
\entry{bits2str user-defined function}{147}{\code {bits2str} user-defined function}
\entry{testbits.awk program}{147}{\code {testbits.awk} program}
\entry{numbers, converting, to strings}{147}{numbers, converting, to strings}
\entry{strings, converting, numbers to}{147}{strings, converting, numbers to}
\entry{converting, numbers, to strings}{147}{converting, numbers, to strings}
\entry{gawk, string-translation functions}{148}{\command {gawk}, string-translation functions}
\entry{functions, string-translation}{148}{functions, string-translation}
\entry{internationalization}{148}{internationalization}
\entry{awk programs, internationalizing}{148}{\command {awk} programs, internationalizing}
\entry{dcgettext function (gawk)}{148}{\code {dcgettext} function (\command {gawk})}
\entry{dcngettext function (gawk)}{148}{\code {dcngettext} function (\command {gawk})}
\entry{bindtextdomain function (gawk)}{148}{\code {bindtextdomain} function (\command {gawk})}
\entry{user-defined, functions}{148}{user-defined, functions}
\entry{functions, user-defined}{148}{functions, user-defined}
\entry{functions, defining}{148}{functions, defining}
\entry{names, functions}{149}{names, functions}
\entry{functions, names of}{149}{functions, names of}
\entry{namespace issues, functions}{149}{namespace issues, functions}
\entry{programming conventions, functions, writing}{149}{programming conventions, functions, writing}
\entry{variables, shadowing}{149}{variables, shadowing}
\entry{recursive functions}{149}{recursive functions}
\entry{functions, recursive}{149}{functions, recursive}
\entry{POSIX awk, function keyword in}{149}{POSIX \command {awk}, \code {function} keyword in}
\entry{portability, functions, defining}{150}{portability, functions, defining}
\entry{rev user-defined function}{150}{\code {rev} user-defined function}
\entry{ctime user-defined function}{151}{\code {ctime} user-defined function}
\entry{functions, user-defined, calling}{151}{functions, user-defined, calling}
\entry{call by value}{151}{call by value}
\entry{call by reference}{152}{call by reference}
\entry{arrays, as parameters to functions}{152}{arrays, as parameters to functions}
\entry{functions, arrays as parameters to}{152}{functions, arrays as parameters to}
\entry{undefined functions}{152}{undefined functions}
\entry{functions, undefined}{152}{functions, undefined}
\entry{lint checking, undefined functions}{153}{lint checking, undefined functions}
\entry{portability, next statement in user-defined functions}{153}{portability, \code {next} statement in user-defined functions}
\entry{return statement, user-defined functions}{153}{\code {return} statement, user-defined functions}
\entry{programming conventions, function parameters}{153}{programming conventions, function parameters}
\entry{internationalization, localization}{155}{internationalization, localization}
\entry{gawk, internationalization and, See internationalization}{155}{\command {gawk}, internationalization and, See internationalization}
\entry{internationalization, localization, gawk and}{155}{internationalization, localization, \command {gawk} and}
\entry{internationalization}{155}{internationalization}
\entry{localization, See internationalization, localization}{155}{localization, See internationalization, localization}
\entry{localization}{155}{localization}
\entry{internationalizing a program}{155}{internationalizing a program}
\entry{gettext library}{155}{\code {gettext} library}
\entry{portability, gettext library and}{155}{portability, \code {gettext} library and}
\entry{textdomain function (C library)}{155}{\code {textdomain} function (C library)}
\entry{.po files}{156}{\code {.po} files}
\entry{files, .po}{156}{files, \code {.po}}
\entry{portable object files}{156}{portable object files}
\entry{files, portable object}{156}{files, portable object}
\entry{.mo files}{156}{\code {.mo} files}
\entry{files, .mo}{156}{files, \code {.mo}}
\entry{message object files}{156}{message object files}
\entry{files, message object}{156}{files, message object}
\entry{bindtextdomain function (C library)}{156}{\code {bindtextdomain} function (C library)}
\entry{.mo files, specifying directory of}{156}{\code {.mo} files, specifying directory of}
\entry{files, .mo, specifying directory of}{156}{files, \code {.mo}, specifying directory of}
\entry{message object files, specifying directory of}{156}{message object files, specifying directory of}
\entry{files, message object, specifying directory of}{156}{files, message object, specifying directory of}
\entry{gettext function (C library)}{156}{\code {gettext} function (C library)}
\entry{_ (underscore), _ C macro}{156}{\code {_} (underscore), \code {_} C macro}
\entry{underscore (_), _ C macro}{156}{underscore (\code {_}), \code {_} C macro}
\entry{internationalization, localization, locale categories}{156}{internationalization, localization, locale categories}
\entry{gettext library, locale categories}{156}{\code {gettext} library, locale categories}
\entry{locale categories}{156}{locale categories}
\entry{LC_MESSAGES locale category}{156}{\code {LC_MESSAGES} locale category}
\entry{sorting characters in different languages}{156}{sorting characters in different languages}
\entry{LC_COLLATE locale category}{156}{\code {LC_COLLATE} locale category}
\entry{LC_CTYPE locale category}{156}{\code {LC_CTYPE} locale category}
\entry{monetary information, localization}{156}{monetary information, localization}
\entry{currency symbols, localization}{156}{currency symbols, localization}
\entry{LC_MONETARY locale category}{156}{\code {LC_MONETARY} locale category}
\entry{LC_NUMERIC locale category}{157}{\code {LC_NUMERIC} locale category}
\entry{LC_RESPONSE locale category}{157}{\code {LC_RESPONSE} locale category}
\entry{time, localization and}{157}{time, localization and}
\entry{dates, information related to, localization}{157}{dates, information related to, localization}
\entry{LC_TIME locale category}{157}{\code {LC_TIME} locale category}
\entry{LC_ALL locale category}{157}{\code {LC_ALL} locale category}
\entry{awk programs, internationalizing}{157}{\command {awk} programs, internationalizing}
\entry{TEXTDOMAIN variable}{157}{\code {TEXTDOMAIN} variable}
\entry{internationalization, localization, marked strings}{157}{internationalization, localization, marked strings}
\entry{strings, for localization}{157}{strings, for localization}
\entry{dcgettext function (gawk)}{157}{\code {dcgettext} function (\command {gawk})}
\entry{dcngettext function (gawk)}{157}{\code {dcngettext} function (\command {gawk})}
\entry{.mo files, specifying directory of}{157}{\code {.mo} files, specifying directory of}
\entry{files, .mo, specifying directory of}{157}{files, \code {.mo}, specifying directory of}
\entry{message object files, specifying directory of}{157}{message object files, specifying directory of}
\entry{files, message object, specifying directory of}{157}{files, message object, specifying directory of}
\entry{bindtextdomain function (gawk)}{157}{\code {bindtextdomain} function (\command {gawk})}
\entry{BEGIN pattern, TEXTDOMAIN variable and}{158}{\code {BEGIN} pattern, \code {TEXTDOMAIN} variable and}
\entry{TEXTDOMAIN variable, BEGIN pattern and}{158}{\code {TEXTDOMAIN} variable, \code {BEGIN} pattern and}
\entry{_ (underscore), translatable string}{158}{\code {_} (underscore), translatable string}
\entry{underscore (_), translatable string}{158}{underscore (\code {_}), translatable string}
\entry{LC_MESSAGES locale category, bindtextdomain function (gawk)}{158}{\code {LC_MESSAGES} locale category, \code {bindtextdomain} function (\command {gawk})}
\entry{.po files}{159}{\code {.po} files}
\entry{files, .po}{159}{files, \code {.po}}
\entry{portable object files}{159}{portable object files}
\entry{files, portable object}{159}{files, portable object}
\entry{strings, extracting}{159}{strings, extracting}
\entry{marked strings, extracting}{159}{marked strings, extracting}
\entry{--gen-po option}{159}{\code {--gen-po} option}
\entry{command-line options, string extraction}{159}{command-line options, string extraction}
\entry{string extraction (internationalization)}{159}{string extraction (internationalization)}
\entry{marked string extraction (internationalization)}{159}{marked string extraction (internationalization)}
\entry{extraction, of marked strings (internationalization)}{159}{extraction, of marked strings (internationalization)}
\entry{--gen-po option}{159}{\code {--gen-po} option}
\entry{xgettext utility}{159}{\code {xgettext} utility}
\entry{printf statement, positional specifiers}{159}{\code {printf} statement, positional specifiers}
\entry{positional specifiers, printf statement}{159}{positional specifiers, \code {printf} statement}
\entry{printf statement, positional specifiers, mixing with regular formats}{160}{\code {printf} statement, positional specifiers, mixing with regular formats}
\entry{positional specifiers, printf statement, mixing with regular formats}{160}{positional specifiers, \code {printf} statement, mixing with regular formats}
\entry{format specifiers, mixing regular with positional specifiers}{160}{format specifiers, mixing regular with positional specifiers}
\entry{portability, internationalization and}{160}{portability, internationalization and}
\entry{internationalization, localization, portability and}{160}{internationalization, localization, portability and}
\entry{TEXTDOMAIN variable, portability and}{160}{\code {TEXTDOMAIN} variable, portability and}
\entry{bindtextdomain function (gawk), portability and}{161}{\code {bindtextdomain} function (\command {gawk}), portability and}
\entry{dcgettext function (gawk), portability and}{161}{\code {dcgettext} function (\command {gawk}), portability and}
\entry{dcngettext function (gawk), portability and}{161}{\code {dcngettext} function (\command {gawk}), portability and}
\entry{Linux}{162}{Linux}
\entry{GNU/Linux}{162}{GNU/Linux}
\entry{.po files, converting to .mo}{162}{\code {.po} files, converting to \code {.mo}}
\entry{files, .po, converting to .mo}{162}{files, \code {.po}, converting to \code {.mo}}
\entry{.mo files, converting from .po}{162}{\code {.mo} files, converting from \code {.po}}
\entry{files, .mo, converting from .po}{162}{files, \code {.mo}, converting from \code {.po}}
\entry{portable object files, converting to message object files}{162}{portable object files, converting to message object files}
\entry{files, portable object, converting to message object files}{162}{files, portable object, converting to message object files}
\entry{message object files, converting from portable object files}{162}{message object files, converting from portable object files}
\entry{files, message object, converting from portable object files}{162}{files, message object, converting from portable object files}
\entry{msgfmt utility}{162}{\command {msgfmt} utility}
\entry{--with-included-gettext configuration option}{163}{\code {--with-included-gettext} configuration option}
\entry{configuration option, --with-included-gettext}{163}{configuration option, \code {--with-included-gettext}}
\entry{advanced features, network connections, See Also networks, connections}{164}{advanced features, network connections, See Also networks, connections}
\entry{gawk, features, advanced}{164}{\command {gawk}, features, advanced}
\entry{advanced features, gawk}{164}{advanced features, \command {gawk}}
\entry{--non-decimal-data option}{164}{\code {--non-decimal-data} option}
\entry{advanced features, gawk, nondecimal input data}{164}{advanced features, \command {gawk}, nondecimal input data}
\entry{input, data, nondecimal}{164}{input, data, nondecimal}
\entry{constants, nondecimal}{164}{constants, nondecimal}
\entry{programming conventions, --non-decimal-data option}{164}{programming conventions, \code {--non-decimal-data} option}
\entry{--non-decimal-data option, strtonum function and}{164}{\code {--non-decimal-data} option, \code {strtonum} function and}
\entry{strtonum function (gawk), --non-decimal-data option and}{164}{\code {strtonum} function (\command {gawk}), \code {--non-decimal-data} option and}
\entry{Brennan, Michael}{165}{Brennan, Michael}
\entry{programmers, attractiveness of}{165}{programmers, attractiveness of}
\entry{advanced features, gawk, processes, communicating with}{165}{advanced features, \command {gawk}, processes, communicating with}
\entry{processes, two-way communications with}{165}{processes, two-way communications with}
\entry{coprocesses}{165}{coprocesses}
\entry{input/output, two-way}{165}{input/output, two-way}
\entry{| (vertical bar), |& operator (I/O)}{165}{\code {|} (vertical bar), \code {|&} operator (I/O)}
\entry{vertical bar (|), |& I/O operator (I/O)}{165}{vertical bar (\code {|}), \code {|&} I/O operator (I/O)}
\entry{csh utility, |& operator, comparison with}{165}{\command {csh} utility, \code {|&} operator, comparison with}
\entry{deadlocks}{166}{deadlocks}
\entry{buffering, input/output}{166}{buffering, input/output}
\entry{getline command, deadlock and}{166}{\code {getline} command, deadlock and}
\entry{close function, two-way pipes and}{166}{\code {close} function, two-way pipes and}
\entry{sort utility, coprocesses and}{166}{\command {sort} utility, coprocesses and}
\entry{advanced features, gawk, network programming}{167}{advanced features, \command {gawk}, network programming}
\entry{networks, programming}{167}{networks, programming}
\entry{TCP/IP}{167}{TCP/IP}
\entry{/inet/ files (gawk)}{167}{\code {/inet/} files (\command {gawk})}
\entry{files, /inet/ (gawk)}{167}{files, \code {/inet/} (\command {gawk})}
\entry{EMISTERED}{167}{\code {EMISTERED}}
\entry{raw sockets}{167}{raw sockets}
\entry{sockets}{167}{sockets}
\entry{getservbyname function (C library)}{167}{\code {getservbyname} function (C library)}
\entry{advanced features, gawk, BSD portals}{168}{advanced features, \command {gawk}, BSD portals}
\entry{portal files}{168}{portal files}
\entry{files, portal}{168}{files, portal}
\entry{BSD portals}{168}{BSD portals}
\entry{/p files (gawk)}{168}{\code {/p} files (\command {gawk})}
\entry{files, /p (gawk)}{168}{files, \code {/p} (\command {gawk})}
\entry{--enable-portals configuration option}{168}{\code {--enable-portals} configuration option}
\entry{operating systems, BSD-based}{168}{operating systems, BSD-based}
\entry{| (vertical bar), |& operator (I/O), two-way communications}{168}{\code {|} (vertical bar), \code {|&} operator (I/O), two-way communications}
\entry{vertical bar (|), |& operator (I/O), two-way communications}{168}{vertical bar (\code {|}), \code {|&} operator (I/O), two-way communications}
\entry{awk programs, profiling}{168}{\command {awk} programs, profiling}
\entry{profiling awk programs}{168}{profiling \command {awk} programs}
\entry{pgawk program}{168}{\command {pgawk} program}
\entry{profiling gawk, See pgawk program}{168}{profiling \command {gawk}, See \command {pgawk} program}
\entry{awkprof.out file}{168}{\code {awkprof.out} file}
\entry{files, awkprof.out}{168}{files, \code {awkprof.out}}
\entry{pgawk program, awkprof.out file}{168}{\command {pgawk} program, \code {awkprof.out} file}
\entry{--profile option}{168}{\code {--profile} option}
\entry{BEGIN pattern, pgawk program}{169}{\code {BEGIN} pattern, \command {pgawk} program}
\entry{END pattern, pgawk program}{169}{\code {END} pattern, \command {pgawk} program}
\entry{patterns, counts}{170}{patterns, counts}
\entry{loops, count for header}{170}{loops, count for header}
\entry{functions, user-defined, counts}{170}{functions, user-defined, counts}
\entry{user-defined, functions, counts}{170}{user-defined, functions, counts}
\entry{{\tt \char 123}{\tt \char 125} (braces), pgawk program}{170}{\code {{\tt \char 123}{\tt \char 125}} (braces), \command {pgawk} program}
\entry{braces ({\tt \char 123}{\tt \char 125}), pgawk program}{170}{braces (\code {{\tt \char 123}{\tt \char 125}}), \command {pgawk} program}
\entry{() (parentheses), pgawk program}{170}{\code {()} (parentheses), \command {pgawk} program}
\entry{parentheses (), pgawk program}{170}{parentheses \code {()}, \command {pgawk} program}
\entry{profiling awk programs, dynamically}{171}{profiling \command {awk} programs, dynamically}
\entry{pgawk program, dynamic profiling}{171}{\command {pgawk} program, dynamic profiling}
\entry{kill command, dynamic profiling}{171}{\command {kill} command, dynamic profiling}
\entry{USR1 signal}{171}{\code {USR1} signal}
\entry{signals, USR1/SIGUSR1}{171}{signals, \code {USR1}/\code {SIGUSR1}}
\entry{HUP signal}{171}{\code {HUP} signal}
\entry{signals, HUP/SIGHUP}{171}{signals, \code {HUP}/\code {SIGHUP}}
\entry{INT signal (MS-DOS)}{171}{\code {INT} signal (MS-DOS)}
\entry{signals, INT/SIGINT (MS-DOS)}{171}{signals, \code {INT}/\code {SIGINT} (MS-DOS)}
\entry{QUIT signal (MS-DOS)}{171}{\code {QUIT} signal (MS-DOS)}
\entry{signals, QUIT/SIGQUIT (MS-DOS)}{171}{signals, \code {QUIT}/\code {SIGQUIT} (MS-DOS)}
\entry{command line, invoking awk from}{172}{command line, invoking \command {awk} from}
\entry{awk, invoking}{172}{\command {awk}, invoking}
\entry{arguments, command-line, invoking awk}{172}{arguments, command-line, invoking \command {awk}}
\entry{options, command-line, invoking awk}{172}{options, command-line, invoking \command {awk}}
\entry{GNU long options}{172}{GNU long options}
\entry{long options}{172}{long options}
\entry{options, long}{172}{options, long}
\entry{dark corner, invoking awk}{172}{dark corner, invoking \command {awk}}
\entry{lint checking, empty programs}{172}{lint checking, empty programs}
\entry{--lint option}{172}{\code {--lint} option}
\entry{options, command-line}{172}{options, command-line}
\entry{command line, options}{172}{command line, options}
\entry{GNU long options}{172}{GNU long options}
\entry{options, long}{172}{options, long}
\entry{POSIX awk, GNU long options and}{172}{POSIX \command {awk}, GNU long options and}
\entry{-F option}{172}{\code {-F} option}
\entry{--field-separator option}{172}{\code {--field-separator} option}
\entry{FS variable, --field-separator option and}{172}{\code {FS} variable, \code {--field-separator} option and}
\entry{-f option}{172}{\code {-f} option}
\entry{--file option}{172}{\code {--file} option}
\entry{awk programs, location of}{172}{\command {awk} programs, location of}
\entry{-v option}{173}{\code {-v} option}
\entry{--assign option}{173}{\code {--assign} option}
\entry{variables, setting}{173}{variables, setting}
\entry{built-in variables, -v option, setting with}{173}{built-in variables, \code {-v} option, setting with}
\entry{variables, built-in, -v option, setting with}{173}{variables, built-in, \code {-v} option, setting with}
\entry{-mf/-mr options}{173}{\code {-mf}/\code {-mr} options}
\entry{memory, setting limits}{173}{memory, setting limits}
\entry{-W option}{173}{\code {-W} option}
\entry{command line, options, end of}{173}{command line, options, end of}
\entry{options, command-line, end of}{173}{options, command-line, end of}
\entry{- (hyphen), filenames beginning with}{173}{\code {-} (hyphen), filenames beginning with}
\entry{hyphen (-), filenames beginning with}{173}{hyphen (\code {-}), filenames beginning with}
\entry{--compat option}{173}{\code {--compat} option}
\entry{--traditional option}{173}{\code {--traditional} option}
\entry{compatibility mode (gawk), specifying}{173}{compatibility mode (\command {gawk}), specifying}
\entry{--copyright option}{173}{\code {--copyright} option}
\entry{GPL (General Public License), printing}{173}{GPL (General Public License), printing}
\entry{--copyleft option}{174}{\code {--copyleft} option}
\entry{--dump-variables option}{174}{\code {--dump-variables} option}
\entry{awkvars.out file}{174}{\code {awkvars.out} file}
\entry{files, awkvars.out}{174}{files, \code {awkvars.out}}
\entry{variables, global, printing list of}{174}{variables, global, printing list of}
\entry{troubleshooting, typographical errors, global variables}{174}{troubleshooting, typographical errors, global variables}
\entry{--gen-po option}{174}{\code {--gen-po} option}
\entry{portable object files, generating}{174}{portable object files, generating}
\entry{files, portable object, generating}{174}{files, portable object, generating}
\entry{--help option}{174}{\code {--help} option}
\entry{--usage option}{174}{\code {--usage} option}
\entry{GNU long options, printing list of}{174}{GNU long options, printing list of}
\entry{options, printing list of}{174}{options, printing list of}
\entry{printing, list of options}{174}{printing, list of options}
\entry{--lint option}{174}{\code {--lint} option}
\entry{lint checking, issuing warnings}{174}{lint checking, issuing warnings}
\entry{warnings, issuing}{174}{warnings, issuing}
\entry{--lint-old option}{174}{\code {--lint-old} option}
\entry{--non-decimal-data option}{174}{\code {--non-decimal-data} option}
\entry{hexadecimal, values, enabling interpretation of}{174}{hexadecimal, values, enabling interpretation of}
\entry{octal values, enabling interpretation of}{174}{octal values, enabling interpretation of}
\entry{troubleshooting, --non-decimal-data option}{174}{troubleshooting, \code {--non-decimal-data} option}
\entry{--posix option}{175}{\code {--posix} option}
\entry{POSIX mode}{175}{POSIX mode}
\entry{gawk, extensions, disabling}{175}{\command {gawk}, extensions, disabling}
\entry{escape sequences, unrecognized}{175}{escape sequences, unrecognized}
\entry{newlines}{175}{newlines}
\entry{whitespace, newlines as}{175}{whitespace, newlines as}
\entry{* (asterisk), ** operator}{175}{\code {*} (asterisk), \code {**} operator}
\entry{asterisk (*), ** operator}{175}{asterisk (\code {*}), \code {**} operator}
\entry{* (asterisk), **= operator}{175}{\code {*} (asterisk), \code {**=} operator}
\entry{asterisk (*), **= operator}{175}{asterisk (\code {*}), \code {**=} operator}
\entry{^ (caret), ^ operator}{175}{\code {^} (caret), \code {^} operator}
\entry{caret (^), ^ operator}{175}{caret (\code {^}), \code {^} operator}
\entry{^ (caret), ^= operator}{175}{\code {^} (caret), \code {^=} operator}
\entry{caret (^), ^= operator}{175}{caret (\code {^}), \code {^=} operator}
\entry{FS variable, as TAB character}{175}{\code {FS} variable, as TAB character}
\entry{fflush function, unsupported}{175}{\code {fflush} function, unsupported}
\entry{--traditional option, --posix option and}{175}{\code {--traditional} option, \code {--posix} option and}
\entry{--posix option, --traditional option and}{175}{\code {--posix} option, \code {--traditional} option and}
\entry{--profile option}{175}{\code {--profile} option}
\entry{awk programs, profiling, enabling}{175}{\command {awk} programs, profiling, enabling}
\entry{--re-interval option}{175}{\code {--re-interval} option}
\entry{regular expressions, interval expressions and}{175}{regular expressions, interval expressions and}
\entry{--source option}{175}{\code {--source} option}
\entry{source code, mixing}{175}{source code, mixing}
\entry{--version option}{176}{\code {--version} option}
\entry{gawk, versions of, information about, printing}{176}{\command {gawk}, versions of, information about, printing}
\entry{-F option, -Ft sets FS to TAB}{176}{\code {-F} option, \code {-Ft} sets \code {FS} to TAB}
\entry{-f option, on command line}{176}{\code {-f} option, on command line}
\entry{--source option}{176}{\code {--source} option}
\entry{POSIXLY_CORRECT environment variable}{176}{\code {POSIXLY_CORRECT} environment variable}
\entry{lint checking, POSIXLY_CORRECT environment variable}{176}{lint checking, \code {POSIXLY_CORRECT} environment variable}
\entry{POSIX mode}{176}{POSIX mode}
\entry{csh utility, POSIXLY_CORRECT environment variable}{176}{\command {csh} utility, \code {POSIXLY_CORRECT} environment variable}
\entry{portability, POSIXLY_CORRECT environment variable}{176}{portability, \code {POSIXLY_CORRECT} environment variable}
\entry{command line, arguments}{177}{command line, arguments}
\entry{arguments, command-line}{177}{arguments, command-line}
\entry{ARGIND variable, command-line arguments}{177}{\code {ARGIND} variable, command-line arguments}
\entry{ARGC/ARGV variables, command-line arguments}{177}{\code {ARGC}/\code {ARGV} variables, command-line arguments}
\entry{input files, variable assignments and}{177}{input files, variable assignments and}
\entry{dark corner, escape sequences}{177}{dark corner, escape sequences}
\entry{files, multiple passes over}{177}{files, multiple passes over}
\entry{AWKPATH environment variable}{177}{\env {AWKPATH} environment variable}
\entry{directories, searching}{177}{directories, searching}
\entry{search paths, for source files}{177}{search paths, for source files}
\entry{differences in awk and gawk, AWKPATH environment variable}{177}{differences in \command {awk} and \command {gawk}, \code {AWKPATH} environment variable}
\entry{features, advanced, See advanced features}{178}{features, advanced, See advanced features}
\entry{options, deprecated}{178}{options, deprecated}
\entry{features, deprecated}{178}{features, deprecated}
\entry{obsolete features}{178}{obsolete features}
\entry{next file statement, deprecated}{178}{\code {next file} statement, deprecated}
\entry{nextfile statement, next file statement and}{178}{\code {nextfile} statement, \code {next file} statement and}
\entry{undocumented features}{179}{undocumented features}
\entry{features, undocumented}{179}{features, undocumented}
\entry{Skywalker, Luke}{179}{Skywalker, Luke}
\entry{Kenobi, Obi-Wan}{179}{Kenobi, Obi-Wan}
\entry{Jedi knights}{179}{Jedi knights}
\entry{Knights, jedi}{179}{Knights, jedi}
\entry{gawk, debugging}{179}{\command {gawk}, debugging}
\entry{debugging gawk}{179}{debugging \command {gawk}}
\entry{troubleshooting, gawk}{179}{troubleshooting, \command {gawk}}
\entry{troubleshooting, -F option}{179}{troubleshooting, \code {-F} option}
\entry{-F option, troubleshooting}{179}{\code {-F} option, troubleshooting}
\entry{FS variable, changing value of}{179}{\code {FS} variable, changing value of}
\entry{libraries of awk functions}{180}{libraries of \command {awk} functions}
\entry{functions, library}{180}{functions, library}
\entry{functions, user-defined, library of}{180}{functions, user-defined, library of}
\entry{Texinfo}{180}{Texinfo}
\entry{portability, example programs}{180}{portability, example programs}
\entry{case sensitivity, example programs}{180}{case sensitivity, example programs}
\entry{IGNORECASE variable, in example programs}{180}{\code {IGNORECASE} variable, in example programs}
\entry{names, arrays/variables}{180}{names, arrays/variables}
\entry{names, functions}{180}{names, functions}
\entry{namespace issues}{180}{namespace issues}
\entry{awk programs, documenting}{180}{\command {awk} programs, documenting}
\entry{documentation, of awk programs}{180}{documentation, of \command {awk} programs}
\entry{variables, global, for library functions}{180}{variables, global, for library functions}
\entry{private variables}{180}{private variables}
\entry{variables, private}{180}{variables, private}
\entry{programming conventions, private variable names}{181}{programming conventions, private variable names}
\entry{_ (underscore), in names of private variables}{181}{\code {_} (underscore), in names of private variables}
\entry{underscore (_), in names of private variables}{181}{underscore (\code {_}), in names of private variables}
\entry{--dump-variables option}{181}{\code {--dump-variables} option}
\entry{arrays, associative, library functions and}{181}{arrays, associative, library functions and}
\entry{libraries of awk functions, associative arrays and}{181}{libraries of \command {awk} functions, associative arrays and}
\entry{functions, library, associative arrays and}{181}{functions, library, associative arrays and}
\entry{Tcl}{181}{Tcl}
\entry{input files, skipping}{182}{input files, skipping}
\entry{libraries of awk functions, nextfile statement}{182}{libraries of \command {awk} functions, \code {nextfile} statement}
\entry{functions, library, nextfile statement}{182}{functions, library, \code {nextfile} statement}
\entry{nextfile statement, implementing}{182}{\code {nextfile} statement, implementing}
\entry{gawk, nextfile statement in}{182}{\command {gawk}, \code {nextfile} statement in}
\entry{programming conventions, nextfile statement}{182}{programming conventions, \code {nextfile} statement}
\entry{nextfile user-defined function}{182}{\code {nextfile} user-defined function}
\entry{assertions}{183}{assertions}
\entry{assert function (C library)}{183}{\code {assert} function (C library)}
\entry{libraries of awk functions, assertions}{183}{libraries of \command {awk} functions, assertions}
\entry{functions, library, assertions}{183}{functions, library, assertions}
\entry{awk programs, lengthy, assertions}{183}{\command {awk} programs, lengthy, assertions}
\entry{assert user-defined function}{183}{\code {assert} user-defined function}
\entry{END pattern, assert user-defined function and}{184}{\code {END} pattern, \code {assert} user-defined function and}
\entry{BEGIN pattern, assert user-defined function and}{184}{\code {BEGIN} pattern, \code {assert} user-defined function and}
\entry{rounding}{184}{rounding}
\entry{rounding numbers}{184}{rounding numbers}
\entry{numbers, rounding}{184}{numbers, rounding}
\entry{libraries of awk functions, rounding numbers}{184}{libraries of \command {awk} functions, rounding numbers}
\entry{functions, library, rounding numbers}{184}{functions, library, rounding numbers}
\entry{print statement, sprintf function and}{184}{\code {print} statement, \code {sprintf} function and}
\entry{printf statement, sprintf function and}{184}{\code {printf} statement, \code {sprintf} function and}
\entry{sprintf function, print/printf statements and}{184}{\code {sprintf} function, \code {print}/\code {printf} statements and}
\entry{round user-defined function}{185}{\code {round} user-defined function}
\entry{random numbers, Cliff}{185}{random numbers, Cliff}
\entry{Cliff random numbers}{185}{Cliff random numbers}
\entry{numbers, Cliff random}{185}{numbers, Cliff random}
\entry{functions, library, Cliff random numbers}{185}{functions, library, Cliff random numbers}
\entry{cliff_rand user-defined function}{185}{\code {cliff_rand} user-defined function}
\entry{libraries of awk functions, character values as numbers}{186}{libraries of \command {awk} functions, character values as numbers}
\entry{functions, library, character values as numbers}{186}{functions, library, character values as numbers}
\entry{characters, values of as numbers}{186}{characters, values of as numbers}
\entry{numbers, as values of characters}{186}{numbers, as values of characters}
\entry{ord user-defined function}{186}{\code {ord} user-defined function}
\entry{chr user-defined function}{186}{\code {chr} user-defined function}
\entry{character sets}{187}{character sets}
\entry{character encodings}{187}{character encodings}
\entry{ASCII}{187}{ASCII}
\entry{EBCDIC}{187}{EBCDIC}
\entry{mark parity}{187}{mark parity}
\entry{libraries of awk functions, merging arrays into strings}{187}{libraries of \command {awk} functions, merging arrays into strings}
\entry{functions, library, merging arrays into strings}{187}{functions, library, merging arrays into strings}
\entry{strings, merging arrays into}{187}{strings, merging arrays into}
\entry{arrays, merging into strings}{187}{arrays, merging into strings}
\entry{join user-defined function}{188}{\code {join} user-defined function}
\entry{libraries of awk functions, managing, time}{188}{libraries of \command {awk} functions, managing, time}
\entry{functions, library, managing time}{188}{functions, library, managing time}
\entry{timestamps, formatted}{188}{timestamps, formatted}
\entry{time, managing}{188}{time, managing}
\entry{gettimeofday user-defined function}{188}{\code {gettimeofday} user-defined function}
\entry{files, managing}{190}{files, managing}
\entry{libraries of awk functions, managing, data files}{190}{libraries of \command {awk} functions, managing, data files}
\entry{functions, library, managing data files}{190}{functions, library, managing data files}
\entry{files, managing, data file boundaries}{190}{files, managing, data file boundaries}
\entry{files, initialization and cleanup}{190}{files, initialization and cleanup}
\entry{beginfile user-defined function}{191}{\code {beginfile} user-defined function}
\entry{endfile user-defined function}{191}{\code {endfile} user-defined function}
\entry{files, reading}{191}{files, reading}
\entry{rewind user-defined function}{191}{\code {rewind} user-defined function}
\entry{troubleshooting, readable data files}{192}{troubleshooting, readable data files}
\entry{readable data files, checking}{192}{readable data files, checking}
\entry{files, skipping}{192}{files, skipping}
\entry{readable.awk program}{192}{\code {readable.awk} program}
\entry{troubleshooting, getline function}{192}{troubleshooting, \code {getline} function}
\entry{assignments as filenames}{192}{assignments as filenames}
\entry{filenames, assignments as}{192}{filenames, assignments as}
\entry{noassign.awk program}{193}{\code {noassign.awk} program}
\entry{libraries of awk functions, command-line options}{193}{libraries of \command {awk} functions, command-line options}
\entry{functions, library, command-line options}{193}{functions, library, command-line options}
\entry{command-line options, processing}{193}{command-line options, processing}
\entry{options, command-line, processing}{193}{options, command-line, processing}
\entry{functions, library, C library}{193}{functions, library, C library}
\entry{arguments, processing}{193}{arguments, processing}
\entry{getopt function (C library)}{193}{\code {getopt} function (C library)}
\entry{getopt user-defined function}{195}{\code {getopt} user-defined function}
\entry{getopt user-defined function}{195}{\code {getopt} user-defined function}
\entry{libraries of awk functions, user database, reading}{198}{libraries of \command {awk} functions, user database, reading}
\entry{functions, library, user database, reading}{198}{functions, library, user database, reading}
\entry{user database, reading}{198}{user database, reading}
\entry{database, users, reading}{198}{database, users, reading}
\entry{PROCINFO array}{198}{\code {PROCINFO} array}
\entry{getpwent function (C library)}{198}{\code {getpwent} function (C library)}
\entry{getpwent user-defined function}{198}{\code {getpwent} user-defined function}
\entry{users, information about, retrieving}{198}{users, information about, retrieving}
\entry{login information}{198}{login information}
\entry{account information}{198}{account information}
\entry{password file}{198}{password file}
\entry{files, password}{198}{files, password}
\entry{pwcat program}{198}{\command {pwcat} program}
\entry{Jacobs, Andrew}{200}{Jacobs, Andrew}
\entry{Robbins, Arnold}{200}{Robbins, Arnold}
\entry{Robbins, Miriam}{200}{Robbins, Miriam}
\entry{_pw_init user-defined function}{200}{\code {_pw_init} user-defined function}
\entry{BEGIN pattern, pwcat program}{201}{\code {BEGIN} pattern, \code {pwcat} program}
\entry{getline command, _pw_init function}{201}{\code {getline} command, \code {_pw_init} function}
\entry{getpwnam function (C library)}{201}{\code {getpwnam} function (C library)}
\entry{getpwnam user-defined function}{201}{\code {getpwnam} user-defined function}
\entry{getpwuid function (C library)}{201}{\code {getpwuid} function (C library)}
\entry{getpwuid user-defined function}{201}{\code {getpwuid} user-defined function}
\entry{getpwent function (C library)}{201}{\code {getpwent} function (C library)}
\entry{getpwent user-defined function}{201}{\code {getpwent} user-defined function}
\entry{endpwent function (C library)}{202}{\code {endpwent} function (C library)}
\entry{endpwent user-defined function}{202}{\code {endpwent} user-defined function}
\entry{libraries of awk functions, group database, reading}{202}{libraries of \command {awk} functions, group database, reading}
\entry{functions, library, group database, reading}{202}{functions, library, group database, reading}
\entry{group database, reading}{202}{group database, reading}
\entry{database, group, reading}{202}{database, group, reading}
\entry{PROCINFO array}{202}{\code {PROCINFO} array}
\entry{getgrent function (C library)}{202}{\code {getgrent} function (C library)}
\entry{getgrent user-defined function}{202}{\code {getgrent} user-defined function}
\entry{groups, information about}{202}{groups, information about}
\entry{account information}{202}{account information}
\entry{group file}{202}{group file}
\entry{files, group}{202}{files, group}
\entry{grcat program}{202}{\command {grcat} program}
\entry{getline command, _gr_init user-defined function}{204}{\code {getline} command, \code {_gr_init} user-defined function}
\entry{_gr_init user-defined function}{204}{\code {_gr_init} user-defined function}
\entry{getgrnam function (C library)}{205}{\code {getgrnam} function (C library)}
\entry{getgrnam user-defined function}{205}{\code {getgrnam} user-defined function}
\entry{getgrgid function (C library)}{205}{\code {getgrgid} function (C library)}
\entry{getgrgid user-defined function}{205}{\code {getgrgid} user-defined function}
\entry{getgruser function (C library)}{206}{\code {getgruser} function (C library)}
\entry{getgruser function, user-defined}{206}{\code {getgruser} function, user-defined}
\entry{getgrent function (C library)}{206}{\code {getgrent} function (C library)}
\entry{getgrent user-defined function}{206}{\code {getgrent} user-defined function}
\entry{endgrent function (C library)}{206}{\code {endgrent} function (C library)}
\entry{endgrent user-defined function}{206}{\code {endgrent} user-defined function}
\entry{awk programs, examples of}{207}{\command {awk} programs, examples of}
\entry{POSIX, programs, implementing in awk}{207}{POSIX, programs, implementing in \command {awk}}
\entry{cut utility}{208}{\command {cut} utility}
\entry{cut utility}{208}{\command {cut} utility}
\entry{fields, cutting}{208}{fields, cutting}
\entry{columns, cutting}{208}{columns, cutting}
\entry{cut.awk program}{208}{\code {cut.awk} program}
\entry{BEGIN pattern, running awk programs and}{209}{\code {BEGIN} pattern, running \command {awk} programs and}
\entry{FS variable, running awk programs and}{209}{\code {FS} variable, running \command {awk} programs and}
\entry{field separators, spaces as}{209}{field separators, spaces as}
\entry{regular expressions, searching for}{212}{regular expressions, searching for}
\entry{searching, files for regular expressions}{212}{searching, files for regular expressions}
\entry{files, searching for regular expressions}{212}{files, searching for regular expressions}
\entry{egrep utility}{212}{\command {egrep} utility}
\entry{egrep.awk program}{213}{\code {egrep.awk} program}
\entry{! (exclamation point), ! operator}{215}{\code {!} (exclamation point), \code {!} operator}
\entry{exclamation point (!), ! operator}{215}{exclamation point (\code {!}), \code {!} operator}
\entry{! operator}{215}{\code {!} operator}
\entry{END pattern, backslash continuation and}{216}{\code {END} pattern, backslash continuation and}
\entry{{\tt \indexbackslash } (backslash), continuing lines and}{216}{\code {{\tt \rawbackslashxx }} (backslash), continuing lines and}
\entry{backslash ({\tt \indexbackslash }), continuing lines and}{216}{backslash (\code {{\tt \rawbackslashxx }}), continuing lines and}
\entry{printing, user information}{216}{printing, user information}
\entry{users, information about, printing}{216}{users, information about, printing}
\entry{id utility}{216}{\command {id} utility}
\entry{id.awk program}{216}{\code {id.awk} program}
\entry{in operator}{218}{\code {in} operator}
\entry{files, splitting}{218}{files, splitting}
\entry{split utility}{218}{\code {split} utility}
\entry{split.awk program}{218}{\code {split.awk} program}
\entry{files, multiple, duplicating output into}{220}{files, multiple, duplicating output into}
\entry{output, duplicating into files}{220}{output, duplicating into files}
\entry{tee utility}{220}{\code {tee} utility}
\entry{flag variables}{220}{flag variables}
\entry{tee.awk program}{220}{\code {tee.awk} program}
\entry{printing, unduplicated lines of text}{221}{printing, unduplicated lines of text}
\entry{text, printing, unduplicated lines of}{221}{text, printing, unduplicated lines of}
\entry{uniq utility}{221}{\command {uniq} utility}
\entry{uniq.awk program}{222}{\code {uniq.awk} program}
\entry{counting}{225}{counting}
\entry{input files, counting elements in}{225}{input files, counting elements in}
\entry{words, counting}{225}{words, counting}
\entry{characters, counting}{225}{characters, counting}
\entry{lines, counting}{225}{lines, counting}
\entry{wc utility}{225}{\command {wc} utility}
\entry{wc.awk program}{226}{\code {wc.awk} program}
\entry{words, duplicate, searching for}{228}{words, duplicate, searching for}
\entry{searching, for words}{228}{searching, for words}
\entry{documents, searching}{228}{documents, searching}
\entry{Texinfo}{228}{Texinfo}
\entry{dupword.awk program}{228}{\code {dupword.awk} program}
\entry{insomnia, cure for}{228}{insomnia, cure for}
\entry{Robbins, Arnold}{228}{Robbins, Arnold}
\entry{time, alarm clock example program}{228}{time, alarm clock example program}
\entry{alarm clock example program}{228}{alarm clock example program}
\entry{alarm.awk program}{229}{\code {alarm.awk} program}
\entry{sleep utility}{230}{\command {sleep} utility}
\entry{characters, transliterating}{231}{characters, transliterating}
\entry{tr utility}{231}{\command {tr} utility}
\entry{translate.awk program}{232}{\code {translate.awk} program}
\entry{printing, mailing labels}{233}{printing, mailing labels}
\entry{mailing labels, printing}{233}{mailing labels, printing}
\entry{labels.awk program}{233}{\code {labels.awk} program}
\entry{words, usage counts, generating}{235}{words, usage counts, generating}
\entry{sort utility}{235}{\command {sort} utility}
\entry{wordfreq.awk program}{236}{\code {wordfreq.awk} program}
\entry{lines, duplicate, removing}{236}{lines, duplicate, removing}
\entry{Rakitzis, Byron}{237}{Rakitzis, Byron}
\entry{histsort.awk program}{237}{\code {histsort.awk} program}
\entry{Texinfo, extracting programs from source files}{237}{Texinfo, extracting programs from source files}
\entry{files, Texinfo, extracting programs from}{237}{files, Texinfo, extracting programs from}
\entry{Texinfo}{237}{Texinfo}
\entry{extract.awk program}{238}{\code {extract.awk} program}
\entry{sed utility}{240}{\command {sed} utility}
\entry{stream editors}{240}{stream editors}
\entry{Brennan, Michael}{241}{Brennan, Michael}
\entry{awksed.awk program}{241}{\command {awksed.awk} program}
\entry{libraries of awk functions, example program for using}{242}{libraries of \command {awk} functions, example program for using}
\entry{functions, library, example program for using}{242}{functions, library, example program for using}
\entry{igawk.sh program}{244}{\code {igawk.sh} program}
\entry{search paths, for source files}{248}{search paths, for source files}
\entry{source files, search path for}{248}{source files, search path for}
\entry{files, source, search path for}{248}{files, source, search path for}
\entry{directories, searching}{248}{directories, searching}
\entry{awk, versions of}{249}{\command {awk}, versions of}
\entry{awk, versions of, changes between V7 and SVR3.1}{249}{\command {awk}, versions of, changes between V7 and SVR3.1}
\entry{awk, versions of, changes between SVR3.1 and SVR4}{250}{\command {awk}, versions of, changes between SVR3.1 and SVR4}
\entry{awk, versions of, changes between SVR4 and POSIX awk}{250}{\command {awk}, versions of, changes between SVR4 and POSIX \command {awk}}
\entry{POSIX awk, changes in awk versions}{250}{POSIX \command {awk}, changes in \command {awk} versions}
\entry{awk, versions of, See Also Bell Laboratories awk}{251}{\command {awk}, versions of, See Also Bell Laboratories \command {awk}}
\entry{extensions, Bell Laboratories awk}{251}{extensions, Bell Laboratories \command {awk}}
\entry{Bell Laboratories awk extensions}{251}{Bell Laboratories \command {awk} extensions}
\entry{Kernighan, Brian}{251}{Kernighan, Brian}
\entry{compatibility mode (gawk), extensions}{252}{compatibility mode (\command {gawk}), extensions}
\entry{extensions, in gawk, not in POSIX awk}{252}{extensions, in \command {gawk}, not in POSIX \command {awk}}
\entry{POSIX, gawk extensions not included in}{252}{POSIX, \command {gawk} extensions not included in}
\entry{next file statement}{254}{\code {next file} statement}
\entry{gawk, list of contributors to}{255}{\command {gawk}, list of contributors to}
\entry{Aho, Alfred}{255}{Aho, Alfred}
\entry{Weinberger, Peter}{255}{Weinberger, Peter}
\entry{Kernighan, Brian}{255}{Kernighan, Brian}
\entry{Rubin, Paul}{255}{Rubin, Paul}
\entry{Fenlason, Jay}{255}{Fenlason, Jay}
\entry{Close, Diane}{255}{Close, Diane}
\entry{Stallman, Richard}{255}{Stallman, Richard}
\entry{Woods, John}{255}{Woods, John}
\entry{Trueman, David}{255}{Trueman, David}
\entry{Rankin, Pat}{255}{Rankin, Pat}
\entry{Kwok, Conrad}{255}{Kwok, Conrad}
\entry{Garfinkle, Scott}{255}{Garfinkle, Scott}
\entry{Williams, Kent}{255}{Williams, Kent}
\entry{Peterson, Hal}{255}{Peterson, Hal}
\entry{Rommel, Kai Uwe}{255}{Rommel, Kai Uwe}
\entry{Jaegermann, Michal}{255}{Jaegermann, Michal}
\entry{Fish, Fred}{255}{Fish, Fred}
\entry{Deifik, Scott}{255}{Deifik, Scott}
\entry{Grigera, Juan}{255}{Grigera, Juan}
\entry{Hankerson, Darrel}{255}{Hankerson, Darrel}
\entry{Zoulas, Christos}{255}{Zoulas, Christos}
\entry{Kahrs, Jurgen}{255}{Kahrs, J\"urgen}
\entry{Davies, Stephen}{255}{Davies, Stephen}
\entry{Brown, Martin}{256}{Brown, Martin}
\entry{Peters, Arno}{256}{Peters, Arno}
\entry{Broder, Alan J.\spacefactor =1000 }{256}{Broder, Alan J.\spacefactor =1000 }
\entry{Buening, Andreas}{256}{Buening, Andreas}
\entry{Hasegawa, Isamu}{256}{Hasegawa, Isamu}
\entry{Robbins, Arnold}{256}{Robbins, Arnold}
\entry{operating systems, See Also GNU/Linux, PC operating systems, Unix}{257}{operating systems, See Also GNU/Linux, PC operating systems, Unix}
\entry{gawk, installing}{257}{\command {gawk}, installing}
\entry{installing gawk}{257}{installing \command {gawk}}
\entry{source code, gawk}{257}{source code, \command {gawk}}
\entry{gawk, source code, obtaining}{257}{\command {gawk}, source code, obtaining}
\entry{FSF (Free Software Foundation)}{257}{FSF (Free Software Foundation)}
\entry{Free Software Foundation (FSF)}{257}{Free Software Foundation (FSF)}
\entry{gawk, distribution}{258}{\command {gawk}, distribution}
\entry{artificial intelligence, gawk and}{258}{artificial intelligence, \command {gawk} and}
\entry{Texinfo}{259}{Texinfo}
\entry{gawk, configuring, options}{261}{\command {gawk}, configuring, options}
\entry{configuration options, gawk}{261}{configuration options, \command {gawk}}
\entry{--enable-portals configuration option}{261}{\code {--enable-portals} configuration option}
\entry{configuration option, --enable-portals}{261}{configuration option, \code {--enable-portals}}
\entry{Linux}{261}{Linux}
\entry{GNU/Linux}{261}{GNU/Linux}
\entry{--with-included-gettext configuration option}{261}{\code {--with-included-gettext} configuration option}
\entry{--with-included-gettext configuration option, configuring gawk with}{261}{\code {--with-included-gettext} configuration option, configuring \command {gawk} with}
\entry{configuration option, --with-included-gettext}{261}{configuration option, \code {--with-included-gettext}}
\entry{--disable-lint configuration option}{261}{\code {--disable-lint} configuration option}
\entry{configuration option, --disable-lint}{261}{configuration option, \code {--disable-lint}}
\entry{--disable-nls configuration option}{262}{\code {--disable-nls} configuration option}
\entry{configuration option, --disable-nls}{262}{configuration option, \code {--disable-nls}}
\entry{gawk, configuring}{262}{\command {gawk}, configuring}
\entry{custom.h file}{262}{\code {custom.h} file}
\entry{amiga}{263}{amiga}
\entry{installation, amiga}{263}{installation, amiga}
\entry{BeOS}{263}{BeOS}
\entry{installation, beos}{263}{installation, beos}
\entry{PC operating systems, gawk on, installing}{264}{PC operating systems, \command {gawk} on, installing}
\entry{operating systems, PC, gawk on, installing}{264}{operating systems, PC, \command {gawk} on, installing}
\entry{operating systems, PC, gawk on}{266}{operating systems, PC, \command {gawk} on}
\entry{PC operating systems, gawk on}{266}{PC operating systems, \command {gawk} on}
\entry{search paths}{266}{search paths}
\entry{gawk, OS/2 version of}{266}{\command {gawk}, OS/2 version of}
\entry{gawk, MS-DOS version of}{266}{\command {gawk}, MS-DOS version of}
\entry{; (semicolon), AWKPATH variable and}{266}{\code {;} (semicolon), \code {AWKPATH} variable and}
\entry{semicolon (;), AWKPATH variable and}{266}{semicolon (\code {;}), \code {AWKPATH} variable and}
\entry{AWKPATH environment variable}{266}{\code {AWKPATH} environment variable}
\entry{differences in awk and gawk, BINMODE variable}{266}{differences in \command {awk} and \command {gawk}, \code {BINMODE} variable}
\entry{BINMODE variable}{266}{\code {BINMODE} variable}
\entry{installation, vms}{268}{installation, vms}
\entry{search paths}{269}{search paths}
\entry{search paths, for source files}{269}{search paths, for source files}
\entry{atari}{270}{atari}
\entry{installation, atari}{270}{installation, atari}
\entry{Linux}{271}{Linux}
\entry{GNU/Linux}{271}{GNU/Linux}
\entry{tandem}{272}{tandem}
\entry{installation, tandem}{272}{installation, tandem}
\entry{archeologists}{272}{archeologists}
\entry{debugging gawk, bug reports}{272}{debugging \command {gawk}, bug reports}
\entry{troubleshooting, gawk, bug reports}{272}{troubleshooting, \command {gawk}, bug reports}
\entry{bug-gawk@gnu.org bug reporting address}{273}{\code {bug-gawk@gnu.org} bug reporting address}
\entry{email address for bug reports, bug-gawk@gnu.org}{273}{email address for bug reports, \code {bug-gawk@gnu.org}}
\entry{bug reports, email address, bug-gawk@gnu.org}{273}{bug reports, email address, \code {bug-gawk@gnu.org}}
\entry{Robbins, Arnold}{273}{Robbins, Arnold}
\entry{comp.lang.awk newsgroup}{273}{\code {comp.lang.awk} newsgroup}
\entry{Fish, Fred}{273}{Fish, Fred}
\entry{Brown, Martin}{273}{Brown, Martin}
\entry{Deifik, Scott}{273}{Deifik, Scott}
\entry{Hankerson, Darrel}{273}{Hankerson, Darrel}
\entry{Grigera, Juan}{273}{Grigera, Juan}
\entry{Davies, Stephen}{273}{Davies, Stephen}
\entry{Rankin, Pat}{273}{Rankin, Pat}
\entry{awk, implementations}{274}{\command {awk}, implementations}
\entry{Brennan, Michael}{274}{Brennan, Michael}
\entry{Kernighan, Brian}{274}{Kernighan, Brian}
\entry{source code, Bell Laboratories awk}{274}{source code, Bell Laboratories \command {awk}}
\entry{Brennan, Michael}{274}{Brennan, Michael}
\entry{mawk program}{274}{\command {mawk} program}
\entry{source code, mawk}{274}{source code, \command {mawk}}
\entry{extensions, mawk}{274}{extensions, \command {mawk}}
\entry{Sumner, Andrew}{275}{Sumner, Andrew}
\entry{awka compiler for awk}{275}{\command {awka} compiler for \command {awk}}
\entry{source code, awka}{275}{source code, \command {awka}}
\entry{Beebe, Nelson H.F.}{275}{Beebe, Nelson H.F.}
\entry{pawk profiling Bell Labs awk}{275}{\command {pawk} profiling Bell Labs \command {awk}}
\entry{gawk, implementation issues}{276}{\command {gawk}, implementation issues}
\entry{implementation issues, gawk}{276}{implementation issues, \command {gawk}}
\entry{gawk, implementation issues, downward compatibility}{276}{\command {gawk}, implementation issues, downward compatibility}
\entry{gawk, implementation issues, debugging}{276}{\command {gawk}, implementation issues, debugging}
\entry{troubleshooting, gawk}{276}{troubleshooting, \command {gawk}}
\entry{implementation issues, gawk, debugging}{276}{implementation issues, \command {gawk}, debugging}
\entry{adding, features to gawk}{276}{adding, features to \command {gawk}}
\entry{features, adding to gawk}{276}{features, adding to \command {gawk}}
\entry{gawk, features, adding}{276}{\command {gawk}, features, adding}
\entry{gawk, coding style in}{277}{\command {gawk}, coding style in}
\entry{Texinfo}{277}{Texinfo}
\entry{portability, gawk}{278}{portability, \command {gawk}}
\entry{operating systems, porting gawk to}{278}{operating systems, porting \command {gawk} to}
\entry{porting gawk}{278}{porting \command {gawk}}
\entry{Robinson, Will}{279}{Robinson, Will}
\entry{robot, the}{279}{robot, the}
\entry{Lost In Space}{279}{Lost In Space}
\entry{gawk, functions, adding}{279}{\command {gawk}, functions, adding}
\entry{adding, functions to gawk}{279}{adding, functions to \command {gawk}}
\entry{functions, built-in, adding to gawk}{279}{functions, built-in, adding to \command {gawk}}
\entry{gawk, internals}{279}{\command {gawk}, internals}
\entry{awk.h file (internal)}{280}{\code {awk.h} file (internal)}
\entry{floating-point, numbers, AWKNUM internal type}{280}{floating-point, numbers, \code {AWKNUM} internal type}
\entry{numbers, floating-point, AWKNUM internal type}{280}{numbers, floating-point, \code {AWKNUM} internal type}
\entry{AWKNUM internal type}{280}{\code {AWKNUM} internal type}
\entry{NODE internal type}{280}{\code {NODE} internal type}
\entry{strings, NODE internal type}{280}{strings, \code {NODE} internal type}
\entry{numbers, NODE internal type}{280}{numbers, \code {NODE} internal type}
\entry{force_number internal function}{280}{\code {force_number} internal function}
\entry{numeric, values}{280}{numeric, values}
\entry{force_string internal function}{280}{\code {force_string} internal function}
\entry{parameters, number of}{280}{parameters, number of}
\entry{param_cnt internal variable}{280}{\code {param_cnt} internal variable}
\entry{stptr internal variable}{280}{\code {stptr} internal variable}
\entry{stlen internal variable}{280}{\code {stlen} internal variable}
\entry{type internal variable}{280}{\code {type} internal variable}
\entry{vname internal variable}{280}{\code {vname} internal variable}
\entry{arrays, associative, clearing}{280}{arrays, associative, clearing}
\entry{assoc_clear internal function}{280}{\code {assoc_clear} internal function}
\entry{arrays, elements, installing}{280}{arrays, elements, installing}
\entry{assoc_lookup internal function}{280}{\code {assoc_lookup} internal function}
\entry{strings}{280}{strings}
\entry{make_string internal function}{280}{\code {make_string} internal function}
\entry{numbers}{280}{numbers}
\entry{make_number internal function}{280}{\code {make_number} internal function}
\entry{tmp_string internal function}{281}{\code {tmp_string} internal function}
\entry{tmp_number internal function}{281}{\code {tmp_number} internal function}
\entry{nodes, duplicating}{281}{nodes, duplicating}
\entry{dupnode internal function}{281}{\code {dupnode} internal function}
\entry{memory, releasing}{281}{memory, releasing}
\entry{free_temp internal macro}{281}{\code {free_temp} internal macro}
\entry{make_builtin internal function}{281}{\code {make_builtin} internal function}
\entry{arguments, retrieving}{281}{arguments, retrieving}
\entry{get_argument internal function}{281}{\code {get_argument} internal function}
\entry{functions, return values, setting}{281}{functions, return values, setting}
\entry{set_value internal function}{281}{\code {set_value} internal function}
\entry{ERRNO variable}{281}{\code {ERRNO} variable}
\entry{update_ERRNO internal function}{281}{\code {update_ERRNO} internal function}
\entry{chdir function, implementing in gawk}{282}{\code {chdir} function, implementing in \command {gawk}}
\entry{stat function, implementing in gawk}{282}{\code {stat} function, implementing in \command {gawk}}
\entry{files, information about, retrieving}{282}{files, information about, retrieving}
\entry{directories, changing}{282}{directories, changing}
\entry{programming conventions, gawk internals}{284}{programming conventions, \command {gawk} internals}
\entry{programming conventions, gawk internals}{287}{programming conventions, \command {gawk} internals}
\entry{gawk, interpreter, adding code to}{287}{\command {gawk}, interpreter, adding code to}
\entry{extension function (gawk)}{287}{\code {extension} function (\command {gawk})}
\entry{PERL}{288}{PERL}
\entry{Wall, Larry}{288}{Wall, Larry}
\entry{Robbins, Arnold}{288}{Robbins, Arnold}
\entry{gawk, interpreter, adding code to}{289}{\command {gawk}, interpreter, adding code to}
\entry{programming, concepts}{291}{programming, concepts}
\entry{programming, concepts}{291}{programming, concepts}
\entry{processing data}{291}{processing data}
\entry{compiled programs}{291}{compiled programs}
\entry{interpreted programs}{291}{interpreted programs}
\entry{programming, basic steps}{291}{programming, basic steps}
\entry{algorithms}{292}{algorithms}
\entry{records}{292}{records}
\entry{fields}{292}{fields}
\entry{data-driven languages}{292}{data-driven languages}
\entry{languages, data-driven}{292}{languages, data-driven}
\entry{variables}{292}{variables}
\entry{values, numeric}{292}{values, numeric}
\entry{values, string}{292}{values, string}
\entry{scalar values}{292}{scalar values}
\entry{integers}{292}{integers}
\entry{floating-point, numbers}{292}{floating-point, numbers}
\entry{numbers, floating-point}{292}{numbers, floating-point}
\entry{unsigned integers}{292}{unsigned integers}
\entry{integers, unsigned}{292}{integers, unsigned}
\entry{double-precision floating-point}{292}{double-precision floating-point}
\entry{single-precision floating-point}{292}{single-precision floating-point}
\entry{null strings}{293}{null strings}
\entry{Kernighan, Brian}{293}{Kernighan, Brian}
\entry{Ritchie, Dennis}{293}{Ritchie, Dennis}
\entry{floating-point}{294}{floating-point}
\entry{negative zero}{295}{negative zero}
\entry{positive zero}{295}{positive zero}
\entry{zero, negative vs.\spacefactor =1000  positive}{295}{zero, negative vs.\spacefactor =1000  positive}
\entry{Spencer, Henry}{296}{Spencer, Henry}
\entry{sed utility}{296}{\command {sed} utility}
\entry{amazing awk assembler (aaa)}{296}{amazing \command {awk} assembler (\command {aaa})}
\entry{amazingly workable formatter (awf)}{296}{amazingly workable formatter (\command {awf})}
\entry{awf (amazingly workable formatter) program}{296}{\command {awf} (amazingly workable formatter) program}
\entry{ANSI}{296}{ANSI}
\entry{ISO 8859-1}{297}{ISO 8859-1}
\entry{ISO Latin-1}{297}{ISO Latin-1}
\entry{character sets (machine character encodings)}{297}{character sets (machine character encodings)}
\entry{chem utility}{298}{\command {chem} utility}
\entry{compiled programs}{298}{compiled programs}
\entry{dark corner}{298}{dark corner}
\entry{epoch, definition of}{299}{epoch, definition of}
\entry{FSF (Free Software Foundation)}{300}{FSF (Free Software Foundation)}
\entry{Free Software Foundation (FSF)}{300}{Free Software Foundation (FSF)}
\entry{Stallman, Richard}{300}{Stallman, Richard}
\entry{GPL (General Public License)}{300}{GPL (General Public License)}
\entry{General Public License (GPL)}{300}{General Public License (GPL)}
\entry{GNU General Public License}{300}{GNU General Public License}
\entry{FSF (Free Software Foundation)}{300}{FSF (Free Software Foundation)}
\entry{Free Software Foundation (FSF)}{300}{Free Software Foundation (FSF)}
\entry{GNU Project}{300}{GNU Project}
\entry{interpreted programs}{301}{interpreted programs}
\entry{ISO}{301}{ISO}
\entry{LGPL (Lesser General Public License)}{301}{LGPL (Lesser General Public License)}
\entry{Lesser General Public License (LGPL)}{301}{Lesser General Public License (LGPL)}
\entry{GNU Lesser General Public License}{301}{GNU Lesser General Public License}
\entry{P1003.2 POSIX standard}{302}{P1003.2 POSIX standard}
\entry{Linux}{304}{Linux}
\entry{GNU/Linux}{304}{GNU/Linux}
\entry{Unix}{304}{Unix}
\entry{BSD-based operating systems}{304}{BSD-based operating systems}
\entry{NetBSD}{304}{NetBSD}
\entry{FreeBSD}{304}{FreeBSD}
\entry{OpenBSD}{304}{OpenBSD}
\entry{FDL (Free Documentation License)}{312}{FDL (Free Documentation License)}
\entry{Free Documentation License (FDL)}{312}{Free Documentation License (FDL)}
\entry{GNU Free Documentation License}{312}{GNU Free Documentation License}
