X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=pod%2Fperlfunc.pod;h=0d09e855e8b472f847f471801ac0188395b0f711;hb=fbad3eb55c1f8c84d1dfd0e484ecddeffc891e79;hp=58c3e7199ce929ed9f88c308bfe0d7ada092e656;hpb=60f9f73cb29fd732238c21658d3c834b5b058ced;p=p5sagit%2Fp5-mst-13.2.git
diff --git a/pod/perlfunc.pod b/pod/perlfunc.pod
index 58c3e71..0d09e85 100644
--- a/pod/perlfunc.pod
+++ b/pod/perlfunc.pod
@@ -15,7 +15,7 @@ operator. A unary operator generally provides a scalar context to its
argument, while a list operator may provide either scalar and list
contexts for its arguments. If it does both, the scalar arguments will
be first, and the list argument will follow. (Note that there can ever
-be only one list argument.) For instance, splice() has three scalar
+be only one such list argument.) For instance, splice() has three scalar
arguments followed by a list.
In the syntax descriptions that follow, list operators that expect a
@@ -318,7 +318,7 @@ produce more accurate results than the bare stat() mode bits.
When under the C function, which C is the opposite of.
=item oct
Interprets EXPR as an octal string and returns the corresponding
-value. (If EXPR happens to start off with C<0x>, interprets it as
-a hex string instead.) The following will handle decimal, octal, and
+value. (If EXPR happens to start off with C<0x>, interprets it as a
+hex string. If EXPR starts off with C<0b>, it is interpreted as a
+binary string.) The following will handle decimal, binary, octal, and
hex in the standard Perl or C notation:
$val = oct($val) if $val =~ /^0/;
@@ -2263,7 +2281,8 @@ C<'w+'>, C<'a'>, and C<'a+'>.
If the filename begins with C<'|'>, the filename is interpreted as a
command to which output is to be piped, and if the filename ends with a
-C<'|'>, the filename is interpreted See L
+C<'|'>, the filename is interpreted as a command which pipes output to
+us. See L
for more examples of this. (You are not allowed to C to a command
that pipes both in I out, but see L, L,
and L for alternatives.)
@@ -2394,7 +2413,9 @@ See L for more examples of this.
NOTE: On any operation that may do a fork, any unflushed buffers remain
unflushed in both processes, which means you may need to set C<$|> to
-avoid duplicate output.
+avoid duplicate output. On systems that support a close-on-exec flag on
+files, the flag will be set for the newly opened file descriptor as
+determined by the value of $^F. See L.
Closing any piped filehandle causes the parent process to wait for the
child to finish, and returns the status value in C<$?>.
@@ -2444,7 +2465,7 @@ them, and automatically close whenever and however you leave that scope:
$first; # Or here.
}
-See L for some details about mixing reading and writing.
+See L for some details about mixing reading and writing.
=item opendir DIRHANDLE,EXPR
@@ -2466,8 +2487,10 @@ returning the string containing the structure. The TEMPLATE is a
sequence of characters that give the order and type of values, as
follows:
+ a A string with arbitrary binary data, will be null padded.
A An ascii string, will be space padded.
- a An ascii string, will be null padded.
+ Z A null terminated (asciz) string, will be null padded.
+
b A bit string (ascending bit order, like vec()).
B A bit string (descending bit order).
h A hex string (low nybble first).
@@ -2500,6 +2523,12 @@ follows:
(These 'shorts' and 'longs' are _exactly_ 16 bits and
_exactly_ 32 bits, respectively.)
+ q A signed quad (64-bit) value.
+ Q An unsigned quad value.
+ (Available only if your system supports 64-bit integer values
+ _and_ if Perl has been compiled to support those.
+ Causes a fatal error otherwise.)
+
f A single-precision float in the native format.
d A double-precision float in the native format.
@@ -2519,30 +2548,58 @@ follows:
X Back up a byte.
@ Null fill to absolute position.
+The following rules apply:
+
+=over 8
+
+=item *
+
Each letter may optionally be followed by a number giving a repeat
-count. With all types except C<"a">, C<"A">, C<"b">, C<"B">, C<"h">, C<"H">, and C<"P"> the
-pack function will gobble up that many values from the LIST. A C<*> for the
-repeat count means to use however many items are left. The C<"a"> and C<"A">
-types gobble just one value, but pack it as a string of length count,
-padding with nulls or spaces as necessary. (When unpacking, C<"A"> strips
-trailing spaces and nulls, but C<"a"> does not.) Likewise, the C<"b"> and C<"B">
-fields pack a string that many bits long. The C<"h"> and C<"H"> fields pack a
-string that many nybbles long. The C<"p"> type packs a pointer to a null-
-terminated string. You are responsible for ensuring the string is not a
-temporary value (which can potentially get deallocated before you get
-around to using the packed result). The C<"P"> packs a pointer to a structure
-of the size indicated by the length. A NULL pointer is created if the
-corresponding value for C<"p"> or C<"P"> is C.
-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 interchange 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 into
-float and thence back to double again will lose precision (i.e.,
-C) will not in general equal C<$foo>).
+count. With all types except C<"a">, C<"A">, C<"Z">, C<"b">, C<"B">, C<"h">,
+C<"H">, and C<"P"> the pack function will gobble up that many values from
+the LIST. A C<*> for the repeat count means to use however many items are
+left.
+
+=item *
+
+The C<"a">, C<"A"> and C<"Z"> types gobble just one value, but pack it as a
+string of length count, padding with nulls or spaces as necessary. When
+unpacking, C<"A"> strips trailing spaces and nulls, C<"Z"> strips everything
+after the first null, and C<"a"> returns data verbatim.
+
+=item *
+
+Likewise, the C<"b"> and C<"B"> fields pack a string that many bits long.
+
+=item *
+
+The C<"h"> and C<"H"> fields pack a string that many nybbles long.
+
+=item *
+
+The C<"p"> type packs a pointer to a null-terminated string. You are
+responsible for ensuring the string is not a temporary value (which can
+potentially get deallocated before you get around to using the packed result).
+The C<"P"> type packs a pointer to a structure of the size indicated by the
+length. A NULL pointer is created if the corresponding value for C<"p"> or
+C<"P"> is C.
+
+=item *
+
+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 interchange 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 into float and thence back to double again will
+lose precision (i.e., C) will not in general
+equal C<$foo>).
+
+=back
Examples:
@@ -2572,11 +2629,18 @@ Examples:
$foo = pack("i9pl", gmtime);
# a real struct tm (on my system anyway)
+ $utmp_template = "Z8 Z8 Z16 L";
+ $utmp = pack($utmp_template, @utmp1);
+ # a struct utmp (BSDish)
+
+ @utmp2 = unpack($utmp_template, $utmp);
+ # "@utmp1" eq "@utmp2"
+
sub bintodec {
unpack("N", pack("B32", substr("0" x 32 . shift, -32)));
}
-The same template may generally also be used in the unpack function.
+The same template may generally also be used in unpack().
=item package
@@ -2614,6 +2678,10 @@ after each command, depending on the application.
See L, L, and L
for examples of such things.
+On systems that support a close-on-exec flag on files, the flag will be set
+for the newly opened file descriptors as determined by the value of $^F.
+See L.
+
=item pop ARRAY
=item pop
@@ -2716,7 +2784,7 @@ but is more efficient. Returns the new number of elements in the array.
=item qw/STRING/
-Generalized quotes. See L.
+Generalized quotes. See L.
=item quotemeta EXPR
@@ -2773,10 +2841,17 @@ C there, it would have been testing the wrong file.
=item readline EXPR
-Reads from the filehandle whose typeglob is contained in EXPR. In scalar context, a single line
-is read and returned. In list context, reads until end-of-file is
-reached and returns a list of lines (however you've defined lines
-with C<$/> or C<$INPUT_RECORD_SEPARATOR>).
+Reads from the filehandle whose typeglob is contained in EXPR. In scalar
+context, each call reads and returns the next line, until end-of-file is
+reached, whereupon the subsequent call returns undef. In list context,
+reads until end-of-file is reached and returns a list of lines. Note that
+the notion of "line" used here is however you may have defined it
+with C<$/> or C<$INPUT_RECORD_SEPARATOR>). See L.
+
+When C<$/> is set to C and when readline() is in a scalar
+context (i.e. file slurp mode), it returns C<''> the first time,
+followed by C subsequently.
+
This is the internal function implementing the CEXPRE>
operator, but you can use it directly. The CEXPRE>
operator is discussed in more detail in L.
@@ -3040,6 +3115,23 @@ needed. If you really wanted to do so, however, you could use
the construction C<@{[ (some expression) ]}>, but usually a simple
C<(some expression)> suffices.
+Though C can be considered in general to be a unary operator,
+EXPR is also allowed to be a parenthesized list. The list in fact
+behaves as a scalar comma expression, evaluating all but the last
+element in void context and returning the final element evaluated in
+a scalar context.
+
+The following single statement:
+
+ print uc(scalar(&foo,$bar)),$baz;
+
+is the moral equivalent of these two:
+
+ &foo;
+ print(uc($bar),$baz);
+
+See L for more details on unary operators and the comma operator.
+
=item seek FILEHANDLE,POSITION,WHENCE
Sets FILEHANDLE's position, just like the C call of C.
@@ -3316,7 +3408,7 @@ busy multitasking system.
For delays of finer granularity than one second, you may use Perl's
C interface to access setitimer(2) if your system supports it,
-or else see L above.
+or else see L above.
See also the POSIX module's C function.
@@ -3617,6 +3709,7 @@ In addition, Perl permits the following widely-supported conversions:
%X like %x, but using upper-case letters
%E like %e, but using an upper-case "E"
%G like %g, but with an upper-case "E" (if applicable)
+ %b an unsigned integer, in binary
%p a pointer (outputs the Perl value's address in hexadecimal)
%n special: *stores* the number of characters output so far
into the next variable in the parameter list
@@ -3915,8 +4008,8 @@ system-dependent; they are available via the standard module C.
For historical reasons, some values work on almost every system
supported by perl: zero means read-only, one means write-only, and two
means read/write. We know that these values do I work under
-OS/390 Unix and on the Macintosh; you probably don't want to use them
-in new code.
+OS/390 & VM/ESA Unix and on the Macintosh; you probably don't want to
+use them in new code.
If the file named by FILENAME does not exist and the C call creates
it (typically because MODE includes the C flag), then the value of
@@ -4055,11 +4148,11 @@ This function binds a variable to a package class that will provide the
implementation for the variable. VARIABLE is the name of the variable
to be enchanted. CLASSNAME is the name of a class implementing objects
of correct type. Any additional arguments are passed to the "C"
-method of the class (meaning C, C, or C).
-Typically these are arguments such as might be passed to the C
-function of C. The object returned by the "C" method is also
-returned by the C function, which would be useful if you want to
-access other methods in CLASSNAME.
+method of the class (meaning C, C, C,
+or C). Typically these are arguments such as might be passed
+to the C function of C. The object returned by the "C"
+method is also returned by the C function, which would be useful
+if you want to access other methods in CLASSNAME.
Note that functions such as C and C may return huge lists
when used on large objects, like DBM files. You may prefer to use the
@@ -4076,34 +4169,58 @@ C function to iterate over such. Example:
A class implementing a hash should have the following methods:
TIEHASH classname, LIST
- DESTROY this
FETCH this, key
STORE this, key, value
DELETE this, key
+ CLEAR this
EXISTS this, key
FIRSTKEY this
NEXTKEY this, lastkey
+ DESTROY this
A class implementing an ordinary array should have the following methods:
TIEARRAY classname, LIST
- DESTROY this
FETCH this, key
STORE this, key, value
- [others TBD]
+ FETCHSIZE this
+ STORESIZE this, count
+ CLEAR this
+ PUSH this, LIST
+ POP this
+ SHIFT this
+ UNSHIFT this, LIST
+ SPLICE this, offset, length, LIST
+ EXTEND this, count
+ DESTROY this
+
+A class implementing a file handle should have the following methods:
+
+ TIEHANDLE classname, LIST
+ READ this, scalar, length, offset
+ READLINE this
+ GETC this
+ WRITE this, scalar, length, offset
+ PRINT this, LIST
+ PRINTF this, format, LIST
+ CLOSE this
+ DESTROY this
A class implementing a scalar should have the following methods:
TIESCALAR classname, LIST
- DESTROY this
FETCH this,
STORE this, value
+ DESTROY this
+
+Not all methods indicated above need be implemented. See L,
+L, L, L and L.
Unlike C, the C function will not use or require a module
for you--you need to do that explicitly yourself. See L
or the F module for interesting C implementations.
-For further details see L, L.
+For further details see L, L<"tied VARIABLE">.
=item tied VARIABLE
@@ -4171,7 +4288,7 @@ If EXPR is omitted, merely returns the current umask.
The Unix permission C is represented as three sets of three
bits, or three octal digits: C<0750> (the leading 0 indicates octal
-and isn't one of the the digits). The C value is such a number
+and isn't one of the digits). The C value is such a number
representing disabled permissions bits. The permission (or "mode")
values you pass C or C are modified by your umask, so
even if you tell C to create a file with permissions C<0777>,
@@ -4268,14 +4385,16 @@ 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 += unpack("%32C*", $_);
}
- $checksum %= 65536;
+ $checksum %= 65535;
The following efficiently counts the number of set bits in a bit vector:
$setbits = unpack("%32b*", $selectmask);
+See L for more examples.
+
=item untie VARIABLE
Breaks the binding between a variable and a package. (See C.)
@@ -4383,8 +4502,11 @@ command if the files already exist:
Returns a list consisting of all the values of the named hash. (In a
scalar context, returns the number of values.) The values are
-returned in an apparently random order, but it is the same order as
-either the C or C function would produce on the same hash.
+returned in an apparently random order. The actual random order is
+subject to change in future versions of perl, but it is guaranteed to
+be the same order as either the C or C function would
+produce on the same (unmodified) hash.
+
As a side effect, it resets HASH's iterator. See also C, C,
and C.
@@ -4432,7 +4554,8 @@ If you know the exact length in bits, it can be used in place of the C<*>.
Waits for a child process to terminate and returns the pid of the
deceased process, or C<-1> if there are no child processes. The status is
-returned in C<$?>.
+returned in C<$?>. Note that a return value of C<-1> could mean that
+child processes are being automatically reaped, as described in L.
=item waitpid PID,FLAGS
@@ -4451,7 +4574,8 @@ FLAGS of C<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.)
-See L for other examples.
+Note that a return value of C<-1> could mean that child processes are being
+automatically reaped. See L for details, and for other examples.
=item wantarray