perl(1) CLIX perl(1)
NAME
perl - Runs a practical extraction and report language
SYNOPSIS
perl [flags] filename args
FLAGS
-e The next argument is a command.
-0digits Specifies the record separator ($/) as an octal number. If
there are no digits, the null character is the separator. Other
switches may precede or follow the digits.
The special value 00 causes perl to process files in paragraph mode.
The value 0777 causes perl to process files whole, since no legal
character has that value.
-a Turns on autosplit mode when used with a -n or -p. An implicit split
command to the @F array is the first operation performed inside the
implicit while loop produced by the -n or -p.
-c Checks the syntax of the script and exits
-d Runs the script under the perl debugger. See the section on
Debugging.
-Dnumber
Sets debugging flags.
-ecommandline
Enters one line of script. Use multiple -e commands to build up a
multiline script. If -e is given, perl does not expect a script
filename in the argument list.
-iextension
Specifies that files processed by the <> construct are to be edited
in-place. The perl program renames the input file, opening the
output file by the same name, and selects that output file as the
default for print statements. The extension, if supplied, is added
to the name of the old file to make a backup copy. If no extension
is supplied, no backup is made.
-p Causes perl to iterate over filename arguments. Lines are printed
automatically. To suppress printing, use the -n switch. A -p
overrides a -n switch.
Used in conjunction with -P to tell the C preprocessor where to look
for include files. By default, /usr/include and /usr/lib/perl are
searched.
2/94 - Intergraph Corporation 1
perl(1) CLIX perl(1)
-loctnum
Enables automatic line-ending processing. It has two effects:
first, it automatically chops the line terminator when used with -n
or -p ; second, it assigns $\ to have the value of octnum so that any
print statements will have that line terminator added back on. If
octnum is omitted, sets $\ to the current value of $/.
-n Causes perl to iterate over filename arguments. Note that the lines
are not printed by default. See -p to have lines printed.
-P Applies the C preprocessor to your script before compilation by perl.
(Since both comments and cpp directives begin with the # character,
you should avoid starting comments with any words recognized by the C
preprocessor such as if, else or define.)
-s Enables rudimentary switch parsing for switches on the command line
after the script name but before any filename arguments (or before a
--). Any switch found in this position is removed from @ARGV and
sets the corresponding variable in the perl script.
-S Causes perl use the PATH environment variable to search for the
script (unless the name of the script starts with a slash). This can
be used to emulate #! startup on machines that don't support #!.
-u Causes perl to dump core after compiling your script.
-U Allows perl to do unsafe operations. Currently, the only "unsafe"
operation is the unlinking of directories while running as superuser.
-v Prints the version and patchlevel of your perl executable.
-w Prints warnings about identifiers that are mentioned only once, and
scalar variables that are used before being set. Also warns about
redefined subroutines, and references to undefined filehandles or
filehandles opened read-only that you are attempting to write on.
Also warns you if you use == on values that don't look like numbers,
and if your subroutines recurse more than 100 deep.
-xdirectory
Informs perl that the script is embedded in a message. Leading
garbage will be discarded until the first line that starts with #!
and contains the string "perl". Any meaningful switches on that line
will be applied (but only one group of switches, as with normal #!
processing). If a directory name is specified, perl will switch to
that directory before running the script. The -x switch only
controls the the disposal of leading garbage. The script must be
terminated with __END__ if there is trailing garbage to be ignored
(the script can process any or all of the trailing garbage via the
DATA filehandle if desired).
DESCRIPTION
2 Intergraph Corporation - 2/94
perl(1) CLIX perl(1)
The perl language is an interpreted language optimized for scanning
arbitrary text files, extracting information from those text files, and
printing reports based on that information. It also facilitates many
system management tasks. It combines features of C, sed, awk, and sh.
Expression syntax corresponds quite closely to C expression syntax.
Unlike most UNIX utilities, perl does not arbitrarily limit the size of
your data. If your workstation has the memory, perl can load an entire
file as a single string. Recursion is of unlimited depth. The hash
tables used by associative arrays grow as necessary to prevent degraded
performance.
The perl language uses sophisticated pattern matching techniques to scan
large amounts of data very quickly. Although optimized for scanning text,
perl can also deal with binary data, and can make dbm files look like
associative arrays (where dbm is available).
The perl language can be used for problems which exceed the capabilities
of sed, awk or sh, and can run a little faster. Translators are available
to turn sed and awk scripts into perl scripts.
Upon startup, perl looks for your script in one of the following places:
⊕ Specified line by line via -e switches on the command line.
⊕ Contained in the file specified by the first filename on the command
line. (Note that systems supporting #! notation invoke interpreters
this way.)
⊕ Passed in implicitly via standard input. There must be no filename
arguments. To pass arguments to a stdin script, you must explicitly
specify a - for the script name.
After locating your script, perl compiles it to an internal form and
executes it if it is syntactically correct.
You can use eof to locate the end of each input file, in case you want to
append data to each file, or reset line numbering (see example under eof).
Note that the assignment $ = $/ is made when the switch is processed, so
the input record separator can be different from the output record
separator if the -l switch is followed by a -0 switch:
gnufind / -print0 | perl -ln0e 'print "found $_" if -p'
This sets $\ to newline and then sets $/ to the null character.
The -S flag causes perl to use the PATH environment variable to search for
the script (unless the name of the script starts with /). Typically this
is used to emulate #! startup on machines that don't support #!, in the
following manner:
2/94 - Intergraph Corporation 3
perl(1) CLIX perl(1)
#!/usr/bin/perl
eval "exec /usr/bin/perl -S $0 $*"
if $running_under_some_shell;
The system ignores the first line and feeds the script to /bin/sh, which
proceeds to try to execute the perl script as a shell script. The shell
executes the second line as a normal shell command, and thus starts up the
perl interpreter. On some systems $0 doesn't always contain the full
pathname, so the -S tells perl to search for the script if necessary.
After perl locates the script, it parses the lines and ignores them
because the variable $running_under_some_shell is never true. A better
construct than $* would be ${1+"$@"}, which handles embedded spaces and
such in the filenames, but doesn't work if the script is being interpreted
by csh. To start up sh rather than csh, some systems may have to replace
the #! line with a line containing just a colon, which will be ignored by
perl. Other systems need a different construct that will work under any
of csh, sh or perl, such as the following:
eval '(exit $?0)' && eval 'exec /usr/bin/perl -S $0 ${1+"$@"}'
& eval 'exec /usr/bin/perl -S $0 $argv:q'
if 0;
You can convert the core dump produced by the -u flag into an executable
file by using the undump program (not supplied). This speeds startup at
the expense of some disk space (which you can minimize by stripping the
executable). If you are going to run your executable as a setuid program,
you should compile it using taintperl rather than normal perl. If you
want to execute a portion of your script before dumping, use the dump
operator instead. Note that availability of undump is platform-specific,
and may not be available for a specific port of perl.
Data Types and Objects
The perl language has three data types: scalars, arrays of scalars, and
associative arrays of scalars. Normal arrays are indexed by number, and
associative arrays by string.
The interpretation of operations and values in perl sometimes depends on
the requirements of the context around the operation or value. There are
three major contexts: string, numeric and array. Certain operations
return array values in contexts wanting an array, and scalar values
otherwise. (If this is true of an operation it will be mentioned in the
documentation for that operation.) Operations which return scalars don't
care whether the context is looking for a string or a number, but scalar
variables and values are interpreted as strings or numbers as appropriate
to the context. A scalar is interpreted as TRUE in the boolean sense if
it is not the null string or 0. Booleans returned by operators are 1 for
true and 0 or '' (the null string) for false.
4 Intergraph Corporation - 2/94
perl(1) CLIX perl(1)
There are actually two varieties of null string: defined and undefined.
Undefined null strings are returned when there is no real value for
something, such as when there was an error, or at end of file, or when you
refer to an uninitialized variable or element of an array. An undefined
null string may become defined the first time you access it, but prior to
that you can use the defined() operator to determine whether the value is
defined or not.
References to scalar variables always begin with $, even when referring to
a scalar that is part of an array:
$days # a simple scalar variable
$days[28] # 29th element of array @days
$days{'Feb'} # one value from an associative array
$#days # last index of array @days
Entire arrays or array slices are denoted by @:
@days # ($days[0], $days[1],... $days[n])
@days[3,4,5] # same as @days[3..5]
@days{'a','c'} # same as ($days{'a'},$days{'c'})
Entire associative arrays are denoted by %:
%days # (key1, val1, key2, val2 ...)
Any of these eight constructs may serve as an lvalue, that is, may be
assigned to. (It also turns out that an assignment is itself an lvalue in
certain contexts -- see examples under s, tr, and chop.) Assignment to a
scalar evaluates the righthand side in a scalar context, while assignment
to an array or array slice evaluates the righthand side in an array
context.
You may find the length of array @days by evaluating $#days, as in csh.
(Actually, it's not the length of the array, it's the subscript of the
last element, since there is (ordinarily) a 0th element.) Assigning to
$#days changes the length of the array. Shortening an array by this
method does not actually destroy any values. Lengthening an array that
was previously shortened recovers the values that were in those elements.
You can also gain some measure of efficiency by preextending an array that
is going to get big. (You can also extend an array by assigning to an
element that is off the end of the array. This differs from assigning to
$#whatever in that intervening values are set to null rather than
recovered.) You can truncate an array down to nothing by assigning the
null list () to it. The following are exactly equivalent
@whatever = ();
$#whatever = $[ - 1;
If you evaluate an array in a scalar context, it returns the length of the
array. The following is always true:
2/94 - Intergraph Corporation 5
perl(1) CLIX perl(1)
@whatever == $#whatever - $[ + 1;
Multidimensional arrays are not directly supported, but see the discussion
of the $; variable for a means of emulating multiple subscripts with an
associative array. You could also write a subroutine to turn multiple
subscripts into a single subscript.
Every data type has its own namespace. You can, without fear of conflict,
use the same name for a scalar variable, an array, an associative array, a
filehandle, a subroutine name, and/or a label. Since variable and array
references always start with $, @, or %, the "reserved" words aren't in
fact reserved with respect to variable names. (They are reserved with
respect to labels and filehandles, however, which don't have an initial
special character. You could say open(LOG,'logfile') rather than
open(log,'logfile'). Using uppercase filehandles also improves
readability and protects you from conflict with future reserved words.)
Case is significant -- FOO, Foo and foo are all different names. Names
which start with a letter may also contain digits and underscores. Names
which do not start with a letter are limited to one character, such as $%
or $$. (Most one-character names have a predefined significance to perl.)
Numeric literals are specified in any of the usual floating point or
integer formats:
12345
12345.67
.23E-10
0xffff # hex
0377 # octal
String literals are delimited by either single or double quotes. They
work much like shell quotes: double-quoted string literals are subject to
backslash and variable substitution; single-quoted strings are not (except
for \' and \). The usual backslash rules apply for making characters such
as newline and tab, as well as some more exotic forms:
\t tab
\n newline
\r return
\f form feed
\b backspace
\a alarm (bell)
\e escape
\033 octal char
\x1b hex char
\c[ control char
\l lowercase next char
\u uppercase next char
\L lowercase till \E
\U uppercase till \E
6 Intergraph Corporation - 2/94
perl(1) CLIX perl(1)
\E end case modification
You can also embed newlines directly in your strings; they can end on a
different line than they begin. If you forget your trailing quote, the
error will not be reported until perl finds another line containing the
quote character, which may be much further on in the script. Variable
substitution inside strings is limited to scalar variables, normal array
values, and array slices. The following code segment prints out The price
is $100.
$Price = '$100'; # not interpreted
print "The price is $Price.\n";# interpreted
Note that you can put curly brackets around the identifier to delimit it
from following alphanumerics. Also, note that a single quoted string must
be separated from a preceding word by a space, since single quote is a
valid character in an identifier (see Packages).
Two special literals are __LINE__ and __FILE__, which represent the
current line number and filename at that point in your program. They may
only be used as separate tokens; they will not be interpolated into
strings. In addition, the token __END__ may be used to indicate the
logical end of the script before the actual end of file. Any following
text is ignored (but may be read via the DATA filehandle). The two
control characters ^D and ^Z are synonyms for __END__.
A word that doesn't have any other interpretation in the grammar will be
treated as if it had single quotes around it. For this purpose, a word
consists only of alphanumeric characters and underline, and must start
with an alphabetic character. As with filehandles and labels, a bare word
that consists entirely of lowercase letters risks conflict with future
reserved words, and if you use the -w switch, perl will warn you about any
such words.
Array values are interpolated into double-quoted strings by joining all
the elements of the array with the delimiter specified in the $" variable,
space by default. (Since in versions of perl prior to 3.0 the @ character
was not a metacharacter in double-quoted strings, the interpolation of
@array, $array[EXPR], @array[LIST], $array{EXPR}, or @array{LIST} only
happens if array is referenced elsewhere in the program or is predefined.)
The following are equivalent:
$temp = join($",@ARGV);
system "echo $temp";
system "echo @ARGV";
Within search patterns (which also undergo double-quotish substitution)
2/94 - Intergraph Corporation 7
perl(1) CLIX perl(1)
there is a bad ambiguity: Is /$foo[bar]/ to be interpreted as
/${foo}[bar]/ (where [bar] is a character class for the regular
expression) or as /${foo[bar]}/ (where [bar] is the subscript to array
@foo)? If @foo doesn't otherwise exist, then it's obviously a character
class. If @foo exists, perl takes a good guess about [bar], and is almost
always right. If it does guess wrong, you can force the correct
interpretation with curly brackets as above.
A line-oriented form of quoting is based on the shell here- is syntax.
Following a << you specify a string to terminate the quoted material, and
all lines following the current line down to the terminating string are
the value of the item. The terminating string may be either an identifier
(a word), or some quoted text. If quoted, the type of quotes you use
determines the treatment of the text, just as in regular quoting. An
unquoted identifier works like double quotes. There must be no space
between the << and the identifier. (If you put a space it will be treated
as a null identifier, which is valid, and matches the first blank line--
see Merry Christmas example below.) The terminating string must appear by
itself (unquoted and with no surrounding whitespace) on the terminating
line.
print <<EOF; # same as above
The price is $Price.
EOF
print <<"EOF"; # same as above
The price is $Price.
EOF
print << x 10; # null identifier is delimiter
Merry Christmas!
print <<'EOC`; # execute commands
echo hi there
echo lo there
EOC
print <<foo, <<bar; # you can stack them
I said foo.
foo
I said bar.
bar
Array literals are denoted by separating individual values by commas, and
enclosing the list in parentheses:
(LIST)
In a context not requiring an array value, the value of the array literal
8 Intergraph Corporation - 2/94
perl(1) CLIX perl(1)
is the value of the final element, as in the C comma operator. For
example,
@foo = ('cc', '-E', $bar);
assigns the entire array value to array foo, but
$foo = ('cc', '-E', $bar);
assigns the value of variable bar to variable foo. Note that the value of
an actual array in a scalar context is the length of the array; the
following assigns to $foo the value 3:
@foo = ('cc', '-E', $bar);
$foo = @foo; # $foo gets 3
You may have an optional comma before the closing parenthesis of an array
literal, so that you can say:
@foo = (
1,
2,
3,
);
When a LIST is evaluated, each element of the list is evaluated in an
array context, and the resulting array value is interpolated into LIST
just as if each individual element were a member of LIST. Thus arrays
lose their identity in a LIST--the list
(@foo,@bar,&SomeSub)
contains all the elements of @foo followed by all the elements of @bar,
followed by all the elements returned by the subroutine named SomeSub.
A list value may also be subscripted like a normal array. Examples:
$time = (stat($file))[8]; # stat returns array value
$digit = ('a','b','c','d','e','f')[$digit-10];
return (pop(@foo),pop(@foo))[0];
Array lists may be assigned to if and only if each element of the list is
an lvalue:
($a, $b, $c) = (1, 2, 3);
($map{'red'}, $map{'blue'}, $map{'green'}) = (0x00f, 0x0f0, 0xf00);
2/94 - Intergraph Corporation 9
perl(1) CLIX perl(1)
The final element may be an array or an associative array:
($a, $b, @rest) = split;
local($a, $b, %rest) = @_;
You can actually put an array anywhere in the list, but the first array in
the list will soak up all the values, and anything after it will get a
null value. This may be useful in a local().
An associative array literal contains pairs of values to be interpreted as
a key and a value:
# same as map assignment above
%map = ('red',0x00f,'blue',0x0f0,'green',0xf00);
Array assignment in a scalar context returns the number of elements
produced by the expression on the right side of the assignment:
$x = (($foo,$bar) = (3,2,1)); # set $x to 3, not 2
There are several other pseudo-literals that you should know about. If a
string is enclosed by backticks (grave accents), it first undergoes
variable substitution just like a double quoted string. It is then
interpreted as a command, and the output of that command is the value of
the pseudo-literal, like in a shell. In a scalar context, a single string
consisting of all the output is returned. In an array context, an array
of values is returned, one for each line of output. (You can set $/ to
use a different line terminator.) The command is executed each time the
pseudo-literal is evaluated. The status value of the command is returned
in $? (see Predefined Names for the interpretation of $?). Unlike in csh,
no translation is done on the return data--newlines remain newlines.
Unlike in any of the shells, single quotes do not hide variable names in
the command from interpretation. To pass a $ through to the shell you
need to hide it with a backslash.
Evaluating a filehandle in angle brackets yields the next line from that
file (newline included, so it's never false until EOF, at which time an
undefined value is returned). Ordinarily you must assign that value to a
variable, but there is one situation where an automatic assignment
happens. If (and only if) the input symbol is the only thing inside the
conditional of a while loop, the value is automatically assigned to the
variable "$_". (This may seem like an odd thing to you, but you'll use
the construct in almost every perl script you write.) Anyway, the
following lines are equivalent to each other:
while ($_ = <STDIN>) { print; }
while (<STDIN>) { print; }
for (;<STDIN>;) { print; }
print while $_ = <STDIN>;
10 Intergraph Corporation - 2/94
perl(1) CLIX perl(1)
print while <STDIN>;
The filehandles STDIN, STDOUT and STDERR are predefined. (The filehandles
stdin, stdout and stderr will also work except in packages, where they
would be interpreted as local identifiers rather than global.) Additional
filehandles may be created with the open function.
If a <FILEHANDLE> is used in a context that is looking for an array, an
array consisting of all the input lines is returned, one line per array
element. It's easy to make a LARGE data space this way, so use with care.
The null filehandle <> is special and can be used to emulate the behavior
of sed and awk. Input from <> comes either from standard input, or from
each file listed on the command line. Here's how it works: the first time
<> is evaluated, the ARGV array is checked, and if it is null, $ARGV[0] is
set to '-', which when opened gives you standard input. The ARGV array is
then processed as a list of filenames. The loop
while (<>) {
... # code for each line
}
is equivalent to
unshift(@ARGV, '-') if $#ARGV < $[;
while ($ARGV = shift) {
open(ARGV, $ARGV);
while (<ARGV>) {
... # code for each line
}
}
except that it isn't as cumbersome to say. It really does shift array
ARGV and put the current filename into variable ARGV. It also uses
filehandle ARGV internally. You can modify @ARGV before the first <> as
long as you leave the first filename at the beginning of the array. Line
numbers ($.) continue as if the input was one big happy file. (But see
example under eof for how to reset line numbers on each file.)
If you want to set @ARGV to your own list of files, go right ahead. If
you want to pass switches into your script, you can put a loop on the
front like this:
while ($_ = $ARGV[0], /^-/) {
shift;
last if /^--$/;
/^-D(.*)/ && ($debug = $1);
/^-v/ && $verbose++;
... # other switches
2/94 - Intergraph Corporation 11
perl(1) CLIX perl(1)
}
while (<>) {
... # code for each line
}
The <> symbol will return FALSE only once. If you call it again after
this it will assume you are processing another @ARGV list, and if you
haven't set @ARGV, will input from STDIN.
If the string inside the angle brackets is a reference to a scalar
variable (e.g. <$foo>), then that variable contains the name of the
filehandle to input from.
If the string inside angle brackets is not a filehandle, it is interpreted
as a filename pattern to be globbed, and either an array of filenames or
the next filename in the list is returned, depending on context. One
level of $ interpretation is done first, but you can't say <$foo> because
that's an indirect filehandle as explained in the previous paragraph. You
could insert curly brackets to force interpretation as a filename glob:
<${foo}>. Example:
while (<*.c>) {
chmod 0644, $_;
}
is equivalent to
open(foo, "echo *.c | tr -s ' \t\r\f' '\012\012\012\012'|");
while (<foo>) {
chop;
chmod 0644, $_;
}
In fact, it's currently implemented that way. (Which means it will not
work on filenames with spaces in them unless you have /bin/csh on your
machine.) Of course, the shortest way to do the above is:
chmod 0644, <*.c>;
Syntax
A perl script consists of a sequence of declarations and commands. The
only things that need to be declared in perl are report formats and
subroutines. See the sections below for more information on those
declarations. All uninitialized user-created objects are assumed to start
with a null or 0 value until they are defined by some explicit operation
such as assignment. The sequence of commands is executed just once,
12 Intergraph Corporation - 2/94
perl(1) CLIX perl(1)
unlike in sed and awk scripts, where the sequence of commands is executed
for each input line. While this means that you must explicitly loop over
the lines of your input file (or files), it also means you have much more
control over which files and which lines you look at. (Actually, I'm
lying--it is possible to do an implicit loop with either the -n or -p
switch.)
A declaration can be put anywhere a command can, but has no effect on the
execution of the primary sequence of commands--declarations all take
effect at compile time. Typically all the declarations are put at the
beginning or the end of the script.
The perl language is, for the most part, free-form. (The only exception
to this is format declarations, for fairly obvious reasons.) Comments are
indicated by the # character, and extend to the end of the line. If you
attempt to use /* */ C comments, it will be interpreted either as division
or pattern matching, depending on the context. So don't do that.
Compound Statements
In perl, a sequence of commands may be treated as one command by enclosing
it in curly brackets. We will call this a BLOCK.
The following compound commands may be used to control flow:
if (EXPR) BLOCK
if (EXPR) BLOCK else BLOCK
if (EXPR) BLOCK elsif (EXPR) BLOCK ... else BLOCK
LABEL while (EXPR) BLOCK
LABEL while (EXPR) BLOCK continue BLOCK
LABEL for (EXPR; EXPR; EXPR) BLOCK
LABEL foreach VAR (ARRAY) BLOCK
LABEL BLOCK continue BLOCK
Note that, unlike C and Pascal, these are defined in terms of BLOCKs, not
statements. This means that the curly brackets are required--no dangling
statements allowed. If you want to write conditionals without curly
brackets there are several other ways to do it. The following all do the
same thing:
if (!open(foo)) { die "Can't open $foo: $!"; }
die "Can't open $foo: $!" unless open(foo);
open(foo) || die "Can't open $foo: $!"; # foo or bust!
open(foo) ? 'hi mom' : die "Can't open $foo: $!";
# a bit exotic, that last one
The if statement is straightforward. Since BLOCKs are always bounded by
curly brackets, there is never any ambiguity about which if an else goes
with. If you use unless in place of if, the sense of the test is
2/94 - Intergraph Corporation 13
perl(1) CLIX perl(1)
reversed.
The while statement executes the block as long as the expression is true
(does not evaluate to the null string or 0). The LABEL is optional, and
if present, consists of an identifier followed by a colon. The LABEL
identifies the loop for the loop control statements next, last, and redo
(see below). If there is a continue BLOCK, it is always executed just
before the conditional is about to be evaluated again, similarly to the
third part of a for loop in C. Thus it can be used to increment a loop
variable, even when the loop has been continued via the next statement
(similar to the C "continue" statement).
If the word while is replaced by the word until, the sense of the test is
reversed, but the conditional is still tested before the first iteration.
In either the if or the while statement, you may replace "(EXPR)" with a
BLOCK, and the conditional is true if the value of the last command in
that block is true.
The for loop works exactly like the corresponding while loop:
for ($i = 1; $i < 10; $i++) {
...
}
is the same as
$i = 1;
while ($i < 10) {
...
} continue {
$i++;
}
The foreach loop iterates over a normal array value and sets the variable
VAR to be each element of the array in turn. The variable is implicitly
local to the loop, and regains its former value upon exiting the loop.
The "foreach" keyword is actually identical to the "for" keyword, so you
can use "foreach" for readability or "for" for brevity. If VAR is
omitted, $_ is set to each value. If ARRAY is an actual array (as opposed
to an expression returning an array value), you can modify each element of
the array by modifying VAR inside the loop. Examples:
for (@ary) { s/foo/bar/; }
foreach $elem (@elements) {
$elem *= 2;
}
14 Intergraph Corporation - 2/94
perl(1) CLIX perl(1)
for ((10,9,8,7,6,5,4,3,2,1,'BOOM')) {
print $_, "\n"; sleep(1);
}
for (1..15) { print "Merry Christmas0; }
foreach $item (split(/:[\n:]*/, $ENV{'TERMCAP'})) {
print "Item: $item\n";
}
The BLOCK by itself (labeled or not) is equivalent to a loop that executes
once. Thus you can use any of the loop control statements in it to leave
or restart the block. The continue block is optional. This construct is
particularly nice for doing case structures.
foo: {
if (/^abc/) { $abc = 1; last foo; }
if (/^def/) { $def = 1; last foo; }
if (/^xyz/) { $xyz = 1; last foo; }
$nothing = 1;
}
There is no official switch statement in perl, because there are already
several ways to write the equivalent. In addition to the above, you could
write
foo: {
$abc = 1, last foo if /^abc/;
$def = 1, last foo if /^def/;
$xyz = 1, last foo if /^xyz/;
$nothing = 1;
}
or
foo: {
/^abc/ && do { $abc = 1; last foo; };
/^def/ && do { $def = 1; last foo; };
/^xyz/ && do { $xyz = 1; last foo; };
$nothing = 1;
}
or
foo: {
/^abc/ && ($abc = 1, last foo);
/^def/ && ($def = 1, last foo);
2/94 - Intergraph Corporation 15
perl(1) CLIX perl(1)
/^xyz/ && ($xyz = 1, last foo);
$nothing = 1;
}
or even
if (/^abc/)
{ $abc = 1; }
elsif (/^def/)
{ $def = 1; }
elsif (/^xyz/)
{ $xyz = 1; }
else
{$nothing = 1;}
As it happens, these are all optimized internally to a switch structure,
so perl jumps directly to the desired statement, and you needn't worry
about perl executing a lot of unnecessary statements when you have a
string of 50 elsifs, as long as you are testing the same simple scalar
variable using ==, eq, or pattern matching as above. (If you're curious
as to whether the optimizer has done this for a particular case statement,
you can use the -D1024 switch to list the syntax tree before execution.)
Simple Statements
The only kind of simple statement is an expression evaluated for its side
effects. Every expression (simple statement) must be terminated with a
semicolon. Note that this is like C, but unlike Pascal (and awk).
Any simple statement may optionally be followed by a single modifier, just
before the terminating semicolon. The possible modifiers are:
if EXPR
unless EXPR
while EXPR
until EXPR
The if and unless modifiers have the expected semantics. The while and
until modifiers also have the expected semantics (conditional evaluated
first), except when applied to a do-BLOCK or a do-SUBROUTINE command, in
which case the block executes once before the conditional is evaluated.
This is so that you can write loops like:
do {
$_ = <STDIN>;
...
} until $_ eq ".\n";
16 Intergraph Corporation - 2/94
perl(1) CLIX perl(1)
(See the do operator below. Note also that the loop control commands
described later will NOT work in this construct, since modifiers don't
take loop labels. Sorry.)
Expressions
Since perl expressions work almost exactly like C expressions, only the
differences will be mentioned here.
Here's what perl has that C doesn't:
** The exponentiation operator.
**= The exponentiation assignment operator.
() The null list, used to initialize an array to null.
. Concatenation of two strings.
.= The concatenation assignment operator.
eq String equality (== is numeric equality). For a mnemonic just
think of "eq" as a string. (If you are used to the awk behavior of
using == for either string or numeric equality based on the current
form of the comparands, beware! You must be explicit here.)
ne String inequality (!= is numeric inequality).
lt String less than.
gt String greater than.
le String less than or equal.
ge String greater than or equal.
cmp String comparison, returning -1, 0, or 1.
<=> Numeric comparison, returning -1, 0, or 1.
=~ Certain operations search or modify the string "$_" by default.
This operator makes that kind of operation work on some other
string. The right argument is a search pattern, substitution, or
translation. The left argument is what is supposed to be searched,
substituted, or translated instead of the default "$_". The return
value indicates the success of the operation. (If the right
argument is an expression other than a search pattern,
substitution, or translation, it is interpreted as a search pattern
at run time. This is less efficient than an explicit search, since
the pattern must be compiled every time the expression is
evaluated.) The precedence of this operator is lower than unary
2/94 - Intergraph Corporation 17
perl(1) CLIX perl(1)
minus and autoincrement/decrement, but higher than everything else.
!~ Just like =~ except the return value is negated.
x The repetition operator. Returns a string consisting of the left
operand repeated the number of times specified by the right
operand. In an array context, if the left operand is a list in
parens, it repeats the list.
print '-' x 80; # print row of dashes
print '-' x80; # illegal, x80 is identifier
print "" x ($tab/8), ' ' x ($tab%8);
# tab over
@ones = (1) x 80; # an array of 80 1's
@ones = (5) x @ones;
# set all elements to 5
x= The repetition assignment operator. Only works on scalars.
.. The range operator, which is really two different operators
depending on the context. In an array context, returns an array of
values counting (by ones) from the left value to the right value.
This is useful for writing "for (1..10)" loops and for doing slice
operations on arrays.
In a scalar context, .. returns a boolean value. The operator is
bistable, like a flip-flop.. Each .. operator maintains its own
boolean state. It is false as long as its left operand is false.
Once the left operand is true, the range operator stays true until
the right operand is true, AFTER which the range operator becomes
false again. (It doesn't become false till the next time the range
operator is evaluated. It can become false on the same evaluation
it became true, but it still returns true once.) The right operand
is not evaluated while the operator is in the "false" state, and
the left operand is not evaluated while the operator is in the
"true" state. The scalar .. operator is primarily intended for
doing line number ranges after the fashion of sed or awk. The
precedence is a little lower than || and &&. The value returned is
either the null string for false, or a sequence number (beginning
with 1) for true. The sequence number is reset for each range
encountered. The final sequence number in a range has the string
'E0' appended to it, which doesn't affect its numeric value, but
gives you something to search for if you want to exclude the
endpoint. You can exclude the beginning point by waiting for the
sequence number to be greater than 1. If either operand of scalar
.. is static, that operand is implicitly compared to the $.
variable, the current line number. Examples:
18 Intergraph Corporation - 2/94
perl(1) CLIX perl(1)
As a scalar operator:
if (101 .. 200) { print; }
# print 2nd hundred lines
next line if (1 .. /^$/);
# skip header lines
s/^/> / if (/^$/ .. eof());
# quote body
As an array operator:
for (101 .. 200) { print; }
# print $_ 100 times
@foo = @foo[$[ .. $#foo];
# an expensive no-op
@foo = @foo[$#foo-4 .. $#foo];
# slice last 5 items
-x A file test. This unary operator takes one argument, either a
filename or a filehandle, and tests the associated file to see if
something is true about it. If the argument is omitted, tests $_,
except for -t, which tests STDIN. It returns 1 for true and '' for
false, or the undefined value if the file doesn't exist.
Precedence is higher than logical and relational operators, but
lower than arithmetic operators. The operator may be any of: -r
File is readable by effective uid. -w File is writable by
effective uid. -x File is executable by effective uid. -o File is
owned by effective uid. -R File is readable by real uid. -W File
is writable by real uid.
-X File is executable by real uid.
-O File is owned by real uid.
-e File exists.
-z File has zero size.
-s File has non-zero size (returns size).
-f File is a plain file.
-d File is a directory.
-l File is a symbolic link.
2/94 - Intergraph Corporation 19
perl(1) CLIX perl(1)
-p File is a named pipe (FIFO).
-S File is a socket.
-b File is a block special file.
-c File is a character special file.
-u File has setuid bit set.
-g File has setgid bit set.
-k File has sticky bit set.
-t Filehandle is opened to a tty.
-T File is a text file.
-B File is a binary file (opposite of -T).
-M Age of file in days when script started.
-A Same for access time.
-C Same for inode change time.
The interpretation of the file permission operators -r, -R, -w, -W,
-x and -X is based solely on the mode of the file and the uids and
gids of the user. There may be other reasons you can't actually
read, write or execute the file. Also note that, for the
superuser, -r, -R, -w and -W always return 1, and -x and -X return
1 if any execute bit is set in the mode. Scripts run by the
superuser may thus need to do a stat() in order to determine the
actual mode of the file, or temporarily set the uid to something
else.
Example:
while (<>) {
chop;
next unless -f $_; # ignore specials
...
}
Note that -s/a/b/ does not do a negated substitution. Saying
-exp($foo) still works as expected, however--only single letters
following a minus are interpreted as file tests.
The -T and -B switches work as follows. The first block or so of
the file is examined for odd characters such as strange control
20 Intergraph Corporation - 2/94
perl(1) CLIX perl(1)
codes or metacharacters. If too many odd characters (>10%) are
found, it's a -B file, otherwise it's a -T file.
Also, any file containing null in the first block is considered a
binary file. If -T or -B is used on a filehandle, the current
stdio buffer is examined rather than the first block. Both -T and
-B return TRUE on a null file, or a file at EOF when testing a
filehandle.
If any of the file tests (or either stat operator) are given the
special filehandle consisting of a solitary underline, then the
stat structure of the previous file test (or stat operator) is
used, saving a system call. (This doesn't work with -t, and you
need to remember that lstat and -l will leave values in the stat
structure for the symbolic link, not the real file.) Example:
print "Can do.0 if -r $a || -w _ || -x _;
stat($filename);
print "Readable\n" if -r _;
print "Writable\n" if -w _;
print "Executable\n" if -x _;
print "Setuid\n" if -u _;
print "Setgid\n" if -g _;
print "Sticky\n" if -k _;
print "Text\n" if -T _;
print "Binary\n" if -B _;
Here is what C has that perl doesn't:
unary & Address-of operator.
unary * Dereference-address operator.
(TYPE) Type casting operator.
Like C, perl does a certain amount of expression evaluation at compile
time, whenever it determines that all of the arguments to an operator are
static and have no side effects. In particular, string concatenation
happens at compile time between literals that don't do variable
substitution. Backslash interpretation also happens at compile time. You
can say
'Now is the time for all' . "\n" .
'good men to come to.'
and this all reduces to one string internally.
2/94 - Intergraph Corporation 21
perl(1) CLIX perl(1)
The autoincrement operator has a little extra built-in magic to it. If
you increment a variable that is numeric, or that has ever been used in a
numeric context, you get a normal increment. If, however, the variable
has only been used in string contexts since it was set, and has a value
that is not null and matches the pattern /^[a-zA-Z]*[0-9]*$/, the
increment is done as a string, preserving each character within its range,
with carry:
print ++($foo = '99'); # prints '100'
print ++($foo = 'a0'); # prints 'a1'
print ++($foo = 'Az'); # prints 'Ba'
print ++($foo = 'zz'); # prints 'aaa'
The autodecrement is not magical.
The range operator (in an array context) makes use of the magical
autoincrement algorithm if the minimum and maximum are strings. You can
say
@alphabet = ('A' .. 'Z');
to get all the letters of the alphabet, or
$hexdigit = (0 .. 9, 'a' .. 'f')[$num & 15];
to get a hexadecimal digit, or
@z2 = ('01' .. '31'); print @z2[$mday];
to get dates with leading zeros. (If the final value specified is not in
the sequence that the magical increment would produce, the sequence goes
until the next value would be longer than the final value specified.)
The || and && operators differ from C's in that, rather than returning 0
or 1, they return the last value evaluated. Thus, a portable way to find
out the home directory might be:
$home = $ENV{'HOME'} || $ENV{'LOGDIR'} ||
(getpwuid($<))[7] || die "You're homeless!\n";
Along with the literals and variables mentioned earlier, the operations in
the following section can serve as terms in an expression. Some of these
operations take a LIST as an argument. Such a list can consist of any
combination of scalar arguments or array values; the array values will be
included in the list as if each individual element were interpolated at
that point in the list, forming a longer single-dimensional array value.
Elements of the LIST should be separated by commas. If an operation is
22 Intergraph Corporation - 2/94
perl(1) CLIX perl(1)
listed both with and without parentheses around its arguments, it means
you can either use it as a unary operator or as a function call. To use
it as a function call, the next token on the same line must be a left
parenthesis. (There may be intervening white space.) Such a function
then has highest precedence, as you would expect from a function. If any
token other than a left parenthesis follows, then it is a unary operator,
with a precedence depending only on whether it is a LIST operator or not.
LIST operators have lowest precedence. All other unary operators have a
precedence greater than relational operators but less than arithmetic
operators. See the section on Precedence.
/PATTERN/
See m/PATTERN/.
?PATTERN?
This is just like the /PATTERN/ search, except that it matches only
once between calls to the reset operator. This is a useful
optimization when you only want to see the first occurrence of
something in each file of a set of files, for instance. Only ??
patterns local to the current package are reset.
accept(NEWSOCKET,GENERICSOCKET)
Does the same thing that the accept() system call does. Returns
true if it succeeded, false otherwise. See example in section on
Interprocess Communication.
alarm(SECONDS)
alarm SECONDS
Arranges to have a SIGALRM delivered to this process after the
specified number of seconds (minus 1, actually) have elapsed.
Thus, alarm(15) will cause a SIGALRM at some point more than 14
seconds in the future. Only one timer may be counting at once.
Each call disables the previous timer, and an argument of 0 may be
supplied to cancel the previous timer without starting a new one.
The returned value is the amount of time remaining on the previous
timer.
atan2(Y,X)
Returns the arctangent of Y/X in the range -PI to PI.
bind(SOCKET,NAME)
Does the same thing that the bind system call does. Returns true
if it succeeded, false otherwise. NAME should be a packed address
of the proper type for the socket. See example in section on
Interprocess Communication.
binmode(FILEHANDLE)
binmode FILEHANDLE
Arranges for the file to be read in "binary" mode in operating
systems that distinguish between binary and text files. Files that
are not read in binary mode have CR LF sequences translated to LF
2/94 - Intergraph Corporation 23
perl(1) CLIX perl(1)
on input and LF translated to CR LF on output. Binmode has no
effect under UNIX. If FILEHANDLE is an expression, the value is
taken as the name of the filehandle.
caller(EXPR)
The caller() function returns the context of the current subroutine
call. With EXPR, returns some extra information that the debugger
uses to print a stack trace. The value of EXPR indicates how many
call frames to go back before the current one.
chdir(EXPR)
chdir EXPR
Changes the working directory to EXPR, if possible. If EXPR is
omitted, changes to home directory. Returns 1 upon success, 0
otherwise. See example under die().
chmod(LIST)
chmod LIST
Changes the permissions of a list of files. The first element of
the list must be the numerical mode. Returns the number of files
successfully changed.
chop(LIST)
chop(VARIABLE)
chop VARIABLE
The chop() function chops off the last character of a string and
returns the character chopped. It's used primarily to remove the
newline from the end of an input record, but is much more efficient
than s/\n// because it neither scans nor copies the string. If
VARIABLE is omitted, chops $_. You can actually chop any lvalue,
including an assignment. If you chop a list, each element is
chopped. Only the value of the last chop is returned.
chown(LIST)
chown LIST
Changes the owner (and group) of a list of files. The first two
elements of the list must be the NUMERICAL uid and gid, in that
order. Returns the number of files successfully changed.
chroot(FILENAME)
chroot FILENAME
Does the same as the system call of that name. If you don't know
what it does, don't worry about it. If FILENAME is omitted, does
chroot to $_.
close(FILEHANDLE)
close FILEHANDLE
Closes the file or pipe associated with the file handle. You don't
have to close FILEHANDLE if you are immediately going to do another
open on it, since open will close it for you. (See open.)
However, an explicit close on an input file resets the line counter
24 Intergraph Corporation - 2/94
perl(1) CLIX perl(1)
($.), while the implicit close done by open does not. Also,
closing a pipe will wait for the process executing on the pipe to
complete, in case you want to look at the output of the pipe
afterwards. Closing a pipe explicitly also puts the status value
of the command into $?. FILEHANDLE may be an expression whose
value gives the real filehandle name.
closedir(DIRHANDLE)
closedir DIRHANDLE
Closes a directory opened by opendir().
connect(SOCKET,NAME)
Does the same thing that the connect system call does. Returns
true if it succeeded, false otherwise. NAME should be a package
address of the proper type for the socket. See example in section
on Interprocess Communication.
cos(EXPR)
cos EXPR
Returns the cosine of EXPR (expressed in radians). If EXPR is
omitted takes cosine of $_.
crypt(PLAINTEXT,SALT)
Encrypts a string exactly like the crypt() function in the C
library. Useful for checking the password file for bad passwords.
dbmclose(ASSOC_ARRAY)
dbmclose ASSOC_ARRAY
Breaks the binding between a dbm file and an associative array.
The values remaining in the associative array are meaningless
unless you happen to want to know what was in the cache for the dbm
file. This function is only useful if you have ndbm.
dbmopen(ASSOC,DBNAME,MODE)
This binds a dbm or ndbm file to an associative array. ASSOC is
the name of the associative array. (Unlike normal open, the first
argument is NOT a filehandle, even though it looks like one).
DBNAME is the name of the database (without the .dir or .pag
extension). If the database does not exist, it is created with
protection specified by MODE (as modified by the umask). If your
system only supports the older dbm functions, you may only have one
dbmopen() in your program. If your system has neither dbm nor
ndbm, calling dbmopen() produces a fatal error.
Values assigned to the associative array prior to the dbmopen() are
lost. A certain number of values from the dbm file are cached in
memory. By default this number is 64, but you can increase it by
preallocating that number of garbage entries in the associative
array before the dbmopen(). You can flush the cache if necessary
with the reset command.
2/94 - Intergraph Corporation 25
perl(1) CLIX perl(1)
If you don't have write access to the dbm file, you can only read
associative array variables, not set them. If you want to test
whether you can write, either use file tests or try setting a dummy
array entry inside an eval, which will trap the error.
Note that functions such as keys() and values() may return huge
array values when used on large dbm files. You may prefer to use
the each() function to iterate over large dbm files.
defined(EXPR)
defined EXPR
Returns a boolean value saying whether the lvalue EXPR has a real
value or not. Many operations return the undefined value under
exceptional conditions, such as end of file, uninitialized
variable, system error and such. This function allows you to
distinguish between an undefined null string and a defined null
string with operations that might return a real null string, in
particular referencing elements of an array. You may also check to
see if arrays or subroutines exist. Use on predefined variables is
not guaranteed to produce intuitive results. See also undef.
delete $ASSOC{KEY}
Deletes the specified value from the specified associative array.
Returns the deleted value, or the undefined value if nothing was
deleted. Deleting from $ENV{} modifies the environment. Deleting
from an array bound to a dbm file deletes the entry from the dbm
file.
die(LIST)
die LIST
Outside of an eval, prints the value of LIST to STDERR and exits
with the current value of $! (errno). If $! is 0, exits with the
value of ($? >> 8) (`command` status). If ($? >> 8) is 0, exits
with 255. Inside an eval, the error message is stuffed into $@ and
the eval is terminated with the undefined value. If the value of
EXPR does not end in a newline, the current script line number and
input line number (if any) are also printed, and a newline is
supplied. See also exit.
do BLOCK
Returns the value of the last command in the sequence of commands
indicated by BLOCK. When modified by a loop modifier, executes the
BLOCK once before testing the loop condition. (On other statements
the loop modifiers test the conditional first.)
do SUBROUTINE (LIST)
Executes a SUBROUTINE declared by a sub declaration, and returns
the value of the last expression evaluated in SUBROUTINE. If there
is no subroutine by that name, produces a fatal error. (You may
use the defined operator to determine if a subroutine exists.) If
you pass arrays as part of LIST you may wish to pass the length of
26 Intergraph Corporation - 2/94
perl(1) CLIX perl(1)
the array in front of each array. (See the section on subroutines
later on.) SUBROUTINE may be a scalar variable, in which case the
variable contains the name of the subroutine to execute. The
parentheses are required to avoid confusion with the "do EXPR"
form.
As an alternate form, you may call a subroutine by prefixing the
name with an ampersand: &foo(@args). If you aren't passing any
arguments, you don't have to use parentheses. If you omit the
parentheses, no @_ array is passed to the subroutine. The & form
is also used to specify subroutines to the defined and undef
operators.
dump LABEL
This causes an immediate core dump.
each(ASSOC_ARRAY)
each Returns a 2 element array consisting of the key and value for the
next value of an associative array, so that you can iterate over
it.
eof(FILEHANDLE)
eof() Returns 1 if the next read on FILEHANDLE will return end of file,
or if FILEHANDLE is not open.
eval(EXPR)
eval EXPR
EXPR is parsed and executed as if it were a little perl program.
exec(LIST)
exec LIST
If there is more than one argument in LIST, or if LIST is an array
with more than one value, calls execvp() with the arguments in
LIST.
exit(EXPR)
exit EXPR
Evaluates EXPR and exits immediately with that value.
exp(EXPR)
exp EXPR
Returns e to the power of EXPR.
fcntl(FILEHANDLE,FUNCTION,SCALAR)
Implements the fcntl() function.
fileno(FILEHANDLE)
fileno FILEHANDLE
Returns the file descriptor for a filehandle.
flock(FILEHANDLE,OPERATION)
Calls flock() on FILEHANDLE.
2/94 - Intergraph Corporation 27
perl(1) CLIX perl(1)
fork Performs a fork() call. Returns the child pid to the parent
process and 0 to the child process.
getc(FILEHANDLE)
getc FILEHANDLE
getc Returns the next character from the input file attached to
FILEHANDLE, or a null string at EOF.
getlogin
Returns the current login from /etc/utmp, if any. If NULL, use
getpwuid.
getpeername(SOCKET)
Returns the packed sockaddr address of other end of the SOCKET
connection.
getpgrp(PID)
getpgrp PID
Returns the current process group for the specified PID, 0 for the
current process.
getppid
Returns the process id of the parent process.
getpriority(WHICH,WHO)
Returns the current priority for a process, a process group, or a
user.
getpwnam(NAME)
getgrnam(NAME)
gethostbyname(NAME)
getnetbyname(NAME)
getprotobyname(NAME)
getpwuid(UID)
getgrgid(GID)
getservbyname(NAME,PROTO)
gethostbyaddr(ADDR,ADDRTYPE)
getnetbyaddr(ADDR,ADDRTYPE)
getprotobynumber(NUMBER)
getservbyport(PORT,PROTO)
getpwent
getgrent
gethostent
getnetent
getprotoent
getservent
setpwent
setgrent
sethostent(STAYOPEN)
setnetent(STAYOPEN)
setprotoent(STAYOPEN)
setservent(STAYOPEN)
28 Intergraph Corporation - 2/94
perl(1) CLIX perl(1)
endpwent
endgrent
endhostent
endnetent
endprotoent
endservent
These routines perform the same functions as their counterparts in
the system library.
getsockname(SOCKET)
Returns the packed sockaddr address of this end of the SOCKET
connection.
getsockopt(SOCKET,LEVEL,OPTNAME)
Returns the socket option requested, or undefined if there is an
error.
gmtime(EXPR)
gmtime EXPR
Converts a time as returned by the time function to a 9-element
array with the time analyzed for the Greenwich timezone.
goto LABEL
Finds the statement labeled with LABEL and resumes execution there.
Currently you may only go to statements in the main body of the
program that are not nested inside a do {} construct.
grep(EXPR,LIST)
Evaluates EXPR for each element of LIST (locally setting $_ to each
element) and returns the array value consisting of those elements
for which the expression evaluated to true.
hex(EXPR)
hex EXPR
Returns the decimal value of EXPR interpreted as an hex string.
(To interpret strings that might start with 0 or 0x see oct().) If
EXPR is omitted, uses $_.
index(STR,SUBSTR,POSITION)
index(STR,SUBSTR)
Returns the position of the first occurrence of SUBSTR in STR at or
after POSITION. If POSITION is omitted, starts searching from the
beginning of the string. The return value is based at 0, or
whatever you have set the $[ variable to. If the substring is not
found, returns one less than the base, ordinarily -1.
int(EXPR)
int EXPR
Returns the integer portion of EXPR. If EXPR is omitted, uses $_.
ioctl(FILEHANDLE,FUNCTION,SCALAR)
2/94 - Intergraph Corporation 29
perl(1) CLIX perl(1)
Implements the ioctl() function.
join(EXPR,LIST)
join(EXPR,ARRAY)
Joins the separate strings of LIST or ARRAY into a single string
with fields separated by the value of EXPR, and returns the string.
keys(ASSOC_ARRAY)
keys ASSOC_ARRAY
Returns a normal array consisting of all the keys of the named
associative array.
kill(LIST)
kill LIST
Sends a signal to a list of processes.
last LABEL
last The last command is like the break statement in C (as used in
loops); it immediately exits the loop in question. If the LABEL is
omitted, the command refers to the innermost enclosing loop.
length(EXPR)
length EXPR
Returns the length in characters of the value of EXPR.
link(OLDFILE,NEWFILE)
Creates a new filename linked to the old filename. Returns 1 for
success, 0 otherwise.
listen(SOCKET,QUEUESIZE)
The same as the listen() function does.
local(LIST)
Declares the listed variables to be local to the enclosing block,
subroutine, eval or "do". All the listed elements must be legal
lvalues.
localtime(EXPR)
localtime EXPR
Converts a time as returned by the time function to a 9-element
array with the time analyzed for the local timezone.
log(EXPR)
log EXPR
Returns logarithm (base e) of EXPR.
lstat(FILEHANDLE)
lstat FILEHANDLE
lstat(EXPR)
lstat SCALARVARIABLE
Does the same thing as the stat() function, but stats a symbolic
30 Intergraph Corporation - 2/94
perl(1) CLIX perl(1)
link instead of the file to which the symbolic link points.
m/PATTERN/gio
/PATTERN/gio
Searches a string for a pattern match, and returns true (1) or
false (''). If no string is specified via the =~ or !~ operator,
the $_ string is searched. (The string specified with =~ need not
be an lvalue -- it may be the result of an expression evaluation,
but remember the =~ binds rather tightly.)
mkdir(FILENAME,MODE)
Creates the directory specified by FILENAME, with permissions
specified by MODE (as modified by umask). If it succeeds it
returns 1, otherwise it returns 0 and sets $! (errno).
msgctl(ID,CMD,ARG)
Calls msgctl(). If CMD is &IPC_STAT, then ARG must be a variable
which will hold the returned msqid_ds structure. Returns like
ioctl(): the undefined value for error, "0 but true" for zero, or
the actual return value otherwise.
msgget(KEY,FLAGS)
Calls msgget(). Returns the message queue id, or the undefined
value if there is an error.
msgsnd(ID,MSG,FLAGS)
Calls msgsnd() function to send the message MSG to the message
queue ID. MSG must begin with the long integer message type, which
may be created with pack("L", $type). Returns true if successful,
or false if there is an error.
msgrcv(ID,VAR,SIZE,TYPE,FLAGS)
Calls msgrcv() function to receive a message from message queue ID
into variable VAR with a maximum message size of SIZE. Note that
if a message is received, the message type will be the first thing
in VAR, and the maximum length of VAR is SIZE plus the size of the
message type. Returns true if successful, or false if there is an
error.
next LABEL
next The next command is like the continue statement in C.
oct(EXPR)
oct Returns the decimal value of EXPR interpreted as an octal string.
(If EXPR happens to start off with 0x, interprets it as a hex
string instead.)
open(FILEHANDLE,EXPR)
open(FILEHANDLE)
open FILEHANDLE
Opens the file whose filename is given by EXPR, and associates it
with FILEHANDLE. If FILEHANDLE is an expression, its value is used
2/94 - Intergraph Corporation 31
perl(1) CLIX perl(1)
as the name of the real filehandle wanted. If EXPR is omitted, the
scalar variable of the same name as the FILEHANDLE contains the
filename.
opendir(DIRHANDLE,EXPR)
Opens a directory named EXPR for processing by readdir(),
telldir(), seekdir(), rewinddir() and closedir(). Returns true if
successful. DIRHANDLEs have their own namespace separate from
FILEHANDLEs.
ord(EXPR)
ord EXPR
Returns the numeric ascii value of the first character of EXPR. If
EXPR is omitted, uses $_.
pack(TEMPLATE,LIST)
Takes an array or list of values and packs it into a binary
structure, returning the string containing the structure. The
TEMPLATE is a sequence of characters that give the order and type
of values:
A An ASCII string, will be space padded.
a An ASCII string, will be null padded.
c A signed char value.
C An unsigned char value.
s A signed short value.
S An unsigned short value.
i A signed integer value.
I An unsigned integer value.
l A signed long value.
L An unsigned long value.
n A short in "network" order.
N A long in "network" order.
f A single-precision float in the native format.
d A double-precision float in the native format.
p A pointer to a string.
32 Intergraph Corporation - 2/94
perl(1) CLIX perl(1)
x A null byte.
X Back up a byte.
@ Null fill to absolute position.
u A uuencoded string.
b A bit string (ascending bit order, like vec()).
B A bit string (descending bit order).
h A hex string (low nibble first).
H A hex string (high nibble first).
Each letter may optionally be followed by a number which gives a
repeat count.
pipe(READHANDLE,WRITEHANDLE)
Opens a pair of connected pipes like the corresponding system call.
pop(ARRAY)
pop ARRAY
Pops and returns the last value of the array, shortening the array
by 1.
print(FILEHANDLE
print(LIST)
print FILEHANDLE LIST
print LIST
print Prints a string or a comma-separated list of strings. Returns
non-zero if successful. FILEHANDLE may be a scalar variable name,
in which case the variable contains the name of the filehandle,
thus introducing one level of indirection.
printf(FILEHANDLE
printf(LIST)
printf FILEHANDLE LIST
printf LIST
Equivalent to a print FILEHANDLE sprintf(LIST).
push(ARRAY,LIST)
Treats ARRAY (@ is optional) as a stack, and pushes the values of
LIST onto the end of ARRAY. The length of ARRAY increases by the
length of LIST.
q/STRING/
qq/STRING/ 1
qx/STRING/
2/94 - Intergraph Corporation 33
perl(1) CLIX perl(1)
These are not really functions, but simply syntactic sugar to let
you avoid putting too many backslashes into quoted strings. The q
operator is a generalized single quote, and the qq operator a
generalized double quote. The qx operator is a generalized
backquote. Any non-alphanumeric delimiter can be used in place of
/, including newline. If the delimiter is an opening bracket or
parenthesis, the final delimiter will be the corresponding closing
bracket or parenthesis.
rand(EXPR)
rand
rand Returns a random fractional number between 0 and the value of EXPR.
(EXPR should be positive.) If EXPR is omitted, returns a value
between 0 and 1.
read(FILEHANDLE,SCALAR,LENGTH,OFFSET)
read(FILEHANDLE,SCALAR,LENGTH)
Attempts to read LENGTH bytes of data into variable SCALAR from the
specified FILEHANDLE. Returns the number of bytes actually read,
or undef if there was an error. SCALAR will be grown or shrunk to
the length actually read. An OFFSET may be specified to place the
read data at some other place than the beginning of the string.
This call is actually implemented in terms of stdio's fread call.
readdir(DIRHANDLE)
readdir
Returns the next directory entry for a directory opened by
opendir(). If used in an array context, returns all the rest of
the entries in the directory. If there are no more entries,
returns an undefined value in a scalar context or a null list in an
array context.
readlink(EXPR)
readlink EXPR
Returns the value of a symbolic link, if symbolic links are
implemented. If not, gives a fatal error. If there is some system
error, returns the undefined value and sets $! (errno). If EXPR is
omitted, uses $_.
recv(SOCKET,SCALAR,LEN,FLAGS)
Receives a message on a socket. Attempts to receive LENGTH bytes
of data into variable SCALAR from the specified SOCKET filehandle.
Returns the address of the sender, or the undefined value if
there's an error. SCALAR will be grown or shrunk to the length
actually read. Takes the same flags as the system call of the same
name.
redo LABEL
redo The redo command restarts the loop block without evaluating the
conditional again. The continue block, if any, is not executed.
If the LABEL is omitted, the command refers to the innermost
enclosing loop.
34 Intergraph Corporation - 2/94
perl(1) CLIX perl(1)
rename(OLDNAME,NEWNAME)
Changes the name of a file. Returns 1 for success, 0 otherwise.
Will not work across filesystem boundaries.
require(EXPR)
require EXPR
require
Includes the library file specified by EXPR, or by $_ if EXPR is
not supplied.
reset(EXPR)
reset EXPR
reset Used in a continue block at the end of a loop to clear variables
and reset ?? searches so that they work again. The expression is
interpreted as a list of single characters (hyphens allowed for
ranges). All variables and arrays beginning with one of those
letters are reset to their pristine state. If the expression is
omitted, one-match searches (?pattern?) are reset to match again.
Only resets variables or searches in the current package. Always
returns 1.
return LIST
Returns from a subroutine with the value specified.
reverse(LIST)
reverse LIST
In an array context, returns an array value consisting of the
elements of LIST in the opposite order. In a scalar context,
returns a string value consisting of the bytes of the first element
of LIST in the opposite order.
rewinddir(DIRHANDLE)
rewinddir DIRHANDLE
Sets the current position to the beginning of the directory for the
readdir() routine on DIRHANDLE.
rindex(STR,SUBSTR,POSITION)
rindex(STR,SUBSTR)
Works just like index except that it returns the position of the
LAST occurrence of SUBSTR in STR. If POSITION is specified,
returns the last occurrence at or before that position.
rmdir(FILENAME)
rmdir FILENAME
Deletes the directory specified by FILENAME if it is empty. If it
succeeds it returns 1, otherwise it returns 0 and sets $! (errno).
If FILENAME is omitted, uses $_.
s/PATTERN/REPLACEMENT/gieo
Searches a string for a pattern, and if found, replaces that
pattern with the replacement text and returns the number of
2/94 - Intergraph Corporation 35
perl(1) CLIX perl(1)
substitutions made. Otherwise it returns false (0).
scalar(EXPR)
Forces EXPR to be interpreted in a scalar context and returns the
value of EXPR.
seek(FILEHANDLE,POSITION,WHENCE)
Randomly positions the file pointer for FILEHANDLE, just like the
fseek() call of stdio. FILEHANDLE may be an expression whose value
gives the name of the filehandle. Returns 1 upon success, 0
otherwise.
seekdir(DIRHANDLE,POS)
Sets the current position for the readdir() routine on DIRHANDLE.
POS must be a value returned by telldir().
select(FILEHANDLE)
select Returns the currently selected filehandle.
select(RBITS,WBITS,EBITS,TIMEOUT)
This calls the select() system call with the bitmasks specified.
semctl(ID,SEMNUM,CMD,ARG)
Calls semctl() function. If CMD is &IPC_STAT or &GETALL, then ARG
must be a variable which will hold the returned semid_ds structure
or semaphore value array. Returns like ioctl(): the undefined
value for error, "0 but true" for zero, or the actual return value
otherwise.
Calls the semget() function. Returns the semaphore id, or the
undefined value if there is an error.
semop(KEY,OPSTRING)
Calls the semop() to perform semaphore operations such as signaling
and waiting.
send(SOCKET,MSG,FLAGS,TO)
send(SOCKET,MSG,FLAGS)
Sends a message on a socket. Takes the same flags as the system
call of the same name. On unconnected sockets you must specify a
destination to send TO. Returns the number of characters sent, or
the undefined value if there is an error.
setpgrp(PID,PGRP)
Sets the current process group for the specified PID, 0 for the
current process. Will produce a fatal error if used on a machine
that doesn't implement setpgrp().
setpriority(WHICH,WHO,PRIORITY)
Sets the current priority for a process, a process group, or a
user. Will produce a fatal error if used on a machine that doesn't
implement setpriority().
36 Intergraph Corporation - 2/94
perl(1) CLIX perl(1)
setsockopt(SOCKET,LEVEL,OPTNAME,OPTVAL)
Sets the socket option requested. OPTVAL may be specified as undef
if you don't want to pass an argument.
shift(ARRAY)
shift ARRAY
shift Shifts the first value of the array off and returns it, shortening
the array by 1 and moving everything down. If there are no
elements in the array, returns the undefined value. If ARRAY is
omitted, shifts the @ARGV array in the main program, and the @_
array in subroutines.
shmctl(ID,CMD,ARG)
Calls the shmctl() function.
shmget(KEY,SIZE,FLAGS)
Calls the shmget() function. Returns the shared memory segment id,
or the undefined value if there is an error.
shmread(ID,VAR,POS,SIZE)
shmwrite(ID,STRING,POS,SIZE)
Reads or writes the System V shared memory segment ID starting at
position POS for size SIZE by attaching to it, copying in/out, and
detaching from it. When reading, VAR must be a variable which will
hold the data read. When writing, if STRING is too long, only SIZE
bytes are used; if STRING is too short, nulls are written to fill
out SIZE bytes. Return true if successful, or false if there is an
error.
shutdown(SOCKET,HOW)
Shuts down a socket connection in the manner indicated by HOW,
which has the same interpretation as in the system call of the same
name.
sin(EXPR)
sin EXPR
Returns the sine of EXPR (expressed in radians). If EXPR is
omitted, returns sine of $_.
sleep(EXPR)
sleep EXPR
sleep Causes the script to sleep for EXPR seconds, or forever if no EXPR.
May be interrupted by sending the process a SIGALARM. Returns the
number of seconds actually slept.
socket(SOCKET,DOMAIN,TYPE,PROTOCOL)
Opens a socket of the specified kind and attaches it to filehandle
SOCKET. DOMAIN, TYPE and PROTOCOL are specified the same as for
the system call of the same name. You may need to run h2ph on
sys/socket.h to get the proper values handy in a perl library file.
Return true if successful.
2/94 - Intergraph Corporation 37
perl(1) CLIX perl(1)
socketpair(SOCKET1,SOCKET2,DOMAIN,TYPE,PROTOCOL)
Creates an unnamed pair of sockets in the specified domain, of the
specified type. DOMAIN, TYPE and PROTOCOL are specified the same
as for the system call of the same name. If unimplemented, yields
a fatal error. Return true if successful.
sort(SUBROUTINE
sort(LIST)
sort SUBROUTINE LIST
sort LIST
Sorts the LIST and returns the sorted array value. Nonexistent
values of arrays are stripped out. If SUBROUTINE is omitted, sorts
in standard string comparison order. If SUBROUTINE is specified,
gives the name of a subroutine that returns an integer less than,
equal to, or greater than 0, depending on how the elements of the
array are to be ordered. (The <=> and cmp operators are extremely
useful in such routines.) In the interests of efficiency the
normal calling code for subroutines is bypassed, with the following
effects: the subroutine may not be a recursive subroutine, and the
two elements to be compared are passed into the subroutine not via
@_ but as $a and $b (see example below). They are passed by
reference so don't modify $a and $b. SUBROUTINE may be a scalar
variable name, in which case the value provides the name of the
subroutine to use.
splice(ARRAY,OFFSET,LENGTH,LIST) 1
splice(ARRAY,OFFSET,LENGTH)
splice(ARRAY,OFFSET)
Removes the elements designated by OFFSET and LENGTH from an array,
and replaces them with the elements of LIST, if any. Returns the
elements removed from the array. The array grows or shrinks as
necessary. If LENGTH is omitted, removes everything from OFFSET
onward. The following equivalencies hold (assuming $[ == 0):
push(@a,$x,$y) splice(@a,$#a+1,0,$x,$y)
pop(@a) splice(@a,-1)
shift(@a) splice(@a,0,1)
unshift(@a,$x,$y) splice(@a,0,0,$x,$y)
$a[$x] = $y splice(@a,$x,1,$y);
split(/PATTERN/,EXPR,LIMIT)
split(/PATTERN/,EXPR)
split(/PATTERN/)
split Splits a string into an array of strings, and returns it. (If not
in an array context, returns the number of fields found and splits
into the @_ array. (In an array context, you can force the split
into @_ by using ?? as the pattern delimiters, but it still returns
the array value.)) If EXPR is omitted, splits the $_ string. If
PATTERN is also omitted, splits on whitespace (/[ 0+/). Anything
38 Intergraph Corporation - 2/94
perl(1) CLIX perl(1)
matching PATTERN is taken to be a delimiter separating the fields.
(Note that the delimiter may be longer than one character.) If
LIMIT is specified, splits into no more than that many fields
(though it may split into fewer). If LIMIT is unspecified,
trailing null fields are stripped (which potential users of pop()
would do well to remember). A pattern matching the null string
(not to be confused with a null pattern //, which is just one
member of the set of patterns matching a null string) will split
the value of EXPR into separate characters at each point it matches
that way. (When assigning to a list, if LIMIT is omitted, perl
supplies a LIMIT one larger than the number of variables in the
list, to avoid unnecessary work. For the list above LIMIT would
have been 4 by default. In time critical applications it behooves
you not to split into more fields than you really need.) If the
PATTERN contains parentheses, additional array elements are created
from each matching substring in the delimiter.
The pattern /PATTERN/ may be replaced with an expression to specify
patterns that vary at runtime. (To do runtime compilation only
once, use /$variable/o.) As a special case, specifying a space ('
') will split on white space just as split with no arguments does,
but leading white space does NOT produce a null first field. Thus,
split(' ') can be used to emulate awk's default behavior, whereas
split(/ /) will give you as many null initial fields as there are
leading spaces.
sprintf(FORMAT,LIST)
Returns a string formatted by the usual printf() conventions. The
* character is not supported.
sqrt(EXPR)
sqrt EXPR
Return the square root of EXPR. If EXPR is omitted, returns square
root of $_.
srand(EXPR)
srand EXPR
Sets the random number seed for the rand operator. If EXPR is
omitted, does srand(time).
stat(FILEHANDLE)
stat FILEHANDLE
stat(EXPR)
stat SCALARVARIABLE
Returns a 13-element array giving the statistics for a file, either
the file opened via FILEHANDLE, or named by EXPR. If stat is
passed the special filehandle consisting of an underline, no stat
is done, but the current contents of the stat structure from the
last stat or filetest are returned.
study(SCALAR)
study SCALAR
2/94 - Intergraph Corporation 39
perl(1) CLIX perl(1)
study Takes extra time to study SCALAR ($_ if unspecified) in
anticipation of doing many pattern matches on the string before it
is next modified. This may or may not save time, depending on the
nature and number of patterns you are searching on, and on the
distribution of character frequencies in the string to be
searched--you probably want to compare runtimes with and without it
to see which runs faster. Those loops which scan for many short
constant strings (including the constant parts of more complex
patterns) will benefit most. You may have only one study active at
a time--if you study a different scalar the first is "unstudied".
(The way study works is this: a linked list of every character in
the string to be searched is made, so we know, for example, where
all the 'k' characters are. From each search string, the rarest
character is selected, based on some static frequency tables
constructed from some C programs and English text. Only those
places that contain this "rarest" character are examined.)
substr(EXPR,OFFSET,LEN)
substr(EXPR,OFFSET)
Extracts a substring out of EXPR and returns it. First character
is at offset 0, or whatever you have set $[ to. If OFFSET is
negative, starts that far from the end of the string. If LEN is
omitted, returns everything to the end of the string. You can use
the substr() function as an lvalue, in which case EXPR must be an
lvalue. If you assign something shorter than LEN, the string will
shrink, and if you assign something longer than LEN, the string
will grow to accommodate it. To keep the string the same length
you may need to pad or chop your value using sprintf().
symlink(OLDFILE,NEWFILE)
Creates a new filename symbolically linked to the old filename.
Returns 1 for success, 0 otherwise. On systems that don't support
symbolic links, produces a fatal error at run time. To check for
that, use eval().
syscall(LIST)
syscall LIST
Calls the system call specified as the first element of the list,
passing the remaining elements as arguments to the system call. If
unimplemented, produces a fatal error. The arguments are
interpreted as follows: if a given argument is numeric, the
argument is passed as an int. If not, the pointer to the string
value is passed. You are responsible to make sure a string is
pre-extended long enough to receive any result that might be
written into a string. If your integer arguments are not literals
and have never been interpreted in a numeric context, you may need
to add 0 to them to force them to look like numbers.
sysread(FILEHANDLE,SCALAR,LENGTH,OFFSET)
sysread(FILEHANDLE,SCALAR,LENGTH)
Attempts to read LENGTH bytes of data into variable SACALAR from
40 Intergraph Corporation - 2/94
perl(1) CLIX perl(1)
the specified FILEHANDLE, using the system call read(2). It
bypasses stdio, so mixing this with other kinds of reads may cause
confusion. Returns the number of bytes actually read, or undef if
there was an error. SACALAR will be grown or shrunk to the length
actually read. An OFFSET may be specified to place the read data
at some other place than the beginning of the string.
system(LIST)
system LIST
Does exactly the same thing as "exec LIST" except that a fork is
done first, and the parent process waits for the child process to
complete. Note that argument processing varies depending on the
number of arguments. The return value is the exit status of the
program as returned by the wait() call. To get the actual exit
value divide by 256. See also exec.
syswrite(FILEHANDLE,SACALAR,LENGTH,OFFSET)
syswrite(FILEHANDLE,SACALAR,LENGTH)
Attempts to write LENGTH bytes of data from variable SACALAR to the
specified FILEHANDLE, using the system call write(). It bypasses
stdio, so mixing this with prints may cause confusion. Returns the
number of bytes actually written, or undef if there was an error.
An OFFSET may be specified to place the read data at some other
place than the beginning of the string.
tell(FILEHANDLE)
tell FILEHANDLE
tell Returns the current file position for FILEHANDLE. FILEHANDLE may
be an expression whose value gives the name of the actual
filehandle. If FILEHANDLE is omitted, assumes the file last read.
telldir(DIRHANDLE)
telldir DIRHANDLE
Returns the current position of the readdir() routines on
DIRHANDLE. Value may be given to seekdir() to access a particular
location in a directory. Has the same caveats about possible
directory compaction as the corresponding system library routine.
time Returns the number of non-leap seconds since 00:00:00 UTC, January
1, 1970. Suitable for feeding to gmtime() and localtime().
times Returns a four-element array giving the user and system times, in
seconds, for this process and the children of this process.
tr/SEARCHLIST/REPLACEMENTLIST/cds
y/SEARCHLIST/REPLACEMENTLIST/cds
Translates all occurrences of the characters found in the search
list with the corresponding character in the replacement list. It
returns the number of characters replaced or deleted. If no string
is specified via the =~ or !~ operator, the $_ string is
2/94 - Intergraph Corporation 41
perl(1) CLIX perl(1)
translated. (The string specified with =~ must be a scalar
variable, an array element, or an assignment to one of those, i.e.
an lvalue.) For sed devotees, y is provided as a synonym for tr.
If the c modifier is specified, the SEARCHLIST character set is
complemented. If the d modifier is specified, any characters
specified by SEARCHLIST that are not found in REPLACEMENTLIST are
deleted. (Note that this is slightly more flexible than the
behavior of some tr programs, which delete anything they find in
the SEARCHLIST, period.) If the s modifier is specified, sequences
of characters that were translated to the same character are
squashed down to 1 instance of the character.
If the d modifier was used, the REPLACEMENTLIST is always
interpreted exactly as specified. Otherwise, if the
REPLACEMENTLIST is shorter than the SEARCHLIST, the final character
is replicated till it is long enough. If the REPLACEMENTLIST is
null, the SEARCHLIST is replicated. This latter is useful for
counting characters in a class, or for squashing character
sequences in a class.
truncate(FILEHANDLE,LENGTH)
truncate(EXPR,LENGTH)
Truncates the file opened on FILEHANDLE, or named by EXPR, to the
specified length. Produces a fatal error if truncate isn't
implemented on your system.
umask(EXPR)
umask EXPR
umask Sets the umask for the process and returns the old one. If EXPR is
omitted, merely returns current umask.
undef(EXPR)
undef EXPR
undef Undefines the value of EXPR, which must be an lvalue. Use only on
a scalar value, an entire array, or a subroutine name (using &).
(Undef will probably not do what you expect on most predefined
variables or dbm array values.) Always returns the undefined
value. You can omit the EXPR, in which case nothing is undefined,
but you still get an undefined value that you could, for instance,
return from a subroutine.
unlink(LIST)
unlink LIST
Deletes a list of files. Returns the number of files successfully
deleted.
Note: unlink will not delete directories unless you are superuser
and the -U flag is supplied to perl. Even if these conditions are
met, be warned that unlinking a directory can inflict damage on
your filesystem. Use rmdir instead.
42 Intergraph Corporation - 2/94
perl(1) CLIX perl(1)
unpack(TEMPLATE,EXPR)
Unpack does the reverse of pack: it takes a string representing a
structure and expands it out into an array value, returning the
array value. (In a scalar context, it merely returns the first
value produced.) The TEMPLATE has the same format as in the pack
function.
You may also prefix a field with a %<number> to indicate that you
want a <number>-bit checksum of the items instead of the items
themselves. Default is a 16-bit checksum.
unshift(ARRAY,LIST)
Does the opposite of a shift. Or the opposite of a push, depending
on how you look at it. Prepends list to the front of the array,
and returns the number of elements in the new array.
utime(LIST)
utime LIST
Changes the access and modification times on each file of a list of
files. The first two elements of the list must be the NUMERICAL
access and modification times, in that order. Returns the number
of files successfully changed. The inode modification time of each
file is set to the current time.
values(ASSOC_ARRAY)
values ASSOC_ARRAY
Returns a normal array consisting of all the values of the named
associative array. The values are returned in an apparently random
order, but it is the same order as either the keys() or each()
function would produce on the same array. See also keys() and
each().
vec(EXPR,OFFSET,BITS)
Treats a string as a vector of unsigned integers, and returns the
value of the bitfield specified. May also be assigned to. BITS
must be a power of two from 1 to 32.
Vectors created with vec() can also be manipulated with the logical
operators |, & and ^, which will assume a bit vector operation is
desired when both operands are strings. This interpretation is not
enabled unless there is at least one vec() in your program, to
protect older programs.
wait Waits for a child process to terminate and returns the pid of the
deceased process, or -1 if there are no child processes. The
status is returned in $?.
waitpid(PID,FLAGS)
Waits for a particular child process to terminate and returns the
pid of the deceased process, or -1 if there is no such child
process. The status is returned in $?.
2/94 - Intergraph Corporation 43
perl(1) CLIX perl(1)
wantarray
Returns true if the context of the currently executing subroutine
is looking for an array value. Returns false if the context is
looking for a scalar.
warn(LIST)
warn LIST
Produces a message on stderr just like die(), but doesn't exit.
write(FILEHANDLE)
write(EXPR)
write Writes a formatted record (possibly multi-line) to the specified
file, using the format associated with that file. By default the
format for a file is the one having the same name is the
filehandle, but the format for the current output channel (see
select) may be set explicitly by assigning the name of the format
to the $~ variable.
Top of form processing is handled automatically: if there is
insufficient room on the current page for the formatted record, the
page is advanced by writing a form feed, a special top-of-page
format is used to format the new page header, and then the record
is written. By default the top-of-page format is "top", but it may
be set to the format of your choice by assigning the name to the $^
variable. The number of lines remaining on the current page is in
variable $-, which can be set to 0 to force a new page.
If FILEHANDLE is unspecified, output goes to the current default
output channel, which starts out as stdout but may be changed by
the select operator. If the FILEHANDLE is an EXPR, then the
expression is evaluated and the resulting string is used to look up
the name of the FILEHANDLE at run time.
Precedence
perl operators have the following associativity and precedence:
nonassoc
print printf exec system sort reverse chmod chown kill unlink utime
die return
left ,
right = += -= *=
right ?:
nonassoc
..
left ||
44 Intergraph Corporation - 2/94
perl(1) CLIX perl(1)
left &&
left | ^
left &
nonassoc
== != <=> eq ne cmp|*O
nonassoc
< > <= >= lt gt le ge chdir exit eval reset sleep rand umask
nonassoc
-r -w -x
left << >>
left + - .
left * / % x
left =~ !~
right ! ~ and unary minus
right **
nonassoc
++ --
left '('
As mentioned earlier, if any list operator (for example, print) or any
unary operator (for example, chdir) is followed by a left parenthesis as
the next token on the same line, the operator and arguments within
parentheses are taken to be of highest precedence, just like a normal
function call.
In the absence of parentheses, the precedence of list operators such as
print, sort or chmod is either very high or very low depending on whether
you look at the left side of operator or the right side of it.
Subroutines
A subroutine may be declared as follows:
sub NAME BLOCK
Any arguments passed to the routine come in as array @_, that is ($_[0],
$_[1], ...). The array @_ is a local array, but its values are references
2/94 - Intergraph Corporation 45
perl(1) CLIX perl(1)
to the actual scalar parameters. The return value of the subroutine is
the value of the last expression evaluated, and can be either an array
value or a scalar value. Alternately, a return statement may be used to
specify the returned value and exit the subroutine. To create local
variables see the local operator. A subroutine is called using the do
operator or the & operator. }
Subroutines may be called recursively. If a subroutine is called using
the & form, the argument list is optional. If omitted, no @_ array is set
up for the subroutine; the @_ array at the time of the call is visible to
subroutine instead.
Passing By Reference
Sometimes you don't want to pass the value of an array to a subroutine but
rather the name of it, so that the subroutine can modify the global copy
of it rather than working with a local copy. In perl you can refer to all
the objects of a particular name by prefixing the name with a star: *foo.
When evaluated, it produces a scalar value that represents all the objects
of that name, including any filehandle, format or subroutine. When
assigned to within a local() operation, it causes the name mentioned to
refer to whatever * value was assigned to it.
Assignment to *name is currently recommended only inside a local(). You
can actually assign to *name anywhere, but the previous referent of *name
may be stranded forever.
Note that scalars are already passed by reference, so you can modify
scalar arguments without using this mechanism by referring explicitly to
the $_[nnn] in question. You can modify all the elements of an array by
passing all the elements as scalars, but you have to use the * mechanism
to push, pop or change the size of an array. The * mechanism will
probably be more efficient in any case.
Since a *name value contains unprintable binary data, if it is used as an
argument in a print, or as a %s argument in a printf or sprintf, it then
has the value '*name', just so it prints out pretty.
Even if you don't want to modify an array, this mechanism is useful for
passing multiple arrays in a single LIST, since normally the LIST
mechanism will merge all the array values so that you can't extract out
the individual arrays.
Regular Expressions
The patterns used in pattern matching are regular expressions such as
those supplied in the Version 8 regexp routines. (In fact, the routines
are derived from Henry Spencer's freely redistributable reimplementation
of the V8 routines.) In addition, \w matches an alphanumeric character
(including "_") and \W a nonalphanumeric. Word boundaries may be matched
by \b, and non-boundaries by \B. A whitespace character is matched by \s,
46 Intergraph Corporation - 2/94
perl(1) CLIX perl(1)
non-whitespace by \S. A numeric character is matched by \d, non-numeric
by \D. You may use \w, \s and \d within character classes. Also, \n, \r,
\f, \t and \NNN have their normal interpretations. Within character
classes \b represents backspace rather than a word boundary. Alternatives
may be separated by |. The bracketing construct ( ... ) may also be used,
in which case \<digit> matches the digit'th substring. (Outside of the
pattern, always use $ instead of \ in front of the digit. The scope of
$<digit> (and $`, $& and $') extends to the end of the enclosing BLOCK or
eval string, or to the next pattern match with subexpressions. The
\<digit> notation sometimes works outside the current pattern, but should
not be relied upon.) You may have as many parentheses as you wish. If
you have more than 9 substrings, the variables $10, $11, ... refer to the
corresponding substring. Within the pattern, \10, \11, and so on refer
back to substrings if there have been at least that many left parens
before the backreference. Otherwise (for backward compatibility) \10 is
the same as \010, a backspace, and \11 the same as \011, a tab. And so
on. (\1 through \9 are always backreferences.)
$+ returns whatever the last bracket match matched. $& returns the entire
matched string. ($0 used to return the same thing, but not any more.) $`
returns everything before the matched string. $' returns everything after
the matched string.
By default, the ^ character is only guaranteed to match at the beginning
of the string, the $ character only at the end (or before the newline at
the end) and perl does certain optimizations with the assumption that the
string contains only one line. The behavior of ^ and $ on embedded
newlines will be inconsistent. You may, however, wish to treat a string
as a multi-line buffer, such that the ^ will match after any newline
within the string, and $ will match before any newline. At the cost of a
little more overhead, you can do this by setting the variable $* to 1.
Setting it back to 0 makes perl revert to its old behavior.
To facilitate multi-line substitutions, the . character never matches a
newline (even when $* is 0).
Any item of a regular expression may be followed with digits in curly
brackets of the form {n,m}, where n gives the minimum number of times to
match the item and m gives the maximum. The form {n} is equivalent to
{n,n} and matches exactly n times. The form {n,} matches n or more times.
(If a curly bracket occurs in any other context, it is treated as a
regular character.) The * modifier is equivalent to {0,}, the + modifier
to {1,} and the ? modifier to {0,1}. There is no limit to the size of n
or m, but large numbers will chew up more memory.
You will note that all backslashed metacharacters in perl are
alphanumeric, such as \b, \w, \n. Unlike some other regular expression
languages, there are no backslashed symbols that aren't alphanumeric. So
anything that looks like \, \(, \), \<, \>, \{, or \} is always
interpreted as a literal character, not a metacharacter. This makes it
simple to quote a string that you want to use for a pattern but that you
2/94 - Intergraph Corporation 47
perl(1) CLIX perl(1)
are afraid might contain metacharacters.
Formats
Output record formats for use with the write operator may be declared as
follows:
format NAME =
FORMLIST
.
If the name is omitted, format "STDOUT" is defined. FORMLIST consists of
a sequence of lines, each of which may be of one of three types:
⊕ A comment.
⊕ A "picture" line giving the format for one output line.
⊕ An argument line supplying values to plug into a picture line.
Picture lines are printed exactly as they look, except for certain fields
that substitute values into the line. Each picture field starts with
either @ or ^. The @ field (not to be confused with the array marker @)
is the normal case; ^ fields are used to do rudimentary multi-line text
block filling. The length of the field is supplied by padding out the
field with multiple <, >, or | characters to specify, respectively, left
justification, right justification, or centering. As an alternate form of
right justification, you may also use # characters (with an optional .) to
specify a numeric field. (Use of ^ instead of @ causes the field to be
blanked if undefined.) If any of the values supplied for these fields
contains a newline, only the text up to the newline is printed. The
special field @* can be used for printing multi-line values. It should
appear by itself on a line.
The values are specified on the following line, in the same order as the
picture fields. The values should be separated by commas.
Picture fields that begin with ^ rather than @ are treated specially. The
value supplied must be a scalar variable name which contains a text
string. perl puts as much text as it can into the field, and then chops
off the front of the string so that the next time the variable is
referenced, more of the text can be printed. Normally you would use a
sequence of fields in a vertical stack to print out a block of text. If
you like, you can end the final field with ..., which will appear in the
output if the text was too long to appear in its entirety. You can change
which characters are legal to break on by changing the variable $: to a
list of the desired characters.
Since use of ^ fields can produce variable length records if the text to
be formatted is short, you can suppress blank lines by putting the tilde
(~) character anywhere in the line. (Normally you should put it in the
48 Intergraph Corporation - 2/94
perl(1) CLIX perl(1)
front if possible, for visibility.) The tilde will be translated to a
space upon output. If you put a second tilde contiguous to the first, the
line will be repeated until all the fields on the line are exhausted.
It is possible to intermix prints with writes on the same output channel,
but you'll have to handle $- (lines left on the page) yourself.
If you are printing lots of fields that are usually blank, you should
consider using the reset operator between records. Not only is it more
efficient, but it can prevent the bug of adding another field and
forgetting to zero it.
Interprocess Communication
The IPC facilities of perl are built on the Berkeley socket mechanism. If
you don't have sockets, you can ignore this section. The calls have the
same names as the corresponding system calls, but the arguments tend to
differ, for two reasons. First, perl file handles work differently than C
file descriptors. Second, perl already knows the length of its strings,
so you don't need to pass that information.
Predefined Names
The following names have special meaning to perl.
$_ The default input and pattern-searching space.
$. The current input line number of the last filehandle that was read.
Readonly. Remember that only an explicit close on the filehandle
resets the line number. Since <> never does an explicit close,
line numbers increase across ARGV files (but see examples under
eof).
$/ The input record separator, newline by default. Works like awk's
RS variable, including treating blank lines as delimiters if set to
the null string. You may set it to a multicharacter string to
match a multi-character delimiter.
$, The output field separator for the print operator. Ordinarily the
print operator simply prints out the comma separated fields you
specify. In order to get behavior more like awk, set this variable
as you would set awk's OFS variable to specify what is printed
between fields.
$ This is like $, except that it applies to array values interpolated
into a double-quoted string (or similar interpreted string).
Default is a space.
$ The output record separator for the print operator. Ordinarily the
print operator simply prints out the comma separated fields you
specify, with no trailing newline or record separator assumed. In
order to get behavior more like awk, set this variable as you would
2/94 - Intergraph Corporation 49
perl(1) CLIX perl(1)
set awk's ORS variable to specify what is printed at the end of the
print.
$# The output format for printed numbers. This variable is a half-
hearted attempt to emulate awk's OFMT variable. There are times,
however, when awk and perl have differing notions of what is in
fact numeric. Also, the initial value is %.20g rather than %.6g,
so you need to set $# explicitly to get awk's value.
$% The current page number of the currently selected output channel.
$= The current page length (printable lines) of the currently selected
output channel. Default is 60.
$- The number of lines left on the page of the currently selected
output channel.
$~ The name of the current report format for the currently selected
output channel. Default is name of the filehandle.
$^ The name of the current top-of-page format for the currently
selected output channel. Default is name of the filehandle with
"_TOP" appended.
$| If set to nonzero, forces a flush after every write or print on the
currently selected output channel. Default is 0. Note that STDOUT
will typically be line buffered if output is to the terminal and
block buffered otherwise. Setting this variable is useful
primarily when you are outputting to a pipe, such as when you are
running a perl script under rsh and want to see the output as it's
happening.
$$ The process number of the perl running this script.
$? The status returned by the last pipe close, backtick (``) command
or system operator. Note that this is the status word returned by
the wait() system call, so the exit value of the subprocess is
actually ($? >> 8). $? & 255 gives which signal, if any, the
process died from, and whether there was a core dump.
$& The string matched by the last pattern match (not counting any
matches hidden within a BLOCK or eval enclosed by the current
BLOCK).
$` The string preceding whatever was matched by the last pattern match
(not counting any matches hidden within a BLOCK or eval enclosed by
the current BLOCK).
$' The string following whatever was matched by the last pattern match
(not counting any matches hidden within a BLOCK or eval enclosed by
the current BLOCK).
50 Intergraph Corporation - 2/94
perl(1) CLIX perl(1)
$+ The last bracket matched by the last search pattern. This is
useful if you don't know which of a set of alternative patterns
matched.
$* Set to 1 to do multiline matching within a string, 0 to tell perl
that it can assume that strings contain a single line, for the
purpose of optimizing pattern matches. Pattern matches on strings
containing multiple newlines can produce confusing results when $*
is 0. Default is 0.
$0 Contains the name of the file containing the perl script being
executed. Assigning to $0 modifies the argument area that the
ps(1) program sees.
$<digit>
Contains the subpattern from the corresponding set of parentheses
in the last pattern matched, not counting patterns matched in
nested blocks that have been exited already.
$[ The index of the first element in an array, and of the first
character in a substring. Default is 0, but you could set it to 1
to make perl behave more like awk (or Fortran) when subscripting
and when evaluating the index() and substr() functions.
$] The string printed out when you say "perl -v". It can be used to
determine at the beginning of a script whether the perl interpreter
executing the script is in the right range of versions. If used in
a numeric context, returns the version + patchlevel / 1000.
$; The subscript separator for multi-dimensional array emulation.
$! If used in a numeric context, yields the current value of errno,
with all the usual caveats. (This means that you shouldn't depend
on the value of $! to be anything in particular unless you have
gotten a specific error return indicating a system error.) If used
in a string context, yields the corresponding system error string.
You can assign to $! in order to set errno if, for instance, you
want $! to return the string for error n, or you want to set the
exit value for the die operator.
$@ The perl syntax error message from the last eval command. If null,
the last eval parsed and executed correctly (although the
operations you invoked may have failed in the normal fashion).
$< The real uid of this process.
$> The effective uid of this process.
$( The real gid of this process. If you are on a machine that
supports membership in multiple groups simultaneously, gives a
space separated list of groups you are in. The first number is the
2/94 - Intergraph Corporation 51
perl(1) CLIX perl(1)
one returned by getgid(), and the subsequent ones by getgroups(),
one of which may be the same as the first number.
$) The effective gid of this process. If you are on a machine that
supports membership in multiple groups simultaneously, gives a
space separated list of groups you are in. The first number is the
one returned by getegid(), and the subsequent ones by getgroups(),
one of which may be the same as the first number.
$: The current set of characters after which a string may be broken to
fill continuation fields (starting with ^) in a format. Default is
" 0, to break on whitespace or hyphens.
$^D The current value of the debugging flags.
$^F The maximum system file descriptor, ordinarily 2. System file
descriptors are passed to subprocesses, while higher file
descriptors are not. During an open, system file descriptors are
preserved even if the open fails. Ordinary file descriptors are
closed before the open is attempted.
$^I The current value of the inplace-edit extension. Use undef to
disable inplace editing.
$^P The internal flag that the debugger clears so that it doesn't debug
itself. You could conceivable disable debugging yourself by
clearing it.
$^T The time at which the script began running, in seconds since the
epoch. The values returned by the -M , -A and -C filetests are
based on this value.
$^W The current value of the warning switch.
$^X The name that perl itself was executed as, from argv[0].
$ARGV Contains the name of the current file when reading from <>.
@ARGV The array ARGV contains the command line arguments intended for the
script. Note that $#ARGV is the generally number of arguments
minus one, since $ARGV[0] is the first argument, NOT the command
name. See $0 for the command name.
@INC The array INC contains the list of places to look for perl scripts
to be evaluated by the "do EXPR" command or the "require" command.
It initially consists of the arguments to any -I command line
switches, followed by the default perl library, probably
"/usr/local/lib/perl", followed by ".", to represent the current
directory.
%INC The associative array INC contains entries for each filename that
52 Intergraph Corporation - 2/94
perl(1) CLIX perl(1)
has been included via "do" or "require". The key is the filename
you specified, and the value is the location of the file actually
found. The "require" command uses this array to determine whether
a given file has already been included.
$ENV{expr}
The associative array ENV contains your current environment.
Setting a value in ENV changes the environment for child processes.
$SIG{expr}
The associative array SIG is used to set signal handlers for
various signals.
Packages
The perl program provides a mechanism for alternate namespaces to protect
packages from stomping on each others variables. By default, a perl
script starts compiling into the package known as "main". By use of the
package declaration, you can switch namespaces. The scope of the package
declaration is from the declaration itself to the end of the enclosing
block (the same scope as the local() operator). Typically it would be the
first declaration in a file to be included by the "require" operator. You
can switch into a package in more than one place; it merely influences
which symbol table is used by the compiler for the rest of that block.
You can refer to variables and filehandles in other packages by prefixing
the identifier with the package name and a single quote. If the package
name is null, the "main" package as assumed.
Only identifiers starting with letters are stored in the packages symbol
table. All other symbols are kept in package "main". In addition, the
identifiers STDIN, STDOUT, STDERR, ARGV, ARGVOUT, ENV, INC and SIG are
forced to be in package "main", even when used for other purposes than
their built-in one. Note also that, if you have a package called "m", "s"
or "y", the you can't use the qualified form of an identifier since it
will be interpreted instead as a pattern match, a substitution or a
translation.
Evaled strings are compiled in the package in which the eval was compiled
in. (Assignments to $SIG{}, however, assume the signal handler specified
is in the main package. Qualify the signal handler name if you wish to
have a signal handler in a package.) For an example, examine perldb.pl in
the perl library. It initially switches to the DB package so that the
debugger doesn't interfere with variables in the script you are trying to
debug. At various points, however, it temporarily switches back to the
main package to evaluate various expressions in the context of the main
package.
The symbol table for a package happens to be stored in the associative
array of that name prepended with an underscore. The value in each entry
of the associative array is what you are referring to when you use the
*name notation. In fact, the following have the same effect (in package
2/94 - Intergraph Corporation 53
perl(1) CLIX perl(1)
main, anyway), though the first is more efficient because it does the
symbol table lookups at compile time.
Debugging
If you invoke perl with a -d switch, your script will be run under a
debugging monitor. It will halt before the first executable statement and
ask you for a command:
h Prints out a help message.
T Stack trace.
s Single step. Executes until it reaches the beginning of another
statement.
n Next. Executes over subroutine calls, until it reaches the
beginning of the next statement.
f Finish. Executes statements until it has finished the current
subroutine.
c Continue. Executes until the next breakpoint is reached.
c Continue to the specified line. Inserts a one-time-only breakpoint
at the specified line.
<CR> Repeat last n or s.
l min+incr
List incr+1 lines starting at min. If min is omitted, starts where
last listing left off. If incr is omitted, previous value of incr
is used.
l min-max
List lines in the indicated range.
l line List just the indicated line.
l List next window.
- List previous window.
w line List window around line.
l subname
List subroutine. If it's a long subroutine it just lists the
beginning. Use "l" to list more.
/pattern/
Regular expression search forward for pattern; the final / is
optional.
54 Intergraph Corporation - 2/94
perl(1) CLIX perl(1)
?pattern?
Regular expression search backward for pattern; the final ? is
optional.
L List lines that have breakpoints or actions.
S Lists the names of all subroutines.
t Toggle trace mode on or off.
b line condition
Set a breakpoint. If line is omitted, sets a breakpoint on the
line that is about to be executed. If a condition is specified, it
is evaluated each time the statement is reached and a breakpoint is
taken only if the condition is true. Breakpoints may only be set
on lines that begin an executable statement.
b subname condition
Set breakpoint at first executable line of subroutine.
d line Delete breakpoint. If line is omitted, deletes the breakpoint on
the line that is about to be executed.
D Delete all breakpoints.
a line command
Set an action for line. A multi-line command may be entered by
backslashing the newlines.
A Delete all line actions.
< command
Set an action to happen before every debugger prompt. A multi-line
command may be entered by backslashing the newlines.
> command
Set an action to happen after the prompt when you have just given a
command to return to executing the script. A multi-line command
may be entered by backslashing the newlines.
V package
List all variables in package. Default is main package.
! number
Redo a debugging command. If number is omitted, redoes the
previous command.
! -number
Redo the command that was that many commands ago.
H -number
2/94 - Intergraph Corporation 55
perl(1) CLIX perl(1)
Display last number commands. Only commands longer than one
character are listed. If number is omitted, lists them all.
q or ^D
Quit.
command
Execute command as a perl statement. A missing semicolon will be
supplied.
p expr Same as "print DB'OUT expr". The DB'OUT filehandle is opened to
/dev/tty, regardless of where STDOUT may be redirected to.
If you want to modify the debugger, copy perldb.pl from the perl library
to your current directory and modify it as necessary. (You'll also have
to put -I. on your command line.) You can do some customization by
setting up a .perldb file which contains initialization code. For
instance, you could make aliases like these:
$DB'alias{'len'} = 's/^len(.*)/p
length($1)/';
$DB'alias{'stop'} = 's/^stop
(at|in)/b/';
$DB'alias{'.'} =
Setuid Scripts
The perl program is designed to make it easy to write secure setuid and
setgid scripts. Unlike shells, which are based on multiple substitution
passes on each line of the script, perl uses a more conventional
evaluation scheme. Additionally, since the language has more built-in
functionality, it has to rely less upon external (and possibly
untrustworthy) programs to accomplish its purposes.
In an unpatched 4.2 BSD or 4.3 BSD kernel, setuid scripts are
intrinsically insecure, but this kernel feature can be disabled. If it
is, perl can emulate the setuid and setgid mechanism when it notices the
otherwise useless setuid and setgid bits on perl scripts. If the kernel
feature isn't disabled, perl will complain that your setuid script is
insecure. You'll need to either disable the kernel setuid script feature,
or put a C wrapper around the script.
When perl is executing a setuid script, it takes special precautions to
prevent you from falling into any obvious traps. (In some ways, a perl
script is more secure than the corresponding C program.) Any command line
argument, environment variable, or input is marked as "tainted", and may
not be used, directly or indirectly, in any command that invokes a
subshell, or in any command that modifies files, directories, or
processes. Any variable that is set within an expression that has
previously referenced a tainted value also becomes tainted (even if it is
56 Intergraph Corporation - 2/94
perl(1) CLIX perl(1)
logically impossible for the tainted value to influence the variable).
If you try to do something insecure, you will get a fatal error saying
something like Insecure dependency or Insecure PATH. Note that you can
still write an insecure system call or exec, but only by explicitly doing
something like the previous example. You can also bypass the tainting
mechanism by referencing subpatterns -- perl presumes that if you
reference a substring using $1, $2, and so on, you knew what you were
doing when you wrote the pattern:
$ARGV[0] =~ /^-P(
96$printer = $1; # Not tainted
This is fairly secure since \w+ doesn't match shell metacharacters. Use
of .+ would have been insecure, but perl doesn't check for that, so you
must be careful with your patterns. This is the only mechanism for
untainting user-supplied filenames if you want to do file operations on
them (unless you make $> equal to $<).
It's also possible to get into trouble with other operations that don't
care whether they use tainted values. Make judicious use of file tests in
dealing with any user-supplied filenames. When possible, do opens and
such after setting $> = $<. perl doesn't prevent you from opening tainted
filenames for reading, so be careful what you print out. The tainting
mechanism is intended to prevent stupid mistakes, not to remove the need
for thought.
Environment
The perl program uses PATH in executing subprocesses, and in finding the
script if -S is used. HOME or LOGDIR are used if chdir has no argument.
Apart from these, perl uses no environment variables, except to make them
available to the script being executed, and to child processes. However,
scripts running setuid would do well to execute the following lines before
doing anything else:
$ENV{'PATH'} = '/bin:/usr/bin'; # or whatever you need
$ENV{'SHELL'} = '/bin/sh' if $ENV{'SHELL'} ne '';
$ENV{'IFS'} = '' if $ENV{'IFS'} ne '';
FILES
/tmp/perl-eXXXXXX
Temporary file for -e commands.
ERRORS
Compilation errors will tell you the line number of the error, with an
2/94 - Intergraph Corporation 57
perl(1) CLIX perl(1)
indication of the next token or token type that was to be examined. (In
the case of a script passed to perl via -e switches, each -e is counted as
one line.)
Setuid scripts have additional constraints that can produce error messages
such as Insecure dependency. See the section on setuid scripts.
RELATED INFORMATION
Commands: a2p (awk to perl translator), s2p (sed to perl translator),
awk(1), sed(1).
Wall, Larry and Schwartz, Randall L. (1991), Programming Perl, Sebastopol,
CA: O'Reilly & Associates, Inc.
58 Intergraph Corporation - 2/94