jv@mh.nl (Johan Vromans) (06/27/90)
Archive-name: perlref.texinfo/part01
---- Cut Here and unpack ----
#!/bin/sh
# This is perlref.texinfo, a shell archive (shar 3.24)
# made 06/26/1990 19:44 UTC by jv@squirrel
# Source directory /u/jv/perlref/texinfo
#
# existing files WILL be overwritten
#
# This is part 1 of a multipart archive
# do not concatenate these parts, unpack them in order with /bin/sh
#
# This shar contains:
# length mode name
# ------ ---------- ------------------------------------------
# 43795 -rw-r--r-- perlref.texinfo
#
if touch 2>&1 | fgrep '[-amc]' > /dev/null
then TOUCH=touch
else TOUCH=true
fi
if test -r shar3_seq_.tmp; then
echo "Must unpack archives in sequence!"
next=`cat shar3_seq_.tmp`; echo "Please unpack part $next next"
exit 1
fi
# ============= perlref.texinfo ==============
echo "x - extracting perlref.texinfo (Text)"
sed 's/^X//' << 'SHAR_EOF' > perlref.texinfo &&
X\input texinfo @c -*-texinfo-*-
X@setfilename perlref.info
X@settitle perlref
X
X@ifinfo
XThis file documents perl, a practical extension and report language.
XGNU texinfo version 3.0.18.1.1 adapted by rich@@rice.edu.
X
XCopyright @copyright{} 1989, 1990 Johan Vromans
X@TeX{} version Copyright @copyright{} 1990 Raymond Chen
XRev. 3.0.18.1
XUse and reproduction of this information is unlimited.
X@end ifinfo
X
X@titlepage
X@sp 10
X@center @titlefont{Perl Reference Guide}
X@sp 1
X@center for perl version 3.0
X@sp 2
X@center Perl program designed and created by Larry Wall (lwall@@jpl-devvax.jpl.nasa.gov)
X@sp .5
X@center Reference guide designed and created by Johan Vromans (jv@@mh.nl)
X@sp .5
X@center @TeX{} version by Raymond Chen (raymond@@math.berkeley.edu)
X@vskip 0pt plus 1filll
XCopyright @copyright{} 1989, 1990 Johan Vromans
X@sp .1
X@TeX{} version Copyright @copyright{} 1990 Raymond Chen
X@sp .1
XRev. 3.0.18.1
X@sp .1
XUse and reproduction of this information is unlimited.
X@end titlepage
X
X
X@node Top, Command line options, (dir), (dir)
X
X@menu
X* Command line options::
X* Literals::
X* Variables::
X* Statements::
X* Flow control::
X* Operators::
X* File test operators::
X* Arithmetic functions::
X* Conversion functions::
X* Structure conversion::
X* String functions::
X* Array and list functions::
X* File operations::
X* Directory reading routines::
X* Input/Output::
X* Search and replace functions::
X* System interaction::
X* Networking::
X* Miscellaneous::
X* Info from system files::
X* Regular expressions::
X* Formats::
X* Special variables::
X* Special arrays::
X* The perl debugger::
X* Index::
X@end menu
X
X@node Command line options, Literals, , Top
X@chapter Command line options
X
X@table @samp
X@item -a
Xturns on autosplit mode when used with @samp{-n} or @samp{-p}. Splits
Xto @samp{@@F}.@refill
X
X@samp{-d}
Xruns the script under the debugger. Use @samp{-de 0} to start the
Xdebugger without a script.@refill
X
X@item -D@var{number}
Xsets debugging flags.
X
X@item -e @var{commandline}
Xmay be used to enter one line of script. Multiple @samp{-e} commands may
Xbe given to build up a multi-line script.@refill
X
X@item -i@var{extension}
Xspecifies that files processed by the @code{<>} construct are to be
Xedited in-place.@refill
X
X@item -I@var{directory}
Xwith @samp{-P}: tells the C preprocessor where to look
Xfor include files.@refill
X
X@item -n
Xassumes an input loop around your script. Lines are not printed.
X
X@item -p
Xassumes an input loop around your script. Lines are printed.
X
X@item -P
Xruns the C preprocessor on the script before compilation by perl.
X
X@item -s
Xinterprets @samp{-xxx} on the command line as switches and sets the
Xcorresponding variables @var{$xxx} in the script.@refill
X
X@item -S
Xuses the @var{PATH} environment variable to search for the script.
X
X@item -u
Xdumps core after compiling the script.
X
X@item -U
Xallows perl to do unsafe operations.
X
X@item -v
Xprints the version and patchlevel of your perl executable.
X
X@item -w
Xprints warnings about possible spelling errors and other error-prone
Xconstructs in the script.@refill
X@end table
X
X@c----------------------------------------------------------------
X@node Literals, Variables, Command line options, Top
X@chapter Literals
X
X@table @asis
X@item Numeric:
X@code{123}, @code{123.4}, @code{5E-10}, @code{0xff} (hex),
X@code{0377} (octal).@refill
X
X@item String:
X@code{"abc"}, @code{'abc'}. Variables are interpolated when
X@code{"@dots{}"} are used. @code{q/@dots{}/} can be used instead
Xof @code{'@dots{}'}, @code{qq/@dots{}/} instead of @code{"@dots{}"},
X(any delimiter instead of @code{/@dots{}/}).@refill
X
X@item Array:
X@code{(1,2,3)}. @code{()} is empty array. Also: @code{($a,$b,@@rest) =
X(1,2,@dots{});} Enums are fine: @code{(1..4)} is @code{(1,2,3,4)}.
XLikewise @code{('abc'..'ade')}.@refill
X
X@item Filehandles:
X@code{<STDIN>}, @code{<STDOUT>}, @code{<STDERR>}, @code{<handle>},
X@code{<$var>}. @code{<>} is the input stream formed by the files
Xspecified in @code{@@ARGV}, or @code{STDIN} if no arguments are
Xsupplied.@refill
X
X@item Globs:
X@code{<pattern>} evaluates to all filenames according to the pattern.
XUse @code{<${var}>} to glob from a variable.@refill
X
X@item Commands:
X@code{`command`} evaluates to the output of the command.
X
X@c
X@c Is Here-Is correct? Is it clear? Rich
X@c
X@item Here-Is:
XThe identifier must follow @code{<<} immediately.
X@example
X@code{<<identifier}.
X@var{input text}
Xidentifier
X@end example
X@end table
X
X@c----------------------------------------------------------------
X@node Variables, Statements, Literals, Top
X@chapter Variables
X
X@table @code
X@item $var
Xa simple scalar variable
X
X@item $var[28]
X29th element of array @code{@@var} (the @code{[]} are part of it)
X
X@item $var{'Feb'}
Xone value from associative array @code{%var}
X
X@item $#var
Xlast index of array @code{@@var}
X
X@item @@var
Xthe entire array
X
X@item @@var[3,4,5]
Xa slice of the array @code{@@var}
X
X@item @@var{'a','b'}
Xa slice of @code{%var}; same as @code{('a','b')}
X
X@item %var
Xthe entire associative array
X
X@item $var{'a',1,@dots{}}
Xemulates a multi-dimensional array
X
X@item ('a',1,@dots{})[4]
Xsubscripts an array literal
X
X@item *name
Xrefers to all objects represented by name. @code{*name1 = *name2} makes
X@code{name1} identical to @code{name2}.
X@end table
X
X@c----------------------------------------------------------------
X@node Statements, Flow control, Variables, Top
X@chapter Statements
X
XEvery statement is an expression, optionally followed by a modifier, and
Xterminated by a semi-colon.
X
XExecution of expressions can depend on other expressions using one of
Xthe modifiers @code{if}, @code{unless}, @code{while} or @code{until}, e.g.:
X@example
X@var{EXPR1} if @var{EXPR2};
X@var{EXPR1} until @var{EXPR2};
X@end example
X
XAlso, by using one of the logical operators @code{||}, @code{&&}
Xor @code{?:}, e.g.:
X@example
X@var{EXPR1} || @var{EXPR2};
X@var{EXPR1} ? @var{EXPR2} : @var{EXPR3};
X@end example
X
XStatements can be combined to form a @var{BLOCK} when enclosed in @code{@{@}}.
X
XCompound statements may be used to control flow (@code{[]} denote optional
Xparts, @code{*} means: defaults to @code{$_} if omitted):@refill
X
X@example
Xif (@var{EXPR}) @var{BLOCK} [ [ elsif (@var{EXPR}) @var{BLOCK} @dots{} ] else @var{BLOCK} ]
Xunless (@var{EXPR}) @var{BLOCK} [ else @var{BLOCK} ]
X[@var{LABEL}:] while (@var{EXPR}) @var{BLOCK} [ continue @var{BLOCK} ]
X[@var{LABEL}:] until (@var{EXPR}) @var{BLOCK} [ continue @var{BLOCK} ]
X[@var{LABEL}:] for (@var{EXPR}; @var{EXPR}; @var{EXPR}) @var{BLOCK}
X[@var{LABEL}:] foreach @var{VAR}* (@var{ARRAY}) @var{BLOCK}
X[@var{LABEL}:] @var{BLOCK} [ continue @var{BLOCK} ]
X@end example
X
XSpecial forms are:
X@example
Xdo @var{BLOCK} while @var{EXPR};
Xdo @var{BLOCK} until @var{EXPR};
X@end example
Xwhich are guaranteed to perform @var{BLOCK} once before testing @var{EXPR}.
X
X@c----------------------------------------------------------------
X@node Flow control, Operators, Statements, Top
X@chapter Flow control
X
X@table @code
X
X@item do @var{BLOCK}
XReturns the value of the last command in the sequence of
Xcommands indicated by @var{BLOCK}.
X
X@item do @var{SUBROUTINE} (@var{LIST})
XExecutes a @var{SUBROUTINE} declared by a @code{sub} declaration, and
Xreturns the value of the last expression evaluated in
X@var{SUBROUTINE}. Also: @code{&@var{SUBROUTINE}}.@refill
X
X@item do @var{EXPR}
XUses the value of @var{EXPR} as a filename and executes the contents of
Xthe file as a perl script. Errors are returned in @code{$@@}.@refill
X
X@item goto @var{LABEL}
XContinue execution at the specified label.
X
X@item last [@var{LABEL}]
XImmediately exits the loop in question. Skips continue block.
X
X@item next [@var{LABEL}]
XStarts the next iteration of the loop.
X
Xredo [@var{LABEL}]
X@item Restarts the loop block without evaluating the conditional again.
X
X@item return @var{EXPR}
XReturns from a subroutine with the value specified.
X@end table
X
X@c----------------------------------------------------------------
X@node Operators, File test operators, Flow control, Top
X@chapter Operators
X
X@table @asis
X@item @code{+} @code{-} @code{*} @code{/}
XAddition, subtraction, multiplication, division.
X
X@item @code{%}
XModulo division.
X
X@item @code{|} @code{&} @code{^}
XBitwise or, bitwise and, bitwise exclusive or.
X
X@item @code{>>} @code{<<}
XBitwise shift right, bitwise shift left.
X
X@item @code{**}
XExponentiation.
X
X@item @code{.}
XConcatenation of two strings.
X
X@item @code{x}
XReturns a string consisting of the left operand repeated the
Xnumber of times specified by the right operand.@refill
X@end table
X
XAll of the above operators also have an assignment operator, e.g. @code{.=}.
X
X@table @code
X@item @code{++} @code{--}
XAuto-increment (magical on strings), auto-decrement.
X
X@item @code{?:}
XAlternation (if-then-else) operator.
X
X@item @code{||} @code{&&}
XLogical or, logical and.
X
X@item @code{==} @code{!=}
XNumeric equality, inequality.
X
X@item @code{eq} @code{ne}
XString equality, inequality.
X
X@item @code{<} @code{>}
XNumeric less than, greater than.
X
X@item @code{lt} @code{gt}
XString less than, greater than.
X
X@item @code{<=} @code{>=}
XNumeric less (greater) than or equal to.
X
X@item @code{le} @code{ge}
XString less (greater) than or equal.
X
X@item @code{=~} @code{!~}
XSearch pattern, substitution, or translation (negated).
X
X@item @code{..}
XEnumeration, also input line range operator.
X
X@item @code{,}
XComma operator.
X@end table
X
X@c----------------------------------------------------------------
X@node File test operators, Arithmetic functions, Operators, Top
X@chapter File test operators
X
X@c %%rjc%% Changed "This unary operator" to "These unary operators"
X@c %%rjc%% and concomitant grammar changes
X
XThese unary operators take one argument, either a filename or a
Xfilehandle, and test the associated file to see if something is true
Xabout it. If the argument is omitted, tests @code{$_} (except for
X@code{-t}, which tests @var{STDIN}). If the special argument @code{_}
X(underscore) is passed, uses the info of the preceding test.@refill
X
X@table @asis
X@code{-r}/@code{-w}/@code{-x}/@code{-o}
XFile is readable/writable/executable/owned by effective uid.
X
X@item @code{-R}/@code{-W}/@code{-X}/@code{-O}
XFile is readable/writable/executable/owned by real uid.
X
X@item @code{-e}/@code{-z}/@code{-s}
XFile exists / has zero/non-zero size.
X
X@item @code{-f}/@code{-d}
XFile is a plain file, a directory.
X
X@item @code{-l}/@code{-S}/@code{-p}
XFile is a symbolic link, a socket, a named pipe (FIFO).
X
X@item @code{-b}/@code{-c}
XFile is a block/character special file.
X
X@item @code{-u}/@code{-g}/@code{-k}
XFile has setuid/setgid/sticky bit set.
X
X@item @code{-t}
XTests if filehandle (STDIN by default) is opened to a tty.
X
X@item @code{-T}/@code{-B}
XFile is a text/non-text (binary) file. Both @code{-T} and @code{-B}
Xreturn @var{TRUE} on a null file, or a file at EOF when testing a
Xfilehandle.@refill
X@end table
X
XAn @code{*} after the parameter list indicates that this function may be
Xused either as a function or as a unary operator, without the
Xparentheses. The symbol @code{*} after a parameter indicates that this
Xparameter will default to @code{$_} if omitted.@refill
X
X@c----------------------------------------------------------------
X@node Arithmetic functions, Conversion functions, File test operators, Top
X@chapter Arithmetic functions
X
X@table @code
X
X@item atan2(@var{X},@var{Y})
XReturns the arctangent of @var{X/Y} in the range -Pi to Pi.
X
X@item cos(@var{EXPR}*)*
XReturns the cosine of @var{EXPR} (expressed in radians).
X
X@item exp(@var{EXPR}*)*
XReturns e to the power of @var{EXPR}.
X
X@item int(@var{EXPR}*)*
XReturns the integer portion of @var{EXPR}.
X
X@item log(@var{EXPR}*)*
XReturns natural logarithm (base @var{e}) of @var{EXPR}.
X
X@item rand [(@var{EXPR})*]
XReturns a random fractional number between 0 and the value of
X@var{EXPR}. If @var{EXPR} is omitted, returns a value between 0 and
X1.@refill
X
X@item sin(@var{EXPR}*)*
XReturns the sine of @var{EXPR} (expressed in radians).
X
X@item sqrt(@var{EXPR}*)*
XReturn the square root of @var{EXPR}.
X
X@item srand[(@var{EXPR})*]
XSets the random number seed for the rand operator.
X
X@item time
XReturns the number of seconds since January 1, 1970. Suitable for
Xfeeding to gmtime(@dots{}) and localtime(@dots{}).@refill
X@end table
X
X@c----------------------------------------------------------------
X@node Conversion functions, Structure conversion, Arithmetic functions, Top
X@chapter Conversion functions
X
X@table @code
X
X@item gmtime(@var{EXPR})*
XConverts a time as returned by the time function to a 9-element
Xarray @code{($sec, $min, $hour, $mday, $mon, $year, $wday, $yday,
X$isdst)} with the time analyzed for the Greenwich timezone. @code{$mon}
Xhas the range 0@dots{}11 and @code{$wday} has the range
X0@dots{}6.@refill
X
X@c %%rjc%% \* added
X@item hex(@var{EXPR}*)*
XReturns the decimal value of @var{EXPR} interpreted as an hex string.
X
X@item localtime(@var{EXPR})*
XConverts a time as returned by the time function to a 9-element
Xarray with the time analyzed for the local timezone.@refill
X
X@c %%rjc%% \* added
X@item oct(@var{EXPR}*)*
XReturns the decimal value of @var{EXPR} interpreted as an octal string.
XIf @var{EXPR} starts off with 0x, interprets it as a hex string
Xinstead.@refill
X
X@item ord(@var{EXPR}*)*
XReturns the ascii value of the first character of @var{EXPR}.
X
X@item vec(@var{EXPR},@var{OFFSET},@var{BITS})
XTreats @var{EXPR} as a string of unsigned ints, and yields the bit at
X@var{OFFSET}. @var{BITS} must be between 1 and 32. May be used as an
Xlvalue.@refill
X@end table
X
XA @var{LIST} is a (possibly parenthesised) list of expressions,
Xvariables or @var{LIST}s. In all circumstances, an array variable or an
Xarray slice may be used instead of a @var{LIST}.@refill
X
X@c----------------------------------------------------------------
X@node Structure conversion, String functions, Conversion functions, Top
X@chapter Structure conversion
X
X@table @code
X
X@item pack(@var{TEMPLATE},@var{LIST})
XPacks the values into a binary structure using @var{TEMPLATE}.
X
X@item unpack(@var{TEMPLATE},@var{EXPR})
XUnpacks the structure @var{EXPR} into an array, using @var{TEMPLATE}.
X
X@var{TEMPLATE} is a sequence of characters as follows:
X
X@table @asis
X@item @code{a}/@code{A}
XAscii string, null/space padded
X
X@item @code{c}/@code{C}
XNative/unsigned char value
X
X@item @code{s}/@code{S}
XSigned/unsigned short value
X
X@item @code{i}/@code{I}
XSigned/unsigned integer value
X
X@item @code{l}/@code{L}
XSigned/unsigned long value
X
X@item @code{n}/@code{N}
XShort/long in network byte order
X
X@item @code{p}
XPointer to a string
X
X@item @code{x}
XNull byte
X@end table
X@end table
X
XEach character may be followed by a decimal number which will be used as
Xa repeat count. Spaces may be included in the template for readability
Xpurposes.@refill
X
X@c----------------------------------------------------------------
X@node String functions, Array and list functions, Structure conversion, Top
X@chapter String functions
X
X@table @code
X
X@item chop(@var{LIST}*)
XChops off the last character on all elements of the list; returns the
Xlast chopped character. The parentheses may be omitted if @var{LIST} is
Xa single variable.@refill
X
X@item crypt(@var{PLAINTEXT},@var{SALT})
XEncrypts a string.
X
X@c %%rjc%%\* added
X@item eval(@var{EXPR}*)*
X@var{EXPR} is parsed and executed as if it were a little perl program.
XThe value returned is the value of the last expression evaluated. If
Xthere is a syntax error or runtime error, an undefined string is
Xreturned by eval, and @code{$@@} is set to the error message.@refill
X
X@item index(@var{STR},@var{SUBSTR})
XReturns the position of @var{SUBSTR} in @var{STR}. If the substring is not
Xfound, returns @code{$[-1}.@refill
X
X@c %%rjc%% \* added
X@item length(@var{EXPR}*)*
XReturns the length in characters of the value of @var{EXPR}.
X
X@item rindex(@var{STR},@var{SUBSTR})
XReturns the position of the last occurrence of @var{SUBSTR} in @var{STR}.
X
X@item substr(@var{EXPR},@var{OFFSET},@var{LEN})
XExtracts a substring out of @var{EXPR} and returns it. If @var{OFFSET} is
Xnegative, counts from the end of the string. May be used as an
Xlvalue.@refill
X@end table
X
X@c----------------------------------------------------------------
X@node Array and list functions, File operations, String functions, Top
X@chapter Array and list functions
X
X@table @code
X
X@item delete @code{$}@var{ARRAY}$@{$@var{KEY}$@}$
XDeletes the specified value from the specified associative array.
XReturns the deleted value.@refill
X
X@item each(@code{%}@var{ARRAY})*
XReturns a 2-element array consisting of the key and value for the
Xnext value of an associative array. Entries are returned in an
Xapparently random order. When the array is entirely read, a null array
Xis returned. The next call to each(@dots{}) after that will start
Xiterating again.@refill
X
X@item grep(@var{EXPR},@var{LIST})
XEvaluates @var{EXPR} for each element of the @var{LIST}, locally setting
X@code{$_} to refer to the element. Modifying @code{$_} will modify the
Xcorresponding element from @var{LIST}. Returns array of elements from
X@var{LIST} for which @var{EXPR} returned true.@refill
X
X@item join(@var{EXPR},@var{LIST})
XJoins the separate strings of @var{LIST} into a single string with fields
Xseparated by the value of @var{EXPR}, and returns the string.@refill
X
X@item keys(@code{%}@var{ARRAY})*
XReturns a normal array consisting of all the keys of the named
Xassociative array.@refill
X
X@item pop(@code{@@}@var{ARRAY})*
XPops and returns the last value of the array, shortens the array by 1.
X
X@item push(@code{@@}@var{ARRAY},@var{LIST})
XPushes the values of @var{LIST} onto the end of @var{ARRAY}. The length of
SHAR_EOF
echo "End of perlref.texinfo part 1"
echo "File perlref.texinfo is continued in part 2"
echo "2" > shar3_seq_.tmp
exit 0
--
Johan Vromans jv@mh.nl via internet backbones
Multihouse Automatisering bv uucp: ..!{uunet,hp4nl}!mh.nl!jv
Doesburgweg 7, 2803 PL Gouda, The Netherlands phone/fax: +31 1820 62911/62500
------------------------ "Arms are made for hugging" -------------------------jv@mh.nl (Johan Vromans) (06/27/90)
Archive-name: perlref.texinfo/part02
---- Cut Here and unpack ----
#!/bin/sh
# this is xxx.02 (part 2 of perlref.texinfo)
# do not concatenate these parts, unpack them in order with /bin/sh
# file perlref.texinfo continued
#
if touch 2>&1 | fgrep '[-amc]' > /dev/null
then TOUCH=touch
else TOUCH=true
fi
if test ! -r shar3_seq_.tmp; then
echo "Please unpack part 1 first!"
exit 1
fi
(read Scheck
if test "$Scheck" != 2; then
echo "Please unpack part $Scheck next!"
exit 1
else
exit 0
fi
) < shar3_seq_.tmp || exit 1
echo "x - Continuing file perlref.texinfo"
sed 's/^X//' << 'SHAR_EOF' >> perlref.texinfo &&
X@var{ARRAY} increases by the length of @var{LIST}.@refill
X
X@item reverse(@var{LIST})*
XReturns the @var{LIST} in reverse order.
X
X@item shift[(@code{@@}@var{ARRAY})*]
XShifts the first value of the array off and returns it, shortening the
Xarray by 1 and moving everything down. If @code{@@}@var{ARRAY} is
Xomitted, shifts @code{@@ARGV} in main and @code{@@_} in
Xsubroutines.@refill
X
X@item sort([@var{SUBROUTINE}] @var{LIST})*
XSorts the @var{LIST} and returns the sorted array value. If
X@var{SUBROUTINE} is specified, gives the name of a subroutine that
Xreturns less than zero, zero, or greater than zero, depending on how the
Xelements of the array, available to the routine as @code{$a} and
X@code{$b}, are to be ordered.@refill
X
X@item splice(@code{@@}@var{ARRAY},@var{OFFSET}[,@var{LENGTH}[,@var{LIST}]])
XRemoves the elements of @code{@@}@var{ARRAY} designated by @var{OFFSET} and
X@var{LENGTH}, and replaces them with @var{LIST} (if specified). Returns
Xthe elements removed.@refill
X
X@item split[(/@var{PATTERN}/[,@var{EXPR}*[,@var{LIMIT}]])]
XSplits a string into an array of strings, and returns it. If @var{LIMIT} is
Xspecified, splits in no more than that many fields. If @var{PATTERN} is
Xalso omitted, splits on whitespace (/[ \t\n]+/). If not in array
Xcontext: returns number of fields and splits to @code{@@_}.@refill
X
X@item unshift(@code{@@}@var{ARRAY},@var{LIST})
XPrepends list to the front of the array, and returns the number of
Xelements in the new array.@refill
X
X@item values(@code{%}@var{ARRAY})*
XReturns a normal array consisting of all the values of the named
Xassociative array.@refill
X@end table
X
X@c----------------------------------------------------------------
X@node File operations, Directory reading routines, Array and list functions, Top
X@chapter File operations
X
XFunctions operating on a list of files return the number of files
Xsuccessfully operated upon.@refill
X
X@table @code
X
X@item chmod(@var{LIST})*
XChanges the permissions of a list of files. The first element of the
Xlist must be the numerical mode.@refill
X
X@item chown(@var{LIST})*
XChanges the owner and group of a list of files. The first two
Xelements of the list must be the numerical uid and gid.@refill
X
X@item link(@var{OLDFILE},@var{NEWFILE})
XCreates a new filename linked to the old filename.
X
X@item lstat(@var{FILE})
XLike stat, but does not traverse a final symbolic link.
X
X@item mkdir(@var{DIR},@var{MODE})
XCreates a directory with given permissions. Sets @code{$!} on failure.@refill
X
X@item select(@var{RBITS},@var{WBITS},@var{NBITS},@var{TIMEOUT})
XPerforms a select(2) system call with the same parameters.@refill
X
X@item readlink(@var{EXPR}*)*
XReturns the value of a symbolic link.
X
X@item rename(@var{OLDNAME},@var{NEWNAME})
XChanges the name of a file.
X
X@item rmdir(@var{FILENAME}*)*
XDeletes the directory if it is empty. Sets @code{$!} on failure.@refill
X
X@item stat(@var{FILE})
XReturns a 13-element array @code{($dev, $ino, $mode, $nlink, $uid, $gid,
X$rdev, $size, $atime, $mtime, $ctime, $blksize, $blocks)}. @var{FILE}
Xcan be a filehandle, an expression evaluating to a filename, or @code{_}
Xto refer to the last file test operation. The parentheses may be omitted
Xif @var{FILE} is a filehandle, a variable, or @code{_}.@refill
X
X@item symlink(@var{OLDFILE},@var{NEWFILE})
XCreates a new filename symbolically linked to the old filename.
X
X@item unlink(@var{LIST})*
XDeletes a list of files.
X
X@item utime(@var{LIST})*
XChanges the access and modification times on each file of a list of
Xfiles. The first two elements of the list must be the numerical access
Xand modification times.@refill
X@end table
X
X@c----------------------------------------------------------------
X@node Directory reading routines, Input/Output, File operations, Top
X@chapter Directory reading routines
X
X@table @code
X
X@item closedir(@var{DIRHANDLE})*
XCloses a directory opened by opendir.
X
X@item opendir(@var{DIRHANDLE},@var{DIRNAME})
XOpens a directory on the handle specified.
X
X@item readdir(@var{DIRHANDLE})*
XReturns the next entry (or an array of entries) in the directory.
X
X@item rewinddir(@var{DIRHANDLE})*
XPositions the directory to the beginning.
X
X@item seekdir(@var{DIRHANDLE},@var{POS})
XSets position for readdir on the directory.
X
X@item telldir(@var{DIRHANDLE})*
XReturns the postion in the directory.
X@end table
X
X@c----------------------------------------------------------------
X@node Input/Output, Search and replace functions, Directory reading routines, Top
X@chapter Input/Output
X
XIn input/output operations, @var{FILEHANDLE} may be a filehandle as
Xopened by the @code{open} operator, or a scalar variable which evaluates
Xto the name of a filehandle to be used.@refill
X
X@table @code
X
X@c %%rjc%% MS-DOS properly capitalized
X@item binmode(@var{FILEHANDLE})*
XArranges for the file opened on @var{FILEHANDLE} to be read in
X@code{binary} mode as opposed to @code{text} mode (MS-DOS only).@refill
X
X@item close(@var{FILEHANDLE})*
XCloses the file or pipe associated with the file handle.
X
X@item dbmclose(@code{%}@var{ARRAY})*
XBreaks the binding between the array and the dbm file.
X
X@item dbmopen(@code{%}@var{ARRAY},@var{DBMNAME}, @var{MODE})
XBinds a dbm or ndbm file to the associative array. If the database
Xdoes not exist, it is created with the indicated mode.@refill
X
X@item eof(@var{FILEHANDLE})
XReturns 1 if the next read will return end of file, or if the file is not
Xopen.@refill
X
X@item eof
XReturns the eof status for the last file read.
X
X@item eof()
XIndicates eof on the pseudo file formed of the files listed on the
Xcommand line.@refill
X
X@item fcntl(@var{FILEHANDLE},@var{FUNCTION},@code{$}@var{VAR})
XImplements the fcntl(2) function. This function has non-standard
Xreturn values. See the manual for details.@refill
X
X@item fileno(@var{FILEHANDLE})*
XReturns the file descriptor for a given (open) file.
X
X@item flock(@var{FILEHANDLE},@var{OPERATION})
XCalls flock(2) on the file. @var{OPERATION} adds from 1 (shared), 2
X(exclusive), 4 (non-blocking) or 8 (unlock).@refill
X
X@item getc[(@var{FILEHANDLE})*]
XYields the next character from the file, or @var{NULL} on @var{EOF}. If
X@var{FILEHANDLE} is omitted, reads from @var{STDIN}.@refill
X
X@item ioctl(@var{FILEHANDLE},@var{FUNCTION},@code{$}@var{VAR})
Xperforms ioctl(2) on the file. This function has non-standard return
Xvalues. See the manual for details.@refill
X
X@item open(@var{FILEHANDLE}[,@var{FILENAME}])
XOpens a file and associates it with @var{FILEHANDLE}. If @var{FILENAME}
Xis omitted, the scalar variable of the same name as the @var{FILEHANDLE}
Xmust contain the filename. The filename may be optionally preceded by
X@code{>}, @code{>>} or @code{<} to select output/append/input mode.
XDefault mode is input. Precede with @code{+} to select read/write
Xaccess. Use @code{&@dots{}} to connect to an already opened filehandle.
XPipes to/from commands may be opened with @code{|@dots{}} and
X@code{@dots{}|} . Open returns 1 upon success, undef otherwise, except
Xfor pipes. The parentheses may be omitted, if only a @var{FILEHANDLE} is
Xspecified.@refill
X
X@item pipe(@var{READHANDLE},@var{WRITEHANDLE})
XReturns a pair of connected pipes.
X
X@item print[([@var{FILEHANDLE}] @var{LIST}*)*]
XPrints a string or a comma-separated list of strings. If
X@var{FILEHANDLE} is omitted, prints by default to standard output (or
Xto the last selected output channel---see select(@dots{})).@refill
X
X@item printf[([@var{FILEHANDLE}] @var{LIST})*]
XEquivalent to @code{print @var{FILEHANDLE} sprintf(@var{LIST})}.@refill
X
X@item read(@var{FILEHANDLE},@code{$}@var{VAR},@var{LENGTH})
XRead @var{LENGTH} binary bytes from the file into the variable.
XReturns number of bytes actually read.@refill
X
X@item seek(@var{FILEHANDLE},@var{POSITION},@var{WHENCE})
XRandomly positions the file. Returns 1 upon success, 0 otherwise.@refill
X
X@item select(@var{FILEHANDLE})*
XSets the current default filehandle for output operations. Returns
Xthe previously selected filehandle.@refill
X
X@item sprintf(@var{FORMAT},@var{LIST})
XReturns a string formatted by (almost all of) the usual printf
Xconventions.@refill
X
X@item tell[(@var{FILEHANDLE})]*
XReturns the current file position for the file. If @var{FILEHANDLE} is
Xomitted, assumes the file last read.@refill
X
X@item write[(@var{FILEHANDLE})]*
XWrites a formatted record to the specified file, using the format
Xassociated with that file. See Formats.@refill
X@end table
X
X@c----------------------------------------------------------------
X@node Search and replace functions, System interaction, Input/Output, Top
X@chapter Search and replace functions
X
X@table @code
X
X@item [@var{EXPR} @code{=~}] [m]/@var{PATTERN}/[i][o]
XSearches a string for a pattern. If no string is specified via the @code{=~}
Xor @code{!~} operator, the @code{$_} string is searched. If you prepend
Xan @code{m} you can use any pair of characters as delimiters. If the
Xfinal delimiter is followed by the optional letter @code{i}, the
Xmatching is done in a case-insensitive manner. If you append @code{o},
Xvariables are interpolated only once. If used in a context that requires
Xan array value, a pattern match returns an array consisting of the
Xsubexpressions matched by the parentheses in pattern, i.e. @code{($1,
X$2, $3}@dots{}@code{)}.@refill
X
X@item ?@var{PATTERN}?
XThis is just like the /pattern/ search, except that it matches only
Xonce between calls to the reset operator.@refill
X
X@item [@code{$}@var{VAR} @code{=~}] s/@var{PATTERN}/REPLACEMENT/[g][i][e][o]
XSearches a string for a pattern, and if found, replaces that pattern
Xwith the replacement text and returns the number of substitutions made.
XOtherwise it returns false (0). Optional modifiers: @code{g} indicates
Xthat all occurrences of the pattern are to be replaced; @code{e}
Xindicates that the replacement string is to be interpreted as an
Xexpression, @code{i} and @code{o} as with /@var{PATTERN}/ matching. Any
Xdelimiter may replace the slashes; if single quotes are used, no
Xinterpretation is done on the replacement string.@refill
X
X@item study[(@code{$}@var{VAR}*)*]
XStudy the contents of @code{$}@var{VAR} in anticipation of doing many pattern
Xmatches on the contents before it is next modified.@refill
X
X@item [@code{$}@var{VAR} @code{=~}] tr/@var{SEARCHLIST}/@var{REPLACEMENTLIST}/
XTranslates all occurrences of the characters found in the search list
Xwith the corresponding character in the replacement list. It returns the
Xnumber of characters replaced. @code{y} may be used instead of
X@code{tr}.@refill
X@end table
X
X@c----------------------------------------------------------------
X@node System interaction, Networking, Search and replace functions, Top
X@chapter System interaction
X
X@table @code
X
X@item chdir [(@var{EXPR})*]
XChanges the working directory, @code{$HOME} if @var{EXPR} is omitted.
X
X@item chroot(@var{FILENAME}*)*
XChanges the root for the following commands.
X
X@item die(@var{LIST})*
XPrints the value of @var{LIST} to @var{STDERR} and exits with the current
Xvalue of @code{$!} (errno). If @code{$!} is 0, exits with the value of
X@code{($? >> 8)} (@code{`command`} status). If @code{($? >> 8)} is 0,
Xexits with 255.@refill
X
X@item exec(@var{LIST})*
XExecutes the system command in @var{LIST}.
X
X@item exit(@var{EXPR})*
XExits immediately with the value of @var{EXPR}.
X
X@item fork
XDoes a fork() call. Returns the child pid to the parent process and
Xzero to the child process.@refill
X
X@item getlogin
XReturns the current login name from @file{/etc/utmp}.
X
X@item getpgrp[(@var{PID})*]
XReturns the process group for process @var{PID} (0, or omitted, means
Xthe current process).@refill
X
X@item getppid
XReturns the process id of the parent process.
X
X@item getpriority(@var{WHICH},@var{WHO})
XReturns the current priority for a process, process group, or user.
X
X@item kill(@var{LIST})*
XSends a signal to a list of processes. The first element of the list
Xmust be the signal to send (numeric, or its name as a string).@refill
X
X@item setpgrp(@var{PID},@var{PGRP})
XSets the process group for the @var{PID} (0 = current process).
X
X@item setpriority(@var{WHICH},@var{WHO},@var{PRIO})
XSets the current priority for a process, process group or a user.
X
X@item sleep[(@var{EXPR})*]
XCauses the script to sleep for @var{EXPR} seconds, or forever if no
X@var{EXPR}. Returns the number of seconds actually slept.@refill
X
X@item syscall(@var{LIST})*
XCalls the system call specified in the first element of the list,
Xpassing the rest of the list as arguments to the call.@refill
X
X@item system(@var{LIST})*
XDoes exactly the same thing as @code{exec @var{LIST}} except that a fork is
Xdone first, and the parent process waits for the child process to
Xcomplete.@refill
X
X@item times
XReturns a 4-element array @code{($user, $system, $cuser, $csystem)}
Xgiving the user and system times, in seconds, for this process and the
Xchildren of this process.@refill
X
X@item umask[(@var{EXPR})*]
XSets the umask for the process and returns the old one. If @var{EXPR} is
Xomitted, returns current umask value.@refill
X
X@item wait
XWaits for a child process to terminate and returns the pid of the
Xdeceased process ($-1$ if none). The status is returned in @code{$?}.
X
X@item warn(@var{LIST})*
XPrints the message on @var{STDERR} like die(@dots{}), but doesn't exit.
X@end table
X
X@c----------------------------------------------------------------
X@node Networking, Miscellaneous, System interaction, Top
X@chapter Networking
X
X@table @code
X
X@item accept(@var{NEWSOCKET},@var{GENERICSOCKET})
XAccepts a new socket.
X
X@item bind(@var{SOCKET},@var{NAME})
XBinds the @var{NAME} to the @var{SOCKET}.
X
X@item connect(@var{SOCKET}, @var{NAME})
XConnects the @var{NAME} to the @var{SOCKET}.
X
X@item getpeername(@var{SOCKET})
XReturns the socket address of the other end of the @var{SOCKET}.
X
X@item getsockname(@var{SOCKET})
XReturns the name of the socket.
X
X@item getsockopt(@var{SOCKET},@var{LEVEL},@var{OPTNAME})
XReturns the socket options.
X
X@item listen(@var{SOCKET},@var{QUEUESIZE})
XStarts listening on the specified @var{SOCKET}.
X
X@item recv(@var{SOCKET},@var{SCALAR},@var{LENGTH},@var{FLAGS})
XReceives a message on @var{SOCKET}.
X
X@item send(@var{SOCKET},@var{MSG},@var{FLAGS}[,@var{TO}])
XSends a message on the @var{SOCKET}.
X
X@item setsockopt(@var{SOCKET},@var{LEVEL},@var{OPTNAME},@var{OPTVAL})
XSets the requested socket option.
X
X@item shutdown(@var{SOCKET},@var{HOW})
XShuts down a @var{SOCKET}.
X
X@item socket(@var{SOCKET},@var{DOMAIN},@var{TYPE},@var{PROTOCOL})
XCreates a @var{SOCKET} in @var{DOMAIN} with @var{TYPE} and @var{PROTOCOL}.
X
X@item socketpair(@var{SOCKET1},@var{SOCKET2},@var{DOMAIN},@var{TYPE},@var{PROTOCOL})
XAs socket, but creates a pair of bi-directional sockets.
X@end table
X
X@c----------------------------------------------------------------
X@node Miscellaneous, Info from system files, Networking, Top
X@chapter Miscellaneous
X
X@table @code
X
X@item defined(@var{EXPR})*
XTests whether the lvalue @var{EXPR} has a real value.
X
X@item dump [@var{LABEL}]
XImmediate core dump. When reincarnated, starts at @var{LABEL}.
X
X@item local(@var{LIST})
XDeclares the listed variables to be local to the enclosing block,
Xsubroutine or eval.
X
X@item package @var{NAME}
XDesignates the remainder of the current block as a package, having
Xa separate namespace.@refill
X
X@c %%rjc%% Changed "not omitted" to "supplied"
X@item reset [(@var{EXPR})*]
XResets @code{??} searches so that they work again. If @var{EXPR} is supplied,
Xit is interpreted as a list of single characters (hyphens allowed for
Xranges). All variables and arrays beginning with one of those letters
Xare reset to their pristine state. Only affects the current
Xpackage.@refill
X
X@item sub @var{NAME} $\{$ @var{EXPR}; @dots{}\ $\}$
XDesignates @var{NAME} as a subroutine. Parameters are passed as array
X@code{@@_}. Returns the value of the last expression evaluated.@refill
X
X@item undef[(@var{LVALUE})*]
XUndefines the @var{LVALUE}. Always returns the undefined value.
X
X@item wantarray
XReturns true if the current context expects an array value.
X@end table
X
X@c----------------------------------------------------------------
X@node Info from system files, Regular expressions, Miscellaneous, Top
X@chapter Info from system files
X
X@file{/etc/passwd}.
XInfo is @code{($name, $passwd, $uid, $gid, $quota, $comment, $gcos, $dir, $shell)}.
X
X@table @code
X
X@item endpwent
XEnds lookup processing.
X
X@item getpwent
XGets next info.
X
X@item getpwnam(@var{NAME})
XGets info by name.
X
X@item getpwuid(@var{UID})
XGets info by uid.
X
X@item setpwent
XResets lookup processing.
X@end table
X
X@file{/etc/group}.
XInfo is a 4-item array: @code{($name, $passwd, $gid, $members)}.
X
X@table @code
X
X@item endgrent
XEnds lookup processing.
X
X@item getgrgid(@var{GID})
XGets info by group id.
X
X@item getgrnam(@var{NAME})
XGets info by name.
X
X@item getgrent
XGets next info.
X
X@item setgrent
XResets lookup processing.
X@end table
X
X@file{/etc/hosts}.
XInfo is @code{($name, $aliases, $addrtype, $length, @@addrs)}.
X
X@table @code
X
X@item endhostent
XEnds lookup processing.
X
X@item gethostbyname(@var{NAME})
XGets info by name.
X
X@item gethostent
XGets next info.
X
X@item sethostent(@var{STAYOPEN})
XResets lookup processing.
X@end table
X
X@file{/etc/networks}.
XInfo is @code{($name, $aliases, $addrtype, $net)}.
X
X@table @code
X
X@item endnetent
XEnds lookup processing.
X
X@item getnetbyaddr(@var{ADDR},@var{TYPE})
XGets info by address and type.
X
X@item getnetbyname(@var{NAME})
XGets info by name.
X
X@item getnetent
XGets next info.
X
X@item setnetent(@var{STAYOPEN})
XResets lookup processing.
X@end table
X
X@file{/etc/services}.
XInfo is @code{($name, $aliases, $port, $proto)}.
X
X@table @code
X
X@item endservent
XEnds lookup processing.
X
X@item getservbyname(@var{NAME}, @var{PROTO})
XGets info by name.
X
X@item getservbyport(@var{PORT}, @var{PROTO})
XGets info by port.
X
X@item getservent
XGets next info.
X
X@item setservent(@var{STAYOPEN})
XResets lookup processing.
X@end table
X
X@file{/etc/protocols}.
XInfo is @code{($name, $aliases, $proto)}.
X
X@table @code
X
X@item endprotoent
XEnds lookup processing.
X
X@item getprotobyname(@var{NAME})
XGets info by name.
X
X@item getprotobynumber(@var{NUMBER})
XGets info by number.
X
X@item getprotoent
XGets next info.
X
X@item setprotoent(@var{STAYOPEN})
XResets lookup processing.
X@end table
X
X@c----------------------------------------------------------------
X@node Regular expressions, Formats, Info from system files, Top
X@chapter Regular expressions
X
XStandard UNIX regular expressions, with the following additions:
X
X@table @asis
X
X@item @code{(} @code{)} @code{|} @code{@{} @code{@}}
Xdo not have to be escaped with a @code{\}.
SHAR_EOF
echo "End of perlref.texinfo part 2"
echo "File perlref.texinfo is continued in part 3"
echo "3" > shar3_seq_.tmp
exit 0
--
Johan Vromans jv@mh.nl via internet backbones
Multihouse Automatisering bv uucp: ..!{uunet,hp4nl}!mh.nl!jv
Doesburgweg 7, 2803 PL Gouda, The Netherlands phone/fax: +31 1820 62911/62500
------------------------ "Arms are made for hugging" -------------------------jv@mh.nl (Johan Vromans) (06/27/90)
Archive-name: perlref.texinfo/part03
---- Cut Here and unpack ----
#!/bin/sh
# this is xxx.03 (part 3 of perlref.texinfo)
# do not concatenate these parts, unpack them in order with /bin/sh
# file perlref.texinfo continued
#
if touch 2>&1 | fgrep '[-amc]' > /dev/null
then TOUCH=touch
else TOUCH=true
fi
if test ! -r shar3_seq_.tmp; then
echo "Please unpack part 1 first!"
exit 1
fi
(read Scheck
if test "$Scheck" != 3; then
echo "Please unpack part $Scheck next!"
exit 1
else
exit 0
fi
) < shar3_seq_.tmp || exit 1
echo "x - Continuing file perlref.texinfo"
sed 's/^X//' << 'SHAR_EOF' >> perlref.texinfo &&
X
X@item @code{+}
Xmatches the preceding pattern element one or more times.
X
X@item @code{?}
Xmatches zero or one times.
X
X@c %%rjc%% syntax elaborated
X@item @code{@{@var{n} [, [@var{m}]]@}}
Xdenote the minimum (@var{n}) and maximum (@var{m}) match count. If
X@code{,} is omitted, uses @var{m=n}. If @var{m} is omitted but @code{,}
Xis present, uses @var{m=infinity}.@refill
X
X@item @code{\w}
Xmatches alphanumeric, including @code{_}, @code{\W} matches
Xnon-alphanumeric.@refill
X
X@item @code{\b}
Xmatches word boundaries, @code{\B} matches non-boundaries.
X
X@item @code{\s}
Xmatches whitespace, @code{\S} matches non-whitespace.
X
X@item @code{\d}
Xmatches numeric, @code{\D} matches non-numeric.
X@end table
X
X@code{\n}, @code{\r}, @code{\f}, @code{\t} and @code{\}@var{NNN} have
Xtheir usual meaning.@refill
X
X@code{\w}, @code{\s} and @code{\d} may be used within character classes,
X@code{\b} denotes backspace in this context.@refill
X
X@code{\1} @dots{}\ @code{\9} refer to matched sub-expressions inside the
Xmatch.@refill
X
X@code{$1} @dots{}\ @code{$9} can be used to refer to matched
Xsub-expressions outside the matching.@refill
X
X@table @asis
X
X@item @code{$+}
Xreturns whatever the last bracket match matched.
X
X@item @code{$&}
Xreturns the entire matched string.
X
X@item @code{$`}
Xreturns everything before the matched string.
X
X@item @code{$'}
Xreturns everything after the matched string.
X@end table
X
X@c----------------------------------------------------------------
X@node Formats, Special variables, Regular expressions, Top
X@chapter Formats
X
X@example
Xformat [@var{NAME}] =
X@var{FORMLIST}
X.
X@end example
X
X@var{FORMLIST} pictures the lines, and contains the arguments which will
Xgive values to the fields in the lines. Picture fields are:@refill
X
X@table @code
X
X@item @@<<<@dots{}
Xleft adjusted field, the @code{<} is repeated to denote the
Xlength of the field;
X
X@item @@>>>@dots{}
Xright adjusted field;
X
X@item @@|||@dots{}
Xcentered field;
X
X@item @@*
Xa multi-line field.
X@end table
X
XUse @code{^} instead of @code{@@} for multi-line block filling.
X
XUse @code{~} at the beginning of a line to suppress unwanted empty lines.
X
XUse @code{~~} at the beginning of a line to have this format line
Xrepeated until all fields are exhausted.@refill
X
XSet @code{$-} to zero to force a page break.
X
X@c----------------------------------------------------------------
X@node Special variables, Special arrays, Formats, Top
X@chapter Special variables
X
XThe following variables are global and should be localized in subroutines:
X
X@table @asis
X
X@item @code{$_}
XThe default input and pattern-searching space.
X
X@item @code{$.}
XThe current input line number of the last filehandle that was read.
X
X@item @code{$/}
XThe input record separator, newline by default.
X
X@item @code{$,}
XThe output field separator for the print operator.
X
X@item @code{$"}
XThe separator which joins elements of arrays interpolated in
X strings.
X
X@item @code{$\}
XThe output record separator for the print operator.
X
X@item @code{$#}
XThe output format for printed numbers. Initial value is @code{%.20g}.
X
X@item @code{$*}
XSet to 1 to do multiline matching within a string, 0 to assume
Xstrings contain a single line. Default is 0.@refill
X
X@item @code{$?}
XThe status returned by the last backtick (``) command,
Xpipe close or system operator.
X
X@item @code{$]}
XThe perl version string as displayed with @code{perl -v}.
X
X@item @code{$[}
XThe index of the first element in an array, and of the first character
Xin a substring. Default is 0.@refill
X
X@item @code{$;}
XThe subscript separator for multi-dimensional array emulation.
XDefault is @code{"\034"}.
X
X@item @code{$!}
XIf used in a numeric context, yields the current value of errno. If
Xused in a string context, yields the corresponding error string.@refill
X
X@item @code{$@@}
XThe perl error message from the last eval or @code{do @var{EXPR}} command.
X
X@item @code{$:}
XThe set of characters after which a string may be broken to fill
Xcontinuation fields (starting with @code{^}) in a format.@refill
X
X@item @code{$0}
XThe name of the file containing the perl script being executed.
X
X@item @code{$$}
XThe process number of the perl running this script. Altered (in the
Xchild process) by fork().@refill
X
X@item @code{$<}
XThe real uid of this process.
X
X@item @code{$>}
XThe effective uid of this process.
X
X@item @code{$(}
XThe real gid of this process.
X
X@item @code{$)}
XThe effective gid of this process.
X@end table
X
XThe following variables are context dependent and need not be
Xlocalized:@refill
X
X@table @asis
X
X@item @code{$%}
XThe current page number of the currently selected output channel.
X
X@item @code{$=}
XThe page length of the current output channel. Default is 60 lines.
X
X@item @code{$-}
XThe number of lines left on the page.
X
X@item @code{$~}
XThe name of the current report format.
X
X@item @code{$^}
XThe name of the current top-of-page format.
X
X@item @code{$|}
XIf set to nonzero, forces a flush after every write or print on the
Xcurrently selected output channel. Default is 0.@refill
X
XThe following variables are always local to the current block:
X
X@item @code{$&}
XThe string matched by the last pattern match.
X
X@item @code{$`}
XThe string preceding what was matched by the last pattern match.
X
X@item @code{$'}
XThe string following what was matched by the last pattern match.
X
X@item @code{$+}
XThe last bracket matched by the last search pattern.
X
X@item @code{$1 @dots{} $9}
XContains the subpattern from the corresponding set of parentheses
Xin the last pattern matched.@refill
X@end table
X
X
X@c----------------------------------------------------------------
X@node Special arrays, The perl debugger, Special variables, Top
X@chapter Special arrays
X
X@table @asis
X
X@item @code{@@ARGV}
XContains the command line arguments for the script (not
Xincluding the command name). See @code{$0} for the command name.@refill
X
X@item @code{@@INC}
XContains the list of places to look for perl scripts to be
Xevaluated by the @code{do @var{EXPR}} command.@refill
X
X@item @code{@@_}
XParameter array for subroutines. Also used by split if not in
Xarray context.
X
X@item @code{%ENV}
XContains the current environment.
X
X@item @code{%SIG}
XUsed to set signal handlers for various signals.
X@end table
X
X
X@c----------------------------------------------------------------
X@node The perl debugger, Index, Special arrays, Top
X@chapter The perl debugger (invoked with @code{perl -d})
X
X@table @asis
X
X@item @code{h}
XPrints out a help message.
X
X@item @code{s}
XSingle steps.
X
X@item @code{c}
XContinues (until breakpoint or exit).
X
X@item @key{RET}
XRepeats last @code{s} or @code{n}.
X
X@item @code{n}
XSingle steps around subroutine call.
X
X@item @code{l} [@var{RANGE}]
Xlists a range of lines. @var{RANGE} may be a number, start - end,
Xstart + amount, or a subroutine name. If omitted, continues last
X@code{l}.@refill
X
X@item @code{L}
XLists lines that have breakpoints or actions.
X
X@item @code{t}
XToggles trace mode.
X
X@item @code{b} [@var{LINE}]
XSets breakpoint at (current) line.
X
X@item @code{b} @var{SUBNAME}
XSets breakpoint at the subroutine.
X
X@item @code{S}
XLists names of all subroutines.
X
X@item @code{d} @var{LINE}
XDeletes breakpoint at the given line.
X
X@item @code{D}
XDeletes all breakpoints.
X
X@item @code{A}
XDeletes all line actions.
X
X@item @code{V} [@var{PACKAGE}]
XLists all variables in a package. Default package is main.
X
X@item @code{a} @var{LINE} @var{COMMAND}
XSets an action for line.
X
X@item @code{<} @var{COMMAND}
XSets an action to be executed before every debugger prompt.
X
X@item @code{>} @var{COMMAND}
XSets an action to be executed before every @code{s}, @code{c} or @code{n}
Xcommand.@refill
X
X@item @code{!} [ [@code{-}]@var{NUMBER}]
XRedo a debugging command. Default is previous command.
X
X@item @code{H} [@code{-}@var{NUMBER}]
XDisplays the last @code{-}number commands of more than one letter.
X
X@item @code{q}
XQuits. You may also use your @key{EOF} character.
X
X@item @var{COMMAND}
XExecutes command as a perl statement.
X
X@item @code{p} @var{EXPR}*
XPrints @var{EXPR}.
X@end table
X
X@node Index, , The perl debugger, Top
X@chapter Index
X
XWe need command and function indices.
X
X@contents
X@bye
SHAR_EOF
echo "File perlref.texinfo is complete" &&
$TOUCH -am 0615095490 perlref.texinfo &&
chmod 0644 perlref.texinfo ||
echo "restore of perlref.texinfo failed"
set `wc -c perlref.texinfo`;Wc_c=$1
if test "$Wc_c" != "43795"; then
echo original size 43795, current size $Wc_c
fi
rm -f shar3_seq_.tmp
echo "You have unpacked the last part"
exit 0
--
Johan Vromans jv@mh.nl via internet backbones
Multihouse Automatisering bv uucp: ..!{uunet,hp4nl}!mh.nl!jv
Doesburgweg 7, 2803 PL Gouda, The Netherlands phone/fax: +31 1820 62911/62500
------------------------ "Arms are made for hugging" -------------------------