


      AWK(1)                      (UNIX 5.0)                     AWK(1)



      NAME
           awk - pattern scanning and processing language

      SYNTAX
           awk [ -Fc ] [ prog ] [ parameters ] [ files ]

      DESCRIPTION
           Awk scans each input file for lines that match any of a set
           of patterns specified in prog.  With each pattern in prog
           there can be an associated action that will be performed
           when a line of a file matches the pattern.  The set of
           patterns may appear literally as prog, or in a file
           specified as -f file.  The prog string should be enclosed in
           single quotes (') to protect it from the shell.

           Parameters, in the form x=... y=... etc., may be passed to
           awk.

           Files are read in order; if there are no files, the standard
           input is read.  The file name - means the standard input.
           Each line is matched against the pattern portion of every
           pattern-action statement; the associated action is performed
           for each matched pattern.

           An input line is made up of fields separated by white space.
           (This default can be changed by using FS, see below).  The
           fields are denoted $1, $2, ...; $0 refers to the entire
           line.

           A pattern-action statement has the form:

                pattern { action }

           A missing action means print the line; a missing pattern
           always matches.  An action is a sequence of statements.  A
           statement can be one of the following:

                if ( conditional ) statement [ else statement ]
                while ( conditional ) statement
                for ( expression ; conditional ; expression ) statement
                break
                continue
                { [ statement ] ... }
                variable = expression
                print [ expression-list ] [ >expression ]
                printf format [ , expression-list ] [ >expression ]
                next # skip remaining patterns on this input line
                exit # skip the rest of the input

           Statements are terminated by semicolons, new-lines, or right
           braces.  An empty expression-list stands for the whole line.
           Expressions take on string or numeric values as appropriate,



      Page 1                                          (73 A2 02MT REV1)






      AWK(1)                      (UNIX 5.0)                     AWK(1)



           and are built using the operators +, -, *, /, %, and
           concatenation (indicated by a blank).  The C operators ++,
           --, +=, -=, *=, /=, and %= are also available in
           expressions.  Variables may be real numbers, array elements
           (denoted x[i]) or fields.  Variables are initialized to the
           null string.  Array subscripts may be any numeric or
           character string; this allows for a form of associative
           memory.  String constants are quoted (").

           The print statement prints its arguments on the standard
           output (or on a file if >expr is present), separated by the
           current output field separator, and terminated by the output
           record separator.  The printf statement formats its
           expression list according to the format (see printf(3S)).

           The built-in function length returns the length of its
           argument taken as a string, or of the whole line if no
           argument.  There are also built-in functions exp, log, sqrt,
           and int.  The last truncates its argument to an integer;
           substr(s, m, n) returns the n-character substring of s that
           begins at position m.  The function
           sprintf(fmt, expr, expr, ...) formats the expressions
           according to the printf(3S) format given by fmt and returns
           the resulting string.

           Patterns are arbitrary Boolean combinations ( !, ||, &&, and
           parentheses) of regular expressions and relational
           expressions.  Regular expressions must be surrounded by
           slashes as in egrep (see grep(1)).  Isolated regular
           expressions in a pattern apply to the entire line.  Regular
           expressions may also occur in relational expressions.  A
           pattern may consist of two patterns separated by a comma; in
           this case, the action is performed for all lines between an
           occurrence of the first pattern and the next occurrence of
           the second.

           A relational expression is one of the following:

                expression matchop regular-expression
                expression relop expression

           where a relop is any of the six relational operators in C,
           and a matchop is either ~ (for contains) or !~ (for does not
           contain).  A conditional is an arithmetic expression, a
           relational expression, or a Boolean combination of these.

           The special patterns BEGIN and END may be used to capture
           control before the first and after the last input line is
           read.  BEGIN must be the first pattern, END the last.

           A single character c may be used to separate the fields by
           starting the program with:



      Page 2                                          (73 A2 02MT REV1)






      AWK(1)                      (UNIX 5.0)                     AWK(1)



                BEGIN { FS = c }

           or by using the -Fc option.

           Other variable names with special meanings include NF, the
           number of fields in the current record; NR, the ordinal
           number of the current record; FILENAME, the name of the
           current input file; OFS, the output field separator (default
           blank); ORS, the output record separator (default new-line);
           and OFMT, the output format for numbers (default %.6g).

      EXAMPLES
           Print lines longer than 72 characters:

                length > 72

           Print first two fields in opposite order:

                { print $2, $1 }

           Add up first column, print sum and average:

                     { s += $1 }
                END  { print "sum is", s, " average is", s/NR }

           Print fields in reverse order:

                { for (i = NF; i > 0; --i) print $i }

           Print all lines between start/stop pairs:

                /start/, /stop/

           Print all lines whose first field is different from previous
           one:

                $1 != prev { print; prev = $1 }

           Print file, filling in page numbers starting at 5:

                /Page/ { $2 = n++; }
                       { print }

                command line:  awk -f program n=5 input

      SEE ALSO
           grep(1), lex(1), sed(1).
           Awk-A Pattern Scanning and Processing Language in ROS
           Utility Guide .

      BUGS
           Input white space is not preserved on output if fields are



      Page 3                                          (73 A2 02MT REV1)






      AWK(1)                      (UNIX 5.0)                     AWK(1)



           involved.
           There are no explicit conversions between numbers and
           strings.  To force an expression to be treated as a number,
           add 0 to it. To force it to be treated as a string,
           concatenate the null string ("") to it.


















































      Page 4                                          (73 A2 02MT REV1)



