Return to awk.1 CVS log

Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / usr / src / man / man1

Annotation of cci/usr/src/man/man1/awk.1, revision 1.1

1.1     ! root        1: .TH AWK 1 "18 January 1983"
        !             2: .SH NAME
        !             3: awk \- pattern scanning and processing language
        !             4: .SH SYNOPSIS
        !             5: .B awk
        !             6: [
        !             7: .BI \-F c
        !             8: ]
        !             9: [ prog ] [ file ] ...
        !            10: .SH DESCRIPTION
        !            11: .I Awk
        !            12: scans each input
        !            13: .I file
        !            14: for lines that match any of a set of patterns specified in
        !            15: .IR prog .
        !            16: With each pattern in
        !            17: .I prog
        !            18: there can be an associated action that will be performed
        !            19: when a line of a
        !            20: .I file
        !            21: matches the pattern.
        !            22: The set of patterns may appear literally as
        !            23: .I prog,
        !            24: or in a file
        !            25: specified as
        !            26: .B \-f
        !            27: .IR file .
        !            28: .PP
        !            29: Files are read in order;
        !            30: if there are no files, the standard input is read.
        !            31: The file name `\-'
        !            32: means the standard input.
        !            33: Each line is matched against the
        !            34: pattern portion of every pattern-action statement;
        !            35: the associated action is performed for each matched pattern.
        !            36: .PP
        !            37: An input line is made up of fields separated by white space.
        !            38: (This default can be changed by using FS,
        !            39: .IR "vide infra" ".)"
        !            40: The fields are denoted $1, $2, ... ;
        !            41: $0 refers to the entire line.
        !            42: .PP
        !            43: .PP
        !            44: A pattern-action statement has the form
        !            45: .PP
        !            46:        pattern { action }
        !            47: .PP
        !            48: A missing { action } means print the line;
        !            49: a missing pattern always matches.
        !            50: .PP
        !            51: An action is a sequence of statements.
        !            52: A statement can be one of the following:
        !            53: .PP
        !            54: .nf
        !            55:        if ( conditional ) statement [ else statement ]
        !            56:        while ( conditional ) statement
        !            57:        for ( expression ; conditional ; expression ) statement
        !            58:        break
        !            59:        continue
        !            60:        { [ statement ] ... }
        !            61:        variable = expression
        !            62:        print [ expression-list ] [ >expression ]
        !            63:        printf format [ , expression-list ] [ >expression ]
        !            64:        next    # skip remaining patterns on this input line 
        !            65:        exit    # skip the rest of the input
        !            66: .fi
        !            67: .PP
        !            68: Statements are terminated by
        !            69: semicolons, newlines or right braces.
        !            70: An empty expression-list stands for the whole line.
        !            71: Expressions take on string or numeric values as appropriate,
        !            72: and are built using the operators
        !            73: +, \-, *, /, %,  and concatenation (indicated by a blank).
        !            74: The C operators ++, \-\-, +=, \-=, *=, /=, and %=
        !            75: are also available in expressions.
        !            76: Variables may be scalars, array elements
        !            77: (denoted
        !            78: x[i])
        !            79: or fields.
        !            80: Variables are initialized to the null string.
        !            81: Array subscripts may be any string,
        !            82: not necessarily numeric;
        !            83: this allows for a form of associative memory.
        !            84: String constants are quoted "...".
        !            85: .PP
        !            86: The 
        !            87: .I print
        !            88: statement prints its arguments on the standard output
        !            89: (or on a file if 
        !            90: .I >file
        !            91: is present), separated by the current output field separator,
        !            92: and terminated by the output record separator.
        !            93: The
        !            94: .I printf
        !            95: statement formats its expression list according to the format
        !            96: (see
        !            97: .IR printf (3S)).
        !            98: .PP
        !            99: The built-in function
        !           100: .I length
        !           101: returns the length of its argument
        !           102: taken as a string,
        !           103: or of the whole line if no argument.
        !           104: There are also built-in functions
        !           105: .I exp,
        !           106: .I log,
        !           107: .I sqrt,
        !           108: and
        !           109: .IR int .
        !           110: The last truncates its argument to an integer.
        !           111: .IR substr(s,\ m,\ n)
        !           112: returns the 
        !           113: .IR n -character
        !           114: substring of
        !           115: .I s
        !           116: that begins at position
        !           117: .IR m .
        !           118: The function
        !           119: .IR sprintf(fmt,\ expr,\ expr,\ ...)
        !           120: formats the expressions
        !           121: according to the
        !           122: .IR printf (3S)
        !           123: format given by
        !           124: .I fmt
        !           125: and returns the resulting string.
        !           126: .PP
        !           127: Patterns are arbitrary Boolean combinations
        !           128: (!, \(or\(or, &&, and parentheses) of 
        !           129: regular expressions and
        !           130: relational expressions.
        !           131: Regular expressions must be surrounded
        !           132: by slashes and are as in
        !           133: .IR egrep .
        !           134: Isolated regular expressions
        !           135: in a pattern apply to the entire line.
        !           136: Regular expressions may also occur in
        !           137: relational expressions.
        !           138: .PP
        !           139: A pattern may consist of two patterns separated by a comma;
        !           140: in this case, the action is performed for all lines
        !           141: between an occurrence of the first pattern
        !           142: and the next occurrence of the second.
        !           143: .PP
        !           144: .nf
        !           145: A relational expression is one of the following:
        !           146: .PP
        !           147: .nf
        !           148:        expression matchop regular-expression
        !           149:        expression relop expression
        !           150: .PP
        !           151: .fi
        !           152: where a relop is any of the six relational operators in C,
        !           153: and a matchop is either ~ (for contains)
        !           154: or !~ (for does not contain).
        !           155: A conditional is an arithmetic expression,
        !           156: a relational expression,
        !           157: or a Boolean combination
        !           158: of these.
        !           159: .PP
        !           160: The special patterns
        !           161: BEGIN
        !           162: and
        !           163: END
        !           164: may be used to capture control before the first input line is read
        !           165: and after the last.
        !           166: BEGIN must be the first pattern, END the last.
        !           167: .PP
        !           168: A single character
        !           169: .I c
        !           170: may be used to separate the fields by starting
        !           171: the program with
        !           172: .PP
        !           173:        BEGIN { FS = "c" }
        !           174: .PP
        !           175: or by using the
        !           176: .BI \-F c
        !           177: option.
        !           178: .PP
        !           179: Other variable names with special meanings
        !           180: include NF, the number of fields in the current record;
        !           181: NR, the ordinal number of the current record;
        !           182: FILENAME, the name of the current input file;
        !           183: OFS, the output field separator (default blank);
        !           184: ORS, the output record separator (default newline);
        !           185: and
        !           186: OFMT, the output format for numbers (default "%.6g").
        !           187: .PP
        !           188: .SH EXAMPLES
        !           189: .PP
        !           190: Print lines longer than 72 characters:
        !           191: .PP
        !           192: .nf
        !           193:        length > 72
        !           194: .fi
        !           195: .PP
        !           196: Print first two fields in opposite order:
        !           197: .PP
        !           198: .nf
        !           199:        { print $2, $1 }
        !           200: .fi
        !           201: .PP
        !           202: Add up first column, print sum and average:
        !           203: .PP
        !           204: .nf
        !           205:                { s += $1 }
        !           206:        END     { print "sum is", s, " average is", s/NR }
        !           207: .fi
        !           208: .PP
        !           209: Print fields in reverse order:
        !           210: .PP
        !           211: .nf
        !           212:        { for (i = NF; i > 0; \-\-i) print $i }
        !           213: .fi
        !           214: .PP
        !           215: Print all lines between start/stop pairs:
        !           216: .PP
        !           217: .nf
        !           218:        /start/, /stop/
        !           219: .fi
        !           220: .PP
        !           221: Print all lines whose first field is different from previous one:
        !           222: .PP
        !           223: .nf
        !           224:        $1 != prev { print; prev = $1 }
        !           225: .fi
        !           226: .SH SEE ALSO
        !           227: .PP
        !           228: lex(1), sed(1)
        !           229: .br
        !           230: A. V. Aho, B. W. Kernighan, P. J. Weinberger,
        !           231: .I
        !           232: Awk \- a pattern scanning and processing language
        !           233: .SH BUGS
        !           234: There are no explicit conversions between numbers and strings.
        !           235: To force an expression to be treated as a number add 0 to it;
        !           236: to force it to be treated as a string concatenate ""
        !           237: to it.

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.