Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages


home | help
PERL(1)								       PERL(1)

       perl - Practical	Extraction and Report Language

       perl [options] filename args

       Perl  is	 an interpreted	language optimized for scanning	arbitrary text
       files, extracting information  from  those  text	 files,	 and  printing
       reports	based on that information.  It's also a	good language for many
       system management tasks.	 The language  is  intended  to	 be  practical
       (easy  to  use,	efficient, complete) rather than beautiful (tiny, ele-
       gant, minimal).	It combines (in	the author's opinion, anyway) some  of
       the best	features of C, sed, awk, and sh, so people familiar with those
       languages should	have little difficulty with it.	 (Language  historians
       will  also  note	 some  vestiges	 of csh, Pascal, and even BASIC-PLUS.)
       Expression syntax corresponds quite closely  to	C  expression  syntax.
       Unlike most Unix	utilities, perl	does not arbitrarily limit the size of
       your data--if you've got	the memory, perl can slurp in your whole  file
       as  a  single  string.	Recursion is of	unlimited depth.  And the hash
       tables used by associative arrays grow as necessary to prevent degraded
       performance.   Perl  uses  sophisticated	pattern	matching techniques to
       scan large amounts of data very quickly.	 Although optimized for	 scan-
       ning  text, perl	can also deal with binary data,	and can	make dbm files
       look like associative arrays (where dbm	is  available).	  Setuid  perl
       scripts	are safer than C programs through a dataflow tracing mechanism
       which prevents many stupid security holes.  If you have a problem  that
       would  ordinarily  use sed or awk or sh,	but it exceeds their capabili-
       ties or must run	a little faster, and you don't want to write the silly
       thing  in  C,  then perl	may be for you.	 There are also	translators to
       turn your sed and awk scripts into perl scripts.	 OK, enough hype.

       Upon startup, perl looks	for  your  script  in  one  of	the  following

       1.  Specified line by line via -e switches on the command line.

       2.  Contained  in  the file specified by	the first filename on the com-
	   mand	line.  (Note that systems supporting the  #!  notation	invoke
	   interpreters	this way.)

       3.  Passed  in implicitly via standard input.  This only	works if there
	   are 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.  If
       the script is syntactically correct, it is executed.


       Note: on	first reading this section may not make	 much  sense  to  you.
       It's here at the	front for easy reference.

       A single-character option may be	combined with the following option, if
       any.  This is particularly useful when invoking a script	using  the  #!
       construct which only allows one argument.  Example:

	    #!/usr/bin/perl -spi.bak # same as -s -p -i.bak

       Options include:

	    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.  For example,	if you
	    have a version of find which can print filenames terminated	by the
	    null character, you	can say	this:

		find . -name '*.bak' -print0 | perl -n0e unlink

	    The	 special  value	00 will	cause Perl to slurp files in paragraph
	    mode.  The value 0777 will cause Perl to slurp files  whole	 since
	    there is no	legal character	with that value.

       -a   turns  on  autosplit  mode when used with a	-n or -p.  An implicit
	    split command to the @F array is done as the  first	 thing	inside
	    the	implicit while loop produced by	the -n or -p.

		 perl -ane 'print pop(@F), "\n";'

	    is equivalent to

		 while (<>) {
		      @F = split(' ');
		      print pop(@F), "\n";

       -c   causes  perl to check the syntax of	the script and then exit with-
	    out	executing it.

       -d   runs the script under the  perl  debugger.	 See  the  section  on

	    sets  debugging  flags.  To	watch how it executes your script, use
	    -D14.  (This only works if debugging is compiled into your	perl.)
	    Another  nice  value  is  -D1024, which lists your compiled	syntax
	    tree.  And -D512 displays compiled regular expressions.

       -e commandline
	    may	be used	to enter one line of script.  Multiple -e commands may
	    be	given  to  build up a multi-line script.  If -e	is given, perl
	    will not look for a	script filename	in the argument	list.

	    specifies that files processed by  the  <>	construct  are	to  be
	    edited in-place.  It does this by renaming the input file, opening
	    the	output file by the same	name, and selecting 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.	Saying "perl -p	-i.bak
	    -e "s/foo/bar/;" ... " is the same as using	the script:

		 #!/usr/bin/perl -pi.bak

	    which is equivalent	to

		 while (<>) {
		      if ($ARGV	ne $oldargv) {
			   rename($ARGV, $ARGV . '.bak');
			   open(ARGVOUT, ">$ARGV");
			   $oldargv = $ARGV;
		 continue {
		     print;	# this prints to original filename

	    except that	the -i form doesn't need to compare $ARGV to  $oldargv
	    to	know  when  the	 filename  has changed.	 It does, however, use
	    ARGVOUT for	the selected filehandle.  Note that STDOUT is restored
	    as the default output filehandle after the loop.

	    You	 can use eof to	locate the end of each input file, in case you
	    want to append to each file, or reset line numbering (see  example
	    under eof).

	    may	 be  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.

	    enables  automatic	line-ending  processing.   It has two effects:
	    first, it automatically chops the line terminator when  used  with
	    -n	or  -p , and 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
	    $/.	 For instance, to trim lines to	80 columns:

		 perl -lpe 'substr($_, 80) = ""'

	    Note that the assignment $\	= $/ is	done when the switch  is  pro-
	    cessed,  so	 the  input record separator can be different than the
	    output record separator if the -l  switch  is  followed  by	 a  -0

		 gnufind / -print0 | perl -ln0e	'print "found $_" if -p'

	    This sets $\ to newline and	then sets $/ to	the null character.

       -n   causes perl	to assume the following	loop around your script, which
	    makes it iterate over filename arguments somewhat like "sed	-n" or

		 while (<>) {
		      ...	# your script goes here

	    Note  that	the  lines are not printed by default.	See -p to have
	    lines printed.  Here is an efficient way to	delete all files older
	    than a week:

		 find .	-mtime +7 -print | perl	-nle 'unlink;'

	    This  is  faster  than  using the -exec switch of find because you
	    don't have to start	a process on every filename found.

       -p   causes perl	to assume the following	loop around your script, which
	    makes it iterate over filename arguments somewhat like sed:

		 while (<>) {
		      ...	# your script goes here
		 } continue {

	    Note that the lines	are printed automatically.  To suppress	print-
	    ing	use the	-n switch.  A -p overrides a -n	switch.

       -P   causes your	script to be run through  the  C  preprocessor	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 some rudimentary switch parsing for	switches on  the  com-
	    mand  line after the script	name but before	any filename arguments
	    (or	before a --).  Any switch found	there is  removed  from	 @ARGV
	    and	 sets the corresponding	variable in the	perl script.  The fol-
	    lowing script prints "true"	if and only if the script  is  invoked
	    with a -xyz	switch.

		 #!/usr/bin/perl -s
		 if ($xyz) { print "true\n"; }

       -S   makes  perl	 use  the  PATH	environment variable to	search for the
	    script (unless the name of the script starts with a	slash).	 Typi-
	    cally  this	 is  used to emulate #!	startup	on machines that don't
	    support #!,	in the following manner:

		 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 com-
	    mand, 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.  In	order 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 politely ignored by perl.  Other systems can't  con-
	    trol  that,	 and  need  a totally devious 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;

       -u   causes perl	to dump	core after compiling  your  script.   You  can
	    then  take	this  core dump	and turn it 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	strip-
	    ping the executable).  (Still, a "hello  world"  executable	 comes
	    out	 to  about  200K on my machine.)  If you are going to run your
	    executable as a set-id program then	you should probably 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:  availability  of undump is platform specific and
	    may	not be available for a specific	port of	perl.

       -U   allows perl	to do unsafe operations.  Currently the	only  "unsafe"
	    operations are the unlinking of directories	while running as supe-
	    ruser, and running setuid programs with fatal taint	checks	turned
	    into warnings.

       -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 filehan-
	    dles or filehandles	opened readonly	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.

	    tells  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 nor-
	    mal	 #!  processing).  If a	directory name is specified, Perl will
	    switch to that directory before running the	script.	 The -x	switch
	    only controls 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).

       Data Types and Objects

       Perl has	three data types: scalars, arrays of scalars, and  associative
       arrays  of  scalars.  Normal arrays are indexed by number, and associa-
       tive 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  men-
       tioned  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

       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	refer-
       ring to a scalar	that is	part of	an array.  Thus:

	   $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

       but 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'})

       and 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	preex-
       tending 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:

	    scalar(@whatever) == $#whatever - $[ + 1;

       If you evaluate an associative array in a scalar	context, it returns  a
       value  which  is	 true  if and only if the array	contains any elements.
       (If there are any elements, the value returned is a  string  consisting
       of the number of	used buckets and the number of allocated buckets, sep-
       arated by a slash.)

       Multi-dimensional arrays	are not	directly supported, but	see  the  dis-
       cussion of the $; variable later	for a means of emulating multiple sub-
       scripts 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 con-
       flict, use the same name	for a scalar variable, an array,  an  associa-
       tive  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, how-
       ever,  which  don't have	an initial special character.  Hint: you could
       say open(LOG,'logfile') rather than open(log,'logfile').	 Using	upper-
       case  filehandles  also improves	readability and	protects you from con-
       flict 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, e.g. "$%"	or "$$".  (Most	of the
       one character names have	 a  predefined	significance  to  perl.	  More

       Numeric	literals  are  specified in any	of the usual floating point or
       integer formats:

	   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, tab,	etc., as  well	as  some  more	exotic

	    \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
	    \E	      end case modification

       You can also embed newlines directly in your strings, i.e. they can end
       on a different line than	they begin.  This is nice, but 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.   (In	 other
       words,  identifiers  beginning  with  $	or  @, followed	by an optional
       bracketed expression as	a  subscript.)	 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 DATA
       filehandle may read data	only from the main script, but	not  from  any
       required	 file or evaluated string.)  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 $" vari-
       able, space by default.	(Since in versions of perl prior to 3.0	the  @
       character  was not a metacharacter in double-quoted strings, the	inter-
       polation	 of  @array,  $array[EXPR],  @array[LIST],  $array{EXPR},   or
       @array{LIST}  only happens if array is referenced elsewhere in the pro-
       gram 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)
       there  is  a  bad  ambiguity:   Is  /$foo[bar]/	to  be	interpreted as
       /${foo}[bar]/ (where [bar] is a character class for the regular expres-
       sion) 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, or if you're  just  plain	 para-
       noid,  you  can force the correct interpretation	with curly brackets as

       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	white-
       space) on the terminating line.

	    print <<EOF;	# same as above
       The price is $Price.

	    print <<"EOF";	# same as above
       The price is $Price.

	    print << x 10;	# null identifier is delimiter
       Merry Christmas!

	    print <<`EOC`;	# execute commands
       echo hi there
       echo lo there

	    print <<foo, <<bar;	# you can stack	them
       I said foo.
       I said bar.

       Array  literals	are denoted by separating individual values by commas,
       and enclosing the list in parentheses:


       In a context not	requiring an array value, the value of the array  lit-
       eral  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	= (

       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


       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);

       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--new-
       lines 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 automati-
       cally 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>;
	   print while <STDIN>;

       The filehandles STDIN, STDOUT and STDERR	are predefined.	 (The filehan-
       dles  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

       The null	filehandle <> is special and can be used to emulate the	behav-
       ior 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

	    while (<>) {
		 ...		# code for each	line

       is equivalent to	the following Perl-like	pseudo code:

	    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, and will actually work.   It
       really does shift array ARGV and	put the	current	filename into variable
       ARGV.  It also uses filehandle ARGV internally--<> is  just  a  synonym
       for  <ARGV>,  which  is	magical.   (The	pseudo code above doesn't work
       because it treats <ARGV>	as non-magical.)

       You can modify @ARGV before the first <>	as long	as the array  ends  up
       containing  the	list  of filenames you really want.  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], /^-/)	{
		last if	/^--$/;
		 /^-D(.*)/ && ($debug =	$1);
		 /^-v/ && $verbose++;
		 ...	   # other switches
	    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	inter-
       preted 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 interpre-
       tation 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>) {
		 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>;


       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 dec-
       larations.  All uninitialized user-created objects are assumed to start
       with  a	null or	0 value	until they are defined by some explicit	opera-
       tion such as assignment.	 The sequence of  commands  is	executed  just
       once,  unlike in	sed and	awk scripts, where the sequence	of commands is
       executed	for each input line.  While this means that you	 must  explic-
       itly  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.

       Perl  is, for the most part, a free-form	language.  (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

       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 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

       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 contin-
       ued 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 iter-

       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 {

       The foreach loop	iterates over a	normal array value and sets the	 vari-
       able  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.

	    for	(@ary) { s/foo/bar/; }

	    foreach $elem (@elements) {
		 $elem *= 2;

	    for	((10,9,8,7,6,5,4,3,2,1,'BOOM'))	{
		 print $_, "\n"; sleep(1);

	    for	(1..15)	{ print	"Merry Christmas\n"; }

	    foreach $item (split(/:[\\\n:]*/, $ENV{'TERMCAP'}))	{
		 print "Item: $item\n";

       The BLOCK by itself (labeled or not) is equivalent to a loop that  exe-
       cutes  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;


	    foo: {
		 /^abc/	&& do {	$abc = 1; last foo; };
		 /^def/	&& do {	$def = 1; last foo; };
		 /^xyz/	&& do {	$xyz = 1; last foo; };
		 $nothing = 1;


	    foo: {
		 /^abc/	&& ($abc = 1, last foo);
		 /^def/	&& ($def = 1, last foo);
		 /^xyz/	&& ($xyz = 1, last foo);
		 $nothing = 1;

       or even

	    if (/^abc/)
		 { $abc	= 1; }
	    elsif (/^def/)
		 { $def	= 1; }
	    elsif (/^xyz/)
		 { $xyz	= 1; }
		 {$nothing = 1;}

       As  it  happens,	 these are all optimized internally to a switch	struc-
       ture, 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

       Simple statements

       The only	kind of	simple statement is an expression  evaluated  for  its
       side  effects.	Every simple statement must be terminated with a semi-
       colon, unless it	is the final statement in a block, in which  case  the
       semicolon  is  optional.	  (Semicolon  is still encouraged there	if the
       block takes up more than	one line).

       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	evalu-
       ated.  This is so that you can write loops like:

	    do {
		 $_ = <STDIN>;
	    } until $_ eq ".\n";

       (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.)


       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	behav-
	       ior 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  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 "\t" 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,	and  emulates  the  line-range
	       (comma)	operator  of  sed,  awk, and various editors.  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 test the right operand and become false on
	       the same	evaluation it became true (as in awk),	but  it	 still
	       returns	true once.  If you don't want it to test the right op-
	       erand till the next evaluation (as  in  sed),  use  three  dots
	       (...)  instead  of  two.)   The	right operand is not evaluated
	       while the operator is in	the "false" state, and the left	 oper-
	       and is not evaluated while the operator is in the "true"	state.
	       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:

	       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 rela-
	       tional operators, but lower  than  arithmetic  operators.   The
	       operator	may be any of:
		    -r	 File is readable by effective uid/gid.
		    -w	 File is writable by effective uid/gid.
		    -x	 File is executable by effective uid/gid.
		    -o	 File is owned by effective uid.
		    -R	 File is readable by real uid/gid.
		    -W	 File is writable by real uid/gid.
		    -X	 File is executable by real uid/gid.
		    -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.
		    -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.


		    while (<>) {
			 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  let-
	       ters 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 con-
	       trol  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  cur-
	       rent  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 spe-
       cial 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 sym-
       bolic link, not the real	file.)	Example:

	    print "Can do.\n" if -r $a || -w _ || -x _;

	    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  concatena-
       tion  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.

       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 vari-
       able 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	speci-

       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 val-
       ues will	be included in the list	as if  each  individual	 element  were
       interpolated  at	that point in the list,	forming	a longer single-dimen-
       sional array value.  Elements of	the LIST should	be separated  by  com-
       mas.   If  an  operation	 is  listed  both with and without parentheses
       around its arguments, it	means you can either use it as a unary	opera-
       tor  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.

       For  operators  that  can  be used in either a scalar or	array context,
       failure is generally indicated in a scalar  context  by	returning  the
       undefined  value,  and  in an array context by returning	the null list.
       Remember	though that THERE IS NO	GENERAL	RULE  FOR  CONVERTING  A  LIST
       INTO  A SCALAR.	Each operator decides which sort of scalar it would be
       most appropriate	to return.  Some operators return the  length  of  the
       list that would have been returned in an	array context.	Some operators
       return the first	value in the list.  Some  operators  return  the  last
       value  in the list.  Some operators return a count of successful	opera-
       tions.  In general, they	do what	you want, unless you want consistency.

	       See m/PATTERN/.

	       This  is	just like the /pattern/	search,	except that it matches
	       only once between calls to the reset operator.  This is a  use-
	       ful 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.

	       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
	       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.

	       Returns the arctangent of Y/X in	the range -PI to PI.

	       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 sec-
	       tion on Interprocess Communication.


       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	trans-
	       lated to	LF on input and	LF translated  to  CR  LF  on  output.
	       Binmode	has no effect under Unix.  If FILEHANDLE is an expres-
	       sion, the value is taken	as the name of the filehandle.


       caller  Returns the context of the current subroutine call:

		    ($package,$filename,$line) = caller;

	       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
	       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
	       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.

		    $cnt = chmod 0755, 'foo', 'bar';
		    chmod 0755,	@executables;



       chop VARIABLE

       chop    Chops off the last character of a string	and returns the	 char-
	       acter  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 $_.  Example:

		    while (<>) {
			 chop;	   # avoid \n on last field
			 @array	= split(/:/);

	       You can actually	chop anything that's an	lvalue,	 including  an

		    chop($cwd =	`pwd`);
		    chop($answer = <STDIN>);

	       If you chop a list, each	element	is chopped.  Only the value of
	       the last	chop is	returned.


       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.

		    $cnt = chown $uid, $gid, 'foo', 'bar';
		    chown $uid,	$gid, @filenames;

	       Here's  an example that looks up	non-numeric uids in the	passwd

		    print "User: ";
		    $user = <STDIN>;
		    print "Files: "
		    $pattern = <STDIN>;
		    open(pass, '/etc/passwd')
			 || die	"Can't open passwd: $!\n";
		    while (<pass>) {
			 ($login,$pass,$uid,$gid) = split(/:/);
			 $uid{$login} =	$uid;
			 $gid{$login} =	$gid;
		    @ary = <${pattern}>;     # get filenames
		    if ($uid{$user} eq '') {
			 die "$user not	in passwd file";
		    else {
			 chown $uid{$user}, $gid{$user}, @ary;


       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 omit-
	       ted, does chroot	to $_.


       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 ($.), 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 $?.	 Example:

		    open(OUTPUT, '|sort	>foo');	  # pipe to sort
		    ...	 # print stuff to output
		    close OUTPUT;	# wait for sort	to finish
		    open(INPUT,	'foo');	# get sort's results

	       FILEHANDLE may be an expression	whose  value  gives  the  real
	       filehandle name.


       closedir	DIRHANDLE
	       Closes a	directory opened by opendir().

	       Does the	same thing that	the connect system call	does.  Returns
	       true if it succeeded, false otherwise.  NAME should be a	 pack-
	       age  address of the proper type for the socket.	See example in
	       section on Interprocess Communication.


       cos EXPR
	       Returns the cosine of EXPR (expressed in	radians).  If EXPR  is
	       omitted takes cosine of $_.

	       Encrypts	 a  string  exactly like the crypt() function in the C
	       library.	 Useful	for checking the password file for lousy pass-
	       words.  Only the	guys wearing white hats	should do this.


       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.

	       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
	       perform	only  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.

	       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 set-
	       ting a dummy array entry	inside an eval,	which  will  trap  the

	       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.	 Exam-

		    # print out	history	file offsets
		    while (($key,$val) = each %HIST) {
			 print $key, ' = ', unpack('L',$val), "\n";


       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,  uninitial-
	       ized 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.	 Examples:

		    print if defined $switch{'D'};
		    print "$val\n" while defined($val =	pop(@ary));
		    die	"Can't readlink	$sym: $!"
			 unless	defined($value = readlink $sym);
		    eval '@foo = ()' if	defined(@foo);
		    die	"No XYZ	package	defined" unless	defined	%_XYZ;
		    sub	foo { defined &$bar ? &$bar(@_)	: die "No bar";	}

	       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 envi-
	       ronment.	 Deleting from an array	bound to a  dbm	 file  deletes
	       the entry from the dbm file.

	       The following deletes all the values of an associative array:

		    foreach $key (keys %ARRAY) {
			 delete	$ARRAY{$key};

	       (But it would be	faster to use the reset	command.  Saying undef
	       %ARRAY is faster	yet.)


       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

	       Equivalent examples:

		    die	"Can't cd to spool: $!\n"
			 unless	chdir '/usr/spool/news';

		    chdir '/usr/spool/news' || die "Can't cd to	spool: $!\n"

	       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.  Hint: sometimes appending
	       ", stopped" to your message will	cause it to make better	 sense
	       when the	string "at foo line 123" is appended.  Suppose you are
	       running script "canasta".

		    die	"/etc/games is no good";
		    die	"/etc/games is no good,	stopped";

	       produce,	respectively

		    /etc/games is no good at canasta line 123.
		    /etc/games is no good, stopped at canasta line 123.

	       See also	exit.

       do BLOCK
	       Returns the value of the	last command in	the sequence  of  com-
	       mands  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

	       Executes	a  SUBROUTINE  declared	 by  a	sub  declaration,  and
	       returns	the  value of the last expression evaluated in SUBROU-
	       TINE.  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 the array in front	of each	array.
	       (See the	section	on subroutines later on.)  The parentheses are
	       required	to avoid confusion with	the "do	EXPR" form.

	       SUBROUTINE  may also be a single	scalar variable, in which case
	       the name	of the subroutine to execute is	taken from  the	 vari-

	       As an alternate (and preferred) 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 parenthe-
	       ses.  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:

		    if (defined	&$var) { &$var($parm); undef &$var; }

       do EXPR Uses the	value of EXPR as a filename and	executes the  contents
	       of  the	file  as a perl	script.	 Its primary use is to include
	       subroutines from	a perl subroutine library.

		    do '';

	       is just like

		    eval `cat`;

	       except that it's	more efficient,	more concise, keeps  track  of
	       the  current  filename for error	messages, and searches all the
	       -I libraries if the file	isn't in the  current  directory  (see
	       also  the @INC array in Predefined Names).  It's	the same, how-
	       ever, in	that it	does reparse the file every time you call  it,
	       so  if  you  are	 going to use the file inside a	loop you might
	       prefer to use -P	and #include, at the expense of	a little  more
	       startup	time.	(The  main  problem  with #include is that cpp
	       doesn't grok # comments--a workaround is	to use ";#" for	stand-
	       alone comments.)	 Note that the following are NOT equivalent:

		    do $foo;  #	eval a file
		    do $foo();	   # call a subroutine

	       Note that inclusion of library routines is better done with the
	       "require" operator.

       dump LABEL
	       This causes an immediate	core dump.  Primarily this is so  that
	       you  can	 use the undump	program	to turn	your core dump into an
	       executable binary after having initialized all  your  variables
	       at  the	beginning of the program.  When	the new	binary is exe-
	       cuted it	will begin by executing	a "goto	LABEL" (with  all  the
	       restrictions that goto suffers).	 Think of it as	a goto with an
	       intervening core	dump and reincarnation.	 If LABEL is  omitted,
	       restarts	 the  program from the top.  WARNING: any files	opened
	       at the time of the dump will NOT	be open	any more when the pro-
	       gram  is	reincarnated, with possible resulting confusion	on the
	       part of perl.  See also -u.


		    require '';
		    require '';
		    %days = (

		    dump QUICKSTART if $ARGV[0]	eq '-d';

		    do Getopt('f');


       each ASSOC_ARRAY
	       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.	 Entries are returned in an apparently	random	order.
	       When  the  array	 is  entirely  read,  a	null array is returned
	       (which when assigned produces a FALSE  (0)  value).   The  next
	       call  to	 each()	 after	that  will start iterating again.  The
	       iterator	can be reset only by reading all the elements from the
	       array.	You must not modify the	array while iterating over it.
	       There is	a single iterator for each associative	array,	shared
	       by  all	each(),	keys() and values() function calls in the pro-
	       gram.  The following  prints  out  your	environment  like  the
	       printenv	program, only in a different order:

		    while (($key,$value) = each	%ENV) {
			 print "$key=$value\n";

	       See also	keys() and values().



       eof     Returns	1  if  the  next read on FILEHANDLE will return	end of
	       file, or	if FILEHANDLE is  not  open.   FILEHANDLE  may	be  an
	       expression  whose  value	gives the real filehandle name.	 (Note
	       that this function actually reads a character and then ungetc's
	       it,  so	it  is not very	useful in an interactive context.)  An
	       eof without an argument returns the eof	status	for  the  last
	       file  read.   Empty  parentheses	() may be used to indicate the
	       pseudo file formed of the files listed  on  the	command	 line,
	       i.e.  eof()  is	reasonable  to use inside a while (<>) loop to
	       detect the end of only the last file.   Use  eof(ARGV)  or  eof
	       without the parentheses to test EACH file in a while (<>) loop.

		    # insert dashes just before	last line of last file
		    while (<>) {
			 if (eof()) {
			      print "--------------\n";

		    # reset line numbering on each input file
		    while (<>) {
			 print "$.\t$_";
			 if (eof) {	# Not eof().


       eval EXPR

       eval BLOCK
	       EXPR is parsed and executed as if it were a  little  perl  pro-
	       gram.   It  is executed in the context of the current perl pro-
	       gram, so	that any variable settings, subroutine or format defi-
	       nitions	remain afterwards.  The	value returned is the value of
	       the last	expression evaluated, just as  with  subroutines.   If
	       there is	a syntax error or runtime error, or a die statement is
	       executed, an undefined value is returned	by eval, and $@	is set
	       to  the error message.  If there	was no error, $@ is guaranteed
	       to be a null string.  If	EXPR is	omitted,  evaluates  $_.   The
	       final semicolon,	if any,	may be omitted from the	expression.

	       Note  that, since eval traps otherwise-fatal errors, it is use-
	       ful for determining  whether  a	particular  feature  (such  as
	       dbmopen	or  symlink) is	implemented.  It is also Perl's	excep-
	       tion trapping mechanism,	where the  die	operator  is  used  to
	       raise exceptions.

	       If  the code to be executed doesn't vary, you may use the eval-
	       BLOCK form  to  trap  run-time  errors  without	incurring  the
	       penalty	of recompiling each time.  The error, if any, is still
	       returned	in $@.	Evaluating a single-quoted  string  (as	 EXPR)
	       has  the	 same  effect,	except that the	eval-EXPR form reports
	       syntax errors at	run time via $@, whereas the  eval-BLOCK  form
	       reports	syntax	errors at compile time.	 The eval-EXPR form is
	       optimized to eval-BLOCK the first time it succeeds.  (Since the
	       replacement  side  of  a	 substitution  is considered a single-
	       quoted string when you use the e	modifier, the  same  optimiza-
	       tion occurs there.)  Examples:

		    # make divide-by-zero non-fatal
		    eval { $answer = $a	/ $b; }; warn $@ if $@;

		    # optimized	to same	thing after first use
		    eval '$answer = $a / $b'; warn $@ if $@;

		    # a	compile-time error
		    eval { $answer = };

		    # a	run-time error
		    eval '$answer =';	# sets $@


       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	 argu-
	       ments in	LIST.  If there	is only	one scalar argument, the argu-
	       ment is checked for shell metacharacters.  If  there  are  any,
	       the  entire argument is passed to "/bin/sh -c" for parsing.  If
	       there are none, the argument is split  into  words  and	passed
	       directly	to execvp(), which is more efficient.  Note: exec (and
	       system) do not flush your output	buffer,	so you may need	to set
	       $| to avoid lost	output.	 Examples:

		    exec '/bin/echo', 'Your arguments are: ', @ARGV;
		    exec "sort $outfile	| uniq";

	       If  you	don't  really  want to execute the first argument, but
	       want to lie to the program you  are  executing  about  its  own
	       name,  you  can specify the program you actually	want to	run by
	       assigning that to a variable and	putting	the name of the	 vari-
	       able in front of	the LIST without a comma.  (This always	forces
	       interpretation of the LIST as  a	 multi-valued  list,  even  if
	       there is	only a single scalar in	the list.)  Example:

		    $shell = '/bin/csh';
		    exec $shell	'-sh';	     # pretend it's a login shell


       exit EXPR
	       Evaluates EXPR and exits	immediately with that value.  Example:

		    $ans = <STDIN>;
		    exit 0 if $ans =~ /^[Xx]/;

	       See also	die.  If EXPR is omitted, exits	with 0 status.


       exp EXPR
	       Returns e to the	power of EXPR.	 If  EXPR  is  omitted,	 gives

	       Implements the fcntl(2) function.  You'll probably have to say

		    require "";	# probably /usr/local/lib/perl/

	       first  to  get  the  correct function definitions.  If
	       doesn't exist or	doesn't	have the  correct  definitions	you'll
	       have  to	 roll  your  own, based	on your	C header files such as
	       <sys/fcntl.h>.  (There is a perl	script called h2ph that	 comes
	       with  the  perl kit which may help you in this.)	 Argument pro-
	       cessing and value return	works just  like  ioctl	 below.	  Note
	       that fcntl will produce a fatal error if	used on	a machine that
	       doesn't implement fcntl(2).


       fileno FILEHANDLE
	       Returns the file	descriptor for a filehandle.  Useful for  con-
	       structing  bitmaps  for	select().  If FILEHANDLE is an expres-
	       sion, the value is taken	as the name of the filehandle.

	       Calls flock(2) on FILEHANDLE.  See manual page for flock(2) for
	       definition  of  OPERATION.   Returns true for success, false on
	       failure.	 Will produce a	fatal error if used on a machine  that
	       doesn't	implement flock(2).  Here's a mailbox appender for BSD

		    $LOCK_SH = 1;
		    $LOCK_EX = 2;
		    $LOCK_NB = 4;
		    $LOCK_UN = 8;

		    sub	lock {
			# and, in case someone appended
			# while	we were	waiting...
			seek(MBOX, 0, 2);

		    sub	unlock {

		    open(MBOX, ">>/usr/spool/mail/$ENV{'USER'}")
			 || die	"Can't open mailbox: $!";

		    do lock();
		    print MBOX $msg,"\n\n";
		    do unlock();

       fork    Does a fork() call.   Returns  the  child  pid  to  the	parent
	       process	and  0	to the child process.  Note: unflushed buffers
	       remain unflushed	in both	processes, which means you may need to
	       set $| to avoid duplicate output.


       getc FILEHANDLE

       getc    Returns	the  next  character  from  the	input file attached to
	       FILEHANDLE, or a	null string at EOF.  If	FILEHANDLE is omitted,
	       reads from STDIN.

	       Returns the current login from /etc/utmp, if any.  If null, use

		    $login = getlogin || (getpwuid($<))[0] || "Somebody";

	       Returns the packed sockaddr address of other end	of the	SOCKET

		    # An internet sockaddr
		    $sockaddr =	'S n a4	x8';
		    $hersockaddr = getpeername(S);
		    ($family, $port, $heraddr) =


       getpgrp PID
	       Returns	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 getpgrp(2).  If EXPR is omitted,
	       returns process group of	current	process.

       getppid Returns the process id of the parent process.

	       Returns the current priority for	a process, a process group, or
	       a  user.	  (See getpriority(2).)	 Will produce a	fatal error if
	       used on a machine that doesn't implement	getpriority(2).






























	       These routines perform the same functions as their counterparts
	       in  the	system	library.   Within an array context, the	return
	       values from the various get routines are	as follows:

		       $quota,$comment,$gcos,$dir,$shell) = getpw...
		    ($name,$passwd,$gid,$members) = getgr...
		    ($name,$aliases,$addrtype,$length,@addrs) =	gethost...
		    ($name,$aliases,$addrtype,$net) = getnet...
		    ($name,$aliases,$proto) = getproto...
		    ($name,$aliases,$port,$proto) = getserv...

	       (If the entry doesn't exist you get a null list.)

	       Within a	scalar context,	you get	the name, unless the  function
	       was  a  lookup  by name,	in which case you get the other	thing,
	       whatever	it is.	(If the	entry doesn't exist you	get the	 unde-
	       fined value.)  For example:

		    $uid = getpwnam
		    $name = getpwuid
		    $name = getpwent
		    $gid = getgrnam
		    $name = getgrgid
		    $name = getgrent

	       The  $members  value  returned by getgr... is a space separated
	       list of the login names of the members of the group.

	       For the gethost... functions, if	the h_errno variable  is  sup-
	       ported  in C, it	will be	returned to you	via $? if the function
	       call fails.  The	@addrs value returned by a successful call  is
	       a  list of the raw addresses returned by	the corresponding sys-
	       tem library call.  In the Internet domain, each address is four
	       bytes long and you can unpack it	by saying something like:

		    ($a,$b,$c,$d) = unpack('C4',$addr[0]);

	       Returns	the  packed sockaddr address of	this end of the	SOCKET

		    # An internet sockaddr
		    $sockaddr =	'S n a4	x8';
		    $mysockaddr	= getsockname(S);
		    ($family, $port, $myaddr) =

	       Returns the socket option requested, or undefined if  there  is
	       an error.


       gmtime EXPR
	       Converts	a time as returned by the time function	to a 9-element
	       array with the time analyzed for	the Greenwich timezone.	 Typi-
	       cally used as follows:

	       ($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst) =

	       All  array  elements  are  numeric,  and	come straight out of a
	       struct tm.  In particular this means that $mon  has  the	 range
	       0..11  and  $wday has the range 0..6.  If EXPR is omitted, does

       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  {}  con-
	       struct.	 This  statement  is not implemented very efficiently,
	       and is here only	to make	the sed-to-perl	translator easier.   I
	       may  change  its	semantics at any time, consistent with support
	       for translated sed scripts.  Use	it at your own	risk.	Better
	       yet, don't use it at all.

	       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.  In a
	       scalar context, returns the number of times the expression  was

		    @foo = grep(!/^#/, @bar);	 # weed	out comments

	       Note that, since	$_ is a	reference into the array value,	it can
	       be used to modify the elements of the  array.   While  this  is
	       useful  and supported, it can cause bizarre results if the LIST
	       is not a	named array.


       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	$_.


	       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've set the $[	variable to.  If the substring
	       is not found, returns one less than the base, ordinarily	-1.


       int EXPR
	       Returns the integer portion of EXPR.  If	EXPR is	omitted,  uses

	       Implements the ioctl(2) function.  You'll probably have to say

		    require "";	# probably /usr/local/lib/perl/

	       first  to  get  the  correct function definitions.  If
	       doesn't exist or	doesn't	have the  correct  definitions	you'll
	       have  to	 roll  your  own, based	on your	C header files such as
	       <sys/ioctl.h>.  (There is a perl	script called h2ph that	 comes
	       with  the perl kit which	may help you in	this.)	SCALAR will be
	       read and/or written depending on	the FUNCTION--a	pointer	to the
	       string  value of	SCALAR will be passed as the third argument of
	       the actual ioctl	call.  (If SCALAR has no string	value but does
	       have  a	numeric	value, that value will be passed rather	than a
	       pointer to the string value.  To	guarantee this to be true, add
	       a  0  to	 the scalar before using it.)  The pack() and unpack()
	       functions are useful for	manipulating the values	of  structures
	       used  by	ioctl().  The following	example	sets the erase charac-
	       ter to DEL.

		    require '';
		    $sgttyb_t =	"ccccs";	  # 4 chars and	a short
		    if (ioctl(STDIN,$TIOCGETP,$sgttyb))	{
			 @ary =	unpack($sgttyb_t,$sgttyb);
			 $ary[2] = 127;
			 $sgttyb = pack($sgttyb_t,@ary);
			      || die "Can't ioctl: $!";

	       The return value	of ioctl (and fcntl) is	as follows:

		    if OS returns:	     perl returns:
		      -1		       undefined value
		      0			       string "0 but true"
		      anything else	       that number

	       Thus perl returns true on success and false on failure, yet you
	       can  still  easily  determine  the actual value returned	by the
	       operating system:

		    ($retval = ioctl(...)) || ($retval = -1);
		    printf "System returned %d\n", $retval;


	       Joins the separate strings of  LIST  or	ARRAY  into  a	single
	       string  with fields separated by	the value of EXPR, and returns
	       the string.  Example:

	       $_ = join(':',

	       See split.


       keys ASSOC_ARRAY
	       Returns a normal	array consisting of all	the keys of the	 named
	       associative array.  The keys are	returned in an apparently ran-
	       dom order, but it is the	same order as either the  values()  or
	       each()  function	produces (given	that the associative array has
	       not been	modified).  Here is yet	 another  way  to  print  your

		    @keys = keys %ENV;
		    @values = values %ENV;
		    while ($#keys >= 0)	{
			 print pop(@keys), '=',	pop(@values), "\n";

	       or how about sorted by key:

		    foreach $key (sort(keys %ENV)) {
			 print $key, '=', $ENV{$key}, "\n";


       kill LIST
	       Sends  a	 signal	 to a list of processes.  The first element of
	       the list	must be	the signal to send.   Returns  the  number  of
	       processes successfully signaled.

		    $cnt = kill	1, $child1, $child2;
		    kill 9, @goners;

	       If the signal is	negative, kills	process	groups instead of pro-
	       cesses.	(On System V, a	negative process number	will also kill
	       process groups, but that's not portable.)  You may use a	signal
	       name in quotes.

       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.  The continue block, if any, is not executed:

		    line: while	(<STDIN>) {
			 last line if /^$/;  # exit when done with header


       length EXPR
	       Returns the length in characters	of the value of	EXPR.  If EXPR
	       is omitted, returns length of $_.

	       Creates a new filename linked to	the old	filename.   Returns  1
	       for success, 0 otherwise.

	       Does  the same thing that the listen system call	does.  Returns
	       true if it succeeded, false otherwise.  See example in  section
	       on Interprocess Communication.

	       Declares	 the  listed  variables	 to  be	local to the enclosing
	       block, subroutine, eval or "do".	 All the listed	elements  must
	       be  legal  lvalues.   This operator works by saving the current
	       values of those variables in LIST on a hidden stack and restor-
	       ing  them  upon	exiting	 the  block, subroutine	or eval.  This
	       means that called subroutines  can  also	 reference  the	 local
	       variable,  but not the global one.  The LIST may	be assigned to
	       if desired, which allows	you to	initialize  your  local	 vari-
	       ables.	(If no initializer is given for	a particular variable,
	       it is created with an undefined value.)	Commonly this is  used
	       to name the parameters to a subroutine.	Examples:

		    sub	RANGEVAL {
			 local($min, $max, $thunk) = @_;
			 local($result)	= '';

			 # Presumably $thunk makes reference to	$i

			 for ($i = $min; $i < $max; $i++) {
			      $result .= eval $thunk;


		    if ($sw eq '-v') {
			# init local array with	global array
			local(@ARGV) = @ARGV;
			system @ARGV;
		    # @ARGV restored

		    # temporarily add to digits	associative array
		    if ($base12) {
			 # (NOTE: not claiming this is efficient!)
			 local(%digits)	= (%digits,'t',10,'e',11);
			 do parse_num();

	       Note  that  local() is a	run-time command, and so gets executed
	       every time through a loop, using	up  more  stack	 storage  each
	       time until it's all released at once when the loop is exited.


       localtime EXPR
	       Converts	a time as returned by the time function	to a 9-element
	       array with the time analyzed for	the local timezone.  Typically
	       used as follows:

	       ($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst) =

	       All  array  elements  are  numeric,  and	come straight out of a
	       struct tm.  In particular this means that $mon  has  the	 range
	       0..11  and  $wday has the range 0..6.  If EXPR is omitted, does


       log EXPR
	       Returns logarithm (base	e)  of	EXPR.	If  EXPR  is  omitted,
	       returns log of $_.


       lstat FILEHANDLE


	       Does  the  same	thing as the stat() function, but stats	a sym-
	       bolic link instead of the file the symbolic link	points to.  If
	       symbolic	 links are unimplemented on your system, a normal stat
	       is done.


	       Searches	a string for a pattern match, and returns true (1)  or
	       false  ('').  If	no string is specified via the =~ or !~	opera-
	       tor, 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.)   See
	       also the	section	on regular expressions.

	       If  /  is the delimiter then the	initial	'm' is optional.  With
	       the 'm' you can use any pair of non-alphanumeric	characters  as
	       delimiters.  This is particularly useful	for matching Unix path
	       names that contain '/'.	If the final delimiter is followed  by
	       the  optional letter 'i', the matching is done in a case-insen-
	       sitive manner.  PATTERN may contain references to scalar	 vari-
	       ables,  which will be interpolated (and the pattern recompiled)
	       every time the pattern search is	evaluated.  (Note that $)  and
	       $| may not be interpolated because they look like end-of-string
	       tests.)	If you want such a pattern to be compiled  only	 once,
	       add an "o" after	the trailing delimiter.	 This avoids expensive
	       run-time	recompilations,	and is useful when the value  you  are
	       interpolating won't change over the life	of the script.	If the
	       PATTERN evaluates to a null string, the most recent  successful
	       regular expression is used instead.

	       If  used	 in  a context that requires an	array value, a pattern
	       match returns an	array consisting of the	subexpressions matched
	       by  the	parentheses  in	the pattern, i.e. ($1, $2, $3...).  It
	       does NOT	actually set $1, $2, etc. in this case,	 nor  does  it
	       set  $+,	 $`,  $&  or  $'.  If the match	fails, a null array is
	       returned.  If the match succeeds, but there were	 no  parenthe-
	       ses, an array value of (1) is returned.


		   open(tty, '/dev/tty');
		   <tty> =~ /^y/i && do	foo();	  # do foo if desired

		   if (/Version: *([0-9.]*)/) {	$version = $1; }

		   next	if m#^/usr/spool/uucp#;

		   # poor man's	grep
		   $arg	= shift;
		   while (<>) {
			print if /$arg/o;    # compile only once

		   if (($F1, $F2, $Etc)	= ($foo	=~ /^(\S+)\s+(\S+)\s*(.*)/))

	       This  last example splits $foo into the first two words and the
	       remainder of the	line, and assigns those	three fields  to  $F1,
	       $F2  and	 $Etc.	 The conditional is true if any	variables were
	       assigned, i.e. if the pattern matched.

	       The "g" modifier	specifies global  pattern  matching--that  is,
	       matching	 as  many times	as possible within the string.	How it
	       behaves depends on  the	context.   In  an  array  context,  it
	       returns	a list of all the substrings matched by	all the	paren-
	       theses in the regular expression.  If there are no parentheses,
	       it  returns a list of all the matched strings, as if there were
	       parentheses around the whole pattern.  In a scalar context,  it
	       iterates	 through  the  string,	returning  TRUE	 each  time it
	       matches,	and FALSE when it eventually runs out of matches.  (In
	       other  words,  it  remembers  where  it	left off last time and
	       restarts	the search at that point.)  It presumes	that you  have
	       not  modified  the  string since	the last match.	 Modifying the
	       string between matches may result in undefined behavior.	  (You
	       can  actually get away with in-place modifications via substr()
	       that do not change the length of	the entire  string.   In  gen-
	       eral,  however,	you  should  be	using s///g for	such modifica-
	       tions.)	Examples:

		    # array context
		    ($one,$five,$fifteen) = (`uptime` =~ /(\d+\.\d+)/g);

		    # scalar context
		    $/ = ""; $*	= 1;
		    while ($paragraph =	<>) {
			while ($paragraph =~ /[a-z]['")]*[.!?]+['")]*\s/g) {
		    print "$sentences\n";

	       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).

	       Calls the System	V IPC function 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

	       Calls the System	V IPC function msgget.	 Returns  the  message
	       queue id, or the	undefined value	if there is an error.

	       Calls  the System V IPC function	msgsnd 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.

	       Calls the System	V IPC function msgrcv  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; it	starts
	       the next	iteration of the loop:

		    line: while	(<STDIN>) {
			 next line if /^#/;  # discard comments

	       Note that if there were a continue block	on the above, it would
	       get executed even on discarded lines.  If the LABEL is omitted,
	       the command refers to the innermost enclosing loop.


       oct EXPR
	       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.)  The following	will  handle  decimal,
	       octal and hex in	the standard notation:

		    $val = oct($val) if	$val =~	/^0/;

	       If EXPR is omitted, uses	$_.



       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	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.	  If  the  filename begins with	"<" or
	       nothing,	the file is opened for input.  If the filename	begins
	       with  ">",  the	file  is  opened  for output.  If the filename
	       begins with ">>", the file is opened for	appending.   (You  can
	       put  a '+' in front of the '>' or '<' to	indicate that you want
	       both read and write access  to  the  file.)   If	 the  filename
	       begins  with  "|",  the filename	is interpreted as a command to
	       which output is to be piped, and	if the filename	 ends  with  a
	       "|",  the  filename is interpreted as command which pipes input
	       to us.  (You may	not have a command  that  pipes	 both  in  and
	       out.)   Opening	'-' opens STDIN	and opening '>-' opens STDOUT.
	       Open returns non-zero upon success, the undefined value	other-
	       wise.  If the open involved a pipe, the return value happens to
	       be the pid of the subprocess.  Examples:

		    $article = 100;
		    open article || die	"Can't find article $article: $!\n";
		    while (<article>) {...

		    open(LOG, '>>/usr/spool/news/twitlog');
					# (log is reserved)

		    open(article, "caesar <$article |");
					# decrypt article

		    open(extract, "|sort >/tmp/Tmp$$");
					# $$ is	our process#

		    # process argument list of files along with	any includes

		    foreach $file (@ARGV) {
			 do process($file, 'fh00');    # no pun	intended

		    sub	process	{
			 local($filename, $input) = @_;
			 $input++;	# this is a string increment
			 unless	(open($input, $filename)) {
			      print STDERR "Can't open $filename: $!\n";
			 while (<$input>) {	  # note use of	indirection
			      if (/^#include "(.*)"/) {
				   do process($1, $input);
			      ...	# whatever

	       You may also, in	the Bourne shell tradition,  specify  an  EXPR
	       beginning  with	">&",  in which	case the rest of the string is
	       interpreted as the name of a filehandle (or file	descriptor, if
	       numeric)	 which is to be	duped and opened.  You may use & after
	       >, >>, <, +>, +>> and +<.  The mode you	specify	 should	 match
	       the  mode  of  the  original filehandle.	 Here is a script that
	       saves, redirects, and restores STDOUT and STDERR:

		    open(SAVEOUT, ">&STDOUT");
		    open(SAVEERR, ">&STDERR");

		    open(STDOUT, ">foo.out") ||	die "Can't redirect stdout";
		    open(STDERR, ">&STDOUT") ||	die "Can't dup stdout";

		    select(STDERR); $| = 1;	  # make unbuffered
		    select(STDOUT); $| = 1;	  # make unbuffered

		    print STDOUT "stdout 1\n";	  # this works for
		    print STDERR "stderr 1\n";	  # subprocesses too


		    open(STDOUT, ">&SAVEOUT");
		    open(STDERR, ">&SAVEERR");

		    print STDOUT "stdout 2\n";
		    print STDERR "stderr 2\n";

	       If you open a pipe on the command  "-",	i.e.  either  "|-"  or
	       "-|", then there	is an implicit fork done, and the return value
	       of open is the pid of the child within the parent process,  and
	       0 within	the child process.  (Use defined($pid) to determine if
	       the open	was successful.)  The filehandle behaves normally  for
	       the  parent,  but  i/o  to that filehandle is piped from/to the
	       STDOUT/STDIN of the child process.  In the  child  process  the
	       filehandle  isn't opened--i/o happens from/to the new STDOUT or
	       STDIN.  Typically this is used like the normal piped open  when
	       you  want  to exercise more control over	just how the pipe com-
	       mand gets executed, such	as when	you are	 running  setuid,  and
	       don't  want  to have to scan shell commands for metacharacters.
	       The following pairs are more or less equivalent:

		    open(FOO, "|tr '[a-z]' '[A-Z]'");
		    open(FOO, "|-") || exec 'tr', '[a-z]', '[A-Z]';

		    open(FOO, "cat -n '$file'|");
		    open(FOO, "-|") || exec 'cat', '-n', $file;

	       Explicitly closing  any	piped  filehandle  causes  the	parent
	       process to wait for the child to	finish,	and returns the	status
	       value in	$?.  Note: on any  operation  which  may  do  a	 fork,
	       unflushed  buffers  remain  unflushed  in both processes, which
	       means you may need to set $| to avoid duplicate output.

	       The filename that is passed  to	open  will  have  leading  and
	       trailing	 whitespace  deleted.	In  order  to open a file with
	       arbitrary weird characters in it, it's necessary	to protect any
	       leading and trailing whitespace thusly:

		       $file =~	s#^(\s)#./$1#;
		       open(FOO, "< $file\0");

	       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
	       Returns the numeric ascii value of the first character of EXPR.
	       If EXPR is omitted, uses	$_.

	       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, as follows:

		    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.
		    v	 A short in "VAX" (little-endian) order.
		    V	 A long	in "VAX" (little-endian) order.
		    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 nybble first).
		    H	 A hex string (high nybble first).

	       Each letter may optionally be followed by a number which	 gives
	       a  repeat count.	 With all types	except "a", "A", "b", "B", "h"
	       and "H",	the pack function will gobble up that many values from
	       the  LIST.   A *	for the	repeat count means to use however many
	       items are left.	The "a"	and "A"	types gobble just  one	value,
	       but  pack it as a string	of length count, padding with nulls or
	       spaces as necessary.  (When unpacking, "A" strips trailing spa-
	       ces  and	 nulls,	 but "a" does not.)  Likewise, the "b" and "B"
	       fields pack a string that many bits  long.   The	 "h"  and  "H"
	       fields  pack  a	string	that  many nybbles long.  Real numbers
	       (floats and doubles) are	in the native machine format only; due
	       to the multiplicity of floating formats around, and the lack of
	       a standard "network" representation,  no	 facility  for	inter-
	       change  has  been  made.	 This means that packed	floating point
	       data written on one machine may not be readable	on  another  -
	       even if both use	IEEE floating point arithmetic (as the endian-
	       ness of the memory representation  is  not  part	 of  the  IEEE
	       spec).	Note that perl uses doubles internally for all numeric
	       calculation, and	converting from	double -> float	-> double will
	       lose  precision	(i.e. unpack("f", pack("f", $foo)) will	not in
	       general equal $foo).

		    $foo = pack("cccc",65,66,67,68);
		    # foo eq "ABCD"
		    $foo = pack("c4",65,66,67,68);
		    # same thing

		    $foo = pack("ccxxcc",65,66,67,68);
		    # foo eq "AB\0\0CD"

		    $foo = pack("s2",1,2);
		    # "\1\0\2\0" on little-endian
		    # "\0\1\0\2" on big-endian

		    $foo = pack("a4","abcd","x","y","z");
		    # "abcd"

		    $foo = pack("aaaa","abcd","x","y","z");
		    # "axyz"

		    $foo = pack("a14","abcdefg");
		    # "abcdefg\0\0\0\0\0\0\0"

		    $foo = pack("i9pl",	gmtime);
		    # a	real struct tm (on my system anyway)

		    sub	bintodec {
			unpack("N", pack("B32",	substr("0" x 32	. shift, -32)));
	       The same	template may generally also  be	 used  in  the	unpack

	       Opens  a	 pair of connected pipes like the corresponding	system
	       call.  Note that	if you set up a	loop of	piped processes, dead-
	       lock  can occur unless you are very careful.  In	addition, note
	       that perl's pipes use stdio buffering, so you may need  to  set
	       $|  to  flush your WRITEHANDLE after each command, depending on
	       the application.	 [Requires version 3.0 patchlevel 9.]


       pop ARRAY
	       Pops and	returns	the last value of the  array,  shortening  the
	       array by	1.  Has	the same effect	as

		    $tmp = $ARRAY[$#ARRAY--];

	       If  there  are  no elements in the array, returns the undefined

       print(FILEHANDLE	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 file-
	       handle,	thus  introducing one level of indirection.  (NOTE: If
	       FILEHANDLE is a variable	and the	next token is a	term,  it  may
	       be  misinterpreted  as  an operator unless you interpose	a + or
	       put parens around the arguments.)  If  FILEHANDLE  is  omitted,
	       prints  by  default to standard output (or to the last selected
	       output channel--see select()).  If LIST is also omitted,	prints
	       $_  to  STDOUT.	To set the default output channel to something
	       other than STDOUT use the select	operation.  Note that, because
	       print  takes  a	LIST,  anything	in the LIST is evaluated in an
	       array context, and any subroutine that you call will  have  one
	       or more of its expressions evaluated in an array	context.  Also
	       be careful not to follow	the print keyword with a  left	paren-
	       thesis  unless  you want	the corresponding right	parenthesis to
	       terminate the arguments to the  print--interpose	 a  +  or  put
	       parens around all the arguments.

       printf(FILEHANDLE LIST)


       printf FILEHANDLE LIST

       printf LIST
	       Equivalent to a "print FILEHANDLE sprintf(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.  Has the same effect as

		   for $value (LIST) {
			$ARRAY[++$#ARRAY] = $value;

	       but is more efficient.



	       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	opera-
	       tor a generalized double	quote.	The qx operator	is a  general-
	       ized  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	corre-
	       sponding	closing	bracket	or parenthesis.	 (Embedded occurrences
	       of the closing bracket need to be backslashed as	usual.)	 Exam-

		    $foo = q!I said, "You said,	'She said it.'"!;
		    $bar = q('This is it.');
		    $today = qx{ date };
		    $_ .= qq
	       *** The previous	line contains the naughty word "$&".\n
			 if /(ibm|apple|awk)/;	    # :-)


       rand EXPR

       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.	 See also srand().


	       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.  To get a true read system call,  see  sys-


       readdir DIRHANDLE
	       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
	       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	$_.

	       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	 unde-
	       fined  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  exe-
	       cuted.	If  the	 LABEL	is  omitted, the command refers	to the
	       innermost enclosing loop.  This command	is  normally  used  by
	       programs	 that  want  to	 lie to	themselves about what was just

		    # a	simpleminded Pascal comment stripper
		    # (warning:	assumes	no { or	} in strings)
		    line: while	(<STDIN>) {
			 while (s|({.*}.*){.*}|$1 |) {}
			 s|{.*}| |;
			 if (s|{.*| |) {
			      $front = $_;
			      while (<STDIN>) {
				   if (/}/) {	  # end	of comment?
					redo line;

	       Changes the name	of a file.  Returns 1 for  success,  0	other-
	       wise.  Will not work across filesystem boundaries.


       require EXPR

       require Includes	 the  library file specified by	EXPR, or by $_ if EXPR
	       is not supplied.	 Has semantics similar to the  following  sub-

		    sub	require	{
			local($filename) = @_;
			return 1 if $INC{$filename};
			ITER: {
			 foreach $prefix (@INC)	{
			     $realfilename = "$prefix/$filename";
			     if	(-f $realfilename) {
			      $result =	do $realfilename;
			      last ITER;
			 die "Can't find $filename in \@INC";
			die $@ if $@;
			die "$filename did not return true value" unless $result;
			$INC{$filename}	= $realfilename;

	       Note  that  the	file will not be included twice	under the same
	       specified name.	The file must return true as the  last	state-
	       ment  to	 indicate  successful  execution of any	initialization
	       code, so	it's customary to end such a  file  with  "1;"	unless
	       you're sure it'll return	true otherwise.


       reset EXPR

       reset   Generally  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	begin-
	       ning  with  one	of  those  letters are reset to	their pristine
	       state.  If the expression is omitted, one-match searches	(?pat-
	       tern?)  are  reset  to  match  again.  Only resets variables or
	       searches	in the current package.	 Always	returns	1.  Examples:

		   reset 'X';	   # reset all X variables
		   reset 'a-z';	   # reset lower case variables
		   reset;	   # just reset	?? searches

	       Note: resetting "A-Z" is	not recommended	since you'll wipe  out
	       your ARGV and ENV arrays.

	       The  use	of reset on dbm	associative arrays does	not change the
	       dbm file.  (It does, however, flush any entries cached by perl,
	       which  may  be  useful  if  you are sharing the dbm file.  Then
	       again, maybe not.)

       return LIST
	       Returns from a subroutine with the value	specified.  (Note that
	       a  subroutine  can  automatically  return the value of the last
	       expression evaluated.  That's the preferred method--use	of  an
	       explicit	return is a bit	slower.)


       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
	       Sets the	current	position to the	beginning of the directory for
	       the readdir() routine on	DIRHANDLE.


	       Works  just  like  index	except that it returns the position of
	       the LAST	occurrence of SUBSTR in	STR.  If  POSITION  is	speci-
	       fied, returns the last occurrence at or before that position.


       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 $_.

	       Searches	 a  string  for	a pattern, and if found, replaces that
	       pattern with the	replacement text and  returns  the  number  of
	       substitutions  made.   Otherwise	it returns false (0).  The "g"
	       is optional, and	if present, indicates that all occurrences  of
	       the  pattern are	to be replaced.	 The "i" is also optional, and
	       if present, indicates that matching is to be done  in  a	 case-
	       insensitive  manner.   The  "e"	is  likewise  optional,	and if
	       present,	indicates that the replacement string is to be	evalu-
	       ated  as	 an  expression	 rather	 than  just as a double-quoted
	       string.	 Any  non-alphanumeric	delimiter  may	 replace   the
	       slashes;	 if  single quotes are used, no	interpretation is done
	       on the replacement string (the e	modifier overrides this,  how-
	       ever); if backquotes are	used, the replacement string is	a com-
	       mand to execute	whose  output  will  be	 used  as  the	actual
	       replacement  text.   If	the PATTERN is delimited by bracketing
	       quotes, the REPLACEMENT has its own pair	of quotes,  which  may
	       or   may	  not  be  bracketing  quotes,	e.g.   s(foo)(bar)  or
	       s<foo>/bar/.  If	no string is specified via the =~ or !~	opera-
	       tor, the	$_ string is searched and modified.  (The string spec-
	       ified with =~ must be a scalar variable,	an array  element,  or
	       an assignment to	one of those, i.e. an lvalue.)	If the pattern
	       contains	a $ that looks like a variable rather than an  end-of-
	       string test, the	variable will be interpolated into the pattern
	       at run-time.  If	you only want the pattern  compiled  once  the
	       first time the variable is interpolated,	add an "o" at the end.
	       If the PATTERN evaluates	to a null string, the most recent suc-
	       cessful	regular	expression is used instead.  See also the sec-
	       tion on regular expressions.  Examples:

		   s/\bgreen\b/mauve/g;	     # don't change wintergreen

		   $path =~ s|/usr/bin|/usr/local/bin|;

		   s/Login: $foo/Login:	$bar/; # run-time pattern

		   ($foo = $bar) =~ s/bar/foo/;

		   $_ =	'abc123xyz';
		   s/\d+/$&*2/e;	# yields 'abc246xyz'
		   s/\d+/sprintf("%5d",$&)/e;	  # yields 'abc	 246xyz'
		   s/\w/$& x 2/eg;	# yields 'aabbcc  224466xxyyzz'

		   s/([^ ]*) *([^ ]*)/$2 $1/;	  # reverse 1st	two fields

	       (Note the use of	$ instead of \ in the last example.  See  sec-
	       tion on regular expressions.)

	       Forces  EXPR  to	be interpreted in a scalar context and returns
	       the value of EXPR.

	       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.

	       Sets  the current position for the readdir() routine on DIRHAN-
	       DLE.  POS must be a value returned by telldir().	 Has the  same
	       caveats	about possible directory compaction as the correspond-
	       ing system library routine.


       select  Returns the currently selected filehandle.   Sets  the  current
	       default filehandle for output, if FILEHANDLE is supplied.  This
	       has two effects:	first, a write or a print without a filehandle
	       will  default  to this FILEHANDLE.  Second, references to vari-
	       ables related to	output will refer to this output channel.  For
	       example,	 if  you  have	to set the top of form format for more
	       than one	output channel,	you might do the following:

		    $^ = 'report1_top';
		    $^ = 'report2_top';

	       FILEHANDLE may be an expression whose value gives the  name  of
	       the actual filehandle.  Thus:

		    $oldfh = select(STDERR); $|	= 1; select($oldfh);

	       This  calls the select system call with the bitmasks specified,
	       which can be constructed	using fileno() and vec(), along	 these

		    $rin = $win	= $ein = '';
		    vec($rin,fileno(STDIN),1) =	1;
		    vec($win,fileno(STDOUT),1) = 1;
		    $ein = $rin	| $win;

	       If  you	want  to  select on many filehandles you might wish to
	       write a subroutine:

		    sub	fhbits {
			local(@fhlist) = split(' ',$_[0]);
			for (@fhlist) {
			 vec($bits,fileno($_),1) = 1;
		    $rin = &fhbits('STDIN TTY SOCK');

	       The usual idiom is:

		    ($nfound,$timeleft)	=
		      select($rout=$rin, $wout=$win, $eout=$ein, $timeout);

	       or to block until something becomes ready:

		    $nfound = select($rout=$rin, $wout=$win,
				   $eout=$ein, undef);

	       Any of the bitmasks can also be undef.  The timeout, if	speci-
	       fied,  is  in  seconds, which may be fractional.	 NOTE: not all
	       implementations are capable of  returning  the  $timeleft.   If
	       not,  they always return	$timeleft equal	to the supplied	$time-

	       Calls the System	V IPC function semctl.	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 System	V IPC function semget.	Returns	the  semaphore
	       id, or the undefined value if there is an error.

	       Calls  the  System  V  IPC  function semop to perform semaphore
	       operations such as signaling and	waiting.  OPSTRING must	 be  a
	       packed  array of	semop structures.  Each	semop structure	can be
	       generated with 'pack("sss", $semnum, $semop,  $semflag)'.   The
	       number  of  semaphore  operations  is  implied by the length of
	       OPSTRING.  Returns true if successful, or false if there	is  an
	       error.	As  an	example, the following code waits on semaphore
	       $semnum of semaphore id $semid:

		    $semop = pack("sss", $semnum, -1, 0);
		    die	"Semaphore trouble: $!\n" unless semop($semid, $semop);

	       To signal the semaphore,	replace	"-1" with "1".


	       Sends a message on a socket.  Takes the same flags as the  sys-
	       tem  call  of  the  same	name.  On unconnected sockets you must
	       specify a destination to	send TO.  Returns the number of	 char-
	       acters sent, or the undefined value if there is an error.

	       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(2).

	       Sets  the current priority for a	process, a process group, or a
	       user.  (See setpriority(2).)  Will produce  a  fatal  error  if
	       used on a machine that doesn't implement	setpriority(2).

	       Sets  the  socket option	requested.  Returns undefined if there
	       is an error.  OPTVAL may	be specified as	 undef	if  you	 don't
	       want to pass an argument.


       shift ARRAY

       shift   Shifts  the first value of the array off	and returns it,	short-
	       ening 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.  (This is determined lexi-
	       cally.)	See also unshift(), push()  and	 pop().	  Shift()  and
	       unshift()  do  the  same	thing to the left end of an array that
	       push() and pop()	do to the right	end.

	       Calls the System	V IPC function shmctl.	If CMD	is  &IPC_STAT,
	       then  ARG  must	be  a  variable	 which	will hold the returned
	       shmid_ds	structure.  Returns like ioctl:	 the  undefined	 value
	       for  error,  "0	but true" for zero, or the actual return value

	       Calls the System	V IPC function	shmget.	  Returns  the	shared
	       memory segment id, or the undefined value if there is an	error.


	       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.

	       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
	       Returns the sine	of EXPR	(expressed in radians).	  If  EXPR  is
	       omitted,	returns	sine of	$_.


       sleep EXPR

       sleep   Causes  the  script to sleep for	EXPR seconds, or forever if no
	       EXPR.  May be interrupted by sending  the  process  a  SIGALRM.
	       Returns	the  number  of	 seconds actually slept.  You probably
	       cannot mix alarm() and sleep() calls, since  sleep()  is	 often
	       implemented using alarm().

	       Opens  a	 socket	of the specified kind and attaches it to file-
	       handle 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.  See the example
	       in the section on Interprocess Communication.

	       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  unimple-
	       mented, yields a	fatal error.  Return true if successful.

       sort(SUBROUTINE LIST)



       sort BLOCK LIST

       sort LIST
	       Sorts the LIST and returns the sorted array value.  Nonexistent
	       values of arrays	are stripped out.  If SUBROUTINE or  BLOCK  is
	       omitted,	sorts in standard string comparison order.  If SUBROU-
	       TINE 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.)  SUBROU-
	       TINE may	be a scalar variable name, in  which  case  the	 value
	       provides	the name of the	subroutine to use.  In place of	a SUB-
	       ROUTINE name, you can provide a BLOCK as	an anonymous,  in-line
	       sort subroutine.

	       In the interests	of efficiency the normal calling code for sub-
	       routines	is bypassed, with the following	effects:  the  subrou-
	       tine 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.


		    # sort lexically
		    @articles =	sort @files;

		    # same thing, but with explicit sort routine
		    @articles =	sort {$a cmp $b} @files;

		    # same thing in reversed order
		    @articles =	sort {$b cmp $a} @files;

		    # sort numerically ascending
		    @articles =	sort {$a <=> $b} @files;

		    # sort numerically descending
		    @articles =	sort {$b <=> $a} @files;

		    # sort using explicit subroutine name
		    sub	byage {
			$age{$a} <=> $age{$b};	  # presuming integers
		    @sortedclass = sort	byage @class;

		    sub	reverse	{ $b cmp $a; }
		    @harry = ('dog','cat','x','Cain','Abel');
		    @george = ('gone','chased','yz','Punished','Axed');
		    print sort @harry;
			 # prints AbelCaincatdogx
		    print sort reverse @harry;
			 # prints xdogcatCainAbel
		    print sort @george,	'to', @harry;
			 # prints AbelAxedCainPunishedcatchaseddoggonetoxyz



	       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	every-
	       thing 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);

	       Example,	assuming array lengths are passed before arrays:

		    sub	aeq { #	compare	two array values
			 local(@a) = splice(@_,0,shift);
			 local(@b) = splice(@_,0,shift);
			 return	0 unless @a == @b;     # same len?
			 while (@a) {
			     return 0 if pop(@a) ne pop(@b);
			 return	1;
		    if (&aeq($len,@foo[1..$len],0+@bar,@bar)) {	... }




       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	white-
	       space (/[ \t\n]+/).  Anything 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 con-
	       fused 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.  For example:

		    print join(':', split(/ */,	'hi there'));

	       produces	the output 'h:i:t:h:e:r:e'.

	       The LIMIT parameter can be used to partially split a line

		    ($login, $passwd, $remainder) = split(/:/, $_, 3);

	       (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.


	       produces	the array value


	       The pattern /PATTERN/ may be replaced  with  an	expression  to
	       specify patterns	that vary at runtime.  (To do runtime compila-
	       tion only once, use /$variable/o.)  As a	special	case, specify-
	       ing  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.


		    open(passwd, '/etc/passwd');
		    while (<passwd>) {
			 ($login, $passwd, $uid, $gid, $gcos, $home, $shell)
			      =	split(/:/);

	       (Note  that  $shell above will still have a newline on it.  See
	       chop().)	 See also join.

	       Returns a string	formatted by  the  usual  printf  conventions.
	       The * character is not supported.


       sqrt EXPR
	       Return  the  square  root of EXPR.  If EXPR is omitted, returns
	       square root of $_.


       srand EXPR
	       Sets the	random number seed for the rand	operator.  If EXPR  is
	       omitted,	does srand(time).


       stat FILEHANDLE


	       Returns	a  13-element  array giving the	statistics for a file,
	       either the file	opened	via  FILEHANDLE,  or  named  by	 EXPR.
	       Returns	a null list if the stat	fails.	Typically used as fol-

			  = stat($filename);

	       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.

		    if (-x $file && (($d) = stat(_)) &&	$d < 0)	{
			 print "$file is executable NFS	file\n";

	       (This  only  works  on  machines	for which the device number is
	       negative	under NFS.)


       study SCALAR

       study   Takes extra time	to study SCALAR	($_ if unspecified) in antici-
	       pation 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 with-
	       out 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.)

	       For example, here is  a	loop  which  inserts  index  producing
	       entries before any line containing a certain pattern:

		    while (<>) {
			 print ".IX foo\n" if /\bfoo\b/;
			 print ".IX bar\n" if /\bbar\b/;
			 print ".IX blurfl\n" if /\bblurfl\b/;

	       In  searching  for  /\bfoo\b/,  only those locations in $_ that
	       contain 'f' will	be looked at, because 'f' is rarer  than  'o'.
	       In  general,  this  is  a big win except	in pathological	cases.
	       The only	question is whether it saves you  more	time  than  it
	       took to build the linked	list in	the first place.

	       Note  that  if you have to look for strings that	you don't know
	       till runtime, you can build an entire loop as a string and eval
	       that  to	 avoid	recompiling  all  your	patterns all the time.
	       Together	with undefining	 $/  to	 input	entire	files  as  one
	       record,	this  can  be very fast, often faster than specialized
	       programs	like fgrep.  The  following  scans  a  list  of	 files
	       (@files)	for a list of words (@words), and prints out the names
	       of those	files that contain a match:

		    $search = 'while (<>) { study;';
		    foreach $word (@words) {
			$search	.= "++\$seen{\$ARGV} if	/\\b$word\\b/;\n";
		    $search .= "}";
		    @ARGV = @files;
		    undef $/;
		    eval $search;	# this screams
		    $/ = "\n";		# put back to normal input delim
		    foreach $file (sort	keys(%seen)) {
			print $file, "\n";


	       Extracts	a substring out	of EXPR	and returns it.	 First charac-
	       ter is at offset	0, or whatever you've 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().

	       Creates a new filename symbolically linked to the old filename.
	       Returns 1 for success, 0	otherwise.  On systems that don't sup-
	       port  symbolic  links,  produces	a fatal	error at run time.  To
	       check for that, use eval:

		    $symlink_exists = (eval 'symlink("","");', $@ eq '');


       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  con-
	       text,  you may need to add 0 to them to force them to look like

		    require '';	  # may	need to	run h2ph
		    syscall(&SYS_write,	fileno(STDOUT),	"hi there\n", 9);


	       Attempts	to read	LENGTH bytes of	data into variable SCALAR from
	       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.  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


       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.


	       Attempts	to write LENGTH	bytes of data from variable SCALAR  to
	       the  specified  FILEHANDLE, using the system call write(2).  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    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


       telldir DIRHANDLE
	       Returns the current  position  of  the  readdir()  routines  on
	       DIRHANDLE.  Value may be	given to seekdir() to access a partic-
	       ular location in	a directory.  Has the same caveats about  pos-
	       sible  directory	compaction as the corresponding	system library

       time    Returns the number of non-leap seconds since 00:00:00 UTC, Jan-
	       uary  1,	 1970.	 Suitable  for	feeding	to gmtime() and	local-

       times   Returns a four-element array giving the user and	system	times,
	       in  seconds, for	this process and the children of this process.

		   ($user,$system,$cuser,$csystem) = times;


	       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 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 SEARCHLIST is delimited by bracketing
	       quotes, the REPLACEMENTLIST has its own pair of	quotes,	 which
	       may  or	may  not  be  bracketing quotes, e.g.  tr[A-Z][a-z] or

	       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	speci-
	       fied, 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  REPLACE-
	       MENTLIST	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.


		   $ARGV[1] =~ y/A-Z/a-z/;   # canonicalize to lower case

		   $cnt	= tr/*/*/;	     # count the stars in $_

		   $cnt	= tr/0-9//;	     # count the digits	in $_

		   tr/a-zA-Z//s;	     # bookkeeper -> bokeper

		   ($HOST = $host) =~ tr/a-z/A-Z/;

		   y/a-zA-Z/ /cs;	     # change non-alphas to single space

		   tr/\200-\377/\0-\177/;    # delete 8th bit


	       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   Sets  the  umask	 for  the process and returns the old one.  If
	       EXPR is omitted,	merely returns current umask.


       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	prede-
	       fined variables or dbm array values.)  Always returns the unde-
	       fined 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.	Examples:

		    undef $foo;
		    undef $bar{'blurfl'};
		    undef @ary;
		    undef %assoc;
		    undef &mysub;
		    return (wantarray ?	() : undef) if $they_blew_it;


       unlink LIST
	       Deletes a list of files.	 Returns the number of files  success-
	       fully deleted.

		    $cnt = unlink 'a', 'b', 'c';
		    unlink @goners;
		    unlink <*.bak>;

	       Note:  unlink  will not delete directories unless you are supe-
	       ruser and the -U	flag is	supplied to perl.  Even	if these  con-
	       ditions	are  met,  be  warned  that  unlinking a directory can
	       inflict damage on your filesystem.  Use rmdir instead.

	       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.  Here's a subroutine that does substring:

		    sub	substr {
			 local($what,$where,$howmuch) =	@_;
			 unpack("x$where a$howmuch", $what);

	       and then	there's

		    sub	ord { unpack("c",$_[0]); }

	       In addition, you	may prefix a field with	a %<number>  to	 indi-
	       cate that you want a <number>-bit checksum of the items instead
	       of the items themselves.	 Default is a  16-bit  checksum.   For
	       example,	the following computes the same	number as the System V
	       sum program:

		    while (<>) {
			$checksum += unpack("%16C*", $_);
		    $checksum %= 65536;

	       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.

		    unshift(ARGV, '-e')	unless $ARGV[0]	=~ /^-/;


       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.
	       Example of a "touch" command:

		    $now = time;
		    utime $now,	$now, @ARGV;


       values ASSOC_ARRAY
	       Returns a normal	array consisting of  all  the  values  of  the
	       named  associative array.  The values are returned in an	appar-
	       ently 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().

	       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.

	       To transform a bit vector into a	string or  array  of  0's  and
	       1's, use	these:

		    $bits = unpack("b*", $vector);
		    @bits = split(//, unpack("b*", $vector));

	       If  you	know the exact length in bits, it can be used in place
	       of the *.

       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 $?.

	       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 $?.  If you say

		    require "sys/wait.h";

	       then you	can do a non-blocking  wait  for  any  process.	  Non-
	       blocking	 wait  is only available on machines supporting	either
	       the waitpid (2) or wait4	(2) system  calls.   However,  waiting
	       for a particular	pid with FLAGS of 0 is implemented everywhere.
	       (Perl emulates the system call by remembering the status	values
	       of  processes  that  have exited	but have not been harvested by
	       the Perl	script yet.)

	       Returns true if the context of the currently executing  subrou-
	       tine  is	looking	for an array value.  Returns false if the con-
	       text is looking for a scalar.

		    return wantarray ? () : undef;


       warn LIST
	       Produces	a message on STDERR just like "die", but doesn't exit.



       write   Writes  a  formatted record (possibly multi-line) to the	speci-
	       fied 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	 chan-
	       nel (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  the
	       name  of	 the  filehandle  with	"_TOP" appended, but it	may be
	       dynamicallly set	to the format of your choice by	assigning  the
	       name  to	the $^ variable	while the filehandle is	selected.  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.  For
	       more on formats,	see the	section	on formats later on.

	       Note that write is NOT the opposite of read.


       Perl operators have the following associativity and precedence:

       nonassoc	 print printf exec system sort reverse
		      chmod chown kill unlink utime die	return
       left	 ,
       right	 = += -= *= etc.
       right	 ?:
       nonassoc	 ..
       left	 ||
       left	 &&
       left	 | ^
       left	 &
       nonassoc	 == != <=> eq ne cmp
       nonassoc	 < > <=	>= lt gt le ge
       nonassoc	 chdir exit eval reset sleep rand umask
       nonassoc	 -r -w -x etc.
       left	 << >>
       left	 + - .
       left	 * / % x
       left	 =~ !~
       right	 ! ~ and unary minus
       right	 **
       nonassoc	 ++ --
       left	 '('

       As mentioned earlier, if	any list operator (print, etc.)	or  any	 unary
       operator	 (chdir,  etc.)	 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.  Examples:

	    chdir $foo || die;	     # (chdir $foo) || die
	    chdir($foo)	|| die;	     # (chdir $foo) || die
	    chdir ($foo) || die;     # (chdir $foo) || die
	    chdir +($foo) || die;    # (chdir $foo) || die

       but, because * is higher	precedence than	||:

	    chdir $foo * 20;	     # chdir ($foo * 20)
	    chdir($foo)	* 20;	     # (chdir $foo) * 20
	    chdir ($foo) * 20;	     # (chdir $foo) * 20
	    chdir +($foo) * 20;	     # chdir ($foo * 20)

	    rand 10 * 20;	     # rand (10	* 20)
	    rand(10) * 20;	     # (rand 10) * 20
	    rand (10) *	20;	     # (rand 10) * 20
	    rand +(10) * 20;	     # rand (10	* 20)

       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.
       For example, in

	    @ary = (1, 3, sort 4, 2);
	    print @ary;		# prints 1324

       the  commas on the right	of the sort are	evaluated before the sort, but
       the commas on the left are evaluated after.  In other words, list oper-
       ators  tend  to	gobble up all the arguments that follow	them, and then
       act like	a simple term with regard to the preceding  expression.	  Note
       that you	have to	be careful with	parens:

	    # These evaluate exit before doing the print:
	    print($foo,	exit);	# Obviously not	what you want.
	    print $foo,	exit;	# Nor is this.

	    # These do the print before	evaluating exit:
	    (print $foo), exit;	# This is what you want.
	    print($foo), exit;	# Or this.
	    print ($foo), exit;	# Or even this.

       Also note that

	    print ($foo	& 255) + 1, "\n";

       probably	doesn't	do what	you expect at first glance.


       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  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	state-
       ment 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.


	    sub	MAX {
		 local($max) = pop(@_);
		 foreach $foo (@_) {
		      $max = $foo if $max < $foo;

	    $bestday = &MAX($mon,$tue,$wed,$thu,$fri);


	    # get a line, combining continuation lines
	    #  that start with whitespace
	    sub	get_line {
		 $thisline = $lookahead;
		 line: while ($lookahead = <STDIN>) {
		      if ($lookahead =~	/^[ \t]/) {
			   $thisline .=	$lookahead;
		      else {
			   last	line;

	    $lookahead = <STDIN>;    # get first line
	    while ($_ =	do get_line()) {

       Use array assignment to a local list to name your formal	arguments:

	    sub	maybeset {
		 local($key, $value) = @_;
		 $foo{$key} = $value unless $foo{$key};

       This  also  has	the  effect of turning call-by-reference into call-by-
       value, since the	assignment copies the values.

       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 vis-
       ible to subroutine instead.

	    do foo(1,2,3);	# pass three arguments
	    &foo(1,2,3);	# the same

	    do foo();	   # pass a null list
	    &foo();		# the same
	    &foo;		# pass no arguments--more efficient

       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, for-
       mat  or	subroutine.   When  assigned to	within a local() operation, it
       causes the name mentioned to refer to whatever *	value was assigned  to
       it.  Example:

	    sub	doubleary {
		local(*someary)	= @_;
		foreach	$elem (@someary) {
		 $elem *= 2;
	    do doubleary(*foo);
	    do doubleary(*bar);

       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.  This may	or may not bother you.

       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 mech-
       anism 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  rou-
       tines  are derived from Henry Spencer's freely redistributable reimple-
       mentation 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, 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 interpreta-
       tions.  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	 some-
       times  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 correspond-
       ing substring.  Within the pattern, \10,	\11, etc. refer	back  to  sub-
       strings	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.  Examples:

	    s/^([^ ]*) *([^ ]*)/$2 $1/;	  # swap first two words

	    if (/Time: (..):(..):(..)/)	{
		 $hours	= $1;
		 $minutes = $2;
		 $seconds = $3;

       By  default,  the ^ character is	only guaranteed	to match at the	begin-
       ning of the string, the $ character only	at the end (or before the new-
       line  at	 the end) and perl does	certain	optimizations with the assump-
       tion 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

       To facilitate multi-line	substitutions, the . character never matches a
       newline	(even  when  $*	 is 0).	 In particular,	the following leaves a
       newline on the $_ string:

	    $_ = <STDIN>;

       If the newline is unwanted, try one of

	    chop; s/.*(some_string).*/$1/;
	    /(some_string)/ && ($_ = $1);

       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 alphanu-
       meric, such as \b, \w, \n.  Unlike some other regular  expression  lan-
       guages,	there are no backslashed symbols that aren't alphanumeric.  So
       anything	that looks like	\\, \(,	\), \<,	\>, \{,	or \} is always	inter-
       preted as a literal character, not a metacharacter.  This makes it sim-
       ple to quote a string that you want to use for a	pattern	but  that  you
       are  afraid  might  contain  metacharacters.  Simply quote all the non-
       alphanumeric characters:

	    $pattern =~	s/(\W)/\\$1/g;


       Output record formats for use with the write operator may  declared  as

	   format NAME =

       If name is omitted, format "STDOUT" is defined.	FORMLIST consists of a
       sequence	of lines, each of which	may be of one of three types:

       1.  A comment.

       2.  A "picture" line giving the format for one output line.

       3.  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 # charac-
       ters (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	front  if possible, for	visibility.)  The tilde	will be	trans-
       lated 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.  (If you use a field of the @  variety,  the  expression
       you supply had better not give the same value every time	forever!)


       # a report on the /etc/passwd file
       format STDOUT_TOP =
			       Passwd File
       Name		   Login    Office   Uid   Gid Home
       format STDOUT =
       @<<<<<<<<<<<<<<<<<< @||||||| @<<<<<<@>>>> @>>>> @<<<<<<<<<<<<<<<<<
       $name,		   $login,  $office,$uid,$gid, $home

       # a report from a bug report form
       format STDOUT_TOP =
			       Bug Reports
       @<<<<<<<<<<<<<<<<<<<<<<<	    @|||	 @>>>>>>>>>>>>>>>>>>>>>>>
       $system,			     $%,	 $date
       format STDOUT =
       Subject:	@<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
       Index: @<<<<<<<<<<<<<<<<<<<<<<<<<<<< ^<<<<<<<<<<<<<<<<<<<<<<<<<<<<
	      $index,			    $description
       Priority: @<<<<<<<<<< Date: @<<<<<<< ^<<<<<<<<<<<<<<<<<<<<<<<<<<<<
		 $priority,	   $date,   $description
       From: @<<<<<<<<<<<<<<<<<<<<<<<<<<<<< ^<<<<<<<<<<<<<<<<<<<<<<<<<<<<
	     $from,			    $description
       Assigned	to: @<<<<<<<<<<<<<<<<<<<<<< ^<<<<<<<<<<<<<<<<<<<<<<<<<<<<
		    $programmer,	    $description
       ~				    ^<<<<<<<<<<<<<<<<<<<<<<<<<<<<
       ~				    ^<<<<<<<<<<<<<<<<<<<<<<<<<<<<
       ~				    ^<<<<<<<<<<<<<<<<<<<<<<<<<<<<
       ~				    ^<<<<<<<<<<<<<<<<<<<<<<<<<<<<
       ~				    ^<<<<<<<<<<<<<<<<<<<<<<<...

       It  is possible to intermix prints with writes on the same output chan-
       nel, 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  for-
       getting 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 differ-
       ently  than  C file descriptors.	 Second, perl already knows the	length
       of its strings, so you don't need to pass that information.  Here is  a
       sample client (untested):

	    ($them,$port) = @ARGV;
	    $port = 2345 unless	$port;
	    $them = 'localhost'	unless $them;

	    $SIG{'INT'}	= 'dokill';
	    sub	dokill { kill 9,$child if $child; }

	    require 'sys/';

	    $sockaddr =	'S n a4	x8';
	    chop($hostname = `hostname`);

	    ($name, $aliases, $proto) =	getprotobyname('tcp');
	    ($name, $aliases, $port) = getservbyname($port, 'tcp')
		 unless	$port =~ /^\d+$/;
	    ($name, $aliases, $type, $len, $thisaddr) =
	    ($name, $aliases, $type, $len, $thataddr) =	gethostbyname($them);

	    $this = pack($sockaddr, &AF_INET, 0, $thisaddr);
	    $that = pack($sockaddr, &AF_INET, $port, $thataddr);

	    socket(S, &PF_INET,	&SOCK_STREAM, $proto) || die "socket: $!";
	    bind(S, $this) || die "bind: $!";
	    connect(S, $that) || die "connect: $!";

	    select(S); $| = 1; select(stdout);

	    if ($child = fork) {
		 while (<>) {
		      print S;
		 sleep 3;
		 do dokill();
	    else {
		 while (<S>) {

       And here's a server:

	    ($port) = @ARGV;
	    $port = 2345 unless	$port;

	    require 'sys/';

	    $sockaddr =	'S n a4	x8';

	    ($name, $aliases, $proto) =	getprotobyname('tcp');
	    ($name, $aliases, $port) = getservbyname($port, 'tcp')
		 unless	$port =~ /^\d+$/;

	    $this = pack($sockaddr, &AF_INET, $port, "\0\0\0\0");

	    select(NS);	$| = 1;	select(stdout);

	    socket(S, &PF_INET,	&SOCK_STREAM, $proto) || die "socket: $!";
	    bind(S, $this) || die "bind: $!";
	    listen(S, 5) || die	"connect: $!";

	    select(S); $| = 1; select(stdout);

	    for	(;;) {
		 print "Listening again\n";
		 ($addr	= accept(NS,S))	|| die $!;
		 print "accept ok\n";

		 ($af,$port,$inetaddr) = unpack($sockaddr,$addr);
		 @inetaddr = unpack('C4',$inetaddr);
		 print "$af $port @inetaddr\n";

		 while (<NS>) {
		      print NS;

       Predefined Names

       The  following  names  have special meaning to perl.  I could have used
       alphabetic symbols for some of these, but I didn't  want	 to  take  the
       chance  that  someone  would  say reset "a-zA-Z"	and wipe them all out.
       You'll just have	to suffer along	with these  silly  symbols.   Most  of
       them have reasonable mnemonics, or analogues in one of the shells.

       $_      The  default  input and pattern-searching space.	 The following
	       pairs are equivalent:

		    while (<>) {...	# only equivalent in while!
		    while ($_ =	<>) {...

		    $_ =~ /^Subject:/

		    $_ =~ y/a-z/A-Z/


	       (Mnemonic: underline is understood in certain operations.)

       $.      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).	 (Mnemonic: many  programs  use	 .  to
	       mean the	current	line number.)

       $/      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.  Note that setting
	       it to "\n\n" means something slightly different than setting it
	       to "", if the file contains consecutive blank  lines.   Setting
	       it  to  ""  will	treat two or more consecutive blank lines as a
	       single blank line.  Setting it to "\n\n"	 will  blindly	assume
	       that  the  next	input character	belongs	to the next paragraph,
	       even if it's a newline.	(Mnemonic: / is	used to	 delimit  line
	       boundaries when quoting poetry.)

       $,      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.	 (Mnemonic: what is printed when there
	       is a , in your print statement.)

       $""     This is like $, except that it applies to array values interpo-
	       lated  into  a  double-quoted  string  (or  similar interpreted
	       string).	 Default is a space.  (Mnemonic: obvious, I think.)

       $\      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 set awk's ORS variable to specify what is
	       printed at the end of the print.	 (Mnemonic: you	set $\ instead
	       of adding \n at the end of the print.  Also, it's just like  /,
	       but it's	what you get "back" from perl.)

       $#      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.  (Mnemonic: # is the number sign.)

       $%      The current page	number of the currently	selected output	 chan-
	       nel.  (Mnemonic:	% is page number in nroff.)

       $=      The  current  page  length  (printable  lines) of the currently
	       selected	output channel.	 Default is 60.	 (Mnemonic: = has hor-
	       izontal lines.)

       $-      The  number of lines left on the	page of	the currently selected
	       output channel.	(Mnemonic: lines_on_page - lines_printed.)

       $~      The name	 of  the  current  report  format  for	the  currently
	       selected	 output	 channel.   Default is name of the filehandle.
	       (Mnemonic: brother to $^.)

       $^      The name	of the current top-of-page format  for	the  currently
	       selected	 output	 channel.   Default  is	name of	the filehandle
	       with "_TOP" appended.  (Mnemonic: points	to top of page.)

       $|      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.  (Mnemonic: when  you  want  your
	       pipes to	be piping hot.)

       $$      The process number of the perl running this script.  (Mnemonic:
	       same as shells.)

       $?      The status returned by the last pipe close, backtick (``)  com-
	       mand  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.  (Mnemonic: similar to sh and ksh.)

       $&      The  string  matched  by	the last successful pattern match (not
	       counting	any matches hidden within a BLOCK or eval enclosed  by
	       the current BLOCK).  (Mnemonic: like & in some editors.)

       $`      The  string preceding whatever was matched by the last success-
	       ful pattern match (not counting any  matches  hidden  within  a
	       BLOCK  or  eval	enclosed  by the current BLOCK).  (Mnemonic: `
	       often precedes a	quoted string.)

       $'      The string following whatever was matched by the	last  success-
	       ful  pattern  match  (not  counting any matches hidden within a
	       BLOCK or	eval enclosed by the  current  BLOCK).	 (Mnemonic:  '
	       often follows a quoted string.)	Example:

		    $_ = 'abcdefghi';
		    print "$`:$&:$'\n";	     # prints abc:def:ghi

       $+      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.	 For example:

		   /Version: (.*)|Revision: (.*)/ && ($rev = $+);

	       (Mnemonic: be positive and forward looking.)

       $*      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.  (Mnemonic:	* matches mul-
	       tiple things.)  Note that this  variable	 only  influences  the
	       interpretation  of  ^ and $.  A literal newline can be searched
	       for even	when $*	== 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.  (Mnemonic: same as sh and ksh.)

	       Contains	the subpattern from the	corresponding set of parenthe-
	       ses  in the last	pattern	matched, not counting patterns matched
	       in nested blocks	that have  been	 exited	 already.   (Mnemonic:
	       like \digit.)

       $[      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 sub-
	       scripting and when evaluating the index()  and  substr()	 func-
	       tions.  (Mnemonic: [ begins subscripts.)

       $]      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 ver-
	       sions.  If used in a numeric context,  returns  the  version  +
	       patchlevel / 1000.  Example:

		    # see if getc is available
		       ($version,$patchlevel) =
			  $] =~	/(\d+\.\d+).*\nPatch level: (\d+)/;
		       print STDERR "(No filename completion available.)\n"
			  if $version *	1000 + $patchlevel < 2016;

	       or, used	numerically,

		    warn "No checksumming!\n" if $] < 3.019;

	       (Mnemonic: Is this version of perl in the right bracket?)

       $;      The  subscript separator	for multi-dimensional array emulation.
	       If you refer to an associative array element as

	       it really means

		    $foo{join($;, $a, $b, $c)}

	       But don't put

		    @foo{$a,$b,$c}	# a slice--note	the @

	       which means


	       Default is "\034", the same as SUBSEP in	 awk.	Note  that  if
	       your keys contain binary	data there might not be	any safe value
	       for $;.	(Mnemonic: comma (the syntactic	 subscript  separator)
	       is a semi-semicolon.  Yeah, I know, it's	pretty lame, but $, is
	       already taken for something more	important.)

       $!      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  particu-
	       lar  unless  you've gotten a specific error return indicating a
	       system error.)  If used in a string context, yields the	corre-
	       sponding	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.  (Mnemonic: What just went bang?)

       $@      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).
	       (Mnemonic: Where	was the	syntax error "at"?)

       $<      The real	uid of this process.  (Mnemonic: it's the uid you came
	       FROM, if	you're running setuid.)

       $>      The effective uid of this process.  Example:

		    $< = $>;  #	set real uid to	the effective uid
		    ($<,$>) = ($>,$<);	# swap real and	effective uid

	       (Mnemonic: it's the uid you went	TO, if you're running setuid.)
	       Note:  $<  and  $>  can	only be	swapped	on machines supporting

       $(      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  one	 returned by getgid(), and the subsequent ones by get-
	       groups(), one of	which may be the same  as  the	first  number.
	       (Mnemonic:  parentheses are used	to GROUP things.  The real gid
	       is the group you	LEFT, if you're	running	setgid.)

       $)      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.	 (Mnemonic: parentheses	are used to GROUP things.  The
	       effective gid is	the group that's RIGHT for you,	if you're run-
	       ning setgid.)

	       Note:  $<,  $>, $( and $) can only be set on machines that sup-
	       port the	corresponding set[re][ug]id() routine.	$( and $)  can
	       only be swapped on machines supporting setregid().

       $:      The  current set	of characters after which a string may be bro-
	       ken to fill continuation	fields (starting with ^) in a  format.
	       Default	 is   "	\n-",  to  break  on  whitespace  or  hyphens.
	       (Mnemonic: a "colon" in poetry is a part	of a line.)

       $^D     The current value of the	debugging flags.  (Mnemonic: value  of
	       -D switch.)

       $^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  descrip-
	       tors are	closed before the open is attempted.

       $^I     The  current value of the inplace-edit extension.  Use undef to
	       disable inplace editing.	 (Mnemonic: value of -i	switch.)

       $^L     What formats output to perform a	formfeed.  Default is \f.

       $^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.	 (Mnemonic: related to
	       the -w 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	 argu-
	       ments  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/share/perl", followed by	".", to	repre-
	       sent the	current	directory.

       %INC    The  associative	 array	INC contains entries for each filename
	       that 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.

	       The  associative	 array	ENV contains your current environment.
	       Setting a value in ENV changes the environment for  child  pro-

	       The  associative	 array	SIG is used to set signal handlers for
	       various signals.	 Example:

		    sub	handler	{  # 1st argument is signal name
			 local($sig) = @_;
			 print "Caught a SIG$sig--shutting down\n";

		    $SIG{'INT'}	= 'handler';
		    $SIG{'QUIT'} = 'handler';
		    $SIG{'INT'}	= 'DEFAULT'; # restore default action
		    $SIG{'QUIT'} = 'IGNORE'; # ignore SIGQUIT

	       The SIG array only contains values for the signals actually set
	       within the perl script.


       Perl  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 pack-
       age 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"	opera-
       tor.  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	 pack-
       ages  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  sym-
       bol 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.

       Eval'ed	strings	are compiled in	the package in which the eval was com-
       piled 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, exam-
       ine  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	tempo-
       rarily switches back to the main	package	to  evaluate  various  expres-
       sions 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  main, anyway), though the first is	more efficient because
       it does the symbol table	lookups	at compile time:

	    local(*foo)	= *bar;
	    local($_main{'foo'}) = $_main{'bar'};

       You can use this	to print out all  the  variables  in  a	 package,  for
       instance.  Here is from the perl library:
	    package dumpvar;

	    sub	main'dumpvar {
		($package) = @_;
		local(*stab) = eval("*_$package");
		while (($key,$val) = each(%stab)) {
			local(*entry) =	$val;
			if (defined $entry) {
			    print "\$$key = '$entry'\n";
			if (defined @entry) {
			    print "\@$key = (\n";
			    foreach $num ($[ ..	$#entry) {
				print "	 $num\t'",$entry[$num],"'\n";
			    print ")\n";
			if ($key ne "_$package"	&& defined %entry) {
			    print "\%$key = (\n";
			    foreach $key (sort keys(%entry)) {
				print "	 $key\t'",$entry{$key},"'\n";
			    print ")\n";

       Note  that,  even though	the subroutine is compiled in package dumpvar,
       the name	of the subroutine is qualified so that its  name  is  inserted
       into package "main".


       Each  programmer	 will,	of  course, have his or	her own	preferences in
       regards to formatting, but there	are some general guidelines that  will
       make your programs easier to read.

       1.  Just	 because  you  CAN  do something a particular way doesn't mean
	   that	you SHOULD do it that way.  Perl is designed to	give you  sev-
	   eral	 ways  to  do  anything, so consider picking the most readable
	   one.	 For instance

		open(FOO,$foo) || die "Can't open $foo:	$!";

	   is better than

		die "Can't open	$foo: $!" unless open(FOO,$foo);

	   because the second way hides	the main point of the statement	 in  a
	   modifier.  On the other hand

		print "Starting	analysis\n" if $verbose;

	   is better than

		$verbose && print "Starting analysis\n";

	   since the main point	isn't whether the user typed -v	or not.

	   Similarly,  just  because an	operator lets you assume default argu-
	   ments doesn't mean that you have to make use	of the defaults.   The
	   defaults  are  there	 for lazy systems programmers writing one-shot
	   programs.  If you want your program to be readable,	consider  sup-
	   plying the argument.

	   Along the same lines, just because you can omit parentheses in many
	   places doesn't mean that you	ought to:

		return print reverse sort num values array;
		return print(reverse(sort num (values(%array))));

	   When	in doubt, parenthesize.	 At the	very least it  will  let  some
	   poor	schmuck	bounce on the %	key in vi.

	   Even	 if  you  aren't  in doubt, consider the mental	welfare	of the
	   person who has to maintain the code after you, and who will	proba-
	   bly put parens in the wrong place.

       2.  Don't go through silly contortions to exit a	loop at	the top	or the
	   bottom, when	perl provides the "last" operator so you can  exit  in
	   the middle.	Just outdent it	a little to make it more visible:

		for (;;) {
		last line if $foo;
		    next line if /^#/;

       3.  Don't  be afraid to use loop	labels--they're	there to enhance read-
	   ability as well as to allow	multi-level  loop  breaks.   See  last

       4.  For portability, when using features	that may not be	implemented on
	   every machine, test the construct in	an eval	to see	if  it	fails.
	   If  you  know  what	version	or patchlevel a	particular feature was
	   implemented,	you can	test $]	to see if it will be there.

       5.  Choose mnemonic identifiers.

       6.  Be consistent.


       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, such as:

       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 cur-
		   rent	subroutine.

       c	   Continue.  Executes until the next breakpoint is reached.

       c line	   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.

       ?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	break-
		   point 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 new-

       > command   Set an action to happen after the prompt when  you've  just
		   given  a  command  to  return  to  executing	the script.  A
		   multi-line command may be entered by	backslashing the  new-

       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   Display last	n commands.  Only  commands  longer  than  one
		   character  are  listed.   If	 number	is omitted, lists them

       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 redi-
		   rected to.

       If  you	want  to  modify  the  debugger,  copy 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 customiza-
       tion 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{'.'} =
	     's/^\./p "\$DB\'sub(\$DB\'line):\t",\$DB\'line[\$DB\'line]/';

       Setuid Scripts

       Perl  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	evalu-
       ation scheme with fewer hidden "gotchas".  Additionally,	since the lan-
       guage  has more built-in	functionality, it has to rely less upon	exter-
       nal (and	possibly untrustworthy)	programs to accomplish its purposes.

       In an unpatched 4.2 or 4.3bsd 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/gid  bits on perl scripts.  If the kernel feature isn't
       disabled, perl will complain loudly that	your setuid  script  is	 inse-
       cure.   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 logically impossible for the tainted value to	 influence  the	 vari-
       able).  For example:

	    $foo = shift;	     # $foo is tainted
	    $bar = $foo,'bar';	     # $bar is also tainted
	    $xxx = <>;		     # Tainted
	    $path = $ENV{'PATH'};    # Tainted,	but see	below
	    $abc = 'abc';	     # Not tainted

	    system "echo $foo";	     # Insecure
	    system "/bin/echo",	$foo;	  # Secure (doesn't use	sh)
	    system "echo $bar";	     # Insecure
	    system "echo $abc";	     # Insecure	until PATH set

	    $ENV{'PATH'} = '/bin:/usr/bin';
	    $ENV{'IFS'}	= '' if	$ENV{'IFS'} ne '';

	    $path = $ENV{'PATH'};    # Not tainted
	    system "echo $abc";	     # Is secure now!

	    open(FOO,"$foo");	     # OK
	    open(FOO,">$foo");	     # Not OK

	    open(FOO,"echo $foo|");  # Not OK, but...
	    open(FOO,"-|") || exec 'echo', $foo;    # OK

	    $zzz = `echo $foo`;	     # Insecure, zzz tainted

	    unlink $abc,$foo;	     # Insecure
	    umask $foo;		     # Insecure

	    exec "echo $foo";	     # Insecure
	    exec "echo", $foo;	     # Secure (doesn't use sh)
	    exec "sh", '-c', $foo;   # Considered secure, alas

       The  taintedness	is associated with each	scalar value, so some elements
       of an array can be tainted, and others not.

       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 last example above.  You can also bypass the
       tainting	mechanism by referencing subpatterns--perl  presumes  that  if
       you  reference  a  substring  using $1, $2, etc,	you knew what you were
       doing when you wrote the	pattern:

	    $ARGV[0] =~	/^-P(\w+)$/;
	    $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 the 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.

       HOME	   Used	if chdir has no	argument.

       LOGDIR	   Used	if chdir has no	argument and HOME is not set.

       PATH	   Used	in executing subprocesses, and in finding  the	script
		   if -S is used.

       PERLLIB	   A  colon-separated list of directories in which to look for
		   Perl	library	files before looking in	the  standard  library
		   and the current directory.

       PERLDB	   The command used to get the debugger	code.  If unset, uses

			require	''

       Apart  from  these, perl	uses no	other environment variables, except to
       make them available to the script being executed,  and  to  child  pro-
       cesses.	 However,  scripts running setuid would	do well	to execute the
       following lines before doing anything else, just	to keep	people honest:

	   $ENV{'PATH'}	= '/bin:/usr/bin';    #	or whatever you	need
	   $ENV{'SHELL'} = '/bin/sh' if	$ENV{'SHELL'} ne '';
	   $ENV{'IFS'} = '' if $ENV{'IFS'} ne '';

       Larry Wall <>
       MS-DOS port by Diomidis Spinellis <>

       /tmp/perl-eXXXXXX   temporary file for -e commands.

       a2p  awk	to perl	translator
       s2p  sed	to perl	translator

       Compilation  errors will	tell you the line number of the	error, with an
       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  mes-
       sages  such  as	"Insecure  dependency".	  See  the  section  on	setuid

       Accustomed awk users should take	special	note of	the following:

       *   Semicolons are required after all simple statements in perl (except
	   at the end of a block).  Newline is not a statement delimiter.

       *   Curly brackets are required on ifs and whiles.

       *   Variables begin with	$ or @ in perl.

       *   Arrays  index  from 0 unless	you set	$[.  Likewise string positions
	   in substr() and index().

       *   You have to	decide	whether	 your  array  has  numeric  or	string

       *   Associative	array  values  do  not spring into existence upon mere

       *   You have to decide whether you want to use string or	 numeric  com-

       *   Reading  an input line does not split it for	you.  You get to split
	   it yourself to an array.  And  the  split  operator	has  different

       *   The	current	 input	line  is normally in $_, not $0.  It generally
	   does	not have the newline stripped.	($0 is the name	of the program

       *   $<digit>  does not refer to fields--it refers to substrings matched
	   by the last match pattern.

       *   The print statement does not	add field and record separators	unless
	   you set $, and $\.

       *   You must open your files before you print to	them.

       *   The	range  operator	is "..", not comma.  (The comma	operator works
	   as in C.)

       *   The match operator is "=~", not "~".	 ("~" is the one's  complement
	   operator, as	in C.)

       *   The	exponentiation	operator  is  "**",  not "^".  ("^" is the XOR
	   operator, as	in C.)

       *   The concatenation operator is ".", not the null string.  (Using the
	   null	 string	would render "/pat/ /pat/" unparsable, since the third
	   slash would be interpreted as a division operator--the  tokener  is
	   in  fact slightly context sensitive for operators like /, ?,	and <.
	   And in fact,	. itself can be	the beginning of a number.)

       *   Next, exit and continue work	differently.

       *   The following variables work	differently

		  Awk		    Perl
		  ARGC		    $#ARGV
		  ARGV[0]	    $0
		  FNR		    $. - something
		  FS		    (whatever you like)
		  NF		    $#Fld, or some such
		  NR		    $.
		  OFMT		    $#
		  OFS		    $,
		  ORS		    $\
		  RLENGTH	    length($&)
		  RS		    $/
		  RSTART	    length($`)
		  SUBSEP	    $;

       *   When	in doubt, run the awk construct	through	a2p and	 see  what  it
	   gives you.

       Cerebral	C programmers should take note of the following:

       *   Curly brackets are required on ifs and whiles.

       *   You should use "elsif" rather than "else if"

       *   Break and continue become last and next, respectively.

       *   There's no switch statement.

       *   Variables begin with	$ or @ in perl.

       *   Printf does not implement *.

       *   Comments begin with #, not /*.

       *   You can't take the address of anything.

       *   ARGV	must be	capitalized.

       *   The	"system"  calls	 link, unlink, rename, etc. return nonzero for
	   success, not	0.

       *   Signal handlers deal	with signal names, not numbers.

       Seasoned	sed programmers	should take note of the	following:

       *   Backreferences in substitutions use $ rather	than \.

       *   The pattern matching	metacharacters (, ), and | do not  have	 back-
	   slashes in front.

       *   The range operator is .. rather than	comma.

       Sharp shell programmers should take note	of the following:

       *   The	backtick  operator does	variable interpretation	without	regard
	   to the presence of single quotes in the command.

       *   The backtick	operator does no  translation  of  the	return	value,
	   unlike csh.

       *   Shells  (especially	csh) do	several	levels of substitution on each
	   command line.  Perl does substitution only  in  certain  constructs
	   such	 as  double  quotes, backticks,	angle brackets and search pat-

       *   Shells interpret scripts a little bit at a time.  Perl compiles the
	   whole program before	executing it.

       *   The arguments are available via @ARGV, not $1, $2, etc.

       *   The environment is not automatically	made available as variables.

       The  Perl  book,	 Programming Perl  ,  has  the following omissions and

       On page 5, the examples which read

	    eval "/usr/bin/perl

       should read

	    eval "exec /usr/bin/perl

       On page 195, the	equivalent to the System V sum program only works  for
       very small files.  To do	larger files, use

	    undef $/;
	    $checksum =	unpack("%32C*",<>) % 32767;

       The  descriptions  of  alarm and	sleep refer to signal SIGALARM.	 These
       should refer to SIGALRM.

       The -0 switch to	set the	initial	value of $/ was	added  to  Perl	 after
       the book	went to	press.

       The -l switch now does automatic	line ending processing.

       The qx//	construct is now a synonym for backticks.

       $0 may now be assigned to set the argument displayed by ps (1).

       The new @###.## format was omitted accidentally from the	description on

       It wasn't known at press	time that s///ee caused	 multiple  evaluations
       of the replacement expression.  This is to be construed as a feature.

       (LIST) x	$count now does	array replication.

       There is	now no limit on	the number of parentheses in a regular expres-

       In double-quote context,	more escapes are supported: \e,	\a, \x1b, \c[,
       \l, \L, \u, \U, \E.  The	latter five control up/lower case translation.

       The $/ variable may now be set to a multi-character delimiter.

       There is	now a g	modifier on ordinary pattern matching that  causes  it
       to iterate through a string finding multiple matches.

       All of the $^X variables	are new	except for $^T.

       The  default  top-of-form  format  for FILEHANDLE is now	FILEHANDLE_TOP
       rather than top.

       The eval	{} and sort {} constructs were added in	version	4.018.

       The v and V (little-endian) template options for	pack and  unpack  were
       added in	4.019.

       Perl  is	 at  the mercy of your machine's definitions of	various	opera-
       tions such as type casting, atof() and sprintf().

       If your stdio requires an seek or eof between reads  and	 writes	 on  a
       particular  stream, so does perl.  (This	doesn't	apply to sysread() and

       While none of the built-in data types have any  arbitrary  size	limits
       (apart  from  memory  size),  there are still a few arbitrary limits: a
       given identifier	may not	be longer than 255 characters, and  no	compo-
       nent  of	 your  PATH  may  be longer than 255 if	you use	-S.  A regular
       expression may not compile to more than 32767 bytes internally.

       Perl actually stands for	Pathologically Eclectic	 Rubbish  Lister,  but
       don't tell anyone I said	that.

3rd Berkeley Distribution					       PERL(1)


Want to link to this manual page? Use this URL:

home | help