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

repo_name: mthl/texinfo

license: mit