Museum

Home

Lab Overview

Retrotechnology Articles

Online Manuals

⇒ awk(1) — GENIX 4.1A

Media Vault

Software Library

Restoration Projects

Artifacts Sought

Related Articles

lex(1)

sed(1)



      AWK(1)                  GENIX Programmer's Manual                  AWK(1)



      NAME
           awk - pattern scanning and processing language

      SYNOPSIS
           awk [ -Fc ] [ prog ] [ file ] ...

      DESCRIPTION
           Awk scans each input file for lines that match any of a set of  pat-
           terns  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.

           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  state-
           ment; 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, vide infra.) 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, newlines or  right  braces.
           An  empty  expression-list  stands  for the whole line.  Expressions
           take on string or numeric values as appropriate, and are built using
           the  operators  +,  -,  *,  /, %,  and concatenation (indicated by a
           blank).  The C operators ++, --, +=, -=, *=, /=,  and  %=  are  also
           available  in expressions.  Variables may be scalars, array elements
           (denoted x[i]) or fields.  Variables are  initialized  to  the  null
           string.   Array  subscripts  may  be  any  string,  not  necessarily



      Printed 11/16/83                                                        1





      AWK(1)                  GENIX Programmer's Manual                  AWK(1)



           numeric; this allows for a form of associative memory.  String  con-
           stants are quoted "...".

           The print statement prints its arguments on the standard output  (or
           on  a  file  if  >file  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(3)).

           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(3) 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  and  are  as  in
           egrep.   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 input line is read and after the last.  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

                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



      Printed 11/16/83                                                        2





      AWK(1)                  GENIX Programmer's Manual                  AWK(1)



           output  field  separator  (default  blank);  ORS,  the output record
           separator (default newline); 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 }

      SEE ALSO
           lex(1), sed(1)
           A. V. Aho, B. W. Kernighan, P. J. Weinberger, Awk - a pattern  scan-
           ning and processing language

      BUGS
           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 "" to it.
















      Printed 11/16/83                                                        3



Typewritten Software • bear@typewritten.org • Edmonds, WA 98026