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