Geek Gadgets 1

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

/ Geek Gadgets 1 / ADE-1.bin / ade-bin / info / gawk.info-8 < prev next >

Wrap

GNU Info File | 1996-10-12 | 39.9 KB | 1,174 lines

This is Info file gawk.info, produced by Makeinfo-1.55 from the input file /gnu-src/gawk-2.15.6/gawk.texi. This file documents `awk', a program that you can use to select particular records in a file and perform operations upon them. This is Edition 0.15 of `The GAWK Manual', for the 2.15 version of the GNU implementation of AWK. Copyright (C) 1989, 1991, 1992, 1993 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: Regexp Summary, Next: Actions Summary, Prev: Pattern Summary, Up: Rules Summary Regular Expressions ------------------- Regular expressions are the extended kind found in `egrep'. They are composed of characters as follows: `C' matches the character C (assuming C is a character with no special meaning in regexps). `\C' matches the literal character C. `.' matches any character except newline. `^' matches the beginning of a line or a string. `$' matches the end of a line or a string. `[ABC...]' matches any of the characters ABC... (character class). `[^ABC...]' matches any character except ABC... and newline (negated character class). `R1|R2' matches either R1 or R2 (alternation). `R1R2' matches R1, and then R2 (concatenation). `R+' matches one or more R's. `R*' matches zero or more R's. `R?' matches zero or one R's. `(R)' matches R (grouping). *Note Regular Expressions as Patterns: Regexp, for a more detailed explanation of regular expressions. The escape sequences allowed in string constants are also valid in regular expressions (*note Constant Expressions: Constants.). File: gawk.info, Node: Actions Summary, Prev: Regexp Summary, Up: Rules Summary Actions ------- Action statements are enclosed in braces, `{' and `}'. Action statements consist of the usual assignment, conditional, and looping statements found in most languages. The operators, control statements, and input/output statements available are patterned after those in C. * Menu: * Operator Summary:: `awk' operators. * Control Flow Summary:: The control statements. * I/O Summary:: The I/O statements. * Printf Summary:: A summary of `printf'. * Special File Summary:: Special file names interpreted internally. * Numeric Functions Summary:: Built-in numeric functions. * String Functions Summary:: Built-in string functions. * Time Functions Summary:: Built-in time functions. * String Constants Summary:: Escape sequences in strings. File: gawk.info, Node: Operator Summary, Next: Control Flow Summary, Prev: Actions Summary, Up: Actions Summary Operators ......... The operators in `awk', in order of increasing precedence, are: `= += -= *= /= %= ^=' Assignment. Both absolute assignment (`VAR=VALUE') and operator assignment (the other forms) are supported. `?:' A conditional expression, as in C. This has the form `EXPR1 ? eXPR2 : EXPR3'. If EXPR1 is true, the value of the expression is EXPR2; otherwise it is EXPR3. Only one of EXPR2 and EXPR3 is evaluated. `||' Logical "or". `&&' Logical "and". `~ !~' Regular expression match, negated match. `< <= > >= != ==' The usual relational operators. `BLANK' String concatenation. `+ -' Addition and subtraction. `* / %' Multiplication, division, and modulus. `+ - !' Unary plus, unary minus, and logical negation. `^' Exponentiation (`**' may also be used, and `**=' for the assignment operator, but they are not specified in the POSIX standard). `++ --' Increment and decrement, both prefix and postfix. `$' Field reference. *Note Expressions as Action Statements: Expressions, for a full description of all the operators listed above. *Note Examining Fields: Fields, for a description of the field reference operator. File: gawk.info, Node: Control Flow Summary, Next: I/O Summary, Prev: Operator Summary, Up: Actions Summary Control Statements .................. The control statements are as follows: if (CONDITION) STATEMENT [ else STATEMENT ] while (CONDITION) STATEMENT do STATEMENT while (CONDITION) for (EXPR1; EXPR2; EXPR3) STATEMENT for (VAR in ARRAY) STATEMENT break continue delete ARRAY[INDEX] exit [ EXPRESSION ] { STATEMENTS } *Note Control Statements in Actions: Statements, for a full description of all the control statements listed above. File: gawk.info, Node: I/O Summary, Next: Printf Summary, Prev: Control Flow Summary, Up: Actions Summary I/O Statements .............. The input/output statements are as follows: `getline' Set `$0' from next input record; set `NF', `NR', `FNR'. `getline <FILE' Set `$0' from next record of FILE; set `NF'. `getline VAR' Set VAR from next input record; set `NF', `FNR'. `getline VAR <FILE' Set VAR from next record of FILE. `next' Stop processing the current input record. The next input record is read and processing starts over with the first pattern in the `awk' program. If the end of the input data is reached, the `END' rule(s), if any, are executed. `next file' Stop processing the current input file. The next input record read comes from the next input file. `FILENAME' is updated, `FNR' is set to 1, and processing starts over with the first pattern in the `awk' program. If the end of the input data is reached, the `END' rule(s), if any, are executed. `print' Prints the current record. `print EXPR-LIST' Prints expressions. `print EXPR-LIST > FILE' Prints expressions on FILE. `printf FMT, EXPR-LIST' Format and print. `printf FMT, EXPR-LIST > file' Format and print on FILE. Other input/output redirections are also allowed. For `print' and `printf', `>> FILE' appends output to the FILE, and `| COMMAND' writes on a pipe. In a similar fashion, `COMMAND | getline' pipes input into `getline'. `getline' returns 0 on end of file, and -1 on an error. *Note Explicit Input with `getline': Getline, for a full description of the `getline' statement. *Note Printing Output: Printing, for a full description of `print' and `printf'. Finally, *note The `next' Statement: Next Statement., for a description of how the `next' statement works. File: gawk.info, Node: Printf Summary, Next: Special File Summary, Prev: I/O Summary, Up: Actions Summary `printf' Summary ................ The `awk' `printf' statement and `sprintf' function accept the following conversion specification formats: `%c' An ASCII character. If the argument used for `%c' is numeric, it is treated as a character and printed. Otherwise, the argument is assumed to be a string, and the only first character of that string is printed. `%d' `%i' A decimal number (the integer part). `%e' A floating point number of the form `[-]d.ddddddE[+-]dd'. `%f' A floating point number of the form [`-']`ddd.dddddd'. `%g' Use `%e' or `%f' conversion, whichever produces a shorter string, with nonsignificant zeros suppressed. `%o' An unsigned octal number (again, an integer). `%s' A character string. `%x' An unsigned hexadecimal number (an integer). `%X' Like `%x', except use `A' through `F' instead of `a' through `f' for decimal 10 through 15. `%%' A single `%' character; no argument is converted. There are optional, additional parameters that may lie between the `%' and the control letter: `-' The expression should be left-justified within its field. `WIDTH' The field should be padded to this width. If WIDTH has a leading zero, then the field is padded with zeros. Otherwise it is padded with blanks. `.PREC' A number indicating the maximum width of strings or digits to the right of the decimal point. Either or both of the WIDTH and PREC values may be specified as `*'. In that case, the particular value is taken from the argument list. *Note Using `printf' Statements for Fancier Printing: Printf, for examples and for a more detailed description. File: gawk.info, Node: Special File Summary, Next: Numeric Functions Summary, Prev: Printf Summary, Up: Actions Summary Special File Names .................. When doing I/O redirection from either `print' or `printf' into a file, or via `getline' from a file, `gawk' recognizes certain special file names internally. These file names allow access to open file descriptors inherited from `gawk''s parent process (usually the shell). The file names are: `/dev/stdin' The standard input. `/dev/stdout' The standard output. `/dev/stderr' The standard error output. `/dev/fd/N' The file denoted by the open file descriptor N. In addition the following files provide process related information about the running `gawk' program. `/dev/pid' Reading this file returns the process ID of the current process, in decimal, terminated with a newline. `/dev/ppid' Reading this file returns the parent process ID of the current process, in decimal, terminated with a newline. `/dev/pgrpid' Reading this file returns the process group ID of the current process, in decimal, terminated with a newline. `/dev/user' Reading this file returns a single record terminated with a newline. The fields are separated with blanks. The fields represent the following information: `$1' The value of the `getuid' system call. `$2' The value of the `geteuid' system call. `$3' The value of the `getgid' system call. `$4' The value of the `getegid' system call. If there are any additional fields, they are the group IDs returned by `getgroups' system call. (Multiple groups may not be supported on all systems.) These file names may also be used on the command line to name data files. These file names are only recognized internally if you do not actually have files by these names on your system. *Note Standard I/O Streams: Special Files, for a longer description that provides the motivation for this feature. File: gawk.info, Node: Numeric Functions Summary, Next: String Functions Summary, Prev: Special File Summary, Up: Actions Summary Numeric Functions ................. `awk' has the following predefined arithmetic functions: `atan2(Y, X)' returns the arctangent of Y/X in radians. `cos(EXPR)' returns the cosine in radians. `exp(EXPR)' the exponential function. `int(EXPR)' truncates to integer. `log(EXPR)' the natural logarithm function. `rand()' returns a random number between 0 and 1. `sin(EXPR)' returns the sine in radians. `sqrt(EXPR)' the square root function. `srand(EXPR)' use EXPR as a new seed for the random number generator. If no EXPR is provided, the time of day is used. The return value is the previous seed for the random number generator. File: gawk.info, Node: String Functions Summary, Next: Time Functions Summary, Prev: Numeric Functions Summary, Up: Actions Summary String Functions ................ `awk' has the following predefined string functions: `gsub(R, S, T)' for each substring matching the regular expression R in the string T, substitute the string S, and return the number of substitutions. If T is not supplied, use `$0'. `index(S, T)' returns the index of the string T in the string S, or 0 if T is not present. `length(S)' returns the length of the string S. The length of `$0' is returned if no argument is supplied. `match(S, R)' returns the position in S where the regular expression R occurs, or 0 if R is not present, and sets the values of `RSTART' and `RLENGTH'. `split(S, A, R)' splits the string S into the array A on the regular expression R, and returns the number of fields. If R is omitted, `FS' is used instead. `sprintf(FMT, EXPR-LIST)' prints EXPR-LIST according to FMT, and returns the resulting string. `sub(R, S, T)' this is just like `gsub', but only the first matching substring is replaced. `substr(S, I, N)' returns the N-character substring of S starting at I. If N is omitted, the rest of S is used. `tolower(STR)' returns a copy of the string STR, with all the upper-case characters in STR translated to their corresponding lower-case counterparts. Nonalphabetic characters are left unchanged. `toupper(STR)' returns a copy of the string STR, with all the lower-case characters in STR translated to their corresponding upper-case counterparts. Nonalphabetic characters are left unchanged. `system(CMD-LINE)' Execute the command CMD-LINE, and return the exit status. File: gawk.info, Node: Time Functions Summary, Next: String Constants Summary, Prev: String Functions Summary, Up: Actions Summary Built-in time functions ....................... The following two functions are available for getting the current time of day, and for formatting time stamps. `systime()' returns the current time of day as the number of seconds since a particular epoch (Midnight, January 1, 1970 UTC, on POSIX systems). `strftime(FORMAT, TIMESTAMP)' formats TIMESTAMP according to the specification in FORMAT. The current time of day is used if no TIMESTAMP is supplied. *Note Functions for Dealing with Time Stamps: Time Functions, for the details on the conversion specifiers that `strftime' accepts. File: gawk.info, Node: String Constants Summary, Prev: Time Functions Summary, Up: Actions Summary String Constants ................ String constants in `awk' are sequences of characters enclosed between double quotes (`"'). Within strings, certain "escape sequences" are recognized, as in C. These are: `\\' A literal backslash. `\a' The "alert" character; usually the ASCII BEL character. `\b' Backspace. `\f' Formfeed. `\n' Newline. `\r' Carriage return. `\t' Horizontal tab. `\v' Vertical tab. `\xHEX DIGITS' The character represented by the string of hexadecimal digits following the `\x'. As in ANSI C, all following hexadecimal digits are considered part of the escape sequence. (This feature should tell us something about language design by committee.) E.g., `"\x1B"' is a string containing the ASCII ESC (escape) character. (The `\x' escape sequence is not in POSIX `awk'.) `\DDD' The character represented by the 1-, 2-, or 3-digit sequence of octal digits. Thus, `"\033"' is also a string containing the ASCII ESC (escape) character. `\C' The literal character C. The escape sequences may also be used inside constant regular expressions (e.g., the regexp `/[ \t\f\n\r\v]/' matches whitespace characters). *Note Constant Expressions: Constants. File: gawk.info, Node: Functions Summary, Next: Historical Features, Prev: Rules Summary, Up: Gawk Summary Functions ========= Functions in `awk' are defined as follows: function NAME(PARAMETER LIST) { STATEMENTS } Actual parameters supplied in the function call are used to instantiate the formal parameters declared in the function. Arrays are passed by reference, other variables are passed by value. If there are fewer arguments passed than there are names in PARAMETER-LIST, the extra names are given the null string as value. Extra names have the effect of local variables. The open-parenthesis in a function call of a user-defined function must immediately follow the function name, without any intervening white space. This is to avoid a syntactic ambiguity with the concatenation operator. The word `func' may be used in place of `function' (but not in POSIX `awk'). Use the `return' statement to return a value from a function. *Note User-defined Functions: User-defined, for a more complete description. File: gawk.info, Node: Historical Features, Prev: Functions Summary, Up: Gawk Summary Historical Features =================== There are two features of historical `awk' implementations that `gawk' supports. First, it is possible to call the `length' built-in function not only with no arguments, but even without parentheses! a = length is the same as either of a = length() a = length($0) This feature is marked as "deprecated" in the POSIX standard, and `gawk' will issue a warning about its use if `-W lint' is specified on the command line. The other feature is the use of the `continue' statement outside the body of a `while', `for', or `do' loop. Traditional `awk' implementations have treated such usage as equivalent to the `next' statement. `gawk' will support this usage if `-W posix' has not been specified. File: gawk.info, Node: Sample Program, Next: Bugs, Prev: Gawk Summary, 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 Examining Fields: Fields.) to pick out the individual words from the line, and the built-in variable `NF' (*note Built-in Variables::.) 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' are not 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 some of the more advanced features of the `awk' language. First, we use `tolower' to remove case distinctions. Next, we use `gsub' to remove punctuation characters. Finally, we use the system `sort' utility to process the output of the `awk' script. First, here is the new version of the program: awk ' # Print list of word frequencies { $0 = tolower($0) # remove case distinctions gsub(/[^a-z0-9_ \t]/, "", $0) # remove punctuation for (i = 1; i <= NF; i++) freq[$i]++ } END { for (word in freq) printf "%s\t%d\n", word, freq[word] }' Assuming we have saved this program in a file named `frequency.awk', and that the data is in `file1', the following pipeline awk -f frequency.awk file1 | sort +1 -nr produces a table of the words appearing in `file1' in order of decreasing frequency. The `awk' program suitably massages the data and produces a word frequency table, which is not ordered. The `awk' script's output is then sorted by the `sort' command and printed on the terminal. The options given to `sort' in this example specify to sort using 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. We could have even done the `sort' from within the program, by changing the `END' action to: END { sort = "sort +1 -nr" for (word in freq) printf "%s\t%d\n", word, freq[word] | sort close(sort) }' See the general operating system documentation for more information on how to use the `sort' command. File: gawk.info, Node: Bugs, Next: Notes, Prev: Sample Program, Up: Top Reporting Problems and Bugs *************************** If you have problems with `gawk' or think that you have found a bug, please report it to the developers; we cannot promise to do anything but we might well want to fix it. Before reporting a bug, make sure you have actually found a real bug. Carefully reread the documentation and see if it really says you can do what you're trying to do. If it's not clear whether you should be able to do something or not, report that too; it's a bug in the documentation! Before reporting a bug or trying to fix it yourself, try to isolate it to the smallest possible `awk' program and input data file that reproduces the problem. Then send us the program and data file, some idea of what kind of Unix system you're using, and the exact results `gawk' gave you. Also say what you expected to occur; this will help us decide whether the problem was really in the documentation. Once you have a precise problem, send e-mail to (Internet) `bug-gnu-utils@prep.ai.mit.edu' or (UUCP) `mit-eddie!prep.ai.mit.edu!bug-gnu-utils'. Please include the version number of `gawk' you are using. You can get this information with the command `gawk -W version '{}' /dev/null'. You should send carbon copies of your mail to David Trueman at `david@cs.dal.ca', and to Arnold Robbins, who can be reached at `arnold@skeeve.atl.ga.us'. David is most likely to fix code problems, while Arnold is most likely to fix documentation problems. Non-bug suggestions are always welcome as well. If you have questions about things that are unclear in the documentation or are just obscure features, ask Arnold Robbins; he will try to help you out, although he may not have the time to fix the problem. You can send him electronic mail at the Internet address above. If you find bugs in one of the non-Unix ports of `gawk', please send an electronic mail message to the person who maintains that port. They are listed below, and also in the `README' file in the `gawk' distribution. Information in the `README' file should be considered authoritative if it conflicts with this manual. The people maintaining the non-Unix ports of `gawk' are: MS-DOS The port to MS-DOS is maintained by Scott Deifik. His electronic mail address is `scottd@amgen.com'. VMS The port to VAX VMS is maintained by Pat Rankin. His electronic mail address is `rankin@eql.caltech.edu'. Atari ST The port to the Atari ST is maintained by Michal Jaegermann. His electronic mail address is `ntomczak@vm.ucs.ualberta.ca'. If your bug is also reproducible under Unix, please send copies of your report to the general GNU bug list, as well as to Arnold Robbins and David Trueman, at the addresses listed above. File: gawk.info, Node: Notes, Next: Glossary, Prev: Bugs, 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: * Compatibility Mode:: How to disable certain `gawk' extensions. * Future Extensions:: New features we may implement soon. * Improvements:: Suggestions for improvements by volunteers. File: gawk.info, Node: Compatibility Mode, Next: Future Extensions, Prev: Notes, Up: Notes Downward Compatibility and Debugging ==================================== *Note Extensions in `gawk' not in POSIX `awk': POSIX/GNU, for a summary of the GNU extensions to the `awk' language and program. All of these features can be turned off by invoking `gawk' with the `-W compat' option, or with the `-W posix' option. If `gawk' is compiled for debugging with `-DDEBUG', then there is one more option available on the command line: `-W parsedebug' Print out the parse stack information as the program is being parsed. This option is intended only for serious `gawk' developers, and not for the casual user. It probably has not even been compiled into your version of `gawk', since it slows down execution. File: gawk.info, Node: Future Extensions, Next: Improvements, Prev: Compatibility Mode, Up: Notes Probable Future Extensions ========================== This section briefly lists extensions that indicate the directions we are currently considering for `gawk'. The file `FUTURES' in the `gawk' distributions lists these extensions, as well as several others. `RS' as a regexp The meaning of `RS' may be generalized along the lines of `FS'. Control of subprocess environment Changes made in `gawk' to the array `ENVIRON' may be propagated to subprocesses run by `gawk'. Databases It may be possible to map a GDBM/NDBM/SDBM file into an `awk' array. Single-character fields The null string, `""', as a field separator, will cause field splitting and the `split' function to separate individual characters. Thus, `split(a, "abcd", "")' would yield `a[1] == "a"', `a[2] == "b"', and so on. More `lint' warnings There are more things that could be checked for portability. `RECLEN' variable for fixed length records Along with `FIELDWIDTHS', this would speed up the processing of fixed-length records. `RT' variable to hold the record terminator It is occasionally useful to have access to the actual string of characters that matched the `RS' variable. The `RT' variable would hold these characters. A `restart' keyword After modifying `$0', `restart' would restart the pattern matching loop, without reading a new record from the input. A `|&' redirection The `|&' redirection, in place of `|', would open a two-way pipeline for communication with a sub-process (via `getline' and `print' and `printf'). `IGNORECASE' affecting all comparisons The effects of the `IGNORECASE' variable may be generalized to all string comparisons, and not just regular expression operations. A way to mix command line source code and library files There may be a new option that would make it possible to easily use library functions from a program entered on the command line. GNU-style long options We will add GNU-style long options to `gawk' for compatibility with other GNU programs. (For example, `--field-separator=:' would be equivalent to `-F:'.) File: gawk.info, Node: Improvements, Prev: Future Extensions, Up: Notes Suggestions for 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. 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. This method incurs a lot of overhead, since 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. This may actually happen for the 3.0 version of `gawk'. 2. 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. 3. The programs in the test suite could use documenting in this manual. 4. The programs and data files in the manual should be available in separate files to facilitate experimentation. 5. See the `FUTURES' file for more ideas. Contact us if you would seriously like to tackle any of the items listed there. 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. *Note Overview of Actions: Actions. 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 a good example of a program that would have been better written in another language. ANSI The American National Standards Institute. This organization produces many standards, among them the standard for the C programming 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". *Note Assignment Expressions: Assignment Ops. `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. Built-in Function The `awk' language provides built-in functions that perform various numerical, time stamp related, and string computations. Examples are `sqrt' (for the square root of a number) and `substr' (for a substring of a string). *Note Built-in Functions: Built-in. Built-in Variable `ARGC', `ARGIND', `ARGV', `CONVFMT', `ENVIRON', `ERRNO', `FIELDWIDTHS', `FILENAME', `FNR', `FS', `IGNORECASE', `NF', `NR', `OFMT', `OFS', `ORS', `RLENGTH', `RSTART', `RS', and `SUBSEP', are the variables that have special meaning to `awk'. Changing some of them affects `awk''s running environment. *Note Built-in Variables::. Braces See "Curly Braces." C The system programming language that most GNU software is written in. The `awk' programming language has C-like syntax, and this manual points out similarities between `awk' and C when appropriate. CHEM A preprocessor for `pic' that reads descriptions of molecules and produces `pic' input for drawing them. It was written by Brian Kernighan, and is available from `netlib@research.att.com'. Compound Statement A series of `awk' statements, enclosed in curly braces. Compound statements may be nested. *Note Control Statements in Actions: Statements. 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'. *Note String Concatenation: Concatenation. Conditional Expression An expression using the `?:' ternary operator, such as `EXPR1 ? EXPR2 : EXPR3'. The expression EXPR1 is evaluated; if the result is true, the value of the whole expression is the value of EXPR2 otherwise the value is EXPR3. In either case, only one of EXPR2 and EXPR3 is evaluated. *Note Conditional Expressions: Conditional Exp. Constant Regular Expression A constant regular expression is a regular expression written within slashes, such as `/foo/'. This regular expression is chosen when you write the `awk' program, and cannot be changed doing its execution. *Note How to Use Regular Expressions: Regexp Usage. Comparison Expression A relation that is either true or false, such as `(a < b)'. Comparison expressions are used in `if', `while', and `for' statements, and in patterns to select which input records to process. *Note Comparison Expressions: Comparison Ops. 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. *Note Conversion of Strings and Numbers: Conversion. Dynamic Regular Expression A dynamic regular expression is a regular expression written as an ordinary expression. It could be a string constant, such as `"foo"', but it may also be an expression whose value may vary. *Note How to Use Regular Expressions: Regexp Usage. Escape Sequences A special sequence of characters used for describing nonprinting characters, such as `\n' for newline, or `\033' for the ASCII ESC (escape) character. *Note Constant Expressions: Constants. 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 built-in variable `FS'). Such pieces are called fields. If the pieces are of fixed length, you can use the built-in variable `FIELDWIDTHS' to describe their lengths. *Note How Input is Split into Records: Records. 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 built-in variable `CONVFMT'. *Note Format-Control Letters: Control Letters. 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. *Note Built-in Functions: Built-in. Also, see *Note User-defined Functions: User-defined. `gawk' The GNU implementation of `awk'. GNU "GNU's not Unix". An on-going project of the Free Software Foundation to create a complete, freely distributable, POSIX-compliant computing environment. Input Record A single chunk of data read in by `awk'. Usually, an `awk' input record consists of one line of text. *Note How Input is Split into Records: Records. 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. `awk''s 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. *Note Patterns::. POSIX The name for a series of standards being developed by the IEEE that specify a Portable Operating System interface. The "IX" denotes the Unix heritage of these standards. The main standard of interest for `awk' users is P1003.2, the Command Language and Utilities standard. 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. *Note Patterns::. 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. *Note Redirecting Output of `print' and `printf': Redirection. 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. Regexps may contain escape sequences. *Note Regular Expressions as Patterns: Regexp. 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. Side Effect A side effect occurs when an expression has an effect aside from merely producing a value. Assignment expressions, increment expressions and function calls have side effects. *Note Assignment Expressions: Assignment Ops. Special File A file name interpreted internally by `gawk', instead of being handed directly to the underlying operating system. For example, `/dev/stdin'. *Note Standard I/O Streams: Special Files. 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. *Note Constant Expressions: Constants. Whitespace A sequence of blank or tab characters occurring inside an input record or a string.