Command:   awk  pattern matching language
     Syntax:    awk rules [file] ...
     Flags:     (none)
     Examples:  awk rules input          # Process input  accord-
                                           ing to rules
     Examples:  awk rules   >out         # Input  from  terminal,
                                           output to out

     AWK is a programming language devised  by  Aho,  Weinberger,
     and  Kernighan  at Bell Labs (hence the name).  Awk programs
     search files for specific patterns  and  performs  'actions'
     for every occurrence of these patterns.  The patterns can be
     'regular expressions' as used in the ed editor.  The actions
     are expressed using a subset of the C language.

     The patterns and actions are usually  placed  in  a  'rules'
     file  whose  name  must be the first argument in the command
     line, preceded by the flag f.  Otherwise, the first argument
     on  the  command line is taken to be a string containing the
     rules themselves. All other arguments are taken  to  be  the
     names  of  text  files on which the rules are to be applied,
     with  being the standard input.   To  take  rules  from  the
     standard input, use f .

     The command:
             awk  rules  prog.*
     would read the patterns and  actions  rules  from  the  file
     rules and apply them to all the arguments.

     The general format of a rules file is:
        <pattern> { <action> }    <pattern> { <action> }    ...
     There may be any number of  these  <pattern>  {  <action>  }
     sequences in the rules file.  Awk reads a line of input from
     the  current  input  file  and  applies  every  <pattern>  {
     <action> } in sequence to the line.

     If the <pattern> corresponding to any { <action> } is  miss-
     ing,  the  action  is  applied  to every line of input.  The
     default { <action> } is to print the matched input line.

     Patterns

     The <pattern>s may consist of any valid  C  expression.   If
     the  <pattern>  consists  of  two expressions separated by a
     comma, it is taken to be a range and the  <action>  is  per-
     formed   on  all  lines  of  input  that  match  the  range.
     <pattern>s may contain 'regular expressions' delimited by an
     @  symbol.   Regular expressions can be thought of as a gen-
     eralized 'wildcard' string matching  mechanism,  similar  to
     that  used  by many operating systems to specify file names.
     Regular expressions may contain any of the following charac-
     ters:
       x    An ordinary character
       \    The backslash quotes any character
       ^    A circumflex at the beginning of an expr matches  the
            beginning of a line.
       $    A dollar-sign at the end of an expression matches the
            end of a line.
       .    A period matches any single character except newline.
       *    An expression followed by an asterisk matches zero or
            more  occurrences  of  that expression: 'fo*' matches
            'f', 'fo', 'foo', 'fooo', etc.
       +    An expression followed by a plus sign matches one  or
            more  occurrences  of  that expression: 'fo+' matches
            'fo', 'foo', 'fooo', etc.
       []   A string enclosed in square brackets matches any sin-
            gle  character in that string, but no others.  If the
            first character in the string is  a  circumflex,  the
            expression  matches  any character except newline and
            the characters in the string.  For  example,  '[xyz]'
            matches  'xx' and 'zyx', while '[^xyz]' matches 'abc'
            but not 'axb'.  A range of characters may  be  speci-
            fied by two characters separated by '-'.

    Actions

     Actions are expressed as a subset of the  C  language.   All
     variables  are  global  and default to int's if not formally
     declared. Only char's and int's and pointers and  arrays  of
     char  and  int are allowed.  Awk allows only decimal integer
     constants to be used-no hex (0xnn) or  octal  (0nn).  String
     and  character  constants  may  contain all of the special C
     escapes (\n, \r, etc.).

     Awk supports the 'if', 'else', 'while' and 'break'  flow  of
     control constructs, which behave exactly as in C.

     Also supported are the following unary and binary operators,
     listed in order from highest to lowest precedence:
       Operator       Type         Associativity
       () []          unary        left to right
       ! ~ ++   * &   unary        right to left
       * / %          binary       left to right
       +              binary       left to right
       << >>          binary       left to right
       < <= > >=      binary       left to right
       == !=          binary       left to right
       &              binary       left to right
       ^              binary       left to right
       |              binary       left to right
       &&             binary       left to right
       ||             binary       left to right
       =              binary       right to left
     Comments are introduced by a '#' symbol and  are  terminated
     by  the first newline character.  The standard '/*' and '*/'
     comment delimiters are not supported and will  result  in  a
     syntax error.


     Fields


     When awk reads a line  from  the  current  input  file,  the
     record is automatically separated into 'fields.'  A field is
     simply a  string  of  consecutive  characters  delimited  by
     either  the beginning or end of line, or a 'field separator'
     character.  Initially, the field separators  are  the  space
     and  tab  character.  The special unary operator '$' is used
     to reference one of the fields in the current  input  record
     (line).  The fields are numbered sequentially starting at 1.
     The expression '$0' references the entire input line.

     Similarly, the 'record separator' is used to  determine  the
     end  of  an  input  'line,' initially the newline character.
     The field and record separators may be  changed  programati-
     cally  by one of the actions and will remain in effect until
     changed again.

     Multiple (up to 10) field separators are allowed at a  time,
     but only one record separator.

     Fields behave exactly like strings; and can be used  in  the
     same  context  as  a character array.  These 'arrays' can be
     considered to have been declared as:

          char ($n)[ 128 ];

     In other words, they are 128 bytes long.   Notice  that  the
     parentheses  are  necessary  because  the operators [] and $
     associate from right to left; without  them,  the  statement
     would have parsed as:

          char $(1[ 128 ]);

     which is obviously ridiculous.

     If the contents of one of these field arrays is altered, the
     '$0'  field  will  reflect  this  change.  For example, this
     expression:

          *$4 = 'A';

     will change the first character of the fourth  field  to  an
     upper-  case  letter  'A'.   Then,  when the following input
     line:

          120 PRINT "Name         address        Zip"

     is processed, it would be printed as:

          120 PRINT "Name         Address        Zip"

     Fields may also be modified with the strcpy() function  (see
     below).  For example, the expression:
          strcpy( $4, "Addr." );
     applied to the same line above would yield:
          120 PRINT "Name         Addr.        Zip"

     Predefined Variables

     The following variables are pre-defined:
       FS          Field separator (see below).
       RS          Record separator (see below also).
       NF          Number  of  fields  in  current  input  record
                    (line).
       NR          Number of records processed thus far.
       FILENAME    Name of current input file.
       BEGIN       A special <pattern> that matches the beginning
                    of input text.
       END         A special <pattern> that matches  the  end  of
                    input text.
     Awk also provides some useful built-in functions for  string
     manipulation and printing:
       print(arg)  Simple printing of strings only, terminated by
                    '\n'.
       printf(arg...)Exactly the printf() function from C.
       getline()   Reads the next record and returns 0 on end  of
                    file.
       nextfile()  Closes the current input file and begins  pro-
                    cessing the next file
       strlen(s)   Returns the length of its string argument.
       strcpy(s,t) Copies the string 't' to the string 's'.
       strcmp(s,t) Compares the 's' to 't' and returns 0 if  they
                    match.
       toupper(c)  Returns its character  argument  converted  to
                    upper-case.
       tolower(c)  Returns its character  argument  converted  to
                    lower-case.
       match(s,@re@)Compares  the  string  's'  to  the   regular
                    expression  're'  and  returns  the number of
                    matches found (zero if none).

     Authors

     Awk was written  by  Saeko  Hirabauashi  and  Kouichi  Hira-
     bayashi.