312 lines
6.0 KiB
Groff
312 lines
6.0 KiB
Groff
.nr X
|
|
.if \nX=0 .ds x} oawk 1 "Directory and File Management Utilities" "\&"
|
|
.TH \*(x}
|
|
.tr `
|
|
.SH NAME
|
|
oawk \- pattern scanning and processing language
|
|
.SH SYNOPSIS
|
|
.nf
|
|
\f3oawk\f1 [ \f3\-F\f1c ] [ prog ] [ parameters ] [ files ]
|
|
.fi
|
|
.SH DESCRIPTION
|
|
.I oawk
|
|
scans each input
|
|
.I file
|
|
for lines that match any of a set of patterns specified in
|
|
.IR prog .
|
|
With each pattern in
|
|
.I prog
|
|
there can be an associated action that will be performed
|
|
when a line of a
|
|
.I file
|
|
matches the pattern.
|
|
The set of patterns may appear literally as
|
|
.IR prog ,
|
|
or in a file
|
|
specified as
|
|
.B \-f
|
|
.IR file .
|
|
The
|
|
.I prog
|
|
string should be enclosed in single quotes
|
|
.RB ( \(fm )
|
|
to protect it from the shell.
|
|
.PP
|
|
.I Parameters,
|
|
in the form x=...
|
|
y=...
|
|
etc., may be passed to
|
|
.I oawk.
|
|
.PP
|
|
Files are read in order;
|
|
if there are no files, the standard input is read.
|
|
The filename
|
|
.B \-
|
|
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.
|
|
.PP
|
|
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
|
|
.BR $1 ,
|
|
.BR $2 ,
|
|
\&...;
|
|
.B $0
|
|
refers to the entire line.
|
|
.PP
|
|
.PP
|
|
A pattern-action statement has the form:
|
|
.PP
|
|
.RS
|
|
pattern { action }
|
|
.RE
|
|
.PP
|
|
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:
|
|
.PP
|
|
.RS
|
|
.nf
|
|
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
|
|
.fi
|
|
.RE
|
|
.PP
|
|
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,
|
|
and are built using the operators
|
|
.BR + ,
|
|
.BR \- ,
|
|
.BR \(** ,
|
|
.BR / ,
|
|
.BR % ,
|
|
and concatenation (indicated by a blank).
|
|
The
|
|
.BR C operators
|
|
.BR ++ ,
|
|
.BR \-\- ,
|
|
.BR += ,
|
|
.BR \-= ,
|
|
.BR \(**= ,
|
|
.BR /= ,
|
|
and
|
|
.B %=
|
|
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 numeric;
|
|
this allows for a form of associative memory.
|
|
String constants are quoted (\f3"\fP).
|
|
.PP
|
|
The
|
|
.I print
|
|
statement prints its arguments on the standard output
|
|
(or on a file if
|
|
.BI > expr
|
|
is present), separated by the current output field separator,
|
|
and terminated by the output record separator.
|
|
The
|
|
.I printf
|
|
statement formats its expression list according to the format
|
|
(see \f2printf\f1(3S)).
|
|
.PP
|
|
The built-in function
|
|
.I 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
|
|
.IR exp ,
|
|
.IR log ,
|
|
.IR sqrt ,
|
|
and
|
|
.IR int .
|
|
The last truncates its argument to an integer;
|
|
.IR substr ( s , `m ,\c
|
|
.IR `n )
|
|
returns the
|
|
.IR n -character
|
|
substring of
|
|
.I s
|
|
that begins at position
|
|
.IR m .
|
|
The function
|
|
.IR sprintf ( fmt , `expr ,\c
|
|
.IR `expr , `... )
|
|
formats the expressions
|
|
according to the
|
|
.IR printf (3S)
|
|
format given by
|
|
.I fmt
|
|
and returns the resulting string.
|
|
.PP
|
|
Patterns are arbitrary Boolean combinations
|
|
(
|
|
.BR ! ,
|
|
\(bv\(bv,
|
|
.BR && ,
|
|
and parentheses) of
|
|
regular expressions and
|
|
relational expressions.
|
|
Regular expressions must be surrounded
|
|
by slashes and are as in
|
|
.I egrep
|
|
(see
|
|
.IR 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.
|
|
.PP
|
|
A relational expression is one of the following:
|
|
.PP
|
|
.RS
|
|
expression matchop regular-expression
|
|
.br
|
|
expression relop expression
|
|
.RE
|
|
.PP
|
|
where a relop is any of the six relational operators in C,
|
|
and a matchop is either
|
|
.B ~
|
|
(for
|
|
.IR contains )
|
|
or
|
|
.B !~
|
|
(for
|
|
.IR "does not contain" ).
|
|
A conditional is an arithmetic expression,
|
|
a relational expression,
|
|
or a Boolean combination
|
|
of these.
|
|
.PP
|
|
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.
|
|
.PP
|
|
A single character
|
|
.I c
|
|
may be used to separate the fields by starting
|
|
the program with:
|
|
.PP
|
|
.RS
|
|
BEGIN { FS = \f2c\fP }
|
|
.RE
|
|
.PP
|
|
or by using the
|
|
.BI \-F c
|
|
option.
|
|
.PP
|
|
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
|
|
.BR %.6g ).
|
|
.PP
|
|
.SH EXAMPLES
|
|
Print lines longer than 72 characters:
|
|
.PP
|
|
.RS
|
|
length > 72
|
|
.RE
|
|
.PP
|
|
Print first two fields in opposite order:
|
|
.PP
|
|
.RS
|
|
{ print $2, $1 }
|
|
.RE
|
|
.PP
|
|
Add up first column, print sum and average:
|
|
.PP
|
|
.RS
|
|
{ s += $1 }
|
|
.br
|
|
END { print "sum is", s, " average is", s/NR }
|
|
.RE
|
|
.PP
|
|
Print fields in reverse order:
|
|
.PP
|
|
.RS
|
|
{ for (i = NF; i > 0; \-\-i) print $i }
|
|
.RE
|
|
.PP
|
|
Print all lines between start/stop pairs:
|
|
.PP
|
|
.RS
|
|
/start/, /stop/
|
|
.RE
|
|
.PP
|
|
Print all lines whose first field is different from previous one:
|
|
.PP
|
|
.RS
|
|
$1 != prev { print; prev = $1 }
|
|
.RE
|
|
.PP
|
|
Print file, filling in page numbers starting at 5:
|
|
.PP
|
|
.RS
|
|
/Page/ { $2 = n++; }
|
|
{ print }
|
|
.RE
|
|
.PP
|
|
command line: oawk \-f program n=5 input
|
|
.SH SEE ALSO
|
|
awk(1),
|
|
grep(1),
|
|
lex(1),
|
|
perl(1),
|
|
sed(1),
|
|
printf(3S).
|
|
.SH BUGS
|
|
Input white space is not preserved on output if fields are involved.
|
|
.br
|
|
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
|
|
(\f3""\fP) to it.
|
|
.tr ``
|
|
.\" @(#)oawk.1 6.2 of 9/2/83
|