texindex/tests/gawk.cp

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