


      AAAAWWWWKKKK((((1111))))                      ((((UUUUNNNNIIIIXXXX 5555....0000))))                     AAAAWWWWKKKK((((1111))))



      NNNNAAAAMMMMEEEE
           awk - pattern scanning and processing language

      SSSSYYYYNNNNTTTTAAAAXXXX
           aaaawwwwkkkk [ ----FFFFc ] [ prog ] [ parameters ] [ files ]

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

           _P_a_r_a_m_e_t_e_r_s, in the form x=... y=... etc., may be passed to
           _a_w_k.

           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 $$$$1111, $$$$2222, ...; $$$$0000 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                                                   (9010-E)






      AAAAWWWWKKKK((((1111))))                      ((((UUUUNNNNIIIIXXXX 5555....0000))))                     AAAAWWWWKKKK((((1111))))



           and are built using the operators ++++, ----, ****, ////, %%%%, and
           concatenation (indicated by a blank).  The CCCC 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 _p_r_i_n_t statement prints its arguments on the standard
           output (or on a file if >>>>_e_x_p_r is present), separated by the
           current output field separator, and terminated by the output
           record separator.  The _p_r_i_n_t_f statement formats its
           expression list according to the format (see _p_r_i_n_t_f(3S)).

           The built-in function _l_e_n_g_t_h returns the length of its
           argument taken as a string, or of the whole line if no
           argument.  There are also built-in functions _e_x_p, _l_o_g, _s_q_r_t,
           and _i_n_t.  The last truncates its argument to an integer;
           _s_u_b_s_t_r(_s, _m, _n) returns the _n-character substring of _s that
           begins at position _m.  The function
           _s_p_r_i_n_t_f(_f_m_t, _e_x_p_r, _e_x_p_r, ...) formats the expressions
           according to the _p_r_i_n_t_f(3S) format given by _f_m_t 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 _e_g_r_e_p (see _g_r_e_p(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 _c_o_n_t_a_i_n_s) or !!!!~~~~ (for _d_o_e_s _n_o_t
           _c_o_n_t_a_i_n).  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                                                   (9010-E)






      AAAAWWWWKKKK((((1111))))                      ((((UUUUNNNNIIIIXXXX 5555....0000))))                     AAAAWWWWKKKK((((1111))))



                BEGIN { FS = _c }

           or by using the ----FFFF_c 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 %%%%....6666gggg).

      EEEEXXXXAAAAMMMMPPPPLLLLEEEESSSS
           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

      SSSSEEEEEEEE AAAALLLLSSSSOOOO
           grep(1), lex(1), sed(1).
           _A_w_k-_A _P_a_t_t_e_r_n _S_c_a_n_n_i_n_g _a_n_d _P_r_o_c_e_s_s_i_n_g _L_a_n_g_u_a_g_e in _R_O_S
           _U_t_i_l_i_t_y _G_u_i_d_e .

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



      Page 3                                                   (9010-E)






      AAAAWWWWKKKK((((1111))))                      ((((UUUUNNNNIIIIXXXX 5555....0000))))                     AAAAWWWWKKKK((((1111))))



           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                                                   (9010-E)



