Garbo

home *** CD-ROM | disk | FTP | other *** search

/ Garbo / Garbo.cdr / pc / unix / gawk_doc.zoo / gawk-info-5 < prev next >

Wrap

Text File | 1989-04-13 | 35.8 KB | 961 lines

Info file gawk-info, produced by Makeinfo, -*- Text -*- from input file gawk.texinfo. This file documents `awk', a program that you can use to select particular records in a file and perform operations upon them. Copyright (C) 1989 Free Software Foundation, Inc. Permission is granted to make and distribute verbatim copies of this manual provided the copyright notice and this permission notice are preserved on all copies. Permission is granted to copy and distribute modified versions of this manual under the conditions for verbatim copying, provided that the entire resulting derived work is distributed under the terms of a permission notice identical to this one. Permission is granted to copy and distribute translations of this manual into another language, under the above conditions for modified versions, except that this permission notice may be stated in a translation approved by the Foundation. File: gawk-info, Node: User-modified, Next: Auto-set, Up: Special Special Variables That Control `awk' ==================================== This is a list of the variables which you can change to control how `awk' does certain things. `FS' `FS' is the input field separator (*note Field Separators::.). The value is a regular expression that matches the separations between fields in an input record. The default value is `" "', a string consisting of a single space. As a special exception, this value actually means that any sequence of spaces and tabs is a single separator. It also causes spaces and tabs at the beginning or end of a line to be ignored. You can set the value of `FS' on the command line using the `-F' option: awk -F, 'PROGRAM' INPUT-FILES `OFMT' This string is used by `awk' to control conversion of numbers to strings (*note Conversion::.). It works by being passed, in effect, as the first argument to the `sprintf' function. Its default value is `"%.6g"'. `OFS' This is the output field separator (*note Output Separators::.). It is output between the fields output by a `print' statement. Its default value is `" "', a string consisting of a single space. `ORS' This is the output record separator (*note Output Separators::.). It is output at the end of every `print' statement. Its default value is the newline character, often represented in `awk' programs as `\n'. `RS' This is `awk''s record separator (*note Records::.). Its default value is a string containing a single newline character, which means that an input record consists of a single line of text. `SUBSEP' `SUBSEP' is a subscript separator (*note Multi-dimensional::.). It has the default value of `"\034"', and is used to separate the parts of the name of a multi--dimensional array. Thus, if you access `foo[12,3]', it really accesses `foo["12\0343"]'. File: gawk-info, Node: Auto-set, Prev: User-modified, Up: Special Special Variables That Convey Information to You ================================================ This is a list of the variables that are set automatically by `awk' on certain occasions so as to provide information for your program. `ARGC' `ARGV' The command--line arguments available to `awk' are stored in an array called `ARGV'. `ARGC' is the number of command--line arguments present. `ARGV' is indexed from zero to `ARGC' - 1. For example: awk '{ print ARGV[$1] }' inventory-shipped BBS-list In this example, `ARGV[0]' contains `"awk"', `ARGV[1]' contains `"inventory-shipped"', and `ARGV[2]' contains `"BBS-list"'. `ARGC' is 3, one more than the index of the last element in `ARGV' since the elements are numbered from zero. Notice that the `awk' program is not treated as an argument. The `-f' `FILENAME' option, and the `-F' option, are also not treated as arguments for this purpose. Variable assignments on the command line *are* treated as arguments, and do show up in the `ARGV' array. Your program can alter `ARGC' the elements of `ARGV'. Each time `awk' reaches the end of an input file, it uses the next element of `ARGV' as the name of the next input file. By storing a different string there, your program can change which files are read. You can use `-' to represent the standard input. By storing additional elements and incrementing `ARGC' you can cause additional files to be read. If you decrease the value of `ARGC', that eliminates input files from the end of the list. By recording the old value of `ARGC' elsewhere, your program can treat the eliminated arguments as something other than file names. To eliminate a file from the middle of the list, store the null string (`""') into `ARGV' in place of the file's name. As a special feature, `awk' ignores file names that have been replaced with the null string. `ENVIRON' This is an array that contains the values of the environment. The array indices are the environment variable names; the values are the values of the particular environment variables. For example, `ENVIRON["HOME"]' might be `/u/close'. Changing this array does not affect the environment passed on to any programs that `awk' may spawn via redirection or the `system' function. (This may not work under operating systems other than MS-DOS, Unix, or GNU.) `FILENAME' This is the name of the file that `awk' is currently reading. If `awk' is reading from the standard input (in other words, there are no files listed on the command line), `FILENAME' is set to `"-"'. `FILENAME' is changed each time a new file is read (*note Reading Files::.). `FNR' `FNR' is the current record number in the current file. `FNR' is incremented each time a new record is read (*note Getline::.). It is reinitialized to 0 each time a new input file is started. `NF' `NF' is the number of fields in the current input record. `NF' is set each time a new record is read, when a new field is created, or when $0 changes (*note Fields::.). `NR' This is the number of input records `awk' has processed since the beginning of the program's execution. (*note Records::.). `NR' is set each time a new record is read. `RLENGTH' `RLENGTH' is the length of the string matched by the `match' function (*note String Functions::.). `RLENGTH' is set by invoking the `match' function. Its value is the length of the matched string, or -1 if no match was found. `RSTART' `RSTART' is the start of the string matched by the `match' function (*note String Functions::.). `RSTART' is set by invoking the `match' function. Its value is the position of the string where the matched string starts, or 0 if no match was found. File: gawk-info, Node: Sample Program, Next: Notes, Prev: Special, Up: Top Sample Program ************** The following example is a complete `awk' program, which prints the number of occurrences of each word in its input. It illustrates the associative nature of `awk' arrays by using strings as subscripts. It also demonstrates the `for X in ARRAY' construction. Finally, it shows how `awk' can be used in conjunction with other utility programs to do a useful task of some complexity with a minimum of effort. Some explanations follow the program listing. awk ' # Print list of word frequencies { for (i = 1; i <= NF; i++) freq[$i]++ } END { for (word in freq) printf "%s\t%d\n", word, freq[word] }' The first thing to notice about this program is that it has two rules. The first rule, because it has an empty pattern, is executed on every line of the input. It uses `awk''s field--accessing mechanism (*note Fields::.) to pick out the individual words from the line, and the special variable `NF' (*note Special::.) to know how many fields are available. For each input word, an element of the array `freq' is incremented to reflect that the word has been seen an additional time. The second rule, because it has the pattern `END', is not executed until the input has been exhausted. It prints out the contents of the `freq' table that has been built up inside the first action. Note that this program has several problems that would prevent it from being useful by itself on real text files: * Words are detected using the `awk' convention that fields are separated by whitespace and that other characters in the input (except newlines) don't have any special meaning to `awk'. This means that punctuation characters count as part of words. * The `awk' language considers upper and lower case characters to be distinct. Therefore, `foo' and `Foo' will not be treated by this program as the same word. This is undesirable since in normal text, words are capitalized if they begin sentences, and a frequency analyzer should not be sensitive to that. * The output does not come out in any useful order. You're more likely to be interested in which words occur most frequently, or having an alphabetized table of how frequently each word occurs. The way to solve these problems is to use other operating system utilities to process the input and output of the `awk' script. Suppose the script shown above is saved in the file `frequency.awk'. Then the shell command: tr A-Z a-z < file1 | tr -cd 'a-z\012' \ | awk -f frequency.awk \ | sort +1 -nr produces a table of the words appearing in `file1' in order of decreasing frequency. The first `tr' command in this pipeline translates all the upper case characters in `file1' to lower case. The second `tr' command deletes all the characters in the input except lower case characters and newlines. The second argument to the second `tr' is quoted to protect the backslash in it from being interpreted by the shell. The `awk' program reads this suitably massaged data and produces a word frequency table, which is not ordered. The `awk' script's output is now sorted by the `sort' command and printed on the terminal. The options given to `sort' in this example specify to sort by the second field of each input line (skipping one field), that the sort keys should be treated as numeric quantities (otherwise `15' would come before `5'), and that the sorting should be done in descending (reverse) order. See the general operating system documentation for more information on how to use the `tr' and `sort' commands. File: gawk-info, Node: Notes, Next: Glossary, Prev: Sample Program, Up: Top Implementation Notes ******************** This appendix contains information mainly of interest to implementors and maintainers of `gawk'. Everything in it applies specifically to `gawk', and not to other implementations. * Menu: * Extensions:: Things`gawk' does that Unix `awk' does not. * Future Extensions:: Things likely to appear in a future release. * Improvements:: Suggestions for future improvements. * Manual Improvements:: Suggestions for improvements to this manual. File: gawk-info, Node: Extensions, Next: Future Extensions, Up: Notes GNU Extensions to the AWK Language ================================== Several new features are in a state of flux. They are described here merely to document them somewhat, but they will probably change. We hope they will be incorporated into other versions of `awk', too. All of these features can be turned off either by compiling `gawk' with `-DSTRICT', or by invoking `gawk' as `awk'. The `AWKPATH' environment variable When opening a file supplied via the `-f' option, if the filename does not contain a `/', `gawk' will perform a "path search" for the file, similar to that performed by the shell. `gawk' gets its search path from the `AWKPATH' environment variable. If that variable does not exist, it uses the default path `".:/usr/lib/awk:/usr/local/lib/awk"'. Case Independent Matching Two new operators have been introduced, `~~', and `!~~'. These perform regular expression match and no-match operations that are case independent. In other words, `A' and `a' would both match `/a/'. The `-i' option This option causes the `~' and `!~' operators to behave like the `~~' and `!~~' operators described above. The `-v' option This option prints version information for this particular copy of `gawk'. This is so you can determine if your copy of `gawk' is up to date with respect to whatever the Free Software Foundation is currently distributing. It may disappear in a future version of `gawk'. File: gawk-info, Node: Future Extensions, Next: Improvements, Prev: Extensions, Up: Notes Extensions Likely To Appear In A Future Release =============================================== Here are some more extensions that indicate the directions we are currently considering for `gawk'. Like the previous section, this section is also subject to change. None of these are implemented yet. The `IGNORECASE' special variable If `IGNORECASE' is non--zero, then *all* regular expression matching will be done in a case--independent fashion. The `-i' option and the `~~' and `!~~' operators will go away, as this mechanism generalizes those facilities. More Escape Sequences The ANSI C `\a', and `\x' escape sequences will be recognized. Unix `awk' does not recognize `\v', although `gawk' does. `RS' as a regexp The meaning of `RS' will be generalized along the lines of `FS'. Transliteration Functions We are planning on adding `toupper' and `tolower' functions which will take string arguments, and return strings where the case of each letter has been transformed to upper-- or lower--case respectively. Access To System File Descriptors `gawk' will recognize the special file names `/dev/stdin', `/dev/stdout', `/dev/stderr', and `/dev/fd/N' internally. These will allow access to inherited file descriptors from within an `awk' program. File: gawk-info, Node: Improvements, Next: Manual Improvements, Prev: Future Extensions, Up: Notes Suggestions for Future Improvements =================================== Here are some projects that would--be `gawk' hackers might like to take on. They vary in size from a few days to a few weeks of programming, depending on which one you choose and how fast a programmer you are. Please send any improvements you write to the maintainers at the GNU project. 1. State machine regexp matcher: At present, `gawk' uses the backtracking regular expression matcher from the GNU subroutine library. If a regexp is really going to be used a lot of times, it is faster to convert it once to a description of a finite state machine, then run a routine simulating that machine every time you want to match the regexp. You could use the matching routines used by GNU `egrep'. 2. Compilation of `awk' programs: `gawk' uses a `Bison' (YACC--like) parser to convert the script given it into a syntax tree; the syntax tree is then executed by a simple recursive evaluator. Both of these steps incur a lot of overhead, since parsing can be slow (especially if you also do the previous project and convert regular expressions to finite state machines at compile time) and the recursive evaluator performs many procedure calls to do even the simplest things. It should be possible for `gawk' to convert the script's parse tree into a C program which the user would then compile, using the normal C compiler and a special `gawk' library to provide all the needed functions (regexps, fields, associative arrays, type coercion, and so on). An easier possibility might be for an intermediate phase of `awk' to convert the parse tree into a linear byte code form like the one used in GNU Emacs Lisp. The recursive evaluator would then be replaced by a straight line byte code interpreter that would be intermediate in speed between running a compiled program and doing what `gawk' does now. File: gawk-info, Node: Manual Improvements, Prev: Improvements, Up: Notes Suggestions For Future Improvements of This Manual ================================================== 1. An error message section has not been included in this version of the manual. Perhaps some nice beta testers will document some of the messages for the future. 2. A summary page has not been included, as the ``man'', or help, page that comes with the `gawk' code should suffice. GNU only supports Info, so this manual itself should contain whatever forms of information it would be useful to have on an Info summary page. 3. A function and variable index has not been included as we are not sure what to put in it. 4. A section summarizing the differences between V7 `awk' and System V Release 4 `awk' would be useful for long--time `awk' hackers. File: gawk-info, Node: Glossary, Next: Index, Prev: Notes, Up: Top Glossary ******** Action A series of `awk' statements attached to a rule. If the rule's pattern matches an input record, the `awk' language executes the rule's action. Actions are always enclosed in curly braces. Amazing `awk' assembler Henry Spencer at the University of Toronto wrote a retargetable assembler completely as `awk' scripts. It is thousands of lines long, including machine descriptions for several 8--bit microcomputers. It is distributed with `gawk' and is a good example of a program that would have been better written in another language. Assignment An `awk' expression that changes the value of some `awk' variable or data object. An object that you can assign to is called an "lvalue". Built-in function The `awk' language provides built--in functions that perform various numerical and string computations. Examples are `sqrt' (for the square root of a number) and `substr' (for a substring of a string). C The system programming language that most of GNU is written in. The `awk' programming language has C--like syntax, and this manual points out similarities between `awk' and C when appropriate. Compound statement A series of `awk' statements, enclosed in curly braces. Compound statements may be nested. Concatenation Concatenating two strings means sticking them together, one after another, giving a new string. For example, the string `foo' concatenated with the string `bar' gives the string `foobar'. Conditional expression A relation that is either true or false, such as `(a < b)'. Conditional expressions are used in `if' and `while' statements, and in patterns to select which input records to process. Curly braces The characters `{' and `}'. Curly braces are used in `awk' for delimiting actions, compound statements, and function bodies. Data objects These are numbers and strings of characters. Numbers are converted into strings and vice versa, as needed. Escape Sequences A special sequence of characters used for describing non--printable characters, such as `\n' for newline, or `\033' for the ASCII ESC (escape) character. Field When `awk' reads an input record, it splits the record into pieces separated by whitespace (or by a separator regexp which you can change by setting the special variable `FS'). Such pieces are called fields. Format Format strings are used to control the appearance of output in the `printf' statement. Also, data conversions from numbers to strings are controlled by the format string contained in the special variable `OFMT'. Function A specialized group of statements often used to encapsulate general or program--specific tasks. `awk' has a number of built--in functions, and also allows you to define your own. `gawk' The GNU implementation of `awk'. `awk' language The language in which `awk' programs are written. `awk' program An `awk' program consists of a series of "patterns" and "actions", collectively known as "rules". For each input record given to the program, the program's rules are all processed in turn. `awk' programs may also contain function definitions. `awk' script Another name for an `awk' program. Input record A single chunk of data read in by `awk'. Usually, an `awk' input record consists of one line of text. Keyword In the `awk' language, a keyword is a word that has special meaning. Keywords are reserved and may not be used as variable names. The keywords are: `if', `else', `while', `do...while', `for', `for...in', `break', `continue', `delete', `next', `function', `func', and `exit'. Lvalue An expression that can appear on the left side of an assignment operator. In most languages, lvalues can be variables or array elements. In `awk', a field designator can also be used as an lvalue. Number A numeric valued data object. The `gawk' implementation uses double precision floating point to represent numbers. Pattern Patterns tell `awk' which input records are interesting to which rules. A pattern is an arbitrary conditional expression against which input is tested. If the condition is satisfied, the pattern is said to "match" the input record. A typical pattern might compare the input record against a regular expression. Range (of input lines) A sequence of consecutive lines from the input file. A pattern can specify ranges of input lines for `awk' to process, or it can specify single lines. Recursion When a function calls itself, either directly or indirectly. If this isn't clear, refer to the entry for ``recursion''. Redirection Redirection means performing input from other than the standard input stream, or output to other than the standard output stream. You can redirect the output of the `print' and `printf' statements to a file or a system command, using the `>', `>>', and `|' operators. You can redirect input to the `getline' statement using the `<' and `|' operators. Regular Expression See ``regexp''. Regexp Short for "regular expression". A regexp is a pattern that denotes a set of strings, possibly an infinite set. For example, the regexp `R.*xp' matches any string starting with the letter `R' and ending with the letters `xp'. In `awk', regexps are used in patterns and in conditional expressions. Rule A segment of an `awk' program, that specifies how to process single input records. A rule consists of a "pattern" and an "action". `awk' reads an input record; then, for each rule, if the input record satisfies the rule's pattern, `awk' executes the rule's action. Otherwise, the rule does nothing for that input record. Special Variable The variables `ARGC', `ARGV', `ENVIRON', `FILENAME', `FNR', `FS', `NF', `NR', `OFMT', `OFS', `ORS', `RLENGTH', `RSTART', `RS', `SUBSEP', have special meaning to `awk'. Changing some of them affects `awk''s running environment. Stream Editor A program that reads records from an input stream and processes them one or more at a time. This is in contrast with batch programs, which may expect to read their input files in entirety before starting to do anything, and with interactive programs, which require input from the user. String A datum consisting of a sequence of characters, such as `I am a string'. Constant strings are written with double--quotes in the `awk' language, and may contain "escape sequences". Whitespace A sequence of blank or tab characters occurring inside an input record or a string. File: gawk-info, Node: Index, Prev: Glossary, Up: Top Index ***** * Menu: * #!: Executable Scripts. * -f option: Long. * `$NF', last field in record: Fields. * `$' (field operator): Fields. * `>>': Redirection. * `>': Redirection. * `BEGIN', special pattern: BEGIN/END. * `END', special pattern: BEGIN/END. * `awk' language: This Manual. * `awk' program: This Manual. * `break' statement: Break. * `close' statement for input: Close Input. * `close' statement for output: Close Output. * `continue' statement: Continue. * `delete' statement: Delete. * `exit' statement: Exit. * `for (x in ...)': Scanning an Array. * `for' statement: For. * `if' statement: If. * `next' statement: Next. * `print $0': Very Simple. * `printf' statement, format of: Basic Printf. * `printf', format-control characters: Format-Control. * `printf', modifiers: Modifiers. * `print' statement: Print. * `return' statement: Return Statement. * `while' statement: While. * `|': Redirection. * `BBS-list' file: The Files. * `inventory-shipped' file: The Files. * Accessing fields: Fields. * Acronym: History. * Action, curly braces: Actions. * Action, curly braces: Getting Started. * Action, default: Very Simple. * Action, definition of: Getting Started. * Action, general: Actions. * Action, separating statements: Actions. * Applications of `awk': When. * Arguments in function call: Function Calls. * Arguments, Command Line: Command Line. * Arithmetic operators: Arithmetic Ops. * Array assignment: Assigning Elements. * Array reference: Reference to Elements. * Arrays: Array Intro. * Arrays, definition of: Array Intro. * Arrays, deleting an element: Delete. * Arrays, determining presence of elements: Reference to Elements. * Arrays, multi-dimensional subscripts: Multi-dimensional. * Arrays, special `for' statement: Scanning an Array. * Assignment operators: Assignment Ops. * Associative arrays: Array Intro. * Backslash Continuation: Statements/Lines. * Basic function of `gawk': Getting Started. * Body of a loop: While. * Boolean expressions: Boolean Ops. * Boolean operators: Boolean Ops. * Boolean patterns: Boolean. * Built-in functions, list of: Built-in. * Built-in variables: Variables. * Calling a function: Function Calls. * Case sensitivity and gawk: Read Terminal. * Changing contents of a field: Changing Fields. * Changing the record separator: Records. * Closing files and pipes: Close Output. * Command Line: Command Line. * Command line formats: Running gawk. * Command line, setting `FS' on: Field Separators. * Comments: Comments. * Comparison expressions: Comparison Ops. * Comparison expressions as patterns: Comparison Patterns. * Compound statements: Actions. * Computed Regular Expressions: Regexp Usage. * Concatenation: Concatenation. * Conditional Patterns: Conditional Patterns. * Conditional expression: Conditional Exp. * Constants, types of: Constants. * Continuing statements on the next line: Statements/Lines. * Conversion of strings and numbers: Conversion. * Curly braces: Actions. * Curly braces: Getting Started. * Default action: Very Simple. * Default pattern: Very Simple. * Deleting elements of arrays: Delete. * Differences between `gawk' and `awk': Arithmetic Ops. * Differences between `gawk' and `awk': Constants. * Documenting `awk' programs: Comments. * Dynamic Regular Expressions: Regexp Usage. * Element assignment: Assigning Elements. * Element of array: Reference to Elements. * Emacs Lisp: When. * Empty pattern: Empty. * Escape sequence notation: Constants. * Examining fields: Fields. * Executable Scripts: Executable Scripts. * Expression, conditional: Conditional Exp. * Expressions: Actions. * Expressions, boolean: Boolean Ops. * Expressions, comparison: Comparison Ops. * Field separator, `FS': Field Separators. * Field separator, choice of: Field Separators. * Field separator, setting on command line: Field Separators. * Field, changing contents of: Changing Fields. * Fields: Fields. * Fields, negative-numbered: Non-Constant Fields. * Fields, semantics of: Field Separators. * Fields, separating: Field Separators. * Format specifier: Format-Control. * Format string: Basic Printf. * Formatted output: Printf. * Function call: Function Calls. * Function definitions: Actions. * Functions, user-defined: User-defined. * General input: Reading Files. * History of `awk': History. * How gawk works: Two Rules. * Increment operators: Increment Ops. * Input file, sample: The Files. * Input, `getline' function: Getline. * Input, general: Reading Files. * Input, multiple line records: Multiple. * Input, standard: Read Terminal. * Input, standard: Reading Files. * Interaction of `awk' with other programs: I/O Functions. * Invocation of `gawk': Command Line. * Language, `awk': This Manual. * Loop: While. * Loops, breaking out of: Break. * Lvalue: Assignment Ops. * Manual, using this: This Manual. * Metacharacters: Regexp Operators. * Mod function, semantics of: Arithmetic Ops. * Modifiers (in format specifiers): Modifiers. * Multiple line records: Multiple. * Multiple passes over data: Command Line. * Multiple statements on one line: Statements/Lines. * Negative-numbered fields: Non-Constant Fields. * Number of fields, `NF': Fields. * Number of records, `FNR': Records. * Number of records, `NR': Records. * Numerical constant: Constants. * Numerical value: Constants. * One-liners: One-liners. * Operator, Ternary: Conditional Patterns. * Operators, `$': Fields. * Operators, arithmetic: Arithmetic Ops. * Operators, assignment: Assignment Ops. * Operators, boolean: Boolean Ops. * Operators, increment: Increment Ops. * Operators, regular expression matching: Regexp Usage. * Operators, relational: Comparison Ops. * Operators, relational: Comparison Patterns. * Operators, string: Concatenation. * Operators, string-matching: Regexp Usage. * Options, Command Line: Command Line. * Output: Printing. * Output field separator, `OFS': Output Separators. * Output record separator, `ORS': Output Separators. * Output redirection: Redirection. * Output, formatted: Printf. * Output, piping: Redirection. * Passes, Multiple: Command Line. * Pattern, case sensitive: Read Terminal. * Pattern, comparison expressions: Comparison Patterns. * Pattern, default: Very Simple. * Pattern, definition of: Getting Started. * Pattern, empty: Empty. * Pattern, regular expressions: Regexp. * Patterns, `BEGIN': BEGIN/END. * Patterns, `END': BEGIN/END. * Patterns, Conditional: Conditional Patterns. * Patterns, boolean: Boolean. * Patterns, definition of: Patterns. * Patterns, types of: Patterns. * Pipes for output: Redirection. * Printing, general: Printing. * Program, `awk': This Manual. * Program, Self contained: Executable Scripts. * Program, definition of: Getting Started. * Programs, documenting: Comments. * Range pattern: Ranges. * Reading files, `getline' function: Getline. * Reading files, general: Reading Files. * Reading files, multiple line records: Multiple. * Record separator, `RS': Records. * Records, multiple line: Multiple. * Redirection of output: Redirection. * Reference to array: Reference to Elements. * Regexp: Regexp. * Regular Expressions, Computed: Regexp Usage. * Regular Expressions, Dynamic: Regexp Usage. * Regular expression matching operators: Regexp Usage. * Regular expression, metacharacters: Regexp Operators. * Regular expressions as patterns: Regexp. * Regular expressions, field separators and: Field Separators. * Relational operators: Comparison Patterns. * Relational operators: Comparison Ops. * Removing elements of arrays: Delete. * Rule, definition of: Getting Started. * Running gawk programs: Running gawk. * Sample input file: The Files. * Scanning an array: Scanning an Array. * Script, definition of: Getting Started. * Scripts, Executable: Executable Scripts. * Scripts, Shell: Executable Scripts. * Self contained Programs: Executable Scripts. * Separator character, choice of: Field Separators. * Shell Scripts: Executable Scripts. * Single quotes, why they are needed: One-shot. * Special variables, user modifiable: User-modified. * Standard input: Read Terminal. * Standard input: Reading Files. * Statements: Statements. * Statements: Actions. * String constants: Constants. * String operators: Concatenation. * String value: Constants. * String-matching operators: Regexp Usage. * Subscripts, multi-dimensional in arrays: Multi-dimensional. * Ternary Operator: Conditional Patterns. * Use of comments: Comments. * User-defined functions: User-defined. * User-defined variables: Variables. * Uses of `awk': Preface. * Using this manual: This Manual. * Variables, built-in: Variables. * Variables, user-defined: Variables. * What is `awk': Preface. * When to use `awk': When. * file, `awk' program: Long. * patterns, range: Ranges. * program file: Long. * regexp search operators: Regexp Usage. * running long programs: Long. Tag Table: Node: Top918 Node: Preface2804 Node: History4267 Node: License5644 Node: This Manual18989 Node: The Files20330 Node: Getting Started22914 Node: Very Simple24249 Node: Two Rules26030 Node: More Complex28066 Node: Running gawk30908 Node: One-shot31827 Node: Read Terminal32945 Node: Long33862 Node: Executable Scripts34991 Node: Command Line36534 Node: Comments40168 Node: Statements/Lines41067 Node: When43498 Node: Reading Files45420 Node: Records47119 Node: Fields49902 Node: Non-Constant Fields52789 Node: Changing Fields54591 Node: Field Separators57302 Node: Multiple62004 Node: Assignment Options64393 Node: Getline65608 Node: Close Input74958 Node: Printing76023 Node: Print76748 Node: Print Examples78712 Node: Output Separators80751 Node: Redirection82417 Node: Close Output85886 Node: Printf88132 Node: Basic Printf88908 Node: Format-Control90261 Node: Modifiers91806 Node: Printf Examples93108 Node: One-liners95707 Node: Patterns97642 Node: Empty100130 Node: Regexp100402 Node: Regexp Usage101173 Node: Regexp Operators102947 Node: Comparison Patterns107890 Node: Ranges109336 Node: BEGIN/END110722 Node: Boolean113151 Node: Conditional Patterns115605 Node: Actions116105 Node: Expressions117435 Node: Constants119124 Node: Variables121097 Node: Arithmetic Ops122454 Node: Concatenation123840 Node: Comparison Ops124569 Node: Boolean Ops125973 Node: Assignment Ops128266 Node: Increment Ops131817 Node: Conversion134112 Node: Conditional Exp136066 Node: Function Calls137384 Node: Statements139939 Node: If141253 Node: While142627 Node: Do144232 Node: For145265 Node: Break148306 Node: Continue149848 Node: Next151476 Node: Exit152985 Node: Arrays154514 Node: Array Intro155624 Node: Reference to Elements159227 Node: Assigning Elements161115 Node: Array Example161615 Node: Scanning an Array163336 Node: Delete165642 Node: Multi-dimensional166529 Node: Multi-scanning169746 Node: Built-in171303 Node: Numeric Functions172806 Node: String Functions176601 Node: I/O Functions183717 Node: User-defined185189 Node: Definition Syntax185834 Node: Function Example187928 Node: Function Caveats189034 Node: Return Statement191386 Node: Special193612 Node: User-modified194478 Node: Auto-set196511 Node: Sample Program200558 Node: Notes204316 Node: Extensions204909 Node: Future Extensions206490 Node: Improvements207922 Node: Manual Improvements210034 Node: Glossary210928 Node: Index217934