\entry{Brennan, Michael}{2}{Brennan, Michael}
\entry{Brennan, Michael}{3}{Brennan, Michael}
\entry{awk, POSIX and, See Also POSIX awk}{5}{\command {awk}, POSIX and, See Also POSIX \command {awk}}
\entry{awk, POSIX and}{5}{\command {awk}, POSIX and}
\entry{POSIX, awk and}{5}{POSIX, \command {awk} and}
\entry{gawk, awk and}{5}{\command {gawk}, \command {awk} and}
\entry{awk, gawk and}{5}{\command {awk}, \command {gawk} and}
\entry{awk, uses for}{5}{\command {awk}, uses for}
\entry{awk, See Also gawk}{5}{\command {awk}, See Also \command {gawk}}
\entry{gawk, See Also awk}{5}{\command {gawk}, See Also \command {awk}}
\entry{gawk, uses for}{5}{\command {gawk}, uses for}
\entry{GNU awk, See gawk}{5}{GNU \command {awk}, See \command {gawk}}
\entry{recipe for a programming language}{6}{recipe for a programming language}
\entry{programming language, recipe for}{6}{programming language, recipe for}
\entry{sidebar, Recipe for a Programming Language}{6}{sidebar, Recipe for a Programming Language}
\entry{Aho, Alfred}{6}{Aho, Alfred}
\entry{Weinberger, Peter}{6}{Weinberger, Peter}
\entry{Kernighan, Brian}{6}{Kernighan, Brian}
\entry{awk, history of}{6}{\command {awk}, history of}
\entry{Rubin, Paul}{6}{Rubin, Paul}
\entry{Fenlason, Jay}{6}{Fenlason, Jay}
\entry{Trueman, David}{6}{Trueman, David}
\entry{awk, new vs. old}{6}{\command {awk}, new vs.\: old}
\entry{awk, terms describing}{7}{\command {awk}, terms describing}
\entry{gawk, awk and}{7}{\command {gawk}, \command {awk} and}
\entry{awk, gawk and}{7}{\command {awk}, \command {gawk} and}
\entry{POSIX awk}{7}{POSIX \command {awk}}
\entry{Texinfo}{9}{Texinfo}
\entry{Kernighan, Brian}{10}{Kernighan, Brian}
\entry{d.c., See dark corner}{10}{d.c., See dark corner}
\entry{dark corner}{10}{dark corner}
\entry{c.e., See common extensions}{10}{c.e., See common extensions}
\entry{FSF (Free Software Foundation)}{10}{FSF (Free Software Foundation)}
\entry{Free Software Foundation (FSF)}{10}{Free Software Foundation (FSF)}
\entry{Stallman, Richard}{10}{Stallman, Richard}
\entry{GNU Project}{10}{GNU Project}
\entry{GPL (General Public License)}{10}{GPL (General Public License)}
\entry{General Public License, See GPL}{10}{General Public License, See GPL}
\entry{documentation, online}{10}{documentation, online}
\entry{Linux}{10}{Linux}
\entry{GNU/Linux}{10}{GNU/Linux}
\entry{operating systems, BSDbased}{10}{operating systems, BSD-based}
\entry{Close, Diane}{10}{Close, Diane}
\entry{Stallman, Richard}{11}{Stallman, Richard}
\entry{Berry, Karl}{12}{Berry, Karl}
\entry{Chassell, Robert J.}{12}{Chassell, Robert J.\:}
\entry{Hartholz, Marshall}{12}{Hartholz, Marshall}
\entry{Hartholz, Elaine}{12}{Hartholz, Elaine}
\entry{Schreiber, Bert}{12}{Schreiber, Bert}
\entry{Schreiber, Rita}{12}{Schreiber, Rita}
\entry{Hughes, Phil}{12}{Hughes, Phil}
\entry{Trueman, David}{12}{Trueman, David}
\entry{Drepper, Ulrich}{12}{Drepper, Ulrich}
\entry{GNITS mailing list}{12}{GNITS mailing list}
\entry{mailing list, GNITS}{12}{mailing list, GNITS}
\entry{Beebe, Nelson H.F.}{12}{Beebe, Nelson H.F.\:}
\entry{Buening, Andreas}{12}{Buening, Andreas}
\entry{Collado, Manuel}{12}{Collado, Manuel}
\entry{Colombo, Antonio}{12}{Colombo, Antonio}
\entry{Davies, Stephen}{12}{Davies, Stephen}
\entry{Deifik, Scott}{12}{Deifik, Scott}
\entry{Demaille, Akim}{12}{Demaille, Akim}
\entry{G., Daniel Richard}{12}{G., Daniel Richard}
\entry{Hankerson, Darrel}{12}{Hankerson, Darrel}
\entry{Jaegermann, Michal}{12}{Jaegermann, Michal}
\entry{Kahrs, Jurgen}{12}{Kahrs, J\"urgen}
\entry{Kasal, Stepan}{12}{Kasal, Stepan}
\entry{Malmberg, John}{12}{Malmberg, John}
\entry{Pitts, Dave}{12}{Pitts, Dave}
\entry{Ramey, Chet}{12}{Ramey, Chet}
\entry{Rankin, Pat}{12}{Rankin, Pat}
\entry{Schorr, Andrew}{12}{Schorr, Andrew}
\entry{Vinschen, Corinna}{12}{Vinschen, Corinna}
\entry{Zaretskii, Eli}{12}{Zaretskii, Eli}
\entry{Duman, Patrice}{12}{Duman, Patrice}
\entry{Berry, Karl}{12}{Berry, Karl}
\entry{Kernighan, Brian}{12}{Kernighan, Brian}
\entry{Brennan, Michael}{12}{Brennan, Michael}
\entry{Day, Robert P.J.}{12}{Day, Robert P.J.\:}
\entry{Robbins, Miriam}{12}{Robbins, Miriam}
\entry{Robbins, Jean}{12}{Robbins, Jean}
\entry{Robbins, Harry}{12}{Robbins, Harry}
\entry{Gd}{12}{G-d}
\entry{awk, function of}{17}{\command {awk}, function of}
\entry{awk, uses for}{17}{\command {awk}, uses for}
\entry{programming languages,{} datadriven vs. procedural}{17}{programming languages\comma {} data-driven vs.\: procedural}
\entry{awk programs}{17}{\command {awk} programs}
\entry{program, definition of}{17}{program, definition of}
\entry{rule, definition of}{17}{rule, definition of}
\entry{awk programs, running}{17}{\command {awk} programs, running}
\entry{command line, formats}{17}{command line, formats}
\entry{single quote (')}{17}{single quote (\code {'})}
\entry{' (single quote)}{17}{\code {'} (single quote)}
\entry{shells, scripts}{17}{shells, scripts}
\entry{awk programs, running, from shell scripts}{17}{\command {awk} programs, running, from shell scripts}
\entry{standard input}{18}{standard input}
\entry{input, standard}{18}{input, standard}
\entry{input files, running awk without}{18}{input files, running \command {awk} without}
\entry{files, input, See input files}{18}{files, input, See input files}
\entry{input files, running awk without}{18}{input files, running \command {awk} without}
\entry{awk programs, running, without input files}{18}{\command {awk} programs, running, without input files}
\entry{awk programs, running}{18}{\command {awk} programs, running}
\entry{awk programs, lengthy}{18}{\command {awk} programs, lengthy}
\entry{files, awk programs in}{18}{files, \command {awk} programs in}
\entry{f option}{18}{\option {-f} option}
\entry{command line, option f}{18}{command line, option \option {-f}}
\entry{quoting in gawk command lines}{19}{quoting in \command {gawk} command lines}
\entry{single quote (') in gawk command lines}{19}{single quote (\code {'}) in \command {gawk} command lines}
\entry{' (single quote) in gawk command lines}{19}{\code {'} (single quote) in \command {gawk} command lines}
\entry{awk programs}{19}{\command {awk} programs}
\entry{# (number sign), #! (executable scripts)}{19}{\code {#} (number sign), \code {#!} (executable scripts)}
\entry{Unix, awk scripts and}{19}{Unix, \command {awk} scripts and}
\entry{number sign (#), #! (executable scripts)}{19}{number sign (\code {#}), \code {#!} (executable scripts)}
\entry{sidebar, Understanding #!}{19}{sidebar, Understanding \samp {#!}}
\entry{portability, #! (executable scripts)}{20}{portability, \code {#!} (executable scripts)}
\entry{ARGC/ARGV variables, portability and}{20}{\code {ARGC}/\code {ARGV} variables, portability and}
\entry{portability, ARGV variable}{20}{portability, \code {ARGV} variable}
\entry{# (number sign), commenting}{20}{\code {#} (number sign), commenting}
\entry{number sign (#), commenting}{20}{number sign (\code {#}), commenting}
\entry{commenting}{20}{commenting}
\entry{awk programs, documenting}{20}{\command {awk} programs, documenting}
\entry{quoting, for small awk programs}{20}{quoting, for small awk programs}
\entry{single quote ('), vs. apostrophe}{20}{single quote (\code {'}), vs.\: apostrophe}
\entry{' (single quote), vs. apostrophe}{20}{\code {'} (single quote), vs.\: apostrophe}
\entry{ (backslash)}{21}{\code {{\tt \backslashcurfont }} (backslash)}
\entry{backslash ()}{21}{backslash (\code {{\tt \backslashcurfont }})}
\entry{shell quoting, rules for}{21}{shell quoting, rules for}
\entry{shells, quoting, rules for}{21}{shells, quoting, rules for}
\entry{Bourne shell, quoting rules for}{21}{Bourne shell, quoting rules for}
\entry{ (backslash), in shell commands}{21}{\code {{\tt \backslashcurfont }} (backslash), in shell commands}
\entry{backslash (), in shell commands}{21}{backslash (\code {{\tt \backslashcurfont }}), in shell commands}
\entry{single quote ('), in shell commands}{21}{single quote (\code {'}), in shell commands}
\entry{' (single quote), in shell commands}{21}{\code {'} (single quote), in shell commands}
\entry{double quote ("), in shell commands}{22}{double quote (\code {"}), in shell commands}
\entry{" (double quote), in shell commands}{22}{\code {"} (double quote), in shell commands}
\entry{single quote ('), with double quotes}{22}{single quote (\code {'}), with double quotes}
\entry{' (single quote), with double quotes}{22}{\code {'} (single quote), with double quotes}
\entry{null strings in gawk arguments, quoting and}{22}{null strings in \command {gawk} arguments, quoting and}
\entry{quoting in gawk command lines, tricks for}{22}{quoting in \command {gawk} command lines, tricks for}
\entry{Brink, Jeroen}{23}{Brink, Jeroen}
\entry{input files, examples}{23}{input files, examples}
\entry{maillist file}{23}{\code {mail-list} file}
\entry{inventoryshipped file}{23}{\code {inventory-shipped} file}
\entry{actions, default}{24}{actions, default}
\entry{patterns, default}{24}{patterns, default}
\entry{actions, empty}{24}{actions, empty}
\entry{awk programs, oneline examples}{25}{\command {awk} programs, one-line examples}
\entry{expand utility}{25}{\command {expand} utility}
\entry{awk programs}{26}{\command {awk} programs}
\entry{ls utility}{26}{\command {ls} utility}
\entry{line continuations, with C shell}{27}{line continuations, with C shell}
\entry{initialization, automatic}{27}{initialization, automatic}
\entry{line breaks}{27}{line breaks}
\entry{newlines}{27}{newlines}
\entry{gawk, newlines in}{27}{\command {gawk}, newlines in}
\entry{ (backslash), continuing lines and}{27}{\code {{\tt \backslashcurfont }} (backslash), continuing lines and}
\entry{backslash (), continuing lines and}{27}{backslash (\code {{\tt \backslashcurfont }}), continuing lines and}
\entry{portability, backslash continuation and}{28}{portability, backslash continuation and}
\entry{csh utility}{28}{\command {csh} utility}
\entry{backslash (), continuing lines and, in csh}{28}{backslash (\code {{\tt \backslashcurfont }}), continuing lines and, in \command {csh}}
\entry{ (backslash), continuing lines and, in csh}{28}{\code {{\tt \backslashcurfont }} (backslash), continuing lines and, in \command {csh}}
\entry{backslash (), continuing lines and, comments and}{28}{backslash (\code {{\tt \backslashcurfont }}), continuing lines and, comments and}
\entry{ (backslash), continuing lines and, comments and}{28}{\code {{\tt \backslashcurfont }} (backslash), continuing lines and, comments and}
\entry{commenting, backslash continuation and}{28}{commenting, backslash continuation and}
\entry{statements, multiple}{29}{statements, multiple}
\entry{; (semicolon), separating statements in actions}{29}{\code {;} (semicolon), separating statements in actions}
\entry{semicolon (;), separating statements in actions}{29}{semicolon (\code {;}), separating statements in actions}
\entry{variables}{29}{variables}
\entry{awk, uses for}{29}{\command {awk}, uses for}
\entry{Brian Kernighan's awk}{29}{Brian Kernighan's \command {awk}}
\entry{awk programs, complex}{29}{\command {awk} programs, complex}
\entry{command line, invoking awk from}{31}{command line, invoking \command {awk} from}
\entry{awk, invoking}{31}{\command {awk}, invoking}
\entry{arguments, commandline, invoking awk}{31}{arguments, command-line, invoking \command {awk}}
\entry{options, commandline, invoking awk}{31}{options, command-line, invoking \command {awk}}
\entry{GNU long options}{31}{GNU long options}
\entry{long options}{31}{long options}
\entry{options, long}{31}{options, long}
\entry{dark corner, invoking awk}{31}{dark corner, invoking \command {awk}}
\entry{lint checking, empty programs}{31}{lint checking, empty programs}
\entry{lint option}{31}{\option {--lint} option}
\entry{options, commandline}{31}{options, command-line}
\entry{command line, options}{31}{command line, options}
\entry{GNU long options}{31}{GNU long options}
\entry{options, long}{31}{options, long}
\entry{POSIX awk, GNU long options and}{31}{POSIX \command {awk}, GNU long options and}
\entry{F option}{31}{\option {-F} option}
\entry{fieldseparator option}{31}{\option {--field-separator} option}
\entry{FS variable, fieldseparator option and}{31}{\code {FS} variable, \code {--field-separator} option and}
\entry{f option}{31}{\option {-f} option}
\entry{file option}{31}{\option {--file} option}
\entry{awk programs, location of}{31}{\command {awk} programs, location of}
\entry{v option}{32}{\option {-v} option}
\entry{assign option}{32}{\option {--assign} option}
\entry{variables, setting}{32}{variables, setting}
\entry{predefined variables, v option,{} setting with}{32}{predefined variables, \code {-v} option\comma {} setting with}
\entry{variables, predefined v option,{} setting with}{32}{variables, predefined \code {-v} option\comma {} setting with}
\entry{W option}{32}{\option {-W} option}
\entry{command line, options, end of}{32}{command line, options, end of}
\entry{options, commandline, end of}{32}{options, command-line, end of}
\entry{ (hyphen), filenames beginning with}{32}{\code {-} (hyphen), filenames beginning with}
\entry{hyphen (), filenames beginning with}{32}{hyphen (\code {-}), filenames beginning with}
\entry{b option}{32}{\option {-b} option}
\entry{charactersasbytes option}{32}{\option {--characters-as-bytes} option}
\entry{c option}{32}{\option {-c} option}
\entry{traditional option}{32}{\option {--traditional} option}
\entry{compatibility mode (gawk), specifying}{32}{compatibility mode (\command {gawk}), specifying}
\entry{C option}{32}{\option {-C} option}
\entry{copyright option}{32}{\option {--copyright} option}
\entry{GPL (General Public License), printing}{32}{GPL (General Public License), printing}
\entry{d option}{33}{\option {-d} option}
\entry{dumpvariables option}{33}{\option {--dump-variables} option}
\entry{dump all variables of a program}{33}{dump all variables of a program}
\entry{awkvars.out file}{33}{\file {awkvars.out} file}
\entry{files, awkvars.out}{33}{files, \file {awkvars.out}}
\entry{variables, global, printing list of}{33}{variables, global, printing list of}
\entry{troubleshooting, typographical errors,{} global variables}{33}{troubleshooting, typographical errors\comma {} global variables}
\entry{D option}{33}{\option {-D} option}
\entry{debug option}{33}{\option {--debug} option}
\entry{awk debugging, enabling}{33}{\command {awk} debugging, enabling}
\entry{e option}{33}{\option {-e} option}
\entry{source option}{33}{\option {--source} option}
\entry{source code, mixing}{33}{source code, mixing}
\entry{E option}{33}{\option {-E} option}
\entry{exec option}{33}{\option {--exec} option}
\entry{awk programs, location of}{33}{\command {awk} programs, location of}
\entry{CGI, awk scripts for}{33}{CGI, \command {awk} scripts for}
\entry{g option}{34}{\option {-g} option}
\entry{genpot option}{34}{\option {--gen-pot} option}
\entry{portable object files, generating}{34}{portable object files, generating}
\entry{files, portable object, generating}{34}{files, portable object, generating}
\entry{h option}{34}{\option {-h} option}
\entry{help option}{34}{\option {--help} option}
\entry{GNU long options, printing list of}{34}{GNU long options, printing list of}
\entry{options, printing list of}{34}{options, printing list of}
\entry{printing, list of options}{34}{printing, list of options}
\entry{i option}{34}{\option {-i} option}
\entry{include option}{34}{\option {--include} option}
\entry{awk programs, location of}{34}{\command {awk} programs, location of}
\entry{l option}{34}{\option {-l} option}
\entry{load option}{34}{\option {--load} option}
\entry{loading, extensions}{34}{loading, extensions}
\entry{l option}{34}{\option {-l} option}
\entry{lint option}{34}{\option {--lint} option}
\entry{lint checking, issuing warnings}{34}{lint checking, issuing warnings}
\entry{warnings, issuing}{34}{warnings, issuing}
\entry{M option}{35}{\option {-M} option}
\entry{bignum option}{35}{\option {--bignum} option}
\entry{n option}{35}{\option {-n} option}
\entry{nondecimaldata option}{35}{\option {--non-decimal-data} option}
\entry{hexadecimal values,{} enabling interpretation of}{35}{hexadecimal values\comma {} enabling interpretation of}
\entry{octal values,{} enabling interpretation of}{35}{octal values\comma {} enabling interpretation of}
\entry{troubleshooting, nondecimaldata option}{35}{troubleshooting, \code {--non-decimal-data} option}
\entry{N option}{35}{\option {-N} option}
\entry{uselcnumeric option}{35}{\option {--use-lc-numeric} option}
\entry{o option}{35}{\option {-o} option}
\entry{prettyprint option}{35}{\option {--pretty-print} option}
\entry{optimize option}{35}{\option {--optimize} option}
\entry{O option}{35}{\option {-O} option}
\entry{p option}{35}{\option {-p} option}
\entry{profile option}{35}{\option {--profile} option}
\entry{awk profiling, enabling}{35}{\command {awk} profiling, enabling}
\entry{P option}{35}{\option {-P} option}
\entry{posix option}{35}{\option {--posix} option}
\entry{POSIX mode}{35}{POSIX mode}
\entry{gawk, extensions,{} disabling}{35}{\command {gawk}, extensions\comma {} disabling}
\entry{newlines}{36}{newlines}
\entry{whitespace, newlines as}{36}{whitespace, newlines as}
\entry{FS variable, as TAB character}{36}{\code {FS} variable, as TAB character}
\entry{locale decimal point character}{36}{locale decimal point character}
\entry{decimal point character, locale specific}{36}{decimal point character, locale specific}
\entry{traditional option, posix option and}{36}{\option {--traditional} option, \code {--posix} option and}
\entry{posix option, traditional option and}{36}{\option {--posix} option, \code {--traditional} option and}
\entry{r option}{36}{\option {-r} option}
\entry{reinterval option}{36}{\option {--re-interval} option}
\entry{regular expressions, interval expressions and}{36}{regular expressions, interval expressions and}
\entry{S option}{36}{\option {-S} option}
\entry{sandbox option}{36}{\option {--sandbox} option}
\entry{sandbox mode}{36}{sandbox mode}
\entry{L option}{36}{\option {-L} option}
\entry{lintold option}{36}{\option {--lint-old} option}
\entry{V option}{36}{\option {-V} option}
\entry{version option}{36}{\option {--version} option}
\entry{gawk, versions of, information about,{} printing}{36}{\command {gawk}, versions of, information about\comma {} printing}
\entry{F option, Ft sets FS to TAB}{36}{\option {-F} option, \option {-Ft} sets \code {FS} to TAB}
\entry{f option, multiple uses}{36}{\option {-f} option, multiple uses}
\entry{e option}{37}{\option {-e} option}
\entry{POSIXLY_CORRECT environment variable}{37}{\env {POSIXLY_CORRECT} environment variable}
\entry{lint checking, POSIXLY_CORRECT environment variable}{37}{lint checking, \env {POSIXLY_CORRECT} environment variable}
\entry{POSIX mode}{37}{POSIX mode}
\entry{csh utility, POSIXLY_CORRECT environment variable}{37}{\command {csh} utility, \env {POSIXLY_CORRECT} environment variable}
\entry{portability, POSIXLY_CORRECT environment variable}{37}{portability, \env {POSIXLY_CORRECT} environment variable}
\entry{command line, arguments}{37}{command line, arguments}
\entry{arguments, commandline}{37}{arguments, command-line}
\entry{gawk, ARGIND variable in}{37}{\command {gawk}, \code {ARGIND} variable in}
\entry{ARGIND variable, commandline arguments}{37}{\code {ARGIND} variable, command-line arguments}
\entry{ARGV array, indexing into}{37}{\code {ARGV} array, indexing into}
\entry{ARGC/ARGV variables, commandline arguments}{37}{\code {ARGC}/\code {ARGV} variables, command-line arguments}
\entry{input files, variable assignments and}{38}{input files, variable assignments and}
\entry{variable assignments and input files}{38}{variable assignments and input files}
\entry{dark corner, escape sequences}{38}{dark corner, escape sequences}
\entry{files, multiple passes over}{38}{files, multiple passes over}
\entry{environment variables used by gawk}{39}{environment variables used by \command {gawk}}
\entry{AWKPATH environment variable}{39}{\env {AWKPATH} environment variable}
\entry{directories, searching for source files}{39}{directories, searching for source files}
\entry{search paths, for source files}{39}{search paths, for source files}
\entry{differences in awk and gawk, AWKPATH environment variable}{39}{differences in \command {awk} and \command {gawk}, \env {AWKPATH} environment variable}
\entry{AWKLIBPATH environment variable}{40}{\env {AWKLIBPATH} environment variable}
\entry{directories, searching for loadable extensions}{40}{directories, searching for loadable extensions}
\entry{search paths, for loadable extensions}{40}{search paths, for loadable extensions}
\entry{differences in awk and gawk, AWKLIBPATH environment variable}{40}{differences in \command {awk} and \command {gawk}, \code {AWKLIBPATH} environment variable}
\entry{exit status, of gawk}{41}{exit status, of \command {gawk}}
\entry{include directive}{42}{\code address@hidden directive}
\entry{file inclusion, include directive}{42}{file inclusion, \code address@hidden directive}
\entry{including files, include directive}{42}{including files, \code address@hidden directive}
\entry{load directive}{43}{\code address@hidden directive}
\entry{loading extensions, load directive}{43}{loading extensions, \code address@hidden directive}
\entry{extensions, loading, load directive}{43}{extensions, loading, \code address@hidden directive}
\entry{options, deprecated}{43}{options, deprecated}
\entry{features, deprecated}{43}{features, deprecated}
\entry{obsolete features}{43}{obsolete features}
\entry{undocumented features}{44}{undocumented features}
\entry{features, undocumented}{44}{features, undocumented}
\entry{Skywalker, Luke}{44}{Skywalker, Luke}
\entry{Kenobi, ObiWan}{44}{Kenobi, Obi-Wan}
\entry{Jedi knights}{44}{Jedi knights}
\entry{Knights, jedi}{44}{Knights, jedi}
\entry{shells, sea}{44}{shells, sea}
\entry{regexp}{45}{regexp}
\entry{regular expressions}{45}{regular expressions}
\entry{forward slash (/) to enclose regular expressions}{45}{forward slash (\code {/}) to enclose regular expressions}
\entry{/ (forward slash) to enclose regular expressions}{45}{\code {/} (forward slash) to enclose regular expressions}
\entry{regular expressions, as patterns}{45}{regular expressions, as patterns}
\entry{regular expressions, operators}{45}{regular expressions, operators}
\entry{operators, stringmatching}{45}{operators, string-matching}
\entry{stringmatching operators}{45}{string-matching operators}
\entry{~ (tilde), ~ operator}{45}{\code {~} (tilde), \code {~} operator}
\entry{tilde (~), ~ operator}{45}{tilde (\code {~}), \code {~} operator}
\entry{! (exclamation point), !~ operator}{45}{\code {!} (exclamation point), \code {!~} operator}
\entry{exclamation point (!), !~ operator}{45}{exclamation point (\code {!}), \code {!~} operator}
\entry{if statement, use of regexps in}{45}{\code {if} statement, use of regexps in}
\entry{while statement, use of regexps in}{45}{\code {while} statement, use of regexps in}
\entry{dowhile statement, use of regexps in}{45}{\code {do}-\code {while} statement, use of regexps in}
\entry{regexp constants}{46}{regexp constants}
\entry{constant regexps}{46}{constant regexps}
\entry{regular expressions, constants, See regexp constants}{46}{regular expressions, constants, See regexp constants}
\entry{escape sequences, in strings}{46}{escape sequences, in strings}
\entry{backslash (), in escape sequences}{46}{backslash (\code {{\tt \backslashcurfont }}), in escape sequences}
\entry{ (backslash), in escape sequences}{46}{\code {{\tt \backslashcurfont }} (backslash), in escape sequences}
\entry{ (backslash), a escape sequence}{46}{\code {{\tt \backslashcurfont }} (backslash), \code {{\tt \backslashcurfont }a} escape sequence}
\entry{backslash (), a escape sequence}{46}{backslash (\code {{\tt \backslashcurfont }}), \code {{\tt \backslashcurfont }a} escape sequence}
\entry{ (backslash), b escape sequence}{46}{\code {{\tt \backslashcurfont }} (backslash), \code {{\tt \backslashcurfont }b} escape sequence}
\entry{backslash (), b escape sequence}{46}{backslash (\code {{\tt \backslashcurfont }}), \code {{\tt \backslashcurfont }b} escape sequence}
\entry{ (backslash), f escape sequence}{46}{\code {{\tt \backslashcurfont }} (backslash), \code {{\tt \backslashcurfont }f} escape sequence}
\entry{backslash (), f escape sequence}{46}{backslash (\code {{\tt \backslashcurfont }}), \code {{\tt \backslashcurfont }f} escape sequence}
\entry{ (backslash), n escape sequence}{46}{\code {{\tt \backslashcurfont }} (backslash), \code {{\tt \backslashcurfont }n} escape sequence}
\entry{backslash (), n escape sequence}{46}{backslash (\code {{\tt \backslashcurfont }}), \code {{\tt \backslashcurfont }n} escape sequence}
\entry{ (backslash), r escape sequence}{46}{\code {{\tt \backslashcurfont }} (backslash), \code {{\tt \backslashcurfont }r} escape sequence}
\entry{backslash (), r escape sequence}{46}{backslash (\code {{\tt \backslashcurfont }}), \code {{\tt \backslashcurfont }r} escape sequence}
\entry{ (backslash), t escape sequence}{46}{\code {{\tt \backslashcurfont }} (backslash), \code {{\tt \backslashcurfont }t} escape sequence}
\entry{backslash (), t escape sequence}{46}{backslash (\code {{\tt \backslashcurfont }}), \code {{\tt \backslashcurfont }t} escape sequence}
\entry{ (backslash), v escape sequence}{46}{\code {{\tt \backslashcurfont }} (backslash), \code {{\tt \backslashcurfont }v} escape sequence}
\entry{backslash (), v escape sequence}{46}{backslash (\code {{\tt \backslashcurfont }}), \code {{\tt \backslashcurfont }v} escape sequence}
\entry{ (backslash), nnn escape sequence}{46}{\code {{\tt \backslashcurfont }} (backslash), \code {{\tt \backslashcurfont }}\var {nnn} escape sequence}
\entry{backslash (), nnn escape sequence}{46}{backslash (\code {{\tt \backslashcurfont }}), \code {{\tt \backslashcurfont }}\var {nnn} escape sequence}
\entry{ (backslash), x escape sequence}{46}{\code {{\tt \backslashcurfont }} (backslash), \code {{\tt \backslashcurfont }x} escape sequence}
\entry{backslash (), x escape sequence}{46}{backslash (\code {{\tt \backslashcurfont }}), \code {{\tt \backslashcurfont }x} escape sequence}
\entry{common extensions, x escape sequence}{46}{common extensions, \code {{\tt \backslashcurfont }x} escape sequence}
\entry{extensions, common,{} x escape sequence}{46}{extensions, common\comma {} \code {{\tt \backslashcurfont }x} escape sequence}
\entry{ (backslash), / escape sequence}{47}{\code {{\tt \backslashcurfont }} (backslash), \code {{\tt \backslashcurfont }/} escape sequence}
\entry{backslash (), / escape sequence}{47}{backslash (\code {{\tt \backslashcurfont }}), \code {{\tt \backslashcurfont }/} escape sequence}
\entry{ (backslash), " escape sequence}{47}{\code {{\tt \backslashcurfont }} (backslash), \code {{\tt \backslashcurfont }"} escape sequence}
\entry{backslash (), " escape sequence}{47}{backslash (\code {{\tt \backslashcurfont }}), \code {{\tt \backslashcurfont }"} escape sequence}
\entry{backslash (), in escape sequences}{47}{backslash (\code {{\tt \backslashcurfont }}), in escape sequences}
\entry{ (backslash), in escape sequences}{47}{\code {{\tt \backslashcurfont }} (backslash), in escape sequences}
\entry{portability}{47}{portability}
\entry{sidebar, Backslash Before Regular Characters}{47}{sidebar, Backslash Before Regular Characters}
\entry{portability, backslash in escape sequences}{47}{portability, backslash in escape sequences}
\entry{POSIX awk, backslashes in string constants}{47}{POSIX \command {awk}, backslashes in string constants}
\entry{backslash (), in escape sequences, POSIX and}{47}{backslash (\code {{\tt \backslashcurfont }}), in escape sequences, POSIX and}
\entry{ (backslash), in escape sequences, POSIX and}{47}{\code {{\tt \backslashcurfont }} (backslash), in escape sequences, POSIX and}
\entry{troubleshooting, backslash before nonspecial character}{47}{troubleshooting, backslash before nonspecial character}
\entry{Brian Kernighan's awk}{47}{Brian Kernighan's \command {awk}}
\entry{gawk, escape sequences}{47}{\command {gawk}, escape sequences}
\entry{Unix awk, backslashes in escape sequences}{47}{Unix \command {awk}, backslashes in escape sequences}
\entry{mawk utility}{47}{\command {mawk} utility}
\entry{sidebar, Escape Sequences for Metacharacters}{48}{sidebar, Escape Sequences for Metacharacters}
\entry{metacharacters, escape sequences for}{48}{metacharacters, escape sequences for}
\entry{dark corner, escape sequences, for metacharacters}{48}{dark corner, escape sequences, for metacharacters}
\entry{regular expressions, operators}{48}{regular expressions, operators}
\entry{metacharacters in regular expressions}{48}{metacharacters in regular expressions}
\entry{backslash (), regexp operator}{48}{backslash (\code {{\tt \backslashcurfont }}), regexp operator}
\entry{ (backslash), regexp operator}{48}{\code {{\tt \backslashcurfont }} (backslash), regexp operator}
\entry{regular expressions, anchors in}{48}{regular expressions, anchors in}
\entry{Texinfo, chapter beginnings in files}{48}{Texinfo, chapter beginnings in files}
\entry{^ (caret), regexp operator}{48}{\code {^} (caret), regexp operator}
\entry{caret (^), regexp operator}{48}{caret (\code {^}), regexp operator}
\entry{$ (dollar sign), regexp operator}{48}{\code {$} (dollar sign), regexp operator}
\entry{dollar sign ($), regexp operator}{48}{dollar sign (\code {$}), regexp operator}
\entry{. (period), regexp operator}{48}{\code {.} (period), regexp operator}
\entry{period (.), regexp operator}{48}{period (\code {.}), regexp operator}
\entry{POSIX awk, period (.),{} using}{49}{POSIX \command {awk}, period (\code {.})\comma {} using}
\entry{[] (square brackets), regexp operator}{49}{\code {[]} (square brackets), regexp operator}
\entry{square brackets ([]), regexp operator}{49}{square brackets (\code {[]}), regexp operator}
\entry{bracket expressions}{49}{bracket expressions}
\entry{character sets, See Also bracket expressions}{49}{character sets, See Also bracket expressions}
\entry{character lists, See bracket expressions}{49}{character lists, See bracket expressions}
\entry{character classes, See bracket expressions}{49}{character classes, See bracket expressions}
\entry{bracket expressions, complemented}{49}{bracket expressions, complemented}
\entry{| (vertical bar)}{49}{\code {|} (vertical bar)}
\entry{vertical bar (|)}{49}{vertical bar (\code {|})}
\entry{() (parentheses), regexp operator}{49}{\code {()} (parentheses), regexp operator}
\entry{parentheses (), regexp operator}{49}{parentheses \code {()}, regexp operator}
\entry{* (asterisk), * operator, as regexp operator}{49}{\code {*} (asterisk), \code {*} operator, as regexp operator}
\entry{asterisk (*), * operator, as regexp operator}{49}{asterisk (\code {*}), \code {*} operator, as regexp operator}
\entry{+ (plus sign), regexp operator}{49}{\code {+} (plus sign), regexp operator}
\entry{plus sign (+), regexp operator}{49}{plus sign (\code {+}), regexp operator}
\entry{? (question mark), regexp operator}{49}{\code {?} (question mark), regexp operator}
\entry{question mark (?), regexp operator}{49}{question mark (\code {?}), regexp operator}
\entry{interval expressions, regexp operator}{50}{interval expressions, regexp operator}
\entry{POSIX awk, interval expressions in}{50}{POSIX \command {awk}, interval expressions in}
\entry{gawk, interval expressions and}{50}{\command {gawk}, interval expressions and}
\entry{precedence, regexp operators}{50}{precedence, regexp operators}
\entry{regular expressions, operators, precedence of}{50}{regular expressions, operators, precedence of}
\entry{POSIX awk, regular expressions and}{50}{POSIX \command {awk}, regular expressions and}
\entry{gawk, regular expressions, precedence}{50}{\command {gawk}, regular expressions, precedence}
\entry{bracket expressions}{50}{bracket expressions}
\entry{bracket expressions, range expressions}{50}{bracket expressions, range expressions}
\entry{range expressions (regexps)}{50}{range expressions (regexps)}
\entry{character lists in regular expression}{50}{character lists in regular expression}
\entry{ (backslash), in bracket expressions}{51}{\code {{\tt \backslashcurfont }} (backslash), in bracket expressions}
\entry{backslash (), in bracket expressions}{51}{backslash (\code {{\tt \backslashcurfont }}), in bracket expressions}
\entry{^ (caret), in bracket expressions}{51}{\code {^} (caret), in bracket expressions}
\entry{caret (^), in bracket expressions}{51}{caret (\code {^}), in bracket expressions}
\entry{ (hyphen), in bracket expressions}{51}{\code {-} (hyphen), in bracket expressions}
\entry{hyphen (), in bracket expressions}{51}{hyphen (\code {-}), in bracket expressions}
\entry{POSIX awk, bracket expressions and}{51}{POSIX \command {awk}, bracket expressions and}
\entry{Extended Regular Expressions (EREs)}{51}{Extended Regular Expressions (EREs)}
\entry{EREs (Extended Regular Expressions)}{51}{EREs (Extended Regular Expressions)}
\entry{egrep utility}{51}{\command {egrep} utility}
\entry{bracket expressions, character classes}{51}{bracket expressions, character classes}
\entry{POSIX awk, bracket expressions and, character classes}{51}{POSIX \command {awk}, bracket expressions and, character classes}
\entry{bracket expressions, collating elements}{52}{bracket expressions, collating elements}
\entry{bracket expressions, nonASCII}{52}{bracket expressions, non-ASCII}
\entry{collating elements}{52}{collating elements}
\entry{bracket expressions, collating symbols}{52}{bracket expressions, collating symbols}
\entry{collating symbols}{52}{collating symbols}
\entry{bracket expressions, equivalence classes}{52}{bracket expressions, equivalence classes}
\entry{internationalization, localization, character classes}{52}{internationalization, localization, character classes}
\entry{gawk, character classes and}{52}{\command {gawk}, character classes and}
\entry{POSIX awk, bracket expressions and, character classes}{52}{POSIX \command {awk}, bracket expressions and, character classes}
\entry{regular expressions, leftmost longest match}{52}{regular expressions, leftmost longest match}
\entry{regular expressions, computed}{52}{regular expressions, computed}
\entry{regular expressions, dynamic}{52}{regular expressions, dynamic}
\entry{~ (tilde), ~ operator}{52}{\code {~} (tilde), \code {~} operator}
\entry{tilde (~), ~ operator}{52}{tilde (\code {~}), \code {~} operator}
\entry{! (exclamation point), !~ operator}{52}{\code {!} (exclamation point), \code {!~} operator}
\entry{exclamation point (!), !~ operator}{52}{exclamation point (\code {!}), \code {!~} operator}
\entry{regexp constants, slashes vs. quotes}{53}{regexp constants, slashes vs.\: quotes}
\entry{ (backslash), in regexp constants}{53}{\code {{\tt \backslashcurfont }} (backslash), in regexp constants}
\entry{backslash (), in regexp constants}{53}{backslash (\code {{\tt \backslashcurfont }}), in regexp constants}
\entry{" (double quote), in regexp constants}{53}{\code {"} (double quote), in regexp constants}
\entry{double quote ("), in regexp constants}{53}{double quote (\code {"}), in regexp constants}
\entry{troubleshooting, regexp constants vs. string constants}{53}{troubleshooting, regexp constants vs.\: string constants}
\entry{regexp constants, vs. string constants}{53}{regexp constants, vs.\: string constants}
\entry{string constants, vs. regexp constants}{53}{string constants, vs.\: regexp constants}
\entry{sidebar, Using n in Bracket Expressions of Dynamic Regexps}{54}{sidebar, Using \code {{\tt \backslashcurfont }n} in Bracket Expressions of Dynamic Regexps}
\entry{regular expressions, dynamic, with embedded newlines}{54}{regular expressions, dynamic, with embedded newlines}
\entry{newlines, in dynamic regexps}{54}{newlines, in dynamic regexps}
\entry{newlines, in regexp constants}{54}{newlines, in regexp constants}
\entry{regular expressions, operators, gawk}{54}{regular expressions, operators, \command {gawk}}
\entry{gawk, regular expressions, operators}{54}{\command {gawk}, regular expressions, operators}
\entry{operators, GNUspecific}{54}{operators, GNU-specific}
\entry{regular expressions, operators, for words}{54}{regular expressions, operators, for words}
\entry{word, regexp definition of}{54}{word, regexp definition of}
\entry{backslash (), s operator (gawk)}{54}{backslash (\code {{\tt \backslashcurfont }}), \code {{\tt \backslashcurfont }s} operator (\command {gawk})}
\entry{ (backslash), s operator (gawk)}{54}{\code {{\tt \backslashcurfont }} (backslash), \code {{\tt \backslashcurfont }s} operator (\command {gawk})}
\entry{backslash (), S operator (gawk)}{54}{backslash (\code {{\tt \backslashcurfont }}), \code {{\tt \backslashcurfont }S} operator (\command {gawk})}
\entry{ (backslash), S operator (gawk)}{54}{\code {{\tt \backslashcurfont }} (backslash), \code {{\tt \backslashcurfont }S} operator (\command {gawk})}
\entry{backslash (), w operator (gawk)}{54}{backslash (\code {{\tt \backslashcurfont }}), \code {{\tt \backslashcurfont }w} operator (\command {gawk})}
\entry{ (backslash), w operator (gawk)}{54}{\code {{\tt \backslashcurfont }} (backslash), \code {{\tt \backslashcurfont }w} operator (\command {gawk})}
\entry{backslash (), W operator (gawk)}{54}{backslash (\code {{\tt \backslashcurfont }}), \code {{\tt \backslashcurfont }W} operator (\command {gawk})}
\entry{ (backslash), W operator (gawk)}{54}{\code {{\tt \backslashcurfont }} (backslash), \code {{\tt \backslashcurfont }W} operator (\command {gawk})}
\entry{backslash (),  operator (gawk)}{54}{backslash (\code {{\tt \backslashcurfont }}), \code {{\tt \backslashcurfont }<} operator (\command {gawk})}
\entry{ (backslash),  operator (gawk)}{54}{\code {{\tt \backslashcurfont }} (backslash), \code {{\tt \backslashcurfont }<} operator (\command {gawk})}
\entry{backslash (), > operator (gawk)}{54}{backslash (\code {{\tt \backslashcurfont }}), \code {{\tt \backslashcurfont }>} operator (\command {gawk})}
\entry{ (backslash), > operator (gawk)}{54}{\code {{\tt \backslashcurfont }} (backslash), \code {{\tt \backslashcurfont }>} operator (\command {gawk})}
\entry{backslash (), y operator (gawk)}{54}{backslash (\code {{\tt \backslashcurfont }}), \code {{\tt \backslashcurfont }y} operator (\command {gawk})}
\entry{ (backslash), y operator (gawk)}{54}{\code {{\tt \backslashcurfont }} (backslash), \code {{\tt \backslashcurfont }y} operator (\command {gawk})}
\entry{word boundaries,{} matching}{54}{word boundaries\comma {} matching}
\entry{backslash (), B operator (gawk)}{54}{backslash (\code {{\tt \backslashcurfont }}), \code {{\tt \backslashcurfont }B} operator (\command {gawk})}
\entry{ (backslash), B operator (gawk)}{54}{\code {{\tt \backslashcurfont }} (backslash), \code {{\tt \backslashcurfont }B} operator (\command {gawk})}
\entry{buffers, operators for}{55}{buffers, operators for}
\entry{regular expressions, operators, for buffers}{55}{regular expressions, operators, for buffers}
\entry{operators, stringmatching, for buffers}{55}{operators, string-matching, for buffers}
\entry{backslash (), ` operator (gawk)}{55}{backslash (\code {{\tt \backslashcurfont }}), \code {{\tt \backslashcurfont }`} operator (\command {gawk})}
\entry{ (backslash), ` operator (gawk)}{55}{\code {{\tt \backslashcurfont }} (backslash), \code {{\tt \backslashcurfont }`} operator (\command {gawk})}
\entry{backslash (), ' operator (gawk)}{55}{backslash (\code {{\tt \backslashcurfont }}), \code {{\tt \backslashcurfont }'} operator (\command {gawk})}
\entry{ (backslash), ' operator (gawk)}{55}{\code {{\tt \backslashcurfont }} (backslash), \code {{\tt \backslashcurfont }'} operator (\command {gawk})}
\entry{^ (caret), regexp operator}{55}{\code {^} (caret), regexp operator}
\entry{caret (^), regexp operator}{55}{caret (\code {^}), regexp operator}
\entry{? (question mark), regexp operator}{55}{\code {?} (question mark), regexp operator}
\entry{question mark (?), regexp operator}{55}{question mark (\code {?}), regexp operator}
\entry{gawk, wordboundary operator}{55}{\command {gawk}, word-boundary operator}
\entry{wordboundary operator (gawk)}{55}{word-boundary operator (\command {gawk})}
\entry{operators, wordboundary (gawk)}{55}{operators, word-boundary (\command {gawk})}
\entry{regular expressions, gawk, commandline options}{55}{regular expressions, \command {gawk}, command-line options}
\entry{gawk, commandline options, and regular expressions}{55}{\command {gawk}, command-line options, and regular expressions}
\entry{Brian Kernighan's awk}{55}{Brian Kernighan's \command {awk}}
\entry{regular expressions, case sensitivity}{55}{regular expressions, case sensitivity}
\entry{case sensitivity, regexps and}{55}{case sensitivity, regexps and}
\entry{gawk, regular expressions, case sensitivity}{56}{\command {gawk}, regular expressions, case sensitivity}
\entry{case sensitivity, gawk}{56}{case sensitivity, \command {gawk}}
\entry{differences in awk and gawk, regular expressions}{56}{differences in \command {awk} and \command {gawk}, regular expressions}
\entry{~ (tilde), ~ operator}{56}{\code {~} (tilde), \code {~} operator}
\entry{tilde (~), ~ operator}{56}{tilde (\code {~}), \code {~} operator}
\entry{! (exclamation point), !~ operator}{56}{\code {!} (exclamation point), \code {!~} operator}
\entry{exclamation point (!), !~ operator}{56}{exclamation point (\code {!}), \code {!~} operator}
\entry{IGNORECASE variable, with ~ and !~ operators}{56}{\code {IGNORECASE} variable, with \code {~} and \code {!~} operators}
\entry{gawk, IGNORECASE variable in}{56}{\command {gawk}, \code {IGNORECASE} variable in}
\entry{reading input files}{59}{reading input files}
\entry{input files, reading}{59}{input files, reading}
\entry{input files}{59}{input files}
\entry{FILENAME variable}{59}{\code {FILENAME} variable}
\entry{records}{59}{records}
\entry{fields}{59}{fields}
\entry{getline command}{59}{\code {getline} command}
\entry{input, splitting into records}{59}{input, splitting into records}
\entry{records, splitting input into}{59}{records, splitting input into}
\entry{NR variable}{59}{\code {NR} variable}
\entry{FNR variable}{59}{\code {FNR} variable}
\entry{separators, for records}{59}{separators, for records}
\entry{record separators}{59}{record separators}
\entry{newlines, as record separators}{59}{newlines, as record separators}
\entry{RS variable}{59}{\code {RS} variable}
\entry{record separators, changing}{60}{record separators, changing}
\entry{separators, for records}{60}{separators, for records}
\entry{dark corner, input files}{61}{dark corner, input files}
\entry{empty strings}{61}{empty strings}
\entry{null strings}{61}{null strings}
\entry{strings, empty, See null strings}{61}{strings, empty, See null strings}
\entry{gawk, RT variable in}{61}{\command {gawk}, \code {RT} variable in}
\entry{RT variable}{61}{\code {RT} variable}
\entry{records, terminating}{61}{records, terminating}
\entry{terminating records}{61}{terminating records}
\entry{differences in awk and gawk, record separators}{61}{differences in \command {awk} and \command {gawk}, record separators}
\entry{regular expressions, as record separators}{61}{regular expressions, as record separators}
\entry{record separators, regular expressions as}{61}{record separators, regular expressions as}
\entry{separators, for records, regular expressions as}{61}{separators, for records, regular expressions as}
\entry{common extensions, RS as a regexp}{61}{common extensions, \code {RS} as a regexp}
\entry{extensions, common,{} RS as a regexp}{61}{extensions, common\comma {} \code {RS} as a regexp}
\entry{differences in awk and gawk, RS/RT variables}{62}{differences in \command {awk} and \command {gawk}, \code {RS}/\code {RT} variables}
\entry{sidebar, RS = "0" Is Not Portable}{62}{sidebar, \code {RS = "{\tt \backslashcurfont }0"} Is Not Portable}
\entry{portability, data files as single record}{63}{portability, data files as single record}
\entry{differences in awk and gawk, strings, storing}{63}{differences in \command {awk} and \command {gawk}, strings, storing}
\entry{dark corner, strings, storing}{63}{dark corner, strings, storing}
\entry{records, treating files as}{63}{records, treating files as}
\entry{treating files, as single records}{63}{treating files, as single records}
\entry{examining fields}{63}{examining fields}
\entry{fields}{63}{fields}
\entry{accessing fields}{63}{accessing fields}
\entry{fields, examining}{63}{fields, examining}
\entry{POSIX awk, field separators and}{63}{POSIX \command {awk}, field separators and}
\entry{field separators, POSIX and}{63}{field separators, POSIX and}
\entry{separators, field, POSIX and}{63}{separators, field, POSIX and}
\entry{field operator $}{63}{field operator \code {$}}
\entry{$ (dollar sign), $ field operator}{63}{\code {$} (dollar sign), \code {$} field operator}
\entry{dollar sign ($), $ field operator}{63}{dollar sign (\code {$}), \code {$} field operator}
\entry{field operators,{} dollar sign as}{63}{field operators\comma {} dollar sign as}
\entry{NF variable}{63}{\code {NF} variable}
\entry{fields, number of}{63}{fields, number of}
\entry{fields, numbers}{64}{fields, numbers}
\entry{field numbers}{64}{field numbers}
\entry{fields, changing contents of}{65}{fields, changing contents of}
\entry{adding, fields}{65}{adding, fields}
\entry{fields, adding}{65}{fields, adding}
\entry{OFS variable}{66}{\code {OFS} variable}
\entry{output field separator, See OFS variable}{66}{output field separator, See \code {OFS} variable}
\entry{field separators, See Also OFS}{66}{field separators, See Also \code {OFS}}
\entry{dark corner, NF variable, decrementing}{66}{dark corner, \code {NF} variable, decrementing}
\entry{NF variable, decrementing}{66}{\code {NF} variable, decrementing}
\entry{portability, NF variable,{} decrementing}{66}{portability, \code {NF} variable\comma {} decrementing}
\entry{sidebar, Understanding $0}{67}{sidebar, Understanding \code {$0}}
\entry{FS variable}{67}{\code {FS} variable}
\entry{fields, separating}{67}{fields, separating}
\entry{field separators}{67}{field separators}
\entry{fields, separating}{67}{fields, separating}
\entry{troubleshooting, awk uses FS not IFS}{67}{troubleshooting, \command {awk} uses \code {FS} not \code {IFS}}
\entry{FS variable, changing value of}{67}{\code {FS} variable, changing value of}
\entry{BEGIN pattern}{67}{\code {BEGIN} pattern}
\entry{field separators, choice of}{67}{field separators, choice of}
\entry{regular expressions as field separators}{67}{regular expressions as field separators}
\entry{field separators, regular expressions as}{67}{field separators, regular expressions as}
\entry{newlines, as field separators}{68}{newlines, as field separators}
\entry{whitespace, as field separators}{68}{whitespace, as field separators}
\entry{regular expressions, as field separators}{68}{regular expressions, as field separators}
\entry{field separators, regular expressions as}{68}{field separators, regular expressions as}
\entry{null strings}{68}{null strings}
\entry{strings, null}{68}{strings, null}
\entry{empty strings, See null strings}{68}{empty strings, See null strings}
\entry{FS, containing ^}{69}{\code {FS}, containing \code {^}}
\entry{^ (caret), in FS}{69}{\code {^} (caret), in \code {FS}}
\entry{dark corner, ^, in FS}{69}{dark corner, \code {^}, in \code {FS}}
\entry{Brian Kernighan's awk}{69}{Brian Kernighan's \command {awk}}
\entry{common extensions, single character fields}{69}{common extensions, single character fields}
\entry{extensions, common,{} single character fields}{69}{extensions, common\comma {} single character fields}
\entry{differences in awk and gawk, singlecharacter fields}{69}{differences in \command {awk} and \command {gawk}, single-character fields}
\entry{singlecharacter fields}{69}{single-character fields}
\entry{fields, singlecharacter}{69}{fields, single-character}
\entry{dark corner, FS as null string}{69}{dark corner, \code {FS} as null string}
\entry{FS variable, as null string}{69}{\code {FS} variable, as null string}
\entry{F option, commandline}{69}{\option {-F} option, command-line}
\entry{field separator, on command line}{69}{field separator, on command line}
\entry{command line, FS on,{} setting}{69}{command line, \code {FS} on\comma {} setting}
\entry{FS variable, setting from command line}{69}{\code {FS} variable, setting from command line}
\entry{ (backslash), as field separator}{70}{\code {{\tt \backslashcurfont }} (backslash), as field separator}
\entry{backslash (), as field separator}{70}{backslash (\code {{\tt \backslashcurfont }}), as field separator}
\entry{Unix awk, password files,{} field separators and}{70}{Unix \command {awk}, password files\comma {} field separators and}
\entry{Robbins, Arnold}{70}{Robbins, Arnold}
\entry{sidebar, Changing FS Does Not Affect the Fields}{71}{sidebar, Changing \code {FS} Does Not Affect the Fields}
\entry{POSIX awk, field separators and}{71}{POSIX \command {awk}, field separators and}
\entry{field separator, POSIX and}{71}{field separator, POSIX and}
\entry{dark corner, field separators}{71}{dark corner, field separators}
\entry{sed utility}{71}{\command {sed} utility}
\entry{stream editors}{71}{stream editors}
\entry{sidebar, FS and IGNORECASE}{72}{sidebar, \code {FS} and \code {IGNORECASE}}
\entry{data, fixedwidth}{72}{data, fixed-width}
\entry{fixedwidth data}{72}{fixed-width data}
\entry{advanced features, fixedwidth data}{72}{advanced features, fixed-width data}
\entry{troubleshooting, fatal errors, field widths,{} specifying}{72}{troubleshooting, fatal errors, field widths\comma {} specifying}
\entry{w utility}{72}{\command {w} utility}
\entry{FIELDWIDTHS variable}{72}{\code {FIELDWIDTHS} variable}
\entry{gawk, FIELDWIDTHS variable in}{72}{\command {gawk}, \code {FIELDWIDTHS} variable in}
\entry{gawk, splitting fields and}{73}{\command {gawk}, splitting fields and}
\entry{advanced features, specifying field content}{74}{advanced features, specifying field content}
\entry{gawk, FPAT variable in}{74}{\command {gawk}, \code {FPAT} variable in}
\entry{FPAT variable}{74}{\code {FPAT} variable}
\entry{multipleline records}{76}{multiple-line records}
\entry{records, multiline}{76}{records, multiline}
\entry{input, multiline records}{76}{input, multiline records}
\entry{files, reading, multiline records}{76}{files, reading, multiline records}
\entry{input, files, See input files}{76}{input, files, See input files}
\entry{record separators, with multiline records}{76}{record separators, with multiline records}
\entry{RS variable, multiline records and}{76}{\code {RS} variable, multiline records and}
\entry{leftmost longest match}{76}{leftmost longest match}
\entry{matching, leftmost longest}{76}{matching, leftmost longest}
\entry{dark corner, multiline records}{76}{dark corner, multiline records}
\entry{field separator, in multiline records}{76}{field separator, in multiline records}
\entry{FS, in multiline records}{76}{\code {FS}, in multiline records}
\entry{gawk, RT variable in}{78}{\command {gawk}, \code {RT} variable in}
\entry{RT variable}{78}{\code {RT} variable}
\entry{getline command, explicit input with}{78}{\code {getline} command, explicit input with}
\entry{input, explicit}{78}{input, explicit}
\entry{gawk, ERRNO variable in}{78}{\command {gawk}, \code {ERRNO} variable in}
\entry{ERRNO variable, with getline command}{78}{\code {ERRNO} variable, with \command {getline} command}
\entry{differences in awk and gawk, getline command}{78}{differences in \command {awk} and \command {gawk}, \code {getline} command}
\entry{getline command, return values}{78}{\code {getline} command, return values}
\entry{sandbox option, input redirection with getline}{78}{\option {--sandbox} option, input redirection with \code {getline}}
\entry{getline into a variable}{79}{\code {getline} into a variable}
\entry{variables, getline command into,{} using}{79}{variables, \code {getline} command into\comma {} using}
\entry{getline from a file}{80}{\code {getline} from a file}
\entry{input redirection}{80}{input redirection}
\entry{redirection of input}{80}{redirection of input}
\entry{ (left angle bracket),  operator (I/O)}{80}{\code {<} (left angle bracket), \code {<} operator (I/O)}
\entry{left angle bracket (),  operator (I/O)}{80}{left angle bracket (\code {<}), \code {<} operator (I/O)}
\entry{operators, input/output}{80}{operators, input/output}
\entry{POSIX awk,  operator and}{80}{POSIX \command {awk}, \code {<} operator and}
\entry{variables, getline command into,{} using}{80}{variables, \code {getline} command into\comma {} using}
\entry{Kernighan, Brian}{81}{Kernighan, Brian}
\entry{| (vertical bar), | operator (I/O)}{81}{\code {|} (vertical bar), \code {|} operator (I/O)}
\entry{vertical bar (|), | operator (I/O)}{81}{vertical bar (\code {|}), \code {|} operator (I/O)}
\entry{input pipeline}{81}{input pipeline}
\entry{pipe, input}{81}{pipe, input}
\entry{operators, input/output}{81}{operators, input/output}
\entry{Robbins, Bill}{82}{Robbins, Bill}
\entry{Robbins, Miriam}{82}{Robbins, Miriam}
\entry{Robbins, Arnold}{82}{Robbins, Arnold}
\entry{POSIX awk, | I/O operator and}{82}{POSIX \command {awk}, \code {|} I/O operator and}
\entry{Brian Kernighan's awk}{82}{Brian Kernighan's \command {awk}}
\entry{mawk utility}{82}{\command {mawk} utility}
\entry{variables, getline command into,{} using}{82}{variables, \code {getline} command into\comma {} using}
\entry{coprocesses, getline from}{82}{coprocesses, \code {getline} from}
\entry{getline command, coprocesses,{} using from}{82}{\code {getline} command, coprocesses\comma {} using from}
\entry{| (vertical bar), |& operator (I/O)}{82}{\code {|} (vertical bar), \code {|&} operator (I/O)}
\entry{vertical bar (|), |& operator (I/O)}{82}{vertical bar (\code {|}), \code {|&} operator (I/O)}
\entry{operators, input/output}{82}{operators, input/output}
\entry{differences in awk and gawk, input/output operators}{82}{differences in \command {awk} and \command {gawk}, input/output operators}
\entry{variables, getline command into,{} using}{83}{variables, \code {getline} command into\comma {} using}
\entry{differences in awk and gawk, implementation limitations}{83}{differences in \command {awk} and \command {gawk}, implementation limitations}
\entry{implementation issues, gawk, limits}{83}{implementation issues, \command {gawk}, limits}
\entry{awk, implementations, limits}{83}{\command {awk}, implementations, limits}
\entry{gawk, implementation issues, limits}{83}{\command {gawk}, implementation issues, limits}
\entry{side effects, FILENAME variable}{83}{side effects, \code {FILENAME} variable}
\entry{FILENAME variable, getline,{} setting with}{83}{\code {FILENAME} variable, \code {getline}\comma {} setting with}
\entry{dark corner, FILENAME variable}{83}{dark corner, \code {FILENAME} variable}
\entry{getline command, FILENAME variable and}{83}{\code {getline} command, \code {FILENAME} variable and}
\entry{BEGIN pattern, getline and}{83}{\code {BEGIN} pattern, \code {getline} and}
\entry{Moore, Duncan}{83}{Moore, Duncan}
\entry{getline command, variants}{84}{\code {getline} command, variants}
\entry{timeout, reading input}{84}{timeout, reading input}
\entry{differences in awk and gawk, read timeouts}{84}{differences in \command {awk} and \command {gawk}, read timeouts}
\entry{differences in awk and gawk, commandline directories}{86}{differences in \command {awk} and \command {gawk}, command-line directories}
\entry{directories, commandline}{86}{directories, command-line}
\entry{command line, directories on}{86}{command line, directories on}
\entry{printing}{89}{printing}
\entry{output, printing, See printing}{89}{output, printing, See printing}
\entry{print statement}{89}{\code {print} statement}
\entry{printf statement}{89}{\code {printf} statement}
\entry{records, printing}{89}{records, printing}
\entry{lines, blank, printing}{89}{lines, blank, printing}
\entry{text, printing}{89}{text, printing}
\entry{newlines, printing}{89}{newlines, printing}
\entry{fields, printing}{89}{fields, printing}
\entry{print statement, commas, omitting}{90}{\code {print} statement, commas, omitting}
\entry{troubleshooting, print statement,{} omitting commas}{90}{troubleshooting, \code {print} statement\comma {} omitting commas}
\entry{BEGIN pattern, headings,{} adding}{90}{\code {BEGIN} pattern, headings\comma {} adding}
\entry{printf statement, columns,{} aligning}{90}{\code {printf} statement, columns\comma {} aligning}
\entry{columns, aligning}{90}{columns, aligning}
\entry{line continuations, in print statement}{90}{line continuations, in \code {print} statement}
\entry{print statement, line continuations and}{90}{\code {print} statement, line continuations and}
\entry{OFS variable}{91}{\code {OFS} variable}
\entry{output, records}{91}{output, records}
\entry{output record separator, See ORS variable}{91}{output record separator, See \code {ORS} variable}
\entry{ORS variable}{91}{\code {ORS} variable}
\entry{BEGIN pattern, OFS/ORS variables, assigning values to}{91}{\code {BEGIN} pattern, \code {OFS}/\code {ORS} variables, assigning values to}
\entry{numeric, output format}{92}{numeric, output format}
\entry{formats,{} numeric output}{92}{formats\comma {} numeric output}
\entry{sprintf() function}{92}{\code {sprintf()} function}
\entry{OFMT variable}{92}{\code {OFMT} variable}
\entry{output, format specifier,{} OFMT}{92}{output, format specifier\comma {} \code {OFMT}}
\entry{dark corner, OFMT variable}{92}{dark corner, \code {OFMT} variable}
\entry{POSIX awk, OFMT variable and}{92}{POSIX \command {awk}, \code {OFMT} variable and}
\entry{OFMT variable, POSIX awk and}{92}{\code {OFMT} variable, POSIX \command {awk} and}
\entry{printf statement}{92}{\code {printf} statement}
\entry{output, formatted}{92}{output, formatted}
\entry{formatting output}{92}{formatting output}
\entry{printf statement, syntax of}{92}{\code {printf} statement, syntax of}
\entry{format specifiers}{92}{format specifiers}
\entry{printf statement, formatcontrol characters}{93}{\code {printf} statement, format-control characters}
\entry{format specifiers, printf statement}{93}{format specifiers, \code {printf} statement}
\entry{dark corner, formatcontrol characters}{93}{dark corner, format-control characters}
\entry{gawk, formatcontrol characters}{93}{\command {gawk}, format-control characters}
\entry{dark corner, formatcontrol characters}{94}{dark corner, format-control characters}
\entry{gawk, formatcontrol characters}{94}{\command {gawk}, format-control characters}
\entry{printf statement, modifiers}{94}{\code {printf} statement, modifiers}
\entry{modifiers,{} in format specifiers}{94}{modifiers\comma {} in format specifiers}
\entry{differences in awk and gawk, print/printf statements}{94}{differences in \command {awk} and \command {gawk}, \code {print}/\code {printf} statements}
\entry{printf statement, positional specifiers}{94}{\code {printf} statement, positional specifiers}
\entry{positional specifiers, printf statement}{94}{positional specifiers, \code {printf} statement}
\entry{troubleshooting, fatal errors, printf format strings}{96}{troubleshooting, fatal errors, \code {printf} format strings}
\entry{POSIX awk, printf format strings and}{96}{POSIX \command {awk}, \code {printf} format strings and}
\entry{output redirection}{97}{output redirection}
\entry{redirection of output}{97}{redirection of output}
\entry{sandbox option, output redirection with print, printf}{97}{\option {--sandbox} option, output redirection with \code {print}, \code {printf}}
\entry{print statement, See Also redirection,{} of output}{98}{\code {print} statement, See Also redirection\comma {} of output}
\entry{printf statement, See Also redirection,{} of output}{98}{\code {printf} statement, See Also redirection\comma {} of output}
\entry{> (right angle bracket), > operator (I/O)}{98}{\code {>} (right angle bracket), \code {>} operator (I/O)}
\entry{right angle bracket (>), > operator (I/O)}{98}{right angle bracket (\code {>}), \code {>} operator (I/O)}
\entry{operators, input/output}{98}{operators, input/output}
\entry{> (right angle bracket), >> operator (I/O)}{98}{\code {>} (right angle bracket), \code {>>} operator (I/O)}
\entry{right angle bracket (>), >> operator (I/O)}{98}{right angle bracket (\code {>}), \code {>>} operator (I/O)}
\entry{| (vertical bar), | operator (I/O)}{98}{\code {|} (vertical bar), \code {|} operator (I/O)}
\entry{pipe, output}{98}{pipe, output}
\entry{output, pipes}{98}{output, pipes}
\entry{coprocesses}{99}{coprocesses}
\entry{| (vertical bar), |& operator (I/O)}{99}{\code {|} (vertical bar), \code {|&} operator (I/O)}
\entry{operators, input/output}{99}{operators, input/output}
\entry{differences in awk and gawk, input/output operators}{99}{differences in \command {awk} and \command {gawk}, input/output operators}
\entry{troubleshooting, printing}{99}{troubleshooting, printing}
\entry{differences in awk and gawk, implementation limitations}{99}{differences in \command {awk} and \command {gawk}, implementation limitations}
\entry{implementation issues, gawk, limits}{99}{implementation issues, \command {gawk}, limits}
\entry{awk, implementation issues, pipes}{99}{\command {awk}, implementation issues, pipes}
\entry{gawk, implementation issues, pipes}{99}{\command {gawk}, implementation issues, pipes}
\entry{sidebar, Piping into sh}{100}{sidebar, Piping into \command {sh}}
\entry{shells, piping commands into}{100}{shells, piping commands into}
\entry{standard input}{100}{standard input}
\entry{input, standard}{100}{input, standard}
\entry{standard output}{100}{standard output}
\entry{output, standard}{100}{output, standard}
\entry{error output}{100}{error output}
\entry{standard error}{100}{standard error}
\entry{file descriptors}{100}{file descriptors}
\entry{files, descriptors, See file descriptors}{100}{files, descriptors, See file descriptors}
\entry{differences in awk and gawk, error messages}{100}{differences in \command {awk} and \command {gawk}, error messages}
\entry{error handling}{100}{error handling}
\entry{common extensions, /dev/stdin special file}{101}{common extensions, \code {/dev/stdin} special file}
\entry{common extensions, /dev/stdout special file}{101}{common extensions, \code {/dev/stdout} special file}
\entry{common extensions, /dev/stderr special file}{101}{common extensions, \code {/dev/stderr} special file}
\entry{extensions, common,{} /dev/stdin special file}{101}{extensions, common\comma {} \code {/dev/stdin} special file}
\entry{extensions, common,{} /dev/stdout special file}{101}{extensions, common\comma {} \code {/dev/stdout} special file}
\entry{extensions, common,{} /dev/stderr special file}{101}{extensions, common\comma {} \code {/dev/stderr} special file}
\entry{file names, standard streams in gawk}{101}{file names, standard streams in \command {gawk}}
\entry{/dev/...{} special files}{101}{\code {/dev/\dots {}} special files}
\entry{files, /dev/...{} special files}{101}{files, \code {/dev/\dots {}} special files}
\entry{/dev/fd/N special files (gawk)}{101}{\code {/dev/fd/\var {N}} special files (\command {gawk})}
\entry{troubleshooting, quotes with file names}{101}{troubleshooting, quotes with file names}
\entry{gawk, file names in}{101}{\command {gawk}, file names in}
\entry{networks, support for}{101}{networks, support for}
\entry{TCP/IP, support for}{101}{TCP/IP, support for}
\entry{compatibility mode (gawk), file names}{102}{compatibility mode (\command {gawk}), file names}
\entry{file names, in compatibility mode}{102}{file names, in compatibility mode}
\entry{files, output, See output files}{102}{files, output, See output files}
\entry{input files, closing}{102}{input files, closing}
\entry{output, files,{} closing}{102}{output, files\comma {} closing}
\entry{pipe, closing}{102}{pipe, closing}
\entry{coprocesses, closing}{102}{coprocesses, closing}
\entry{getline command, coprocesses,{} using from}{102}{\code {getline} command, coprocesses\comma {} using from}
\entry{close() function}{102}{\code {close()} function}
\entry{differences in awk and gawk, close() function}{103}{differences in \command {awk} and \command {gawk}, \code {close()} function}
\entry{portability, close() function and}{103}{portability, \code {close()} function and}
\entry{close() function, portability}{103}{\code {close()} function, portability}
\entry{| (vertical bar), |& operator (I/O), pipes,{} closing}{104}{\code {|} (vertical bar), \code {|&} operator (I/O), pipes\comma {} closing}
\entry{sidebar, Using close()'s Return Value}{104}{sidebar, Using \code {close()}'s Return Value}
\entry{dark corner, close() function}{104}{dark corner, \code {close()} function}
\entry{close() function, return value}{104}{\code {close()} function, return value}
\entry{return value,{} close() function}{104}{return value\comma {} \code {close()} function}
\entry{differences in awk and gawk, close() function}{104}{differences in \command {awk} and \command {gawk}, \code {close()} function}
\entry{Unix awk, close() function and}{104}{Unix \command {awk}, \code {close()} function and}
\entry{gawk, ERRNO variable in}{104}{\command {gawk}, \code {ERRNO} variable in}
\entry{ERRNO variable, with close() function}{104}{\code {ERRNO} variable, with \command {close()} function}
\entry{expressions}{107}{expressions}
\entry{constants, types of}{107}{constants, types of}
\entry{constants, numeric}{107}{constants, numeric}
\entry{numeric constants}{107}{numeric constants}
\entry{string constants}{107}{string constants}
\entry{differences in awk and gawk, strings}{107}{differences in \command {awk} and \command {gawk}, strings}
\entry{strings, length limitations}{107}{strings, length limitations}
\entry{octal numbers}{107}{octal numbers}
\entry{hexadecimal numbers}{107}{hexadecimal numbers}
\entry{numbers, octal}{107}{numbers, octal}
\entry{numbers, hexadecimal}{107}{numbers, hexadecimal}
\entry{gawk, octal numbers and}{108}{\command {gawk}, octal numbers and}
\entry{gawk, hexadecimal numbers and}{108}{\command {gawk}, hexadecimal numbers and}
\entry{compatibility mode (gawk), octal numbers}{108}{compatibility mode (\command {gawk}), octal numbers}
\entry{compatibility mode (gawk), hexadecimal numbers}{108}{compatibility mode (\command {gawk}), hexadecimal numbers}
\entry{sidebar, A Constant's Base Does Not Affect Its Value}{108}{sidebar, A Constant's Base Does Not Affect Its Value}
\entry{regexp constants}{108}{regexp constants}
\entry{~ (tilde), ~ operator}{108}{\code {~} (tilde), \code {~} operator}
\entry{tilde (~), ~ operator}{108}{tilde (\code {~}), \code {~} operator}
\entry{! (exclamation point), !~ operator}{108}{\code {!} (exclamation point), \code {!~} operator}
\entry{exclamation point (!), !~ operator}{108}{exclamation point (\code {!}), \code {!~} operator}
\entry{dark corner, regexp constants}{109}{dark corner, regexp constants}
\entry{gawk, regexp constants and}{109}{\command {gawk}, regexp constants and}
\entry{regexp constants, in gawk}{109}{regexp constants, in \command {gawk}}
\entry{differences in awk and gawk, regexp constants}{109}{differences in \command {awk} and \command {gawk}, regexp constants}
\entry{dark corner, regexp constants, as arguments to userdefined functions}{109}{dark corner, regexp constants, as arguments to user-defined functions}
\entry{gensub() function (gawk)}{109}{\code {gensub()} function (\command {gawk})}
\entry{sub() function}{109}{\code {sub()} function}
\entry{gsub() function}{109}{\code {gsub()} function}
\entry{variables, userdefined}{110}{variables, user-defined}
\entry{userdefined, variables}{110}{user-defined, variables}
\entry{variables, builtin}{110}{variables, built-in}
\entry{variables, initializing}{110}{variables, initializing}
\entry{variables, assigning on command line}{111}{variables, assigning on command line}
\entry{command line, variables,{} assigning on}{111}{command line, variables\comma {} assigning on}
\entry{v option}{111}{\option {-v} option}
\entry{dark corner, commandline arguments}{111}{dark corner, command-line arguments}
\entry{converting, strings to numbers}{111}{converting, strings to numbers}
\entry{strings, converting}{111}{strings, converting}
\entry{numbers, converting}{111}{numbers, converting}
\entry{converting, numbers to strings}{111}{converting, numbers to strings}
\entry{null strings, converting numbers to strings}{112}{null strings, converting numbers to strings}
\entry{type conversion}{112}{type conversion}
\entry{CONVFMT variable}{112}{\code {CONVFMT} variable}
\entry{dark corner, CONVFMT variable}{112}{dark corner, \code {CONVFMT} variable}
\entry{sidebar, PrePOSIX awk Used OFMT for String Conversion}{112}{sidebar, Pre-POSIX \command {awk} Used \code {OFMT} for String Conversion}
\entry{POSIX awk, OFMT variable and}{112}{POSIX \command {awk}, \code {OFMT} variable and}
\entry{OFMT variable}{112}{\code {OFMT} variable}
\entry{portability, new awk vs. old awk}{112}{portability, new \command {awk} vs.\: old \command {awk}}
\entry{awk, new vs. old, OFMT variable}{112}{\command {awk}, new vs.\: old, \code {OFMT} variable}
\entry{dark corner, locale's decimal point character}{112}{dark corner, locale's decimal point character}
\entry{arithmetic operators}{114}{arithmetic operators}
\entry{operators, arithmetic}{114}{operators, arithmetic}
\entry{common extensions, ** operator}{114}{common extensions, \code {**} operator}
\entry{extensions, common,{} ** operator}{114}{extensions, common\comma {} \code {**} operator}
\entry{POSIX awk, arithmetic operators and}{114}{POSIX \command {awk}, arithmetic operators and}
\entry{troubleshooting, division}{114}{troubleshooting, division}
\entry{division}{114}{division}
\entry{differences in awk and gawk, truncmod operation}{114}{differences in \command {awk} and \command {gawk}, trunc-mod operation}
\entry{truncmod operation}{114}{trunc-mod operation}
\entry{portability, ** operator and}{115}{portability, \code {**} operator and}
\entry{* (asterisk), ** operator}{115}{\code {*} (asterisk), \code {**} operator}
\entry{asterisk (*), ** operator}{115}{asterisk (\code {*}), \code {**} operator}
\entry{Kernighan, Brian}{115}{Kernighan, Brian}
\entry{string operators}{115}{string operators}
\entry{operators, string}{115}{operators, string}
\entry{concatenating}{115}{concatenating}
\entry{troubleshooting, string concatenation}{115}{troubleshooting, string concatenation}
\entry{Brian Kernighan's awk}{115}{Brian Kernighan's \command {awk}}
\entry{mawk utility}{115}{\command {mawk} utility}
\entry{order of evaluation, concatenation}{115}{order of evaluation, concatenation}
\entry{evaluation order, concatenation}{115}{evaluation order, concatenation}
\entry{side effects}{115}{side effects}
\entry{assignment operators}{116}{assignment operators}
\entry{operators, assignment}{116}{operators, assignment}
\entry{expressions, assignment}{116}{expressions, assignment}
\entry{= (equals sign), = operator}{116}{\code {=} (equals sign), \code {=} operator}
\entry{equals sign (=), = operator}{116}{equals sign (\code {=}), \code {=} operator}
\entry{side effects, assignment expressions}{116}{side effects, assignment expressions}
\entry{lvalues/rvalues}{116}{lvalues/rvalues}
\entry{rvalues/lvalues}{116}{rvalues/lvalues}
\entry{assignment operators, lvalues/rvalues}{116}{assignment operators, lvalues/rvalues}
\entry{operators, assignment}{116}{operators, assignment}
\entry{variables, types of}{116}{variables, types of}
\entry{+ (plus sign), += operator}{117}{\code {+} (plus sign), \code {+=} operator}
\entry{plus sign (+), += operator}{117}{plus sign (\code {+}), \code {+=} operator}
\entry{Rankin, Pat}{117}{Rankin, Pat}
\entry{operators, assignment, evaluation order}{118}{operators, assignment, evaluation order}
\entry{assignment operators, evaluation order}{118}{assignment operators, evaluation order}
\entry{ (hyphen), = operator}{118}{\code {-} (hyphen), \code {-=} operator}
\entry{hyphen (), = operator}{118}{hyphen (\code {-}), \code {-=} operator}
\entry{* (asterisk), *= operator}{118}{\code {*} (asterisk), \code {*=} operator}
\entry{asterisk (*), *= operator}{118}{asterisk (\code {*}), \code {*=} operator}
\entry{/ (forward slash), /= operator}{118}{\code {/} (forward slash), \code {/=} operator}
\entry{forward slash (/), /= operator}{118}{forward slash (\code {/}), \code {/=} operator}
\entry{% (percent sign), %= operator}{118}{\code {%} (percent sign), \code {%=} operator}
\entry{percent sign (%), %= operator}{118}{percent sign (\code {%}), \code {%=} operator}
\entry{^ (caret), ^= operator}{118}{\code {^} (caret), \code {^=} operator}
\entry{caret (^), ^= operator}{118}{caret (\code {^}), \code {^=} operator}
\entry{* (asterisk), **= operator}{118}{\code {*} (asterisk), \code {**=} operator}
\entry{asterisk (*), **= operator}{118}{asterisk (\code {*}), \code {**=} operator}
\entry{common extensions, **= operator}{118}{common extensions, \code {**=} operator}
\entry{extensions, common,{} **= operator}{118}{extensions, common\comma {} \code {**=} operator}
\entry{awk language, POSIX version}{118}{\command {awk} language, POSIX version}
\entry{POSIX awk}{118}{POSIX \command {awk}}
\entry{POSIX awk, **= operator and}{118}{POSIX \command {awk}, \code {**=} operator and}
\entry{portability, **= operator and}{118}{portability, \code {**=} operator and}
\entry{sidebar, Syntactic Ambiguities Between /= and Regular Expressions}{118}{sidebar, Syntactic Ambiguities Between \samp {/=} and Regular Expressions}
\entry{dark corner, regexp constants, /= operator and}{118}{dark corner, regexp constants, \code {/=} operator and}
\entry{/ (forward slash), /= operator, vs. /=...{}/ regexp constant}{118}{\code {/} (forward slash), \code {/=} operator, vs. \code {/=\dots {}/} regexp constant}
\entry{forward slash (/), /= operator, vs. /=...{}/ regexp constant}{118}{forward slash (\code {/}), \code {/=} operator, vs. \code {/=\dots {}/} regexp constant}
\entry{regexp constants, /=...{}/, /= operator and}{118}{regexp constants, \code {/=\dots {}/}, \code {/=} operator and}
\entry{dark corner, /= operator vs. /=...{}/ regexp constant}{118}{dark corner, \code {/=} operator vs. \code {/=\dots {}/} regexp constant}
\entry{ambiguity, syntactic: /= operator vs. /=...{}/ regexp constant}{118}{ambiguity, syntactic: \code {/=} operator vs. \code {/=\dots {}/} regexp constant}
\entry{syntactic ambiguity: /= operator vs. /=...{}/ regexp constant}{118}{syntactic ambiguity: \code {/=} operator vs. \code {/=\dots {}/} regexp constant}
\entry{/= operator vs. /=...{}/ regexp constant}{118}{\code {/=} operator vs. \code {/=\dots {}/} regexp constant}
\entry{increment operators}{119}{increment operators}
\entry{operators, decrement/increment}{119}{operators, decrement/increment}
\entry{side effects}{119}{side effects}
\entry{+ (plus sign), ++ operator}{119}{\code {+} (plus sign), \code {++} operator}
\entry{plus sign (+), ++ operator}{119}{plus sign (\code {+}), \code {++} operator}
\entry{side effects, decrement/increment operators}{119}{side effects, decrement/increment operators}
\entry{$ (dollar sign), incrementing fields and arrays}{119}{\code {$} (dollar sign), incrementing fields and arrays}
\entry{dollar sign ($), incrementing fields and arrays}{119}{dollar sign (\code {$}), incrementing fields and arrays}
\entry{decrement operators}{119}{decrement operators}
\entry{+ (plus sign), ++ operator}{119}{\code {+} (plus sign), \code {++} operator}
\entry{plus sign (+), ++ operator}{119}{plus sign (\code {+}), \code {++} operator}
\entry{ (hyphen),  operator}{119}{\code {-} (hyphen), \code {--} operator}
\entry{hyphen (),  operator}{119}{hyphen (\code {-}), \code {--} operator}
\entry{sidebar, Operator Evaluation Order}{120}{sidebar, Operator Evaluation Order}
\entry{precedence}{120}{precedence}
\entry{operators, precedence}{120}{operators, precedence}
\entry{portability, operators}{120}{portability, operators}
\entry{evaluation order}{120}{evaluation order}
\entry{Marx, Groucho}{120}{Marx, Groucho}
\entry{side effects}{120}{side effects}
\entry{truth values}{120}{truth values}
\entry{logical false/true}{120}{logical false/true}
\entry{false, logical}{120}{false, logical}
\entry{true, logical}{120}{true, logical}
\entry{null strings}{120}{null strings}
\entry{dark corner, "0" is actually true}{120}{dark corner, \code {"0"} is actually true}
\entry{comparison expressions}{120}{comparison expressions}
\entry{expressions, comparison}{120}{expressions, comparison}
\entry{expressions, matching, See comparison expressions}{120}{expressions, matching, See comparison expressions}
\entry{matching, expressions, See comparison expressions}{120}{matching, expressions, See comparison expressions}
\entry{relational operators, See comparison operators}{120}{relational operators, See comparison operators}
\entry{operators, relational, See operators,{} comparison}{120}{operators, relational, See operators\comma {} comparison}
\entry{variable typing}{120}{variable typing}
\entry{variables, types of, comparison expressions and}{120}{variables, types of, comparison expressions and}
\entry{numeric, strings}{121}{numeric, strings}
\entry{strings, numeric}{121}{strings, numeric}
\entry{POSIX awk, numeric strings and}{121}{POSIX \command {awk}, numeric strings and}
\entry{ (left angle bracket),  operator}{122}{\code {<} (left angle bracket), \code {<} operator}
\entry{left angle bracket (),  operator}{122}{left angle bracket (\code {<}), \code {<} operator}
\entry{ (left angle bracket), = operator}{122}{\code {<} (left angle bracket), \code {<=} operator}
\entry{left angle bracket (), = operator}{122}{left angle bracket (\code {<}), \code {<=} operator}
\entry{> (right angle bracket), >= operator}{122}{\code {>} (right angle bracket), \code {>=} operator}
\entry{right angle bracket (>), >= operator}{122}{right angle bracket (\code {>}), \code {>=} operator}
\entry{> (right angle bracket), > operator}{122}{\code {>} (right angle bracket), \code {>} operator}
\entry{right angle bracket (>), > operator}{122}{right angle bracket (\code {>}), \code {>} operator}
\entry{= (equals sign), == operator}{122}{\code {=} (equals sign), \code {==} operator}
\entry{equals sign (=), == operator}{122}{equals sign (\code {=}), \code {==} operator}
\entry{! (exclamation point), != operator}{122}{\code {!} (exclamation point), \code {!=} operator}
\entry{exclamation point (!), != operator}{122}{exclamation point (\code {!}), \code {!=} operator}
\entry{~ (tilde), ~ operator}{122}{\code {~} (tilde), \code {~} operator}
\entry{tilde (~), ~ operator}{122}{tilde (\code {~}), \code {~} operator}
\entry{! (exclamation point), !~ operator}{122}{\code {!} (exclamation point), \code {!~} operator}
\entry{exclamation point (!), !~ operator}{122}{exclamation point (\code {!}), \code {!~} operator}
\entry{in operator}{122}{\code {in} operator}
\entry{troubleshooting, == operator}{122}{troubleshooting, \code {==} operator}
\entry{comparison expressions, string vs. regexp}{123}{comparison expressions, string vs.\: regexp}
\entry{~ (tilde), ~ operator}{123}{\code {~} (tilde), \code {~} operator}
\entry{tilde (~), ~ operator}{123}{tilde (\code {~}), \code {~} operator}
\entry{! (exclamation point), !~ operator}{123}{\code {!} (exclamation point), \code {!~} operator}
\entry{exclamation point (!), !~ operator}{123}{exclamation point (\code {!}), \code {!~} operator}
\entry{awk, regexp constants and}{123}{\command {awk}, regexp constants and}
\entry{regexp constants}{123}{regexp constants}
\entry{and Booleanlogic operator}{124}{and Boolean-logic operator}
\entry{or Booleanlogic operator}{124}{or Boolean-logic operator}
\entry{not Booleanlogic operator}{124}{not Boolean-logic operator}
\entry{expressions, Boolean}{124}{expressions, Boolean}
\entry{Boolean expressions}{124}{Boolean expressions}
\entry{operators, Boolean, See Boolean expressions}{124}{operators, Boolean, See Boolean expressions}
\entry{Boolean operators, See Boolean expressions}{124}{Boolean operators, See Boolean expressions}
\entry{logical operators, See Boolean expressions}{124}{logical operators, See Boolean expressions}
\entry{operators, logical, See Boolean expressions}{124}{operators, logical, See Boolean expressions}
\entry{side effects, Boolean operators}{124}{side effects, Boolean operators}
\entry{shortcircuit operators}{125}{short-circuit operators}
\entry{operators, shortcircuit}{125}{operators, short-circuit}
\entry{& (ampersand), && operator}{125}{\code {&} (ampersand), \code {&&} operator}
\entry{ampersand (&), && operator}{125}{ampersand (\code {&}), \code {&&} operator}
\entry{| (vertical bar), || operator}{125}{\code {|} (vertical bar), \code {||} operator}
\entry{vertical bar (|), || operator}{125}{vertical bar (\code {|}), \code {||} operator}
\entry{line continuations}{125}{line continuations}
\entry{! (exclamation point), ! operator}{125}{\code {!} (exclamation point), \code {!} operator}
\entry{exclamation point (!), ! operator}{125}{exclamation point (\code {!}), \code {!} operator}
\entry{newlines}{125}{newlines}
\entry{variables, flag}{125}{variables, flag}
\entry{flag variables}{125}{flag variables}
\entry{next statement}{125}{\code {next} statement}
\entry{conditional expressions}{125}{conditional expressions}
\entry{expressions, conditional}{125}{expressions, conditional}
\entry{expressions, selecting}{125}{expressions, selecting}
\entry{side effects, conditional expressions}{126}{side effects, conditional expressions}
\entry{differences in awk and gawk, line continuations}{126}{differences in \command {awk} and \command {gawk}, line continuations}
\entry{line continuations, gawk}{126}{line continuations, \command {gawk}}
\entry{gawk, line continuation in}{126}{\command {gawk}, line continuation in}
\entry{function calls}{126}{function calls}
\entry{functions, builtin}{126}{functions, built-in}
\entry{arguments, in function calls}{126}{arguments, in function calls}
\entry{troubleshooting, function call syntax}{126}{troubleshooting, function call syntax}
\entry{side effects, function calls}{127}{side effects, function calls}
\entry{precedence}{128}{precedence}
\entry{operators, precedence}{128}{operators, precedence}
\entry{$ (dollar sign), $ field operator}{128}{\code {$} (dollar sign), \code {$} field operator}
\entry{dollar sign ($), $ field operator}{128}{dollar sign (\code {$}), \code {$} field operator}
\entry{+ (plus sign), ++ operator}{128}{\code {+} (plus sign), \code {++} operator}
\entry{plus sign (+), ++ operator}{128}{plus sign (\code {+}), \code {++} operator}
\entry{ (hyphen),  operator}{128}{\code {-} (hyphen), \code {--} operator}
\entry{hyphen (),  operator}{128}{hyphen (\code {-}), \code {--} operator}
\entry{^ (caret), ^ operator}{128}{\code {^} (caret), \code {^} operator}
\entry{caret (^), ^ operator}{128}{caret (\code {^}), \code {^} operator}
\entry{* (asterisk), ** operator}{128}{\code {*} (asterisk), \code {**} operator}
\entry{asterisk (*), ** operator}{128}{asterisk (\code {*}), \code {**} operator}
\entry{+ (plus sign), + operator}{128}{\code {+} (plus sign), \code {+} operator}
\entry{plus sign (+), + operator}{128}{plus sign (\code {+}), \code {+} operator}
\entry{ (hyphen),  operator}{128}{\code {-} (hyphen), \code {-} operator}
\entry{hyphen (),  operator}{128}{hyphen (\code {-}), \code {-} operator}
\entry{! (exclamation point), ! operator}{128}{\code {!} (exclamation point), \code {!} operator}
\entry{exclamation point (!), ! operator}{128}{exclamation point (\code {!}), \code {!} operator}
\entry{* (asterisk), * operator, as multiplication operator}{128}{\code {*} (asterisk), \code {*} operator, as multiplication operator}
\entry{asterisk (*), * operator, as multiplication operator}{128}{asterisk (\code {*}), \code {*} operator, as multiplication operator}
\entry{/ (forward slash), / operator}{128}{\code {/} (forward slash), \code {/} operator}
\entry{forward slash (/), / operator}{128}{forward slash (\code {/}), \code {/} operator}
\entry{% (percent sign), % operator}{128}{\code {%} (percent sign), \code {%} operator}
\entry{percent sign (%), % operator}{128}{percent sign (\code {%}), \code {%} operator}
\entry{+ (plus sign), + operator}{128}{\code {+} (plus sign), \code {+} operator}
\entry{plus sign (+), + operator}{128}{plus sign (\code {+}), \code {+} operator}
\entry{ (hyphen),  operator}{128}{\code {-} (hyphen), \code {-} operator}
\entry{hyphen (),  operator}{128}{hyphen (\code {-}), \code {-} operator}
\entry{ (left angle bracket),  operator}{128}{\code {<} (left angle bracket), \code {<} operator}
\entry{left angle bracket (),  operator}{128}{left angle bracket (\code {<}), \code {<} operator}
\entry{ (left angle bracket), = operator}{128}{\code {<} (left angle bracket), \code {<=} operator}
\entry{left angle bracket (), = operator}{128}{left angle bracket (\code {<}), \code {<=} operator}
\entry{> (right angle bracket), >= operator}{128}{\code {>} (right angle bracket), \code {>=} operator}
\entry{right angle bracket (>), >= operator}{128}{right angle bracket (\code {>}), \code {>=} operator}
\entry{> (right angle bracket), > operator}{128}{\code {>} (right angle bracket), \code {>} operator}
\entry{right angle bracket (>), > operator}{128}{right angle bracket (\code {>}), \code {>} operator}
\entry{= (equals sign), == operator}{128}{\code {=} (equals sign), \code {==} operator}
\entry{equals sign (=), == operator}{128}{equals sign (\code {=}), \code {==} operator}
\entry{! (exclamation point), != operator}{128}{\code {!} (exclamation point), \code {!=} operator}
\entry{exclamation point (!), != operator}{128}{exclamation point (\code {!}), \code {!=} operator}
\entry{> (right angle bracket), >> operator (I/O)}{128}{\code {>} (right angle bracket), \code {>>} operator (I/O)}
\entry{right angle bracket (>), >> operator (I/O)}{128}{right angle bracket (\code {>}), \code {>>} operator (I/O)}
\entry{operators, input/output}{128}{operators, input/output}
\entry{| (vertical bar), | operator (I/O)}{128}{\code {|} (vertical bar), \code {|} operator (I/O)}
\entry{vertical bar (|), | operator (I/O)}{128}{vertical bar (\code {|}), \code {|} operator (I/O)}
\entry{operators, input/output}{128}{operators, input/output}
\entry{| (vertical bar), |& operator (I/O)}{128}{\code {|} (vertical bar), \code {|&} operator (I/O)}
\entry{vertical bar (|), |& operator (I/O)}{128}{vertical bar (\code {|}), \code {|&} operator (I/O)}
\entry{operators, input/output}{128}{operators, input/output}
\entry{print statement, I/O operators in}{128}{\code {print} statement, I/O operators in}
\entry{printf statement, I/O operators in}{128}{\code {printf} statement, I/O operators in}
\entry{~ (tilde), ~ operator}{129}{\code {~} (tilde), \code {~} operator}
\entry{tilde (~), ~ operator}{129}{tilde (\code {~}), \code {~} operator}
\entry{! (exclamation point), !~ operator}{129}{\code {!} (exclamation point), \code {!~} operator}
\entry{exclamation point (!), !~ operator}{129}{exclamation point (\code {!}), \code {!~} operator}
\entry{in operator}{129}{\code {in} operator}
\entry{& (ampersand), && operator}{129}{\code {&} (ampersand), \code {&&} operator}
\entry{ampersand (&), && operator}{129}{ampersand (\code {&}), \code {&&} operator}
\entry{| (vertical bar), || operator}{129}{\code {|} (vertical bar), \code {||} operator}
\entry{vertical bar (|), || operator}{129}{vertical bar (\code {|}), \code {||} operator}
\entry{? (question mark), ?: operator}{129}{\code {?} (question mark), \code {?:} operator}
\entry{question mark (?), ?: operator}{129}{question mark (\code {?}), \code {?:} operator}
\entry{+ (plus sign), += operator}{129}{\code {+} (plus sign), \code {+=} operator}
\entry{plus sign (+), += operator}{129}{plus sign (\code {+}), \code {+=} operator}
\entry{ (hyphen), = operator}{129}{\code {-} (hyphen), \code {-=} operator}
\entry{hyphen (), = operator}{129}{hyphen (\code {-}), \code {-=} operator}
\entry{* (asterisk), *= operator}{129}{\code {*} (asterisk), \code {*=} operator}
\entry{asterisk (*), *= operator}{129}{asterisk (\code {*}), \code {*=} operator}
\entry{* (asterisk), **= operator}{129}{\code {*} (asterisk), \code {**=} operator}
\entry{asterisk (*), **= operator}{129}{asterisk (\code {*}), \code {**=} operator}
\entry{/ (forward slash), /= operator}{129}{\code {/} (forward slash), \code {/=} operator}
\entry{forward slash (/), /= operator}{129}{forward slash (\code {/}), \code {/=} operator}
\entry{% (percent sign), %= operator}{129}{\code {%} (percent sign), \code {%=} operator}
\entry{percent sign (%), %= operator}{129}{percent sign (\code {%}), \code {%=} operator}
\entry{^ (caret), ^= operator}{129}{\code {^} (caret), \code {^=} operator}
\entry{caret (^), ^= operator}{129}{caret (\code {^}), \code {^=} operator}
\entry{POSIX awk, ** operator and}{129}{POSIX \command {awk}, \code {**} operator and}
\entry{portability, operators, not in POSIX awk}{129}{portability, operators, not in POSIX \command {awk}}
\entry{locale, definition of}{129}{locale, definition of}
\entry{patterns}{131}{patterns}
\entry{patterns, types of}{131}{patterns, types of}
\entry{patterns, expressions as}{131}{patterns, expressions as}
\entry{regular expressions, as patterns}{131}{regular expressions, as patterns}
\entry{expressions, as patterns}{131}{expressions, as patterns}
\entry{comparison expressions, as patterns}{132}{comparison expressions, as patterns}
\entry{patterns, comparison expressions as}{132}{patterns, comparison expressions as}
\entry{/ (forward slash), patterns and}{132}{\code {/} (forward slash), patterns and}
\entry{forward slash (/), patterns and}{132}{forward slash (\code {/}), patterns and}
\entry{~ (tilde), ~ operator}{132}{\code {~} (tilde), \code {~} operator}
\entry{tilde (~), ~ operator}{132}{tilde (\code {~}), \code {~} operator}
\entry{! (exclamation point), !~ operator}{132}{\code {!} (exclamation point), \code {!~} operator}
\entry{exclamation point (!), !~ operator}{132}{exclamation point (\code {!}), \code {!~} operator}
\entry{regexp constants, as patterns}{132}{regexp constants, as patterns}
\entry{patterns, regexp constants as}{132}{patterns, regexp constants as}
\entry{Boolean expressions, as patterns}{132}{Boolean expressions, as patterns}
\entry{BEGIN pattern, Boolean patterns and}{133}{\code {BEGIN} pattern, Boolean patterns and}
\entry{END pattern, Boolean patterns and}{133}{\code {END} pattern, Boolean patterns and}
\entry{BEGINFILE pattern, Boolean patterns and}{133}{\code {BEGINFILE} pattern, Boolean patterns and}
\entry{ENDFILE pattern, Boolean patterns and}{133}{\code {ENDFILE} pattern, Boolean patterns and}
\entry{range patterns}{133}{range patterns}
\entry{patterns, ranges in}{133}{patterns, ranges in}
\entry{lines, matching ranges of}{133}{lines, matching ranges of}
\entry{, (comma), in range patterns}{133}{\code {,} (comma), in range patterns}
\entry{comma (,), in range patterns}{133}{comma (\code {,}), in range patterns}
\entry{if statement, actions,{} changing}{133}{\code {if} statement, actions\comma {} changing}
\entry{lines, skipping between markers}{133}{lines, skipping between markers}
\entry{! (exclamation point), ! operator}{133}{\code {!} (exclamation point), \code {!} operator}
\entry{range patterns, line continuation and}{134}{range patterns, line continuation and}
\entry{BEGIN pattern}{134}{\code {BEGIN} pattern}
\entry{END pattern}{134}{\code {END} pattern}
\entry{BEGIN pattern}{134}{\code {BEGIN} pattern}
\entry{END pattern}{134}{\code {END} pattern}
\entry{BEGIN pattern, operators and}{134}{\code {BEGIN} pattern, operators and}
\entry{END pattern, operators and}{134}{\code {END} pattern, operators and}
\entry{input/output, from BEGIN and END}{135}{input/output, from \code {BEGIN} and \code {END}}
\entry{Brian Kernighan's awk}{135}{Brian Kernighan's \command {awk}}
\entry{differences in awk and gawk, BEGIN/END patterns}{135}{differences in \command {awk} and \command {gawk}, \code {BEGIN}/\code {END} patterns}
\entry{POSIX awk, BEGIN/END patterns}{135}{POSIX \command {awk}, \code {BEGIN}/\code {END} patterns}
\entry{print statement, BEGIN/END patterns and}{135}{\code {print} statement, \code {BEGIN}/\code {END} patterns and}
\entry{BEGIN pattern, print statement and}{135}{\code {BEGIN} pattern, \code {print} statement and}
\entry{END pattern, print statement and}{135}{\code {END} pattern, \code {print} statement and}
\entry{next statement, BEGIN/END patterns and}{135}{\code {next} statement, \code {BEGIN}/\code {END} patterns and}
\entry{nextfile statement, BEGIN/END patterns and}{135}{\code {nextfile} statement, \code {BEGIN}/\code {END} patterns and}
\entry{BEGIN pattern, next/nextfile statements and}{135}{\code {BEGIN} pattern, \code {next}/\code {nextfile} statements and}
\entry{END pattern, next/nextfile statements and}{135}{\code {END} pattern, \code {next}/\code {nextfile} statements and}
\entry{BEGINFILE pattern}{135}{\code {BEGINFILE} pattern}
\entry{ENDFILE pattern}{135}{\code {ENDFILE} pattern}
\entry{differences in awk and gawk, BEGINFILE/ENDFILE patterns}{135}{differences in \command {awk} and \command {gawk}, \code {BEGINFILE}/\code {ENDFILE} patterns}
\entry{gawk, ERRNO variable in}{136}{\command {gawk}, \code {ERRNO} variable in}
\entry{ERRNO variable, with BEGINFILE pattern}{136}{\code {ERRNO} variable, with \code {BEGINFILE} pattern}
\entry{nextfile statement, BEGINFILE/ENDFILE patterns and}{136}{\code {nextfile} statement, \code {BEGINFILE}/\code {ENDFILE} patterns and}
\entry{next statement, BEGINFILE/ENDFILE patterns and}{136}{\code {next} statement, \code {BEGINFILE}/\code {ENDFILE} patterns and}
\entry{getline statement, BEGINFILE/ENDFILE patterns and}{136}{\code {getline} statement, \code {BEGINFILE}/\code {ENDFILE} patterns and}
\entry{empty pattern}{136}{empty pattern}
\entry{patterns, empty}{136}{patterns, empty}
\entry{shells, variables}{136}{shells, variables}
\entry{awk programs, shell variables in}{136}{\command {awk} programs, shell variables in}
\entry{shells, quoting}{136}{shells, quoting}
\entry{actions}{137}{actions}
\entry{{\indexlbrace }{\indexrbrace } (braces), actions and}{137}{\code {{\tt \char 123}{\tt \char 125}} (braces), actions and}
\entry{braces ({\indexlbrace }{\indexrbrace }), actions and}{137}{braces (\code {{\tt \char 123}{\tt \char 125}}), actions and}
\entry{separators, for statements in actions}{137}{separators, for statements in actions}
\entry{newlines, separating statements in actions}{137}{newlines, separating statements in actions}
\entry{; (semicolon), separating statements in actions}{137}{\code {;} (semicolon), separating statements in actions}
\entry{semicolon (;), separating statements in actions}{137}{semicolon (\code {;}), separating statements in actions}
\entry{side effects, statements}{138}{side effects, statements}
\entry{control statements}{138}{control statements}
\entry{statements, control, in actions}{138}{statements, control, in actions}
\entry{actions, control statements in}{138}{actions, control statements in}
\entry{compound statements,{} control statements and}{138}{compound statements\comma {} control statements and}
\entry{statements, compound,{} control statements and}{138}{statements, compound\comma {} control statements and}
\entry{body, in actions}{138}{body, in actions}
\entry{{\indexlbrace }{\indexrbrace } (braces), statements, grouping}{138}{\code {{\tt \char 123}{\tt \char 125}} (braces), statements, grouping}
\entry{braces ({\indexlbrace }{\indexrbrace }), statements, grouping}{138}{braces (\code {{\tt \char 123}{\tt \char 125}}), statements, grouping}
\entry{newlines, separating statements in actions}{138}{newlines, separating statements in actions}
\entry{; (semicolon), separating statements in actions}{138}{\code {;} (semicolon), separating statements in actions}
\entry{semicolon (;), separating statements in actions}{138}{semicolon (\code {;}), separating statements in actions}
\entry{if statement}{138}{\code {if} statement}
\entry{while statement}{139}{\code {while} statement}
\entry{loops}{139}{loops}
\entry{loops, while}{139}{loops, \code {while}}
\entry{loops, See Also while statement}{139}{loops, See Also \code {while} statement}
\entry{body, in loops}{139}{body, in loops}
\entry{dowhile statement}{140}{\code {do}-\code {while} statement}
\entry{loops, dowhile}{140}{loops, \code {do}-\code {while}}
\entry{for statement}{140}{\code {for} statement}
\entry{loops, for, iterative}{140}{loops, \code {for}, iterative}
\entry{loops, continue statements and}{141}{loops, \code {continue} statements and}
\entry{in operator}{141}{\code {in} operator}
\entry{switch statement}{141}{\code {switch} statement}
\entry{case keyword}{141}{\code {case} keyword}
\entry{default keyword}{141}{\code {default} keyword}
\entry{break statement}{142}{\code {break} statement}
\entry{loops, exiting}{142}{loops, exiting}
\entry{loops, break statement and}{142}{loops, \code {break} statement and}
\entry{POSIX awk, break statement and}{143}{POSIX \command {awk}, \code {break} statement and}
\entry{dark corner, break statement}{143}{dark corner, \code {break} statement}
\entry{gawk, break statement in}{143}{\command {gawk}, \code {break} statement in}
\entry{Brian Kernighan's awk}{143}{Brian Kernighan's \command {awk}}
\entry{continue statement}{143}{\code {continue} statement}
\entry{POSIX awk, continue statement and}{144}{POSIX \command {awk}, \code {continue} statement and}
\entry{dark corner, continue statement}{144}{dark corner, \code {continue} statement}
\entry{gawk, continue statement in}{144}{\command {gawk}, \code {continue} statement in}
\entry{Brian Kernighan's awk}{144}{Brian Kernighan's \command {awk}}
\entry{next statement}{144}{\code {next} statement}
\entry{awk programs, execution of}{144}{\command {awk} programs, execution of}
\entry{BEGIN pattern, next/nextfile statements and}{145}{\code {BEGIN} pattern, \code {next}/\code {nextfile} statements and}
\entry{END pattern, next/nextfile statements and}{145}{\code {END} pattern, \code {next}/\code {nextfile} statements and}
\entry{POSIX awk, next/nextfile statements and}{145}{POSIX \command {awk}, \code {next}/\code {nextfile} statements and}
\entry{next statement, userdefined functions and}{145}{\code {next} statement, user-defined functions and}
\entry{functions, userdefined, next/nextfile statements and}{145}{functions, user-defined, \code {next}/\code {nextfile} statements and}
\entry{nextfile statement}{145}{\code {nextfile} statement}
\entry{functions, userdefined, next/nextfile statements and}{146}{functions, user-defined, \code {next}/\code {nextfile} statements and}
\entry{nextfile statement, userdefined functions and}{146}{\code {nextfile} statement, user-defined functions and}
\entry{Brian Kernighan's awk}{146}{Brian Kernighan's \command {awk}}
\entry{mawk utility}{146}{\command {mawk} utility}
\entry{exit statement}{146}{\code {exit} statement}
\entry{BEGIN pattern, exit statement and}{146}{\code {BEGIN} pattern, \code {exit} statement and}
\entry{END pattern, exit statement and}{146}{\code {END} pattern, \code {exit} statement and}
\entry{dark corner, exit statement}{146}{dark corner, \code {exit} statement}
\entry{programming conventions, exit statement}{146}{programming conventions, \code {exit} statement}
\entry{predefined variables}{147}{predefined variables}
\entry{variables, predefined}{147}{variables, predefined}
\entry{gawk, predefined variables and}{147}{\command {gawk}, predefined variables and}
\entry{predefined variables, usermodifiable}{147}{predefined variables, user-modifiable}
\entry{usermodifiable variables}{147}{user-modifiable variables}
\entry{BINMODE variable}{147}{\code {BINMODE} variable}
\entry{binary input/output}{147}{binary input/output}
\entry{input/output, binary}{147}{input/output, binary}
\entry{differences in awk and gawk, BINMODE variable}{147}{differences in \command {awk} and \command {gawk}, \code {BINMODE} variable}
\entry{CONVFMT variable}{147}{\code {CONVFMT} variable}
\entry{POSIX awk, CONVFMT variable and}{147}{POSIX \command {awk}, \code {CONVFMT} variable and}
\entry{numbers, converting, to strings}{147}{numbers, converting, to strings}
\entry{strings, converting, numbers to}{147}{strings, converting, numbers to}
\entry{gawk, FIELDWIDTHS variable in}{147}{\command {gawk}, \code {FIELDWIDTHS} variable in}
\entry{FIELDWIDTHS variable}{147}{\code {FIELDWIDTHS} variable}
\entry{differences in awk and gawk, FIELDWIDTHS variable}{147}{differences in \command {awk} and \command {gawk}, \code {FIELDWIDTHS} variable}
\entry{field separators, FIELDWIDTHS variable and}{147}{field separators, \code {FIELDWIDTHS} variable and}
\entry{separators, field, FIELDWIDTHS variable and}{147}{separators, field, \code {FIELDWIDTHS} variable and}
\entry{gawk, FPAT variable in}{147}{\command {gawk}, \code {FPAT} variable in}
\entry{FPAT variable}{147}{\code {FPAT} variable}
\entry{differences in awk and gawk, FPAT variable}{147}{differences in \command {awk} and \command {gawk}, \code {FPAT} variable}
\entry{field separators, FPAT variable and}{147}{field separators, \code {FPAT} variable and}
\entry{separators, field, FPAT variable and}{147}{separators, field, \code {FPAT} variable and}
\entry{FS variable}{147}{\code {FS} variable}
\entry{separators, field}{147}{separators, field}
\entry{field separators}{147}{field separators}
\entry{POSIX awk, FS variable and}{148}{POSIX \command {awk}, \code {FS} variable and}
\entry{gawk, field separators and}{148}{\command {gawk}, field separators and}
\entry{gawk, IGNORECASE variable in}{148}{\command {gawk}, \code {IGNORECASE} variable in}
\entry{IGNORECASE variable}{148}{\code {IGNORECASE} variable}
\entry{differences in awk and gawk, IGNORECASE variable}{148}{differences in \command {awk} and \command {gawk}, \code {IGNORECASE} variable}
\entry{case sensitivity, and string comparisons}{148}{case sensitivity, and string comparisons}
\entry{case sensitivity, and regexps}{148}{case sensitivity, and regexps}
\entry{regular expressions, case sensitivity}{148}{regular expressions, case sensitivity}
\entry{gawk, LINT variable in}{148}{\command {gawk}, \code {LINT} variable in}
\entry{LINT variable}{148}{\code {LINT} variable}
\entry{differences in awk and gawk, LINT variable}{148}{differences in \command {awk} and \command {gawk}, \code {LINT} variable}
\entry{lint checking}{148}{lint checking}
\entry{OFMT variable}{148}{\code {OFMT} variable}
\entry{numbers, converting, to strings}{148}{numbers, converting, to strings}
\entry{strings, converting, numbers to}{148}{strings, converting, numbers to}
\entry{sprintf() function, OFMT variable and}{148}{\code {sprintf()} function, \code {OFMT} variable and}
\entry{print statement, OFMT variable and}{148}{\code {print} statement, \code {OFMT} variable and}
\entry{OFS variable}{148}{\code {OFS} variable}
\entry{separators, field}{148}{separators, field}
\entry{field separators}{148}{field separators}
\entry{ORS variable}{148}{\code {ORS} variable}
\entry{PREC variable}{149}{\code {PREC} variable}
\entry{ROUNDMODE variable}{149}{\code {ROUNDMODE} variable}
\entry{RS variable}{149}{\code {RS} variable}
\entry{separators, for records}{149}{separators, for records}
\entry{record separators}{149}{record separators}
\entry{SUBSEP variable}{149}{\code {SUBSEP} variable}
\entry{separators, subscript}{149}{separators, subscript}
\entry{subscript separators}{149}{subscript separators}
\entry{gawk, TEXTDOMAIN variable in}{149}{\command {gawk}, \code {TEXTDOMAIN} variable in}
\entry{TEXTDOMAIN variable}{149}{\code {TEXTDOMAIN} variable}
\entry{differences in awk and gawk, TEXTDOMAIN variable}{149}{differences in \command {awk} and \command {gawk}, \code {TEXTDOMAIN} variable}
\entry{internationalization, localization}{149}{internationalization, localization}
\entry{predefined variables, conveying information}{149}{predefined variables, conveying information}
\entry{variables, predefined conveying information}{149}{variables, predefined conveying information}
\entry{ARGC/ARGV variables}{149}{\code {ARGC}/\code {ARGV} variables}
\entry{arguments, commandline}{149}{arguments, command-line}
\entry{command line, arguments}{149}{command line, arguments}
\entry{programming conventions, ARGC/ARGV variables}{150}{programming conventions, \code {ARGC}/\code {ARGV} variables}
\entry{dark corner, value of ARGV[0]}{150}{dark corner, value of \code {ARGV[0]}}
\entry{ARGIND variable}{150}{\code {ARGIND} variable}
\entry{differences in awk and gawk, ARGIND variable}{150}{differences in \command {awk} and \command {gawk}, \code {ARGIND} variable}
\entry{files, processing,{} ARGIND variable and}{150}{files, processing\comma {} \code {ARGIND} variable and}
\entry{file names, distinguishing}{150}{file names, distinguishing}
\entry{ENVIRON array}{150}{\code {ENVIRON} array}
\entry{environment variables, in ENVIRON array}{150}{environment variables, in \code {ENVIRON} array}
\entry{gawk, ERRNO variable in}{150}{\command {gawk}, \code {ERRNO} variable in}
\entry{ERRNO variable}{150}{\code {ERRNO} variable}
\entry{differences in awk and gawk, ERRNO variable}{150}{differences in \command {awk} and \command {gawk}, \code {ERRNO} variable}
\entry{error handling, ERRNO variable and}{150}{error handling, \code {ERRNO} variable and}
\entry{FILENAME variable}{150}{\code {FILENAME} variable}
\entry{dark corner, FILENAME variable}{150}{dark corner, \code {FILENAME} variable}
\entry{FNR variable}{151}{\code {FNR} variable}
\entry{NF variable}{151}{\code {NF} variable}
\entry{FUNCTAB array}{151}{\code {FUNCTAB} array}
\entry{gawk, FUNCTAB array in}{151}{\command {gawk}, \code {FUNCTAB} array in}
\entry{differences in awk and gawk, FUNCTAB variable}{151}{differences in \command {awk} and \command {gawk}, \code {FUNCTAB} variable}
\entry{NR variable}{151}{\code {NR} variable}
\entry{gawk, PROCINFO array in}{151}{\command {gawk}, \code {PROCINFO} array in}
\entry{PROCINFO array}{151}{\code {PROCINFO} array}
\entry{differences in awk and gawk, PROCINFO array}{151}{differences in \command {awk} and \command {gawk}, \code {PROCINFO} array}
\entry{effective group ID of gawk user}{151}{effective group ID of \command {gawk} user}
\entry{effective user ID of gawk user}{151}{effective user ID of \command {gawk} user}
\entry{program identifiers}{151}{program identifiers}
\entry{group ID of gawk user}{152}{group ID of \command {gawk} user}
\entry{process group ID of gawk process}{152}{process group ID of \command {gawk} process}
\entry{process ID of gawk process}{152}{process ID of \command {gawk} process}
\entry{parent process ID of gawk process}{152}{parent process ID of \command {gawk} process}
\entry{version of gawk}{152}{version of \command {gawk}}
\entry{gawk version}{152}{\command {gawk} version}
\entry{version of GNU MPFR library}{153}{version of GNU MPFR library}
\entry{version of GNU MP library}{153}{version of GNU MP library}
\entry{maximum precision supported by MPFR library}{153}{maximum precision supported by MPFR library}
\entry{minimum precision required by MPFR library}{153}{minimum precision required by MPFR library}
\entry{version of gawk extension API}{153}{version of \command {gawk} extension API}
\entry{extension API, version number}{153}{extension API, version number}
\entry{supplementary groups of gawk process}{153}{supplementary groups of \command {gawk} process}
\entry{gawk, PROCINFO array in}{153}{\command {gawk}, \code {PROCINFO} array in}
\entry{PROCINFO array, uses}{153}{\code {PROCINFO} array, uses}
\entry{RLENGTH variable}{153}{\code {RLENGTH} variable}
\entry{RSTART variable}{153}{\code {RSTART} variable}
\entry{gawk, RT variable in}{153}{\command {gawk}, \code {RT} variable in}
\entry{RT variable}{153}{\code {RT} variable}
\entry{differences in awk and gawk, RT variable}{153}{differences in \command {awk} and \command {gawk}, \code {RT} variable}
\entry{gawk, SYMTAB array in}{153}{\command {gawk}, \code {SYMTAB} array in}
\entry{SYMTAB array}{153}{\code {SYMTAB} array}
\entry{differences in awk and gawk, SYMTAB variable}{153}{differences in \command {awk} and \command {gawk}, \code {SYMTAB} variable}
\entry{Schorr, Andrew}{154}{Schorr, Andrew}
\entry{sidebar, Changing NR and FNR}{154}{sidebar, Changing \code {NR} and \code {FNR}}
\entry{NR variable, changing}{155}{\code {NR} variable, changing}
\entry{FNR variable, changing}{155}{\code {FNR} variable, changing}
\entry{dark corner, FNR/NR variables}{155}{dark corner, \code {FNR}/\code {NR} variables}
\entry{ARGC/ARGV variables, how to use}{155}{\code {ARGC}/\code {ARGV} variables, how to use}
\entry{arguments, commandline}{155}{arguments, command-line}
\entry{command line, arguments}{155}{command line, arguments}
\entry{differences in awk and gawk, ARGC/ARGV variables}{156}{differences in \command {awk} and \command {gawk}, \code {ARGC}/\code {ARGV} variables}
\entry{arrays}{159}{arrays}
\entry{Wall, Larry}{159}{Wall, Larry}
\entry{arrays, indexing}{160}{arrays, indexing}
\entry{indexing arrays}{160}{indexing arrays}
\entry{associative arrays}{160}{associative arrays}
\entry{arrays, associative}{160}{arrays, associative}
\entry{sparse arrays}{160}{sparse arrays}
\entry{arrays, sparse}{160}{arrays, sparse}
\entry{gawk, IGNORECASE variable in}{161}{\command {gawk}, \code {IGNORECASE} variable in}
\entry{case sensitivity, array indices and}{161}{case sensitivity, array indices and}
\entry{arrays, and IGNORECASE variable}{161}{arrays, and \code {IGNORECASE} variable}
\entry{IGNORECASE variable, and array indices}{161}{\code {IGNORECASE} variable, and array indices}
\entry{arrays, referencing elements}{161}{arrays, referencing elements}
\entry{array members}{161}{array members}
\entry{elements of arrays}{161}{elements of arrays}
\entry{arrays, unassigned elements}{161}{arrays, unassigned elements}
\entry{unassigned array elements}{161}{unassigned array elements}
\entry{empty array elements}{161}{empty array elements}
\entry{nonexistent array elements}{161}{non-existent array elements}
\entry{arrays, elements that don't exist}{161}{arrays, elements that don't exist}
\entry{in operator, testing if array element exists}{161}{\code {in} operator, testing if array element exists}
\entry{side effects, array indexing}{161}{side effects, array indexing}
\entry{arrays, elements, assigning values}{162}{arrays, elements, assigning values}
\entry{elements in arrays, assigning values}{162}{elements in arrays, assigning values}
\entry{arrays, an example of using}{162}{arrays, an example of using}
\entry{elements in arrays, scanning}{163}{elements in arrays, scanning}
\entry{scanning arrays}{163}{scanning arrays}
\entry{arrays, scanning}{163}{arrays, scanning}
\entry{loops, for, array scanning}{163}{loops, \code {for}, array scanning}
\entry{in operator, use in loops}{163}{\code {in} operator, use in loops}
\entry{arrays, for statement and}{163}{arrays, \code {for} statement and}
\entry{for statement, looping over arrays}{163}{\code {for} statement, looping over arrays}
\entry{arrays, elements, order of access by in operator}{163}{arrays, elements, order of access by \code {in} operator}
\entry{elements in arrays, order of access by in operator}{163}{elements in arrays, order of access by \code {in} operator}
\entry{in operator, order of array access}{163}{\code {in} operator, order of array access}
\entry{array scanning order, controlling}{164}{array scanning order, controlling}
\entry{controlling array scanning order}{164}{controlling array scanning order}
\entry{PROCINFO, values of sorted_in}{165}{\code {PROCINFO}, values of \code {sorted_in}}
\entry{numbers, as array subscripts}{167}{numbers, as array subscripts}
\entry{arrays, numeric subscripts}{167}{arrays, numeric subscripts}
\entry{subscripts in arrays, numbers as}{167}{subscripts in arrays, numbers as}
\entry{CONVFMT variable, and array subscripts}{167}{\code {CONVFMT} variable, and array subscripts}
\entry{converting integer array subscripts}{167}{converting integer array subscripts}
\entry{integer array indices}{167}{integer array indices}
\entry{variables, uninitialized,{} as array subscripts}{167}{variables, uninitialized\comma {} as array subscripts}
\entry{uninitialized variables, as array subscripts}{167}{uninitialized variables, as array subscripts}
\entry{subscripts in arrays, uninitialized variables as}{167}{subscripts in arrays, uninitialized variables as}
\entry{arrays, subscripts, uninitialized variables as}{167}{arrays, subscripts, uninitialized variables as}
\entry{null strings, as array subscripts}{168}{null strings, as array subscripts}
\entry{dark corner, array subscripts}{168}{dark corner, array subscripts}
\entry{lint checking, array subscripts}{168}{lint checking, array subscripts}
\entry{delete statement}{168}{\code {delete} statement}
\entry{deleting elements in arrays}{168}{deleting elements in arrays}
\entry{arrays, elements, deleting}{168}{arrays, elements, deleting}
\entry{elements in arrays, deleting}{168}{elements in arrays, deleting}
\entry{null strings, and deleting array elements}{168}{null strings, and deleting array elements}
\entry{lint checking, array elements}{168}{lint checking, array elements}
\entry{common extensions, delete to delete entire arrays}{169}{common extensions, \code {delete} to delete entire arrays}
\entry{extensions, common,{} delete to delete entire arrays}{169}{extensions, common\comma {} \code {delete} to delete entire arrays}
\entry{arrays, deleting entire contents}{169}{arrays, deleting entire contents}
\entry{deleting entire arrays}{169}{deleting entire arrays}
\entry{delete array}{169}{\code {delete} \var {array}}
\entry{differences in awk and gawk, array elements, deleting}{169}{differences in \command {awk} and \command {gawk}, array elements, deleting}
\entry{Brian Kernighan's awk}{169}{Brian Kernighan's \command {awk}}
\entry{portability, deleting array elements}{169}{portability, deleting array elements}
\entry{Brennan, Michael}{169}{Brennan, Michael}
\entry{split() function, array elements,{} deleting}{169}{\code {split()} function, array elements\comma {} deleting}
\entry{subscripts in arrays, multidimensional}{169}{subscripts in arrays, multidimensional}
\entry{arrays, multidimensional}{169}{arrays, multidimensional}
\entry{SUBSEP variable, and multidimensional arrays}{169}{\code {SUBSEP} variable, and multidimensional arrays}
\entry{in operator, index existence in multidimensional arrays}{170}{\code {in} operator, index existence in multidimensional arrays}
\entry{subscripts in arrays, multidimensional, scanning}{171}{subscripts in arrays, multidimensional, scanning}
\entry{arrays, multidimensional, scanning}{171}{arrays, multidimensional, scanning}
\entry{scanning multidimensional arrays}{171}{scanning multidimensional arrays}
\entry{arrays of arrays}{171}{arrays of arrays}
\entry{functions, builtin}{175}{functions, built-in}
\entry{builtin functions}{175}{built-in functions}
\entry{programming conventions, functions, calling}{175}{programming conventions, functions, calling}
\entry{whitespace, functions,{} calling}{175}{whitespace, functions\comma {} calling}
\entry{troubleshooting, gawk, fatal errors,{} function arguments}{175}{troubleshooting, \command {gawk}, fatal errors\comma {} function arguments}
\entry{gawk, function arguments and}{175}{\command {gawk}, function arguments and}
\entry{differences in awk and gawk, function arguments (gawk)}{175}{differences in \command {awk} and \command {gawk}, function arguments (\command {gawk})}
\entry{evaluation order, functions}{175}{evaluation order, functions}
\entry{functions, builtin, evaluation order}{175}{functions, built-in, evaluation order}
\entry{builtin functions, evaluation order}{175}{built-in functions, evaluation order}
\entry{numeric functions}{176}{numeric functions}
\entry{atan2() function}{176}{\code {atan2()} function}
\entry{arctangent}{176}{arctangent}
\entry{cos() function}{176}{\code {cos()} function}
\entry{cosine}{176}{cosine}
\entry{exp() function}{176}{\code {exp()} function}
\entry{exponent}{176}{exponent}
\entry{int() function}{176}{\code {int()} function}
\entry{round to nearest integer}{176}{round to nearest integer}
\entry{log() function}{176}{\code {log()} function}
\entry{logarithm}{176}{logarithm}
\entry{rand() function}{176}{\code {rand()} function}
\entry{random numbers, rand()/srand() functions}{176}{random numbers, \code {rand()}/\code {srand()} functions}
\entry{seeding random number generator}{176}{seeding random number generator}
\entry{random numbers, seed of}{176}{random numbers, seed of}
\entry{sin() function}{177}{\code {sin()} function}
\entry{sine}{177}{sine}
\entry{sqrt() function}{177}{\code {sqrt()} function}
\entry{square root}{177}{square root}
\entry{srand() function}{177}{\code {srand()} function}
\entry{stringmanipulation functions}{177}{string-manipulation functions}
\entry{asorti() function (gawk)}{178}{\code {asorti()} function (\command {gawk})}
\entry{sort array}{178}{sort array}
\entry{arrays, elements, retrieving number of}{178}{arrays, elements, retrieving number of}
\entry{asort() function (gawk)}{178}{\code {asort()} function (\command {gawk})}
\entry{sort array indices}{178}{sort array indices}
\entry{gawk, IGNORECASE variable in}{178}{\command {gawk}, \code {IGNORECASE} variable in}
\entry{gensub() function (gawk)}{178}{\code {gensub()} function (\command {gawk})}
\entry{search and replace in strings}{178}{search and replace in strings}
\entry{substitute in string}{178}{substitute in string}
\entry{gsub() function}{179}{\code {gsub()} function}
\entry{index() function}{180}{\code {index()} function}
\entry{search in string}{180}{search in string}
\entry{find substring in string}{180}{find substring in string}
\entry{dark corner, regexp as second argument to index()}{180}{dark corner, regexp as second argument to \code {index()}}
\entry{length() function}{180}{\code {length()} function}
\entry{string length}{180}{string length}
\entry{length of string}{180}{length of string}
\entry{length of input record}{180}{length of input record}
\entry{input record, length of}{180}{input record, length of}
\entry{portability, length() function}{180}{portability, \code {length()} function}
\entry{POSIX awk, functions and, length()}{180}{POSIX \command {awk}, functions and, \code {length()}}
\entry{dark corner, length() function}{180}{dark corner, \code {length()} function}
\entry{common extensions, length() applied to an array}{180}{common extensions, \code {length()} applied to an array}
\entry{extensions, common,{} length() applied to an array}{180}{extensions, common\comma {} \code {length()} applied to an array}
\entry{differences between gawk and awk}{180}{differences between \command {gawk} and \command {awk}}
\entry{number of array elements}{180}{number of array elements}
\entry{array, number of elements}{180}{array, number of elements}
\entry{match() function}{180}{\code {match()} function}
\entry{string, regular expression match}{180}{string, regular expression match}
\entry{match regexp in string}{180}{match regexp in string}
\entry{RSTART variable, match() function and}{181}{\code {RSTART} variable, \code {match()} function and}
\entry{RLENGTH variable, match() function and}{181}{\code {RLENGTH} variable, \code {match()} function and}
\entry{match() function, RSTART/RLENGTH variables}{181}{\code {match()} function, \code {RSTART}/\code {RLENGTH} variables}
\entry{differences in awk and gawk, match() function}{181}{differences in \command {awk} and \command {gawk}, \code {match()} function}
\entry{troubleshooting, match() function}{182}{troubleshooting, \code {match()} function}
\entry{patsplit() function (gawk)}{182}{\code {patsplit()} function (\command {gawk})}
\entry{split string into array}{182}{split string into array}
\entry{split() function}{182}{\code {split()} function}
\entry{strings splitting, example}{183}{strings splitting, example}
\entry{differences in awk and gawk, split() function}{183}{differences in \command {awk} and \command {gawk}, \code {split()} function}
\entry{dark corner, split() function}{183}{dark corner, \code {split()} function}
\entry{sprintf() function}{183}{\code {sprintf()} function}
\entry{formatting strings}{183}{formatting strings}
\entry{strtonum() function (gawk)}{183}{\code {strtonum()} function (\command {gawk})}
\entry{convert string to number}{183}{convert string to number}
\entry{sub() function}{184}{\code {sub()} function}
\entry{replace in string}{184}{replace in string}
\entry{sub() function, arguments of}{185}{\code {sub()} function, arguments of}
\entry{gsub() function, arguments of}{185}{\code {gsub()} function, arguments of}
\entry{troubleshooting, gsub()/sub() functions}{185}{troubleshooting, \code {gsub()}/\code {sub()} functions}
\entry{substr() function}{185}{\code {substr()} function}
\entry{substring}{185}{substring}
\entry{Brian Kernighan's awk}{185}{Brian Kernighan's \command {awk}}
\entry{troubleshooting, substr() function}{185}{troubleshooting, \code {substr()} function}
\entry{portability, substr() function}{185}{portability, \code {substr()} function}
\entry{case sensitivity, converting case}{186}{case sensitivity, converting case}
\entry{strings, converting letter case}{186}{strings, converting letter case}
\entry{tolower() function}{186}{\code {tolower()} function}
\entry{convert string to lower case}{186}{convert string to lower case}
\entry{toupper() function}{186}{\code {toupper()} function}
\entry{convert string to upper case}{186}{convert string to upper case}
\entry{sidebar, Matching the Null String}{186}{sidebar, Matching the Null String}
\entry{matching, null strings}{186}{matching, null strings}
\entry{null strings, matching}{186}{null strings, matching}
\entry{* (asterisk), * operator, null strings,{} matching}{186}{\code {*} (asterisk), \code {*} operator, null strings\comma {} matching}
\entry{asterisk (*), * operator, null strings,{} matching}{186}{asterisk (\code {*}), \code {*} operator, null strings\comma {} matching}
\entry{escape processing, gsub()/gensub()/sub() functions}{186}{escape processing, \code {gsub()}/\code {gensub()}/\code {sub()} functions}
\entry{sub() function, escape processing}{186}{\code {sub()} function, escape processing}
\entry{gsub() function, escape processing}{186}{\code {gsub()} function, escape processing}
\entry{gensub() function (gawk), escape processing}{186}{\code {gensub()} function (\command {gawk}), escape processing}
\entry{ (backslash), gsub()/gensub()/sub() functions and}{186}{\code {{\tt \backslashcurfont }} (backslash), \code {gsub()}/\code {gensub()}/\code {sub()} functions and}
\entry{backslash (), gsub()/gensub()/sub() functions and}{186}{backslash (\code {{\tt \backslashcurfont }}), \code {gsub()}/\code {gensub()}/\code {sub()} functions and}
\entry{& (ampersand), gsub()/gensub()/sub() functions and}{186}{\code {&} (ampersand), \code {gsub()}/\code {gensub()}/\code {sub()} functions and}
\entry{ampersand (&), gsub()/gensub()/sub() functions and}{186}{ampersand (\code {&}), \code {gsub()}/\code {gensub()}/\code {sub()} functions and}
\entry{Brian Kernighan's awk}{186}{Brian Kernighan's \command {awk}}
\entry{POSIX awk, functions and, gsub()/sub()}{187}{POSIX \command {awk}, functions and, \code {gsub()}/\code {sub()}}
\entry{input/output functions}{189}{input/output functions}
\entry{close() function}{189}{\code {close()} function}
\entry{files, closing}{189}{files, closing}
\entry{close file or coprocess}{189}{close file or coprocess}
\entry{fflush() function}{189}{\code {fflush()} function}
\entry{flush buffered output}{189}{flush buffered output}
\entry{buffers, flushing}{189}{buffers, flushing}
\entry{output, buffering}{189}{output, buffering}
\entry{extensions, common,{} fflush() function}{189}{extensions, common\comma {} \code {fflush()} function}
\entry{Brian Kernighan's awk}{189}{Brian Kernighan's \command {awk}}
\entry{troubleshooting, fflush() function}{189}{troubleshooting, \code {fflush()} function}
\entry{sidebar, Interactive Versus Noninteractive Buffering}{190}{sidebar, Interactive Versus Noninteractive Buffering}
\entry{buffering, interactive vs. noninteractive}{190}{buffering, interactive vs.\: noninteractive}
\entry{system() function}{190}{\code {system()} function}
\entry{invoke shell command}{190}{invoke shell command}
\entry{interacting with other programs}{190}{interacting with other programs}
\entry{troubleshooting, system() function}{191}{troubleshooting, \code {system()} function}
\entry{sandbox option, disabling system() function}{191}{\option {--sandbox} option, disabling \code {system()} function}
\entry{sidebar, Controlling Output Buffering with system()}{191}{sidebar, Controlling Output Buffering with \code {system()}}
\entry{buffers, flushing}{191}{buffers, flushing}
\entry{buffering, input/output}{191}{buffering, input/output}
\entry{output, buffering}{191}{output, buffering}
\entry{time functions}{191}{time functions}
\entry{timestamps}{191}{timestamps}
\entry{log files, timestamps in}{191}{log files, timestamps in}
\entry{files, log,{} timestamps in}{191}{files, log\comma {} timestamps in}
\entry{gawk, timestamps}{191}{\command {gawk}, timestamps}
\entry{POSIX awk, timestamps and}{191}{POSIX \command {awk}, timestamps and}
\entry{date utility, GNU}{192}{\command {date} utility, GNU}
\entry{time, retrieving}{192}{time, retrieving}
\entry{mktime() function (gawk)}{192}{\code {mktime()} function (\command {gawk})}
\entry{generate time values}{192}{generate time values}
\entry{gawk, PROCINFO array in}{192}{\command {gawk}, \code {PROCINFO} array in}
\entry{PROCINFO array}{192}{\code {PROCINFO} array}
\entry{strftime() function (gawk)}{192}{\code {strftime()} function (\command {gawk})}
\entry{format time string}{192}{format time string}
\entry{systime() function (gawk)}{193}{\code {systime()} function (\command {gawk})}
\entry{timestamps}{193}{timestamps}
\entry{current system time}{193}{current system time}
\entry{converting, dates to timestamps}{193}{converting, dates to timestamps}
\entry{dates, converting to timestamps}{193}{dates, converting to timestamps}
\entry{timestamps, converting dates to}{193}{timestamps, converting dates to}
\entry{format specifiers, strftime() function (gawk)}{193}{format specifiers, \code {strftime()} function (\command {gawk})}
\entry{date utility, POSIX}{195}{\code {date} utility, POSIX}
\entry{POSIX awk, date utility and}{195}{POSIX \command {awk}, \code {date} utility and}
\entry{bitmanipulation functions}{196}{bit-manipulation functions}
\entry{bitwise, operations}{196}{bitwise, operations}
\entry{AND bitwise operation}{196}{AND bitwise operation}
\entry{OR bitwise operation}{196}{OR bitwise operation}
\entry{XOR bitwise operation}{196}{XOR bitwise operation}
\entry{operations, bitwise}{196}{operations, bitwise}
\entry{bitwise, complement}{196}{bitwise, complement}
\entry{complement, bitwise}{196}{complement, bitwise}
\entry{bitwise, shift}{196}{bitwise, shift}
\entry{left shift, bitwise}{196}{left shift, bitwise}
\entry{right shift, bitwise}{196}{right shift, bitwise}
\entry{shift, bitwise}{196}{shift, bitwise}
\entry{gawk, bitwise operations in}{196}{\command {gawk}, bitwise operations in}
\entry{and() function (gawk)}{196}{\code {and()} function (\command {gawk})}
\entry{bitwise AND}{196}{bitwise AND}
\entry{compl() function (gawk)}{196}{\code {compl()} function (\command {gawk})}
\entry{bitwise complement}{196}{bitwise complement}
\entry{lshift() function (gawk)}{197}{\code {lshift()} function (\command {gawk})}
\entry{left shift}{197}{left shift}
\entry{or() function (gawk)}{197}{\code {or()} function (\command {gawk})}
\entry{bitwise OR}{197}{bitwise OR}
\entry{rshift() function (gawk)}{197}{\code {rshift()} function (\command {gawk})}
\entry{right shift}{197}{right shift}
\entry{xor() function (gawk)}{197}{\code {xor()} function (\command {gawk})}
\entry{bitwise XOR}{197}{bitwise XOR}
\entry{bits2str() userdefined function}{197}{\code {bits2str()} user-defined function}
\entry{testbits.awk program}{197}{\code {testbits.awk} program}
\entry{converting, strings to numbers}{198}{converting, strings to numbers}
\entry{strings, converting}{198}{strings, converting}
\entry{numbers, converting}{198}{numbers, converting}
\entry{converting, numbers to strings}{198}{converting, numbers to strings}
\entry{number as string of bits}{198}{number as string of bits}
\entry{isarray() function (gawk)}{198}{\code {isarray()} function (\command {gawk})}
\entry{scalar or array}{198}{scalar or array}
\entry{gawk, stringtranslation functions}{198}{\command {gawk}, string-translation functions}
\entry{functions, stringtranslation}{198}{functions, string-translation}
\entry{stringtranslation functions}{198}{string-translation functions}
\entry{internationalization}{198}{internationalization}
\entry{awk programs, internationalizing}{198}{\command {awk} programs, internationalizing}
\entry{bindtextdomain() function (gawk)}{199}{\code {bindtextdomain()} function (\command {gawk})}
\entry{set directory of message catalogs}{199}{set directory of message catalogs}
\entry{dcgettext() function (gawk)}{199}{\code {dcgettext()} function (\command {gawk})}
\entry{translate string}{199}{translate string}
\entry{dcngettext() function (gawk)}{199}{\code {dcngettext()} function (\command {gawk})}
\entry{userdefined functions}{199}{user-defined functions}
\entry{functions, userdefined}{199}{functions, user-defined}
\entry{functions, defining}{199}{functions, defining}
\entry{names, functions}{199}{names, functions}
\entry{functions, names of}{199}{functions, names of}
\entry{namespace issues, functions}{199}{namespace issues, functions}
\entry{programming conventions, functions, writing}{200}{programming conventions, functions, writing}
\entry{variables, shadowing}{200}{variables, shadowing}
\entry{shadowing of variable values}{200}{shadowing of variable values}
\entry{recursive functions}{200}{recursive functions}
\entry{functions, recursive}{200}{functions, recursive}
\entry{common extensions, func keyword}{200}{common extensions, \code {func} keyword}
\entry{extensions, common,{} func keyword}{200}{extensions, common\comma {} \code {func} keyword}
\entry{POSIX awk, function keyword in}{200}{POSIX \command {awk}, \code {function} keyword in}
\entry{portability, functions,{} defining}{201}{portability, functions\comma {} defining}
\entry{function definition example}{201}{function definition example}
\entry{rev() userdefined function}{202}{\code {rev()} user-defined function}
\entry{ctime() userdefined function}{202}{\code {ctime()} user-defined function}
\entry{functions, userdefined, calling}{202}{functions, user-defined, calling}
\entry{local variables, in a function}{203}{local variables, in a function}
\entry{variables, local to a function}{203}{variables, local to a function}
\entry{call by value}{205}{call by value}
\entry{call by reference}{205}{call by reference}
\entry{arrays, as parameters to functions}{205}{arrays, as parameters to functions}
\entry{functions, arrays as parameters to}{205}{functions, arrays as parameters to}
\entry{undefined functions}{206}{undefined functions}
\entry{functions, undefined}{206}{functions, undefined}
\entry{lint checking, undefined functions}{206}{lint checking, undefined functions}
\entry{portability, next statement in userdefined functions}{206}{portability, \code {next} statement in user-defined functions}
\entry{return statement,{} userdefined functions}{206}{\code {return} statement\comma {} user-defined functions}
\entry{programming conventions, function parameters}{207}{programming conventions, function parameters}
\entry{indirect function calls}{208}{indirect function calls}
\entry{function calls, indirect}{208}{function calls, indirect}
\entry{function pointers}{208}{function pointers}
\entry{pointers to functions}{208}{pointers to functions}
\entry{differences in awk and gawk, indirect function calls}{208}{differences in \command {awk} and \command {gawk}, indirect function calls}
\entry{notation for indirect function calls}{209}{\code address@hidden for indirect function calls}
\entry{indirect function calls, notation}{209}{indirect function calls, \code address@hidden
\entry{function calls, indirect, notation for}{209}{function calls, indirect, \code address@hidden for}
\entry{libraries of awk functions}{217}{libraries of \command {awk} functions}
\entry{functions, library}{217}{functions, library}
\entry{functions, userdefined, library of}{217}{functions, user-defined, library of}
\entry{Kernighan, Brian}{217}{Kernighan, Brian}
\entry{Plauger, P.J.}{217}{Plauger, P.J.\:}
\entry{Texinfo}{217}{Texinfo}
\entry{portability, example programs}{217}{portability, example programs}
\entry{case sensitivity, example programs}{217}{case sensitivity, example programs}
\entry{IGNORECASE variable, in example programs}{217}{\code {IGNORECASE} variable, in example programs}
\entry{names, arrays/variables}{218}{names, arrays/variables}
\entry{names, functions}{218}{names, functions}
\entry{namespace issues}{218}{namespace issues}
\entry{awk programs, documenting}{218}{\command {awk} programs, documenting}
\entry{documentation, of awk programs}{218}{documentation, of \command {awk} programs}
\entry{variables, global, for library functions}{218}{variables, global, for library functions}
\entry{private variables}{218}{private variables}
\entry{variables, private}{218}{variables, private}
\entry{programming conventions, private variable names}{218}{programming conventions, private variable names}
\entry{_ (underscore), in names of private variables}{218}{\code {_} (underscore), in names of private variables}
\entry{underscore (_), in names of private variables}{218}{underscore (\code {_}), in names of private variables}
\entry{dumpvariables option, using for library functions}{218}{\option {--dump-variables} option, using for library functions}
\entry{arrays, associative, library functions and}{218}{arrays, associative, library functions and}
\entry{libraries of awk functions, associative arrays and}{218}{libraries of \command {awk} functions, associative arrays and}
\entry{functions, library, associative arrays and}{218}{functions, library, associative arrays and}
\entry{Tcl}{218}{Tcl}
\entry{assertions}{220}{assertions}
\entry{assert() function (C library)}{220}{\code {assert()} function (C library)}
\entry{libraries of awk functions, assertions}{220}{libraries of \command {awk} functions, assertions}
\entry{functions, library, assertions}{220}{functions, library, assertions}
\entry{awk programs, lengthy, assertions}{220}{\command {awk} programs, lengthy, assertions}
\entry{assert() userdefined function}{221}{\code {assert()} user-defined function}
\entry{END pattern, assert() userdefined function and}{221}{\code {END} pattern, \code {assert()} user-defined function and}
\entry{BEGIN pattern, assert() userdefined function and}{222}{\code {BEGIN} pattern, \code {assert()} user-defined function and}
\entry{rounding numbers}{222}{rounding numbers}
\entry{numbers, rounding}{222}{numbers, rounding}
\entry{libraries of awk functions, rounding numbers}{222}{libraries of \command {awk} functions, rounding numbers}
\entry{functions, library, rounding numbers}{222}{functions, library, rounding numbers}
\entry{print statement, sprintf() function and}{222}{\code {print} statement, \code {sprintf()} function and}
\entry{printf statement, sprintf() function and}{222}{\code {printf} statement, \code {sprintf()} function and}
\entry{sprintf() function, print/printf statements and}{222}{\code {sprintf()} function, \code {print}/\code {printf} statements and}
\entry{round() userdefined function}{222}{\code {round()} user-defined function}
\entry{random numbers, Cliff}{223}{random numbers, Cliff}
\entry{Cliff random numbers}{223}{Cliff random numbers}
\entry{numbers, Cliff random}{223}{numbers, Cliff random}
\entry{functions, library, Cliff random numbers}{223}{functions, library, Cliff random numbers}
\entry{cliff_rand() userdefined function}{223}{\code {cliff_rand()} user-defined function}
\entry{libraries of awk functions, character values as numbers}{223}{libraries of \command {awk} functions, character values as numbers}
\entry{functions, library, character values as numbers}{223}{functions, library, character values as numbers}
\entry{characters, values of as numbers}{223}{characters, values of as numbers}
\entry{numbers, as values of characters}{223}{numbers, as values of characters}
\entry{ord() userdefined function}{223}{\code {ord()} user-defined function}
\entry{chr() userdefined function}{223}{\code {chr()} user-defined function}
\entry{_ord_init() userdefined function}{223}{\code {_ord_init()} user-defined function}
\entry{character sets (machine character encodings)}{224}{character sets (machine character encodings)}
\entry{ASCII}{224}{ASCII}
\entry{EBCDIC}{224}{EBCDIC}
\entry{Unicode}{224}{Unicode}
\entry{mark parity}{224}{mark parity}
\entry{libraries of awk functions, merging arrays into strings}{225}{libraries of \command {awk} functions, merging arrays into strings}
\entry{functions, library, merging arrays into strings}{225}{functions, library, merging arrays into strings}
\entry{strings, merging arrays into}{225}{strings, merging arrays into}
\entry{arrays, merging into strings}{225}{arrays, merging into strings}
\entry{join() userdefined function}{225}{\code {join()} user-defined function}
\entry{libraries of awk functions, managing, time}{225}{libraries of \command {awk} functions, managing, time}
\entry{functions, library, managing time}{225}{functions, library, managing time}
\entry{timestamps, formatted}{225}{timestamps, formatted}
\entry{time, managing}{225}{time, managing}
\entry{getlocaltime() userdefined function}{225}{\code {getlocaltime()} user-defined function}
\entry{readfile() userdefined function}{227}{\code {readfile()} user-defined function}
\entry{files, managing}{229}{files, managing}
\entry{libraries of awk functions, managing, data files}{229}{libraries of \command {awk} functions, managing, data files}
\entry{functions, library, managing data files}{229}{functions, library, managing data files}
\entry{files, managing, data file boundaries}{229}{files, managing, data file boundaries}
\entry{files, initialization and cleanup}{229}{files, initialization and cleanup}
\entry{beginfile() userdefined function}{230}{\code {beginfile()} user-defined function}
\entry{endfile() userdefined function}{230}{\code {endfile()} user-defined function}
\entry{sidebar, So Why Does gawk Have BEGINFILE and ENDFILE?}{230}{sidebar, So Why Does \command {gawk} Have \code {BEGINFILE} and \code {ENDFILE}?}
\entry{files, reading}{230}{files, reading}
\entry{rewind() userdefined function}{230}{\code {rewind()} user-defined function}
\entry{troubleshooting, readable data files}{231}{troubleshooting, readable data files}
\entry{readable data files,{} checking}{231}{readable data files\comma {} checking}
\entry{files, skipping}{231}{files, skipping}
\entry{readable.awk program}{231}{\code {readable.awk} program}
\entry{troubleshooting, getline function}{231}{troubleshooting, \code {getline} function}
\entry{zerofile.awk program}{232}{\code {zerofile.awk} program}
\entry{assignments as filenames}{232}{assignments as filenames}
\entry{filenames, assignments as}{232}{filenames, assignments as}
\entry{noassign.awk program}{233}{\code {noassign.awk} program}
\entry{libraries of awk functions, commandline options}{233}{libraries of \command {awk} functions, command-line options}
\entry{functions, library, commandline options}{233}{functions, library, command-line options}
\entry{commandline options, processing}{233}{command-line options, processing}
\entry{options, commandline, processing}{233}{options, command-line, processing}
\entry{functions, library, C library}{233}{functions, library, C library}
\entry{arguments, processing}{233}{arguments, processing}
\entry{getopt() function (C library)}{233}{\code {getopt()} function (C library)}
\entry{getopt() userdefined function}{235}{\code {getopt()} user-defined function}
\entry{getopt() userdefined function}{235}{\code {getopt()} user-defined function}
\entry{libraries of awk functions, user database, reading}{238}{libraries of \command {awk} functions, user database, reading}
\entry{functions, library, user database,{} reading}{238}{functions, library, user database\comma {} reading}
\entry{user database,{} reading}{238}{user database\comma {} reading}
\entry{database, users,{} reading}{238}{database, users\comma {} reading}
\entry{PROCINFO array}{238}{\code {PROCINFO} array}
\entry{getpwent() function (C library)}{238}{\code {getpwent()} function (C library)}
\entry{getpwent() userdefined function}{238}{\code {getpwent()} user-defined function}
\entry{users, information about, retrieving}{238}{users, information about, retrieving}
\entry{login information}{238}{login information}
\entry{account information}{238}{account information}
\entry{password file}{238}{password file}
\entry{files, password}{238}{files, password}
\entry{pwcat program}{238}{\command {pwcat} program}
\entry{Jacobs, Andrew}{239}{Jacobs, Andrew}
\entry{Robbins, Arnold}{239}{Robbins, Arnold}
\entry{Robbins, Miriam}{239}{Robbins, Miriam}
\entry{_pw_init() userdefined function}{240}{\code {_pw_init()} user-defined function}
\entry{BEGIN pattern, pwcat program}{241}{\code {BEGIN} pattern, \code {pwcat} program}
\entry{PROCINFO array, testing the field splitting}{241}{\code {PROCINFO} array, testing the field splitting}
\entry{getline command, _pw_init() function}{241}{\code {getline} command, \code {_pw_init()} function}
\entry{getpwnam() function (C library)}{241}{\code {getpwnam()} function (C library)}
\entry{getpwnam() userdefined function}{241}{\code {getpwnam()} user-defined function}
\entry{getpwuid() function (C library)}{241}{\code {getpwuid()} function (C library)}
\entry{getpwuid() userdefined function}{241}{\code {getpwuid()} user-defined function}
\entry{getpwent() function (C library)}{241}{\code {getpwent()} function (C library)}
\entry{getpwent() userdefined function}{241}{\code {getpwent()} user-defined function}
\entry{endpwent() function (C library)}{242}{\code {endpwent()} function (C library)}
\entry{endpwent() userdefined function}{242}{\code {endpwent()} user-defined function}
\entry{libraries of awk functions, group database, reading}{242}{libraries of \command {awk} functions, group database, reading}
\entry{functions, library, group database,{} reading}{242}{functions, library, group database\comma {} reading}
\entry{group database, reading}{242}{group database, reading}
\entry{database, group, reading}{242}{database, group, reading}
\entry{PROCINFO array, and group membership}{242}{\code {PROCINFO} array, and group membership}
\entry{getgrent() function (C library)}{242}{\code {getgrent()} function (C library)}
\entry{getgrent() userdefined function}{242}{\code {getgrent()} user-defined function}
\entry{groups,{} information about}{242}{groups\comma {} information about}
\entry{account information}{242}{account information}
\entry{group file}{242}{group file}
\entry{files, group}{242}{files, group}
\entry{grcat program}{242}{\command {grcat} program}
\entry{getline command, _gr_init() userdefined function}{243}{\code {getline} command, \code {_gr_init()} user-defined function}
\entry{_gr_init() userdefined function}{243}{\code {_gr_init()} user-defined function}
\entry{getgrnam() function (C library)}{245}{\code {getgrnam()} function (C library)}
\entry{getgrnam() userdefined function}{245}{\code {getgrnam()} user-defined function}
\entry{getgrgid() function (C library)}{245}{\code {getgrgid()} function (C library)}
\entry{getgrgid() userdefined function}{245}{\code {getgrgid()} user-defined function}
\entry{getgruser() function (C library)}{246}{\code {getgruser()} function (C library)}
\entry{getgruser() function, userdefined}{246}{\code {getgruser()} function, user-defined}
\entry{getgrent() function (C library)}{246}{\code {getgrent()} function (C library)}
\entry{getgrent() userdefined function}{246}{\code {getgrent()} user-defined function}
\entry{endgrent() function (C library)}{246}{\code {endgrent()} function (C library)}
\entry{endgrent() userdefined function}{246}{\code {endgrent()} user-defined function}
\entry{walk_array() userdefined function}{246}{\code {walk_array()} user-defined function}
\entry{awk programs, examples of}{251}{\command {awk} programs, examples of}
\entry{POSIX, programs,{} implementing in awk}{251}{POSIX, programs\comma {} implementing in \command {awk}}
\entry{cut utility}{251}{\command {cut} utility}
\entry{cut utility}{251}{\command {cut} utility}
\entry{fields, cutting}{251}{fields, cutting}
\entry{columns, cutting}{251}{columns, cutting}
\entry{cut.awk program}{252}{\code {cut.awk} program}
\entry{BEGIN pattern, running awk programs and}{252}{\code {BEGIN} pattern, running \command {awk} programs and}
\entry{FS variable, running awk programs and}{252}{\code {FS} variable, running \command {awk} programs and}
\entry{field separators, spaces as}{253}{field separators, spaces as}
\entry{regular expressions, searching for}{256}{regular expressions, searching for}
\entry{searching, files for regular expressions}{256}{searching, files for regular expressions}
\entry{files, searching for regular expressions}{256}{files, searching for regular expressions}
\entry{egrep utility}{256}{\command {egrep} utility}
\entry{egrep.awk program}{257}{\code {egrep.awk} program}
\entry{! (exclamation point), ! operator}{259}{\code {!} (exclamation point), \code {!} operator}
\entry{exclamation point (!), ! operator}{259}{exclamation point (\code {!}), \code {!} operator}
\entry{printing, user information}{260}{printing, user information}
\entry{users, information about, printing}{260}{users, information about, printing}
\entry{id utility}{260}{\command {id} utility}
\entry{PROCINFO array, and user and group ID numbers}{260}{\code {PROCINFO} array, and user and group ID numbers}
\entry{id.awk program}{260}{\code {id.awk} program}
\entry{files, splitting}{262}{files, splitting}
\entry{split utility}{262}{\code {split} utility}
\entry{split.awk program}{262}{\code {split.awk} program}
\entry{files, multiple,{} duplicating output into}{263}{files, multiple\comma {} duplicating output into}
\entry{output, duplicating into files}{263}{output, duplicating into files}
\entry{tee utility}{263}{\code {tee} utility}
\entry{flag variables}{263}{flag variables}
\entry{tee.awk program}{264}{\code {tee.awk} program}
\entry{printing, unduplicated lines of text}{265}{printing, unduplicated lines of text}
\entry{text,{} printing, unduplicated lines of}{265}{text\comma {} printing, unduplicated lines of}
\entry{uniq utility}{265}{\command {uniq} utility}
\entry{uniq.awk program}{266}{\code {uniq.awk} program}
\entry{counting}{269}{counting}
\entry{input files, counting elements in}{269}{input files, counting elements in}
\entry{words, counting}{269}{words, counting}
\entry{characters, counting}{269}{characters, counting}
\entry{lines, counting}{269}{lines, counting}
\entry{wc utility}{269}{\command {wc} utility}
\entry{wc.awk program}{269}{\code {wc.awk} program}
\entry{words, duplicate,{} searching for}{271}{words, duplicate\comma {} searching for}
\entry{searching, for words}{271}{searching, for words}
\entry{documents,{} searching}{271}{documents\comma {} searching}
\entry{Texinfo}{271}{Texinfo}
\entry{dupword.awk program}{271}{\code {dupword.awk} program}
\entry{insomnia, cure for}{272}{insomnia, cure for}
\entry{Robbins, Arnold}{272}{Robbins, Arnold}
\entry{Quanstrom, Erik}{272}{Quanstrom, Erik}
\entry{time, alarm clock example program}{272}{time, alarm clock example program}
\entry{alarm clock example program}{272}{alarm clock example program}
\entry{alarm.awk program}{272}{\code {alarm.awk} program}
\entry{sleep utility}{274}{\command {sleep} utility}
\entry{characters, transliterating}{274}{characters, transliterating}
\entry{tr utility}{274}{\command {tr} utility}
\entry{translate.awk program}{275}{\code {translate.awk} program}
\entry{printing, mailing labels}{276}{printing, mailing labels}
\entry{mailing labels,{} printing}{276}{mailing labels\comma {} printing}
\entry{labels.awk program}{277}{\code {labels.awk} program}
\entry{words, usage counts,{} generating}{278}{words, usage counts\comma {} generating}
\entry{sort utility}{279}{\command {sort} utility}
\entry{wordfreq.awk program}{279}{\code {wordfreq.awk} program}
\entry{lines, duplicate,{} removing}{280}{lines, duplicate\comma {} removing}
\entry{Rakitzis, Byron}{280}{Rakitzis, Byron}
\entry{histsort.awk program}{280}{\code {histsort.awk} program}
\entry{Texinfo, extracting programs from source files}{281}{Texinfo, extracting programs from source files}
\entry{files, Texinfo,{} extracting programs from}{281}{files, Texinfo\comma {} extracting programs from}
\entry{Texinfo}{281}{Texinfo}
\entry{extract.awk program}{282}{\code {extract.awk} program}
\entry{sed utility}{284}{\command {sed} utility}
\entry{stream editors}{284}{stream editors}
\entry{Brennan, Michael}{284}{Brennan, Michael}
\entry{awksed.awk program}{284}{\command {awksed.awk} program}
\entry{libraries of awk functions, example program for using}{285}{libraries of \command {awk} functions, example program for using}
\entry{functions, library, example program for using}{285}{functions, library, example program for using}
\entry{igawk.sh program}{287}{\code {igawk.sh} program}
\entry{anagrams, finding}{292}{anagrams, finding}
\entry{anagram.awk program}{292}{\code {anagram.awk} program}
\entry{signature program}{293}{signature program}
\entry{Brini, Davide}{293}{Brini, Davide}
\entry{Johansen, Chris}{293}{Johansen, Chris}
\entry{search paths}{295}{search paths}
\entry{search paths, for source files}{295}{search paths, for source files}
\entry{source files,{} search path for}{295}{source files\comma {} search path for}
\entry{files, source,{} search path for}{295}{files, source\comma {} search path for}
\entry{directories, searching}{295}{directories, searching}
\entry{gawk, features, advanced}{299}{\command {gawk}, features, advanced}
\entry{advanced features, gawk}{299}{advanced features, \command {gawk}}
\entry{Langston, Peter}{299}{Langston, Peter}
\entry{English, Steve}{299}{English, Steve}
\entry{nondecimaldata option}{299}{\option {--non-decimal-data} option}
\entry{advanced features, nondecimal input data}{299}{advanced features, nondecimal input data}
\entry{input, data,{} nondecimal}{299}{input, data\comma {} nondecimal}
\entry{constants, nondecimal}{299}{constants, nondecimal}
\entry{programming conventions, nondecimaldata option}{299}{programming conventions, \code {--non-decimal-data} option}
\entry{nondecimaldata option, strtonum() function and}{299}{\option {--non-decimal-data} option, \code {strtonum()} function and}
\entry{strtonum() function (gawk), nondecimaldata option and}{299}{\code {strtonum()} function (\command {gawk}), \code {--non-decimal-data} option and}
\entry{arrays, sorting}{304}{arrays, sorting}
\entry{asort() function (gawk)}{304}{\code {asort()} function (\command {gawk})}
\entry{asort() function (gawk), arrays,{} sorting}{304}{\code {asort()} function (\command {gawk}), arrays\comma {} sorting}
\entry{asorti() function (gawk)}{304}{\code {asorti()} function (\command {gawk})}
\entry{asorti() function (gawk), arrays,{} sorting}{304}{\code {asorti()} function (\command {gawk}), arrays\comma {} sorting}
\entry{sort function, arrays, sorting}{304}{sort function, arrays, sorting}
\entry{side effects, asort() function}{304}{side effects, \code {asort()} function}
\entry{reference counting, sorting arrays}{305}{reference counting, sorting arrays}
\entry{gawk, IGNORECASE variable in}{305}{\command {gawk}, \code {IGNORECASE} variable in}
\entry{arrays, sorting, and IGNORECASE variable}{305}{arrays, sorting, and \code {IGNORECASE} variable}
\entry{IGNORECASE variable, and array sorting functions}{305}{\code {IGNORECASE} variable, and array sorting functions}
\entry{advanced features, processes,{} communicating with}{305}{advanced features, processes\comma {} communicating with}
\entry{processes, twoway communications with}{305}{processes, two-way communications with}
\entry{coprocesses}{306}{coprocesses}
\entry{input/output, twoway}{306}{input/output, two-way}
\entry{| (vertical bar), |& operator (I/O)}{306}{\code {|} (vertical bar), \code {|&} operator (I/O)}
\entry{vertical bar (|), |& operator (I/O)}{306}{vertical bar (\code {|}), \code {|&} operator (I/O)}
\entry{csh utility, |& operator, comparison with}{306}{\command {csh} utility, \code {|&} operator, comparison with}
\entry{deadlocks}{306}{deadlocks}
\entry{buffering, input/output}{306}{buffering, input/output}
\entry{getline command, deadlock and}{306}{\code {getline} command, deadlock and}
\entry{close() function, twoway pipes and}{306}{\code {close()} function, two-way pipes and}
\entry{sort utility, coprocesses and}{306}{\command {sort} utility, coprocesses and}
\entry{gawk, PROCINFO array in}{307}{\command {gawk}, \code {PROCINFO} array in}
\entry{PROCINFO array, and communications via ptys}{307}{\code {PROCINFO} array, and communications via ptys}
\entry{advanced features, network programming}{307}{advanced features, network programming}
\entry{networks, programming}{307}{networks, programming}
\entry{TCP/IP}{307}{TCP/IP}
\entry{/inet/...{} special files (gawk)}{307}{\code {/inet/\dots {}} special files (\command {gawk})}
\entry{files, /inet/...{} (gawk)}{307}{files, \code {/inet/\dots {}} (\command {gawk})}
\entry{/inet4/...{} special files (gawk)}{307}{\code {/inet4/\dots {}} special files (\command {gawk})}
\entry{files, /inet4/...{} (gawk)}{307}{files, \code {/inet4/\dots {}} (\command {gawk})}
\entry{/inet6/...{} special files (gawk)}{307}{\code {/inet6/\dots {}} special files (\command {gawk})}
\entry{files, /inet6/...{} (gawk)}{307}{files, \code {/inet6/\dots {}} (\command {gawk})}
\entry{EMISTERED}{307}{\code {EMISTERED}}
\entry{getaddrinfo() function (C library)}{308}{\code {getaddrinfo()} function (C library)}
\entry{gawk, ERRNO variable in}{308}{\command {gawk}, \code {ERRNO} variable in}
\entry{ERRNO variable}{308}{\code {ERRNO} variable}
\entry{awk programs, profiling}{309}{\command {awk} programs, profiling}
\entry{profiling awk programs}{309}{profiling \command {awk} programs}
\entry{awkprof.out file}{309}{\code {awkprof.out} file}
\entry{files, awkprof.out}{309}{files, \code {awkprof.out}}
\entry{profile option}{309}{\option {--profile} option}
\entry{BEGIN pattern, and profiling}{309}{\code {BEGIN} pattern, and profiling}
\entry{END pattern, and profiling}{309}{\code {END} pattern, and profiling}
\entry{patterns, counts, in a profile}{311}{patterns, counts, in a profile}
\entry{loops, count for header, in a profile}{311}{loops, count for header, in a profile}
\entry{functions, userdefined, counts, in a profile}{311}{functions, user-defined, counts, in a profile}
\entry{userdefined, functions, counts, in a profile}{311}{user-defined, functions, counts, in a profile}
\entry{{\indexlbrace }{\indexrbrace } (braces)}{311}{\code {{\tt \char 123}{\tt \char 125}} (braces)}
\entry{braces ({\indexlbrace }{\indexrbrace })}{311}{braces (\code {{\tt \char 123}{\tt \char 125}})}
\entry{() (parentheses), in a profile}{311}{\code {()} (parentheses), in a profile}
\entry{parentheses (), in a profile}{311}{parentheses \code {()}, in a profile}
\entry{profiling awk programs, dynamically}{311}{profiling \command {awk} programs, dynamically}
\entry{gawk program, dynamic profiling}{311}{\command {gawk} program, dynamic profiling}
\entry{dynamic profiling}{311}{dynamic profiling}
\entry{kill command,{} dynamic profiling}{312}{\command {kill} command\comma {} dynamic profiling}
\entry{USR1 signal, for dynamic profiling}{312}{\code {USR1} signal, for dynamic profiling}
\entry{SIGUSR1 signal, for dynamic profiling}{312}{\code {SIGUSR1} signal, for dynamic profiling}
\entry{signals, USR1/SIGUSR1, for profiling}{312}{signals, \code {USR1}/\code {SIGUSR1}, for profiling}
\entry{HUP signal, for dynamic profiling}{312}{\code {HUP} signal, for dynamic profiling}
\entry{SIGHUP signal, for dynamic profiling}{312}{\code {SIGHUP} signal, for dynamic profiling}
\entry{signals, HUP/SIGHUP, for profiling}{312}{signals, \code {HUP}/\code {SIGHUP}, for profiling}
\entry{INT signal (MSWindows)}{312}{\code {INT} signal (MS-Windows)}
\entry{SIGINT signal (MSWindows)}{312}{\code {SIGINT} signal (MS-Windows)}
\entry{signals, INT/SIGINT (MSWindows)}{312}{signals, \code {INT}/\code {SIGINT} (MS-Windows)}
\entry{QUIT signal (MSWindows)}{312}{\code {QUIT} signal (MS-Windows)}
\entry{SIGQUIT signal (MSWindows)}{312}{\code {SIGQUIT} signal (MS-Windows)}
\entry{signals, QUIT/SIGQUIT (MSWindows)}{312}{signals, \code {QUIT}/\code {SIGQUIT} (MS-Windows)}
\entry{internationalization, localization}{315}{internationalization, localization}
\entry{gawk, internationalization and, See internationalization}{315}{\command {gawk}, internationalization and, See internationalization}
\entry{internationalization, localization, gawk and}{315}{internationalization, localization, \command {gawk} and}
\entry{internationalization}{315}{internationalization}
\entry{localization, See internationalization,{} localization}{315}{localization, See internationalization\comma {} localization}
\entry{localization}{315}{localization}
\entry{internationalizing a program}{315}{internationalizing a program}
\entry{gettext library}{315}{\command {gettext} library}
\entry{portability, gettext library and}{315}{portability, \command {gettext} library and}
\entry{textdomain() function (C library)}{315}{\code {textdomain()} function (C library)}
\entry{.pot files}{315}{\code {.pot} files}
\entry{files, .pot}{315}{files, \code {.pot}}
\entry{portable object template files}{315}{portable object template files}
\entry{files, portable object template}{315}{files, portable object template}
\entry{.po files}{315}{\code {.po} files}
\entry{files, .po}{315}{files, \code {.po}}
\entry{portable object files}{315}{portable object files}
\entry{files, portable object}{315}{files, portable object}
\entry{.gmo files}{316}{\code {.gmo} files}
\entry{files, .gmo}{316}{files, \code {.gmo}}
\entry{message object files}{316}{message object files}
\entry{files, message object}{316}{files, message object}
\entry{bindtextdomain() function (C library)}{316}{\code {bindtextdomain()} function (C library)}
\entry{.gmo files, specifying directory of}{316}{\code {.gmo} files, specifying directory of}
\entry{files, .gmo, specifying directory of}{316}{files, \code {.gmo}, specifying directory of}
\entry{message object files, specifying directory of}{316}{message object files, specifying directory of}
\entry{files, message object, specifying directory of}{316}{files, message object, specifying directory of}
\entry{gettext() function (C library)}{316}{\code {gettext()} function (C library)}
\entry{_ (underscore), C macro}{316}{\code {_} (underscore), C macro}
\entry{underscore (_), C macro}{316}{underscore (\code {_}), C macro}
\entry{internationalization, localization, locale categories}{316}{internationalization, localization, locale categories}
\entry{gettext library, locale categories}{316}{\command {gettext} library, locale categories}
\entry{locale categories}{316}{locale categories}
\entry{LC_MESSAGES locale category}{316}{\code {LC_MESSAGES} locale category}
\entry{sorting characters in different languages}{316}{sorting characters in different languages}
\entry{LC_COLLATE locale category}{316}{\code {LC_COLLATE} locale category}
\entry{LC_CTYPE locale category}{316}{\code {LC_CTYPE} locale category}
\entry{monetary information, localization}{316}{monetary information, localization}
\entry{currency symbols, localization}{316}{currency symbols, localization}
\entry{LC_MONETARY locale category}{316}{\code {LC_MONETARY} locale category}
\entry{LC_NUMERIC locale category}{317}{\code {LC_NUMERIC} locale category}
\entry{time, localization and}{317}{time, localization and}
\entry{dates, information related to,{} localization}{317}{dates, information related to\comma {} localization}
\entry{LC_TIME locale category}{317}{\code {LC_TIME} locale category}
\entry{LC_ALL locale category}{317}{\code {LC_ALL} locale category}
\entry{awk programs, internationalizing}{317}{\command {awk} programs, internationalizing}
\entry{TEXTDOMAIN variable}{317}{\code {TEXTDOMAIN} variable}
\entry{internationalization, localization, marked strings}{317}{internationalization, localization, marked strings}
\entry{strings, for localization}{317}{strings, for localization}
\entry{dcgettext() function (gawk)}{317}{\code {dcgettext()} function (\command {gawk})}
\entry{dcngettext() function (gawk)}{317}{\code {dcngettext()} function (\command {gawk})}
\entry{.gmo files, specifying directory of}{317}{\code {.gmo} files, specifying directory of}
\entry{files, .gmo, specifying directory of}{317}{files, \code {.gmo}, specifying directory of}
\entry{message object files, specifying directory of}{317}{message object files, specifying directory of}
\entry{files, message object, specifying directory of}{317}{files, message object, specifying directory of}
\entry{bindtextdomain() function (gawk)}{317}{\code {bindtextdomain()} function (\command {gawk})}
\entry{BEGIN pattern, TEXTDOMAIN variable and}{318}{\code {BEGIN} pattern, \code {TEXTDOMAIN} variable and}
\entry{TEXTDOMAIN variable, BEGIN pattern and}{318}{\code {TEXTDOMAIN} variable, \code {BEGIN} pattern and}
\entry{_ (underscore), translatable string}{318}{\code {_} (underscore), translatable string}
\entry{underscore (_), translatable string}{318}{underscore (\code {_}), translatable string}
\entry{LC_MESSAGES locale category, bindtextdomain() function (gawk)}{318}{\code {LC_MESSAGES} locale category, \code {bindtextdomain()} function (\command {gawk})}
\entry{.po files}{319}{\code {.po} files}
\entry{files, .po}{319}{files, \code {.po}}
\entry{portable object files}{319}{portable object files}
\entry{files, portable object}{319}{files, portable object}
\entry{strings, extracting}{319}{strings, extracting}
\entry{marked strings,{} extracting}{319}{marked strings\comma {} extracting}
\entry{genpot option}{319}{\option {--gen-pot} option}
\entry{commandline options, string extraction}{319}{command-line options, string extraction}
\entry{string extraction (internationalization)}{319}{string extraction (internationalization)}
\entry{marked string extraction (internationalization)}{319}{marked string extraction (internationalization)}
\entry{extraction, of marked strings (internationalization)}{319}{extraction, of marked strings (internationalization)}
\entry{genpot option}{319}{\option {--gen-pot} option}
\entry{xgettext utility}{319}{\code {xgettext} utility}
\entry{printf statement, positional specifiers}{319}{\code {printf} statement, positional specifiers}
\entry{positional specifiers, printf statement}{319}{positional specifiers, \code {printf} statement}
\entry{printf statement, positional specifiers, mixing with regular formats}{320}{\code {printf} statement, positional specifiers, mixing with regular formats}
\entry{positional specifiers, printf statement, mixing with regular formats}{320}{positional specifiers, \code {printf} statement, mixing with regular formats}
\entry{format specifiers, mixing regular with positional specifiers}{320}{format specifiers, mixing regular with positional specifiers}
\entry{portability, internationalization and}{320}{portability, internationalization and}
\entry{internationalization, localization, portability and}{320}{internationalization, localization, portability and}
\entry{TEXTDOMAIN variable, portability and}{321}{\code {TEXTDOMAIN} variable, portability and}
\entry{bindtextdomain() function (gawk), portability and}{321}{\code {bindtextdomain()} function (\command {gawk}), portability and}
\entry{dcgettext() function (gawk), portability and}{321}{\code {dcgettext()} function (\command {gawk}), portability and}
\entry{dcngettext() function (gawk), portability and}{321}{\code {dcngettext()} function (\command {gawk}), portability and}
\entry{Linux}{322}{Linux}
\entry{GNU/Linux}{322}{GNU/Linux}
\entry{.po files, converting to .mo}{322}{\code {.po} files, converting to \code {.mo}}
\entry{files, .po, converting to .mo}{322}{files, \code {.po}, converting to \code {.mo}}
\entry{.mo files, converting from .po}{322}{\code {.mo} files, converting from \code {.po}}
\entry{files, .mo, converting from .po}{322}{files, \code {.mo}, converting from \code {.po}}
\entry{portable object files, converting to message object files}{322}{portable object files, converting to message object files}
\entry{files, portable object, converting to message object files}{322}{files, portable object, converting to message object files}
\entry{message object files, converting from portable object files}{322}{message object files, converting from portable object files}
\entry{files, message object, converting from portable object files}{322}{files, message object, converting from portable object files}
\entry{msgfmt utility}{322}{\command {msgfmt} utility}
\entry{debugging awk programs}{325}{debugging \command {awk} programs}
\entry{stack frame}{325}{stack frame}
\entry{breakpoint}{326}{breakpoint}
\entry{watchpoint}{326}{watchpoint}
\entry{sample debugging session}{326}{sample debugging session}
\entry{starting the debugger}{327}{starting the debugger}
\entry{debugger, how to start}{327}{debugger, how to start}
\entry{debugger commands, b (break)}{330}{debugger commands, \code {b} (\code {break})}
\entry{debugger commands, break}{330}{debugger commands, \code {break}}
\entry{break debugger command}{330}{\code {break} debugger command}
\entry{b debugger command (alias for break)}{330}{\code {b} debugger command (alias for \code {break})}
\entry{set breakpoint}{330}{set breakpoint}
\entry{breakpoint, setting}{330}{breakpoint, setting}
\entry{debugger commands, clear}{331}{debugger commands, \code {clear}}
\entry{clear debugger command}{331}{\code {clear} debugger command}
\entry{delete breakpoint at location}{331}{delete breakpoint at location}
\entry{breakpoint at location, how to delete}{331}{breakpoint at location, how to delete}
\entry{debugger commands, condition}{331}{debugger commands, \code {condition}}
\entry{condition debugger command}{331}{\code {condition} debugger command}
\entry{breakpoint condition}{331}{breakpoint condition}
\entry{debugger commands, d (delete)}{331}{debugger commands, \code {d} (\code {delete})}
\entry{debugger commands, delete}{331}{debugger commands, \code {delete}}
\entry{delete debugger command}{331}{\code {delete} debugger command}
\entry{d debugger command (alias for delete)}{331}{\code {d} debugger command (alias for \code {delete})}
\entry{delete breakpoint by number}{331}{delete breakpoint by number}
\entry{breakpoint, delete by number}{331}{breakpoint, delete by number}
\entry{debugger commands, disable}{331}{debugger commands, \code {disable}}
\entry{disable debugger command}{331}{\code {disable} debugger command}
\entry{disable breakpoint}{331}{disable breakpoint}
\entry{breakpoint, how to disable or enable}{331}{breakpoint, how to disable or enable}
\entry{debugger commands, e (enable)}{331}{debugger commands, \code {e} (\code {enable})}
\entry{debugger commands, enable}{331}{debugger commands, \code {enable}}
\entry{enable debugger command}{331}{\code {enable} debugger command}
\entry{e debugger command (alias for enable)}{331}{\code {e} debugger command (alias for \code {enable})}
\entry{enable breakpoint}{331}{enable breakpoint}
\entry{debugger commands, ignore}{331}{debugger commands, \code {ignore}}
\entry{ignore debugger command}{331}{\code {ignore} debugger command}
\entry{ignore breakpoint}{331}{ignore breakpoint}
\entry{debugger commands, t (tbreak)}{331}{debugger commands, \code {t} (\code {tbreak})}
\entry{debugger commands, tbreak}{331}{debugger commands, \code {tbreak}}
\entry{tbreak debugger command}{331}{\code {tbreak} debugger command}
\entry{t debugger command (alias for tbreak)}{331}{\code {t} debugger command (alias for \code {tbreak})}
\entry{temporary breakpoint}{331}{temporary breakpoint}
\entry{debugger commands, commands}{332}{debugger commands, \code {commands}}
\entry{commands debugger command}{332}{\code {commands} debugger command}
\entry{debugger commands, silent}{332}{debugger commands, \code {silent}}
\entry{silent debugger command}{332}{\code {silent} debugger command}
\entry{debugger commands, end}{332}{debugger commands, \code {end}}
\entry{end debugger command}{332}{\code {end} debugger command}
\entry{breakpoint commands}{332}{breakpoint commands}
\entry{commands to execute at breakpoint}{332}{commands to execute at breakpoint}
\entry{debugger commands, c (continue)}{332}{debugger commands, \code {c} (\code {continue})}
\entry{debugger commands, continue}{332}{debugger commands, \code {continue}}
\entry{continue program, in debugger}{332}{continue program, in debugger}
\entry{debugger commands, finish}{332}{debugger commands, \code {finish}}
\entry{finish debugger command}{332}{\code {finish} debugger command}
\entry{debugger commands, n (next)}{332}{debugger commands, \code {n} (\code {next})}
\entry{debugger commands, next}{332}{debugger commands, \code {next}}
\entry{next debugger command}{332}{\code {next} debugger command}
\entry{n debugger command (alias for next)}{332}{\code {n} debugger command (alias for \code {next})}
\entry{singlestep execution, in the debugger}{332}{single-step execution, in the debugger}
\entry{debugger commands, ni (nexti)}{332}{debugger commands, \code {ni} (\code {nexti})}
\entry{debugger commands, nexti}{332}{debugger commands, \code {nexti}}
\entry{nexti debugger command}{332}{\code {nexti} debugger command}
\entry{ni debugger command (alias for nexti)}{332}{\code {ni} debugger command (alias for \code {nexti})}
\entry{debugger commands, return}{332}{debugger commands, \code {return}}
\entry{return debugger command}{332}{\code {return} debugger command}
\entry{debugger commands, r (run)}{332}{debugger commands, \code {r} (\code {run})}
\entry{debugger commands, run}{332}{debugger commands, \code {run}}
\entry{run debugger command}{332}{\code {run} debugger command}
\entry{r debugger command (alias for run)}{332}{\code {r} debugger command (alias for \code {run})}
\entry{debugger commands, s (step)}{333}{debugger commands, \code {s} (\code {step})}
\entry{debugger commands, step}{333}{debugger commands, \code {step}}
\entry{step debugger command}{333}{\code {step} debugger command}
\entry{s debugger command (alias for step)}{333}{\code {s} debugger command (alias for \code {step})}
\entry{debugger commands, si (stepi)}{333}{debugger commands, \code {si} (\code {stepi})}
\entry{debugger commands, stepi}{333}{debugger commands, \code {stepi}}
\entry{stepi debugger command}{333}{\code {stepi} debugger command}
\entry{si debugger command (alias for stepi)}{333}{\code {si} debugger command (alias for \code {stepi})}
\entry{debugger commands, u (until)}{333}{debugger commands, \code {u} (\code {until})}
\entry{debugger commands, until}{333}{debugger commands, \code {until}}
\entry{until debugger command}{333}{\code {until} debugger command}
\entry{u debugger command (alias for until)}{333}{\code {u} debugger command (alias for \code {until})}
\entry{debugger commands, display}{333}{debugger commands, \code {display}}
\entry{display debugger command}{333}{\code {display} debugger command}
\entry{debugger commands, eval}{333}{debugger commands, \code {eval}}
\entry{eval debugger command}{333}{\code {eval} debugger command}
\entry{evaluate expressions, in debugger}{333}{evaluate expressions, in debugger}
\entry{debugger commands, p (print)}{333}{debugger commands, \code {p} (\code {print})}
\entry{debugger commands, print}{333}{debugger commands, \code {print}}
\entry{print debugger command}{333}{\code {print} debugger command}
\entry{p debugger command (alias for print)}{333}{\code {p} debugger command (alias for \code {print})}
\entry{print variables, in debugger}{333}{print variables, in debugger}
\entry{debugger commands, printf}{334}{debugger commands, \code {printf}}
\entry{printf debugger command}{334}{\code {printf} debugger command}
\entry{debugger commands, set}{334}{debugger commands, \code {set}}
\entry{set debugger command}{334}{\code {set} debugger command}
\entry{assign values to variables, in debugger}{334}{assign values to variables, in debugger}
\entry{debugger commands, w (watch)}{334}{debugger commands, \code {w} (\code {watch})}
\entry{debugger commands, watch}{334}{debugger commands, \code {watch}}
\entry{watch debugger command}{334}{\code {watch} debugger command}
\entry{w debugger command (alias for watch)}{334}{\code {w} debugger command (alias for \code {watch})}
\entry{set watchpoint}{334}{set watchpoint}
\entry{debugger commands, undisplay}{334}{debugger commands, \code {undisplay}}
\entry{undisplay debugger command}{334}{\code {undisplay} debugger command}
\entry{stop automatic display, in debugger}{334}{stop automatic display, in debugger}
\entry{debugger commands, unwatch}{334}{debugger commands, \code {unwatch}}
\entry{unwatch debugger command}{334}{\code {unwatch} debugger command}
\entry{delete watchpoint}{334}{delete watchpoint}
\entry{debugger commands, bt (backtrace)}{335}{debugger commands, \code {bt} (\code {backtrace})}
\entry{debugger commands, backtrace}{335}{debugger commands, \code {backtrace}}
\entry{debugger commands, where (backtrace)}{335}{debugger commands, \code {where} (\code {backtrace})}
\entry{backtrace debugger command}{335}{\code {backtrace} debugger command}
\entry{bt debugger command (alias for backtrace)}{335}{\code {bt} debugger command (alias for \code {backtrace})}
\entry{where debugger command}{335}{\code {where} debugger command}
\entry{where debugger command (alias for backtrace)}{335}{\code {where} debugger command (alias for \code {backtrace})}
\entry{call stack, display in debugger}{335}{call stack, display in debugger}
\entry{traceback, display in debugger}{335}{traceback, display in debugger}
\entry{debugger commands, down}{335}{debugger commands, \code {down}}
\entry{down debugger command}{335}{\code {down} debugger command}
\entry{debugger commands, f (frame)}{335}{debugger commands, \code {f} (\code {frame})}
\entry{debugger commands, frame}{335}{debugger commands, \code {frame}}
\entry{frame debugger command}{335}{\code {frame} debugger command}
\entry{f debugger command (alias for frame)}{335}{\code {f} debugger command (alias for \code {frame})}
\entry{debugger commands, up}{335}{debugger commands, \code {up}}
\entry{up debugger command}{335}{\code {up} debugger command}
\entry{debugger commands, i (info)}{335}{debugger commands, \code {i} (\code {info})}
\entry{debugger commands, info}{335}{debugger commands, \code {info}}
\entry{info debugger command}{335}{\code {info} debugger command}
\entry{i debugger command (alias for info)}{335}{\code {i} debugger command (alias for \code {info})}
\entry{show function arguments, in debugger}{335}{show function arguments, in debugger}
\entry{show breakpoints}{335}{show breakpoints}
\entry{automatic displays, in debugger}{335}{automatic displays, in debugger}
\entry{describe call stack frame, in debugger}{335}{describe call stack frame, in debugger}
\entry{list function definitions, in debugger}{335}{list function definitions, in debugger}
\entry{show local variables, in debugger}{335}{show local variables, in debugger}
\entry{show name of current source file, in debugger}{335}{show name of current source file, in debugger}
\entry{show all source files, in debugger}{336}{show all source files, in debugger}
\entry{list all global variables, in debugger}{336}{list all global variables, in debugger}
\entry{show watchpoints}{336}{show watchpoints}
\entry{debugger commands, o (option)}{336}{debugger commands, \code {o} (\code {option})}
\entry{debugger commands, option}{336}{debugger commands, \code {option}}
\entry{option debugger command}{336}{\code {option} debugger command}
\entry{o debugger command (alias for option)}{336}{\code {o} debugger command (alias for \code {option})}
\entry{display debugger options}{336}{display debugger options}
\entry{debugger options}{336}{debugger options}
\entry{debugger history size}{336}{debugger history size}
\entry{debugger default list amount}{336}{debugger default list amount}
\entry{redirect gawk output, in debugger}{336}{redirect \command {gawk} output, in debugger}
\entry{debugger prompt}{336}{debugger prompt}
\entry{debugger history file}{336}{debugger history file}
\entry{save debugger options}{336}{save debugger options}
\entry{instruction tracing, in debugger}{336}{instruction tracing, in debugger}
\entry{debugger, read commands from a file}{336}{debugger, read commands from a file}
\entry{debugger commands, dump}{337}{debugger commands, \code {dump}}
\entry{dump debugger command}{337}{\code {dump} debugger command}
\entry{debugger commands, h (help)}{338}{debugger commands, \code {h} (\code {help})}
\entry{debugger commands, help}{338}{debugger commands, \code {help}}
\entry{help debugger command}{338}{\code {help} debugger command}
\entry{h debugger command (alias for help)}{338}{\code {h} debugger command (alias for \code {help})}
\entry{debugger commands, l (list)}{338}{debugger commands, \code {l} (\code {list})}
\entry{debugger commands, list}{338}{debugger commands, \code {list}}
\entry{list debugger command}{338}{\code {list} debugger command}
\entry{l debugger command (alias for list)}{338}{\code {l} debugger command (alias for \code {list})}
\entry{debugger commands, q (quit)}{338}{debugger commands, \code {q} (\code {quit})}
\entry{debugger commands, quit}{338}{debugger commands, \code {quit}}
\entry{quit debugger command}{338}{\code {quit} debugger command}
\entry{q debugger command (alias for quit)}{338}{\code {q} debugger command (alias for \code {quit})}
\entry{exit the debugger}{338}{exit the debugger}
\entry{debugger commands, trace}{338}{debugger commands, \code {trace}}
\entry{trace debugger command}{338}{\code {trace} debugger command}
\entry{command completion, in debugger}{338}{command completion, in debugger}
\entry{history expansion, in debugger}{338}{history expansion, in debugger}
\entry{arbitrary precision}{341}{arbitrary precision}
\entry{multiple precision}{341}{multiple precision}
\entry{infinite precision}{341}{infinite precision}
\entry{floatingpoint, numbers,{} arbitrary precision}{341}{floating-point, numbers\comma {} arbitrary precision}
\entry{unsigned integers}{341}{unsigned integers}
\entry{integers, unsigned}{341}{integers, unsigned}
\entry{integers, arbitrary precision}{350}{integers, arbitrary precision}
\entry{arbitrary precision integers}{350}{arbitrary precision integers}
\entry{dynamically loaded extensions}{355}{dynamically loaded extensions}
\entry{plugin}{355}{plug-in}
\entry{extension API}{357}{extension API}
\entry{Robbins, Arnold}{359}{Robbins, Arnold}
\entry{Ramey, Chet}{359}{Ramey, Chet}
\entry{allocating memory for extensions}{362}{allocating memory for extensions}
\entry{extensions, allocating memory}{362}{extensions, allocating memory}
\entry{register extension}{363}{register extension}
\entry{extension registration}{363}{extension registration}
\entry{customized input parser}{365}{customized input parser}
\entry{customized output wrapper}{368}{customized output wrapper}
\entry{output wrapper}{368}{output wrapper}
\entry{customized twoway processor}{370}{customized two-way processor}
\entry{printing messages from extensions}{371}{printing messages from extensions}
\entry{messages from extensions}{371}{messages from extensions}
\entry{accessing global variables from extensions}{373}{accessing global variables from extensions}
\entry{array manipulation in extensions}{377}{array manipulation in extensions}
\entry{API version}{385}{API version}
\entry{extension API version}{385}{extension API version}
\entry{API informational variables}{386}{API informational variables}
\entry{extension API informational variables}{386}{extension API informational variables}
\entry{extension search path}{388}{extension search path}
\entry{finding extensions}{388}{finding extensions}
\entry{extension example}{388}{extension example}
\entry{programming conventions, gawk extensions}{391}{programming conventions, \command {gawk} extensions}
\entry{gawk, interpreter,{} adding code to}{397}{\command {gawk}, interpreter\comma {} adding code to}
\entry{extensions distributed with gawk}{398}{extensions distributed with \command {gawk}}
\entry{chdir() extension function}{398}{\code {chdir()} extension function}
\entry{stat() extension function}{398}{\code {stat()} extension function}
\entry{fts() extension function}{399}{\code {fts()} extension function}
\entry{fnmatch() extension function}{401}{\code {fnmatch()} extension function}
\entry{fork() extension function}{402}{\code {fork()} extension function}
\entry{waitpid() extension function}{402}{\code {waitpid()} extension function}
\entry{wait() extension function}{402}{\code {wait()} extension function}
\entry{inplace extension}{402}{\code {inplace} extension}
\entry{ord() extension function}{404}{\code {ord()} extension function}
\entry{chr() extension function}{404}{\code {chr()} extension function}
\entry{readdir extension}{404}{\code {readdir} extension}
\entry{revoutput extension}{405}{\code {revoutput} extension}
\entry{revtwoway extension}{405}{\code {revtwoway} extension}
\entry{writea() extension function}{406}{\code {writea()} extension function}
\entry{reada() extension function}{406}{\code {reada()} extension function}
\entry{readfile() extension function}{406}{\code {readfile()} extension function}
\entry{gettimeofday() extension function}{407}{\code {gettimeofday()} extension function}
\entry{sleep() extension function}{407}{\code {sleep()} extension function}
\entry{testext extension}{407}{\code {testext} extension}
\entry{gawkextlib}{407}{\code {gawkextlib}}
\entry{extensions, where to find}{407}{extensions, where to find}
\entry{gawkextlib project}{407}{\code {gawkextlib} project}
\entry{git utility}{408}{\command {git} utility}
\entry{Expat XML parser library}{408}{Expat XML parser library}
\entry{awk, versions of}{413}{\command {awk}, versions of}
\entry{awk, versions of, changes between V7 and SVR3.1}{413}{\command {awk}, versions of, changes between V7 and SVR3.1}
\entry{awk, versions of, changes between SVR3.1 and SVR4}{414}{\command {awk}, versions of, changes between SVR3.1 and SVR4}
\entry{awk, versions of, changes between SVR4 and POSIX awk}{414}{\command {awk}, versions of, changes between SVR4 and POSIX \command {awk}}
\entry{POSIX awk, changes in awk versions}{414}{POSIX \command {awk}, changes in \command {awk} versions}
\entry{awk, versions of, See Also Brian Kernighan's awk}{415}{\command {awk}, versions of, See Also Brian Kernighan's \command {awk}}
\entry{extensions, Brian Kernighan's awk}{415}{extensions, Brian Kernighan's \command {awk}}
\entry{Brian Kernighan's awk, extensions}{415}{Brian Kernighan's \command {awk}, extensions}
\entry{Kernighan, Brian}{415}{Kernighan, Brian}
\entry{compatibility mode (gawk), extensions}{415}{compatibility mode (\command {gawk}), extensions}
\entry{extensions, in gawk, not in POSIX awk}{415}{extensions, in \command {gawk}, not in POSIX \command {awk}}
\entry{POSIX, gawk extensions not included in}{415}{POSIX, \command {gawk} extensions not included in}
\entry{next file statement}{420}{\code {next file} statement}
\entry{extensions, Brian Kernighan's awk}{423}{extensions, Brian Kernighan's \command {awk}}
\entry{extensions, mawk}{423}{extensions, \command {mawk}}
\entry{Unicode}{424}{Unicode}
\entry{Berry, Karl}{425}{Berry, Karl}
\entry{gawk, list of contributors to}{425}{\command {gawk}, list of contributors to}
\entry{Aho, Alfred}{425}{Aho, Alfred}
\entry{Weinberger, Peter}{425}{Weinberger, Peter}
\entry{Kernighan, Brian}{425}{Kernighan, Brian}
\entry{Rubin, Paul}{425}{Rubin, Paul}
\entry{Fenlason, Jay}{425}{Fenlason, Jay}
\entry{Close, Diane}{425}{Close, Diane}
\entry{Stallman, Richard}{425}{Stallman, Richard}
\entry{Woods, John}{425}{Woods, John}
\entry{Trueman, David}{425}{Trueman, David}
\entry{Kwok, Conrad}{425}{Kwok, Conrad}
\entry{Garfinkle, Scott}{425}{Garfinkle, Scott}
\entry{Williams, Kent}{425}{Williams, Kent}
\entry{Rankin, Pat}{425}{Rankin, Pat}
\entry{Peterson, Hal}{425}{Peterson, Hal}
\entry{Rommel, Kai Uwe}{426}{Rommel, Kai Uwe}
\entry{Jaegermann, Michal}{426}{Jaegermann, Michal}
\entry{Fish, Fred}{426}{Fish, Fred}
\entry{Deifik, Scott}{426}{Deifik, Scott}
\entry{Zaretskii, Eli}{426}{Zaretskii, Eli}
\entry{Grigera, Juan}{426}{Grigera, Juan}
\entry{Hankerson, Darrel}{426}{Hankerson, Darrel}
\entry{Zoulas, Christos}{426}{Zoulas, Christos}
\entry{Kahrs, Jurgen}{426}{Kahrs, J\"urgen}
\entry{Davies, Stephen}{426}{Davies, Stephen}
\entry{Woehlke, Matthew}{426}{Woehlke, Matthew}
\entry{Brown, Martin}{426}{Brown, Martin}
\entry{Peters, Arno}{426}{Peters, Arno}
\entry{Broder, Alan J.}{426}{Broder, Alan J.\:}
\entry{Buening, Andreas}{426}{Buening, Andreas}
\entry{Hasegawa, Isamu}{426}{Hasegawa, Isamu}
\entry{Benzinger, Michael}{426}{Benzinger, Michael}
\entry{McPhee, Patrick}{426}{McPhee, Patrick}
\entry{Wallin, Anders}{426}{Wallin, Anders}
\entry{Gordon, Assaf}{426}{Gordon, Assaf}
\entry{Haque, John}{426}{Haque, John}
\entry{Papadopoulos, Panos}{427}{Papadopoulos, Panos}
\entry{Yawitz, Efraim}{427}{Yawitz, Efraim}
\entry{Schorr, Andrew}{427}{Schorr, Andrew}
\entry{Malmberg, John E.}{427}{Malmberg, John E.}
\entry{Colombo, Antonio}{427}{Colombo, Antonio}
\entry{Robbins, Arnold}{427}{Robbins, Arnold}
\entry{operating systems, See Also GNU/Linux,{} PC operating systems,{} Unix}{429}{operating systems, See Also GNU/Linux\comma {} PC operating systems\comma {} Unix}
\entry{gawk, installing}{429}{\command {gawk}, installing}
\entry{installing gawk}{429}{installing \command {gawk}}
\entry{source code, gawk}{429}{source code, \command {gawk}}
\entry{gawk, source code,{} obtaining}{429}{\command {gawk}, source code\comma {} obtaining}
\entry{FSF (Free Software Foundation)}{429}{FSF (Free Software Foundation)}
\entry{Free Software Foundation (FSF)}{429}{Free Software Foundation (FSF)}
\entry{gawk, distribution}{430}{\command {gawk}, distribution}
\entry{artificial intelligence,{} gawk and}{430}{artificial intelligence\comma {} \command {gawk} and}
\entry{Texinfo}{431}{Texinfo}
\entry{gawk, configuring, options}{433}{\command {gawk}, configuring, options}
\entry{configuration options,{} gawk}{433}{configuration options\comma {} \command {gawk}}
\entry{disableextensions configuration option}{433}{\option {--disable-extensions} configuration option}
\entry{configuration option, disableextensions}{433}{configuration option, \code {--disable-extensions}}
\entry{disablelint configuration option}{433}{\option {--disable-lint} configuration option}
\entry{configuration option, disablelint}{433}{configuration option, \code {--disable-lint}}
\entry{disablenls configuration option}{434}{\option {--disable-nls} configuration option}
\entry{configuration option, disablenls}{434}{configuration option, \code {--disable-nls}}
\entry{withwhinyuserstrftime configuration option}{434}{\option {--with-whiny-user-strftime} configuration option}
\entry{configuration option, withwhinyuserstrftime}{434}{configuration option, \code {--with-whiny-user-strftime}}
\entry{gawk, configuring}{434}{\command {gawk}, configuring}
\entry{custom.h file}{434}{\code {custom.h} file}
\entry{PC operating systems,{} gawk on, installing}{435}{PC operating systems\comma {} \command {gawk} on, installing}
\entry{operating systems, PC,{} gawk on, installing}{435}{operating systems, PC\comma {} \command {gawk} on, installing}
\entry{compiling gawk for MSDOS and MSWindows}{436}{compiling \command {gawk} for MS-DOS and MS-Windows}
\entry{compiling gawk with EMX for OS/2}{436}{compiling \command {gawk} with EMX for OS/2}
\entry{operating systems, PC, gawk on}{437}{operating systems, PC, \command {gawk} on}
\entry{PC operating systems, gawk on}{437}{PC operating systems, \command {gawk} on}
\entry{search paths}{437}{search paths}
\entry{search paths, for source files}{437}{search paths, for source files}
\entry{gawk, MSDOS version of}{437}{\command {gawk}, MS-DOS version of}
\entry{gawk, MSWindows version of}{437}{\command {gawk}, MS-Windows version of}
\entry{; (semicolon), AWKPATH variable and}{437}{\code {;} (semicolon), \env {AWKPATH} variable and}
\entry{semicolon (;), AWKPATH variable and}{437}{semicolon (\code {;}), \env {AWKPATH} variable and}
\entry{AWKPATH environment variable}{437}{\env {AWKPATH} environment variable}
\entry{gawk, OS/2 version of}{437}{\command {gawk}, OS/2 version of}
\entry{UNIXROOT variable, on OS/2 systems}{437}{\code {UNIXROOT} variable, on OS/2 systems}
\entry{common extensions, BINMODE variable}{437}{common extensions, \code {BINMODE} variable}
\entry{extensions, common,{} BINMODE variable}{437}{extensions, common\comma {} \code {BINMODE} variable}
\entry{differences in awk and gawk, BINMODE variable}{437}{differences in \command {awk} and \command {gawk}, \code {BINMODE} variable}
\entry{BINMODE variable}{437}{\code {BINMODE} variable}
\entry{compiling gawk for Cygwin}{438}{compiling \command {gawk} for Cygwin}
\entry{gawk, VMS version of}{439}{\command {gawk}, VMS version of}
\entry{installation, VMS}{439}{installation, VMS}
\entry{compiling gawk for VMS}{439}{compiling \command {gawk} for VMS}
\entry{exit status, of VMS}{441}{exit status, of VMS}
\entry{floatingpoint, VAX/VMS}{441}{floating-point, VAX/VMS}
\entry{search paths}{442}{search paths}
\entry{search paths, for source files}{442}{search paths, for source files}
\entry{archaeologists}{442}{archaeologists}
\entry{debugging gawk, bug reports}{442}{debugging \command {gawk}, bug reports}
\entry{troubleshooting, gawk, bug reports}{442}{troubleshooting, \command {gawk}, bug reports}
\entry{buggawkgnu.org bug reporting address}{442}{\code address@hidden bug reporting address}
\entry{email address for bug reports, buggawkgnu.org}{442}{email address for bug reports, \code address@hidden
\entry{bug reports, email address, buggawkgnu.org}{442}{bug reports, email address, \code address@hidden
\entry{comp.lang.awk newsgroup}{443}{\code {comp.lang.awk} newsgroup}
\entry{Buening, Andreas}{443}{Buening, Andreas}
\entry{Deifik, Scott}{443}{Deifik, Scott}
\entry{Malmberg, John}{443}{Malmberg, John}
\entry{Pitts, Dave}{443}{Pitts, Dave}
\entry{G., Daniel Richard}{443}{G., Daniel Richard}
\entry{Robbins, Arnold}{443}{Robbins, Arnold}
\entry{Zaretskii, Eli}{443}{Zaretskii, Eli}
\entry{awk, implementations}{443}{\command {awk}, implementations}
\entry{Brennan, Michael}{443}{Brennan, Michael}
\entry{Kernighan, Brian}{444}{Kernighan, Brian}
\entry{source code, Brian Kernighan's awk}{444}{source code, Brian Kernighan's \command {awk}}
\entry{awk, versions of, See Also Brian Kernighan's awk}{444}{\command {awk}, versions of, See Also Brian Kernighan's \command {awk}}
\entry{Brian Kernighan's awk, source code}{444}{Brian Kernighan's \command {awk}, source code}
\entry{git utility}{444}{\command {git} utility}
\entry{Brennan, Michael}{444}{Brennan, Michael}
\entry{mawk utility}{444}{\command {mawk} utility}
\entry{source code, mawk}{444}{source code, \command {mawk}}
\entry{Sumner, Andrew}{444}{Sumner, Andrew}
\entry{awka compiler for awk}{444}{\command {awka} compiler for \command {awk}}
\entry{source code, awka}{444}{source code, \command {awka}}
\entry{Beebe, Nelson H.F.}{445}{Beebe, Nelson H.F.\:}
\entry{pawk (profiling version of Brian Kernighan's awk)}{445}{\command {pawk} (profiling version of Brian Kernighan's \command {awk})}
\entry{source code, pawk}{445}{source code, \command {pawk}}
\entry{BusyBox Awk}{445}{BusyBox Awk}
\entry{source code, BusyBox Awk}{445}{source code, BusyBox Awk}
\entry{OpenSolaris}{445}{OpenSolaris}
\entry{Solaris, POSIXcompliant awk}{445}{Solaris, POSIX-compliant \command {awk}}
\entry{source code, Solaris awk}{445}{source code, Solaris \command {awk}}
\entry{Illumos}{445}{Illumos}
\entry{Illumos, POSIXcompliant awk}{445}{Illumos, POSIX-compliant \command {awk}}
\entry{source code, Illumos awk}{445}{source code, Illumos \command {awk}}
\entry{jawk}{445}{\command {jawk}}
\entry{Java implementation of awk}{445}{Java implementation of \command {awk}}
\entry{source code, jawk}{445}{source code, \command {jawk}}
\entry{libmawk}{445}{libmawk}
\entry{source code, libmawk}{445}{source code, libmawk}
\entry{source code, pawk (Python version)}{445}{source code, \command {pawk} (Python version)}
\entry{pawk, awklike facilities for Python}{445}{\code {pawk}, \command {awk}-like facilities for Python}
\entry{QSE awk}{445}{QSE \command {awk}}
\entry{source code, QSE awk}{445}{source code, QSE \command {awk}}
\entry{QuikTrim Awk}{445}{QuikTrim Awk}
\entry{source code, QuikTrim Awk}{445}{source code, QuikTrim Awk}
\entry{gawk, implementation issues}{447}{\command {gawk}, implementation issues}
\entry{implementation issues, gawk}{447}{implementation issues, \command {gawk}}
\entry{gawk, implementation issues, downward compatibility}{447}{\command {gawk}, implementation issues, downward compatibility}
\entry{gawk, implementation issues, debugging}{447}{\command {gawk}, implementation issues, debugging}
\entry{troubleshooting, gawk}{447}{troubleshooting, \command {gawk}}
\entry{implementation issues,{} gawk, debugging}{447}{implementation issues\comma {} \command {gawk}, debugging}
\entry{git utility}{447}{\command {git} utility}
\entry{adding, features to gawk}{448}{adding, features to \command {gawk}}
\entry{features, adding to gawk}{448}{features, adding to \command {gawk}}
\entry{gawk, features, adding}{448}{\command {gawk}, features, adding}
\entry{gawk, coding style in}{448}{\command {gawk}, coding style in}
\entry{Texinfo}{449}{Texinfo}
\entry{git utility}{449}{\command {git} utility}
\entry{portability, gawk}{449}{portability, \command {gawk}}
\entry{operating systems, porting gawk to}{449}{operating systems, porting \command {gawk} to}
\entry{porting gawk}{449}{porting \command {gawk}}
\entry{Git, use of for gawk source code}{451}{Git, use of for \command {gawk} source code}
\entry{Perl}{453}{Perl}
\entry{Wall, Larry}{453}{Wall, Larry}
\entry{Robbins, Arnold}{453}{Robbins, Arnold}
\entry{programming, concepts}{459}{programming, concepts}
\entry{programming, concepts}{459}{programming, concepts}
\entry{processing data}{459}{processing data}
\entry{compiled programs}{459}{compiled programs}
\entry{interpreted programs}{459}{interpreted programs}
\entry{programming, basic steps}{459}{programming, basic steps}
\entry{algorithms}{460}{algorithms}
\entry{records}{460}{records}
\entry{fields}{460}{fields}
\entry{datadriven languages}{460}{data-driven languages}
\entry{languages,{} datadriven}{460}{languages\comma {} data-driven}
\entry{variables}{460}{variables}
\entry{values, numeric}{460}{values, numeric}
\entry{values, string}{460}{values, string}
\entry{scalar values}{460}{scalar values}
\entry{null strings}{461}{null strings}
\entry{Kernighan, Brian}{461}{Kernighan, Brian}
\entry{Ritchie, Dennis}{461}{Ritchie, Dennis}
\entry{Ada programming language}{463}{Ada programming language}
\entry{programming languages, Ada}{463}{programming languages, Ada}
\entry{Spencer, Henry}{463}{Spencer, Henry}
\entry{sed utility}{463}{\command {sed} utility}
\entry{amazing awk assembler (aaa)}{463}{amazing \command {awk} assembler (\command {aaa})}
\entry{amazingly workable formatter (awf)}{463}{amazingly workable formatter (\command {awf})}
\entry{awf (amazingly workable formatter) program}{463}{\command {awf} (amazingly workable formatter) program}
\entry{ANSI}{463}{ANSI}
\entry{ASCII}{465}{ASCII}
\entry{ISO 88591}{465}{ISO 8859-1}
\entry{ISO Latin1}{465}{ISO Latin-1}
\entry{character sets (machine character encodings)}{465}{character sets (machine character encodings)}
\entry{Unicode}{465}{Unicode}
\entry{Kernighan, Brian}{466}{Kernighan, Brian}
\entry{Bentley, Jon}{466}{Bentley, Jon}
\entry{chem utility}{466}{\command {chem} utility}
\entry{compiled programs}{466}{compiled programs}
\entry{McIlroy, Doug}{467}{McIlroy, Doug}
\entry{cookie}{467}{cookie}
\entry{dark corner}{467}{dark corner}
\entry{epoch, definition of}{467}{epoch, definition of}
\entry{FSF (Free Software Foundation)}{468}{FSF (Free Software Foundation)}
\entry{Free Software Foundation (FSF)}{468}{Free Software Foundation (FSF)}
\entry{Stallman, Richard}{468}{Stallman, Richard}
\entry{GPL (General Public License)}{469}{GPL (General Public License)}
\entry{General Public License (GPL)}{469}{General Public License (GPL)}
\entry{GNU General Public License}{469}{GNU General Public License}
\entry{FSF (Free Software Foundation)}{469}{FSF (Free Software Foundation)}
\entry{Free Software Foundation (FSF)}{469}{Free Software Foundation (FSF)}
\entry{GNU Project}{469}{GNU Project}
\entry{interpreted programs}{469}{interpreted programs}
\entry{ISO}{470}{ISO}
\entry{Java programming language}{470}{Java programming language}
\entry{programming languages, Java}{470}{programming languages, Java}
\entry{LGPL (Lesser General Public License)}{470}{LGPL (Lesser General Public License)}
\entry{Lesser General Public License (LGPL)}{470}{Lesser General Public License (LGPL)}
\entry{GNU Lesser General Public License}{470}{GNU Lesser General Public License}
\entry{Linux}{474}{Linux}
\entry{GNU/Linux}{474}{GNU/Linux}
\entry{Unix}{474}{Unix}
\entry{BSDbased operating systems}{474}{BSD-based operating systems}
\entry{NetBSD}{474}{NetBSD}
\entry{FreeBSD}{474}{FreeBSD}
\entry{OpenBSD}{474}{OpenBSD}
\entry{FDL (Free Documentation License)}{487}{FDL (Free Documentation License)}
\entry{Free Documentation License (FDL)}{487}{Free Documentation License (FDL)}
\entry{GNU Free Documentation License}{487}{GNU Free Documentation License}