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