=item *
-The default place to put an input record when a C<E<lt>FHE<gt>>
+The default place to put an input record when a C<< <FH> >>
operation's result is tested by itself as the sole criterion of a C<while>
test. Outside a C<while> test, this will not happen.
=over 8
-=item $E<lt>I<digits>E<gt>
+=item $<I<digits>>
Contains the subpattern from the corresponding set of capturing
parentheses from the last pattern match, not counting patterns
(Mnemonic: be positive and forward looking.)
This variable is read-only and dynamically scoped to the current BLOCK.
+=item @LAST_MATCH_END
+
=item @+
-$+[0] is the offset of the end of the last successful match.
-C<$+[>I<n>C<]> is the offset of the end of the substring matched by
-I<n>-th subpattern, or undef if the subpattern did not match.
-
-Thus after a match against $_, $& coincides with C<substr $_, $-[0],
-$+[0] - $-[0]>. Similarly, C<$>I<n> coincides with C<substr $_, $-[>I<n>C<],
-$+[>I<n>C<] - $-[>I<n>C<]> if C<$-[>I<n>C<]> is defined, and $+ coincides with
-C<substr $_, $-[$#-], $+[$#-]>. One can use C<$#+> to find the number
-of subgroups in the last successful match. Contrast with
-C<$#E<45>>, the last I<matched> subgroup. Compare with C<@E<45>>.
+This array holds the offsets of the ends of the last successful
+submatches in the currently active dynamic scope. C<$+[0]> is
+the offset into the string of the end of the entire match. This
+is the same value as what the C<pos> function returns when called
+on the variable that was matched against. The I<n>th element
+of this array holds the offset of the I<n>th submatch, so
+C<$+[1]> is the offset past where $1 ends, C<$+[2]> the offset
+past where $2 ends, and so on. You can use C<$#+> to determine
+how many subgroups were in the last successful match. See the
+examples given for the C<@-> variable.
=item $MULTILINE_MATCHING
may be different from the actual physical line number in the file,
depending on what notion of "line" is in effect--see C<$/> on how
to change that. An explicit close on a filehandle resets the line
-number. Because C<E<lt>E<gt>> never does an explicit close, line
+number. Because C<< <> >> never does an explicit close, line
numbers increase across ARGV files (but see examples in L<perlfunc/eof>).
Consider this variable read-only: setting it does not reposition
the seek pointer; you'll have to do that on your own. Localizing C<$.>
Used with formats.
(Mnemonic: lines_on_page - lines_printed.)
+=item @LAST_MATCH_START
+
=item @-
$-[0] is the offset of the start of the last successful match.
Thus after a match against $_, $& coincides with C<substr $_, $-[0],
$+[0] - $-[0]>. Similarly, C<$>I<n> coincides with C<substr $_, $-[>I<n>C<],
$+[>I<n>C<] - $-[>I<n>C<]> if C<$-[>I<n>C<]> is defined, and $+ coincides with
-C<substr $_, $-[$#-], $+[$#-]>. One can use C<$#E<45>> to find the last
+C<substr $_, $-[$#-], $+[$#-]>. One can use C<$#-> to find the last
matched subgroup in the last successful match. Contrast with
C<$#+>, the number of subgroups in the regular expression. Compare
with C<@+>.
+This array holds the offsets of the beginnings of the last
+successful submatches in the currently active dynamic scope.
+C<$-[0]> is the offset into the string of the beginning of the
+entire match. The I<n>th element of this array holds the offset
+of the I<n>th submatch, so C<$+[1]> is the offset where $1
+begins, C<$+[2]> the offset where $2 begins, and so on.
+You can use C<$#-> to determine how many subgroups were in the
+last successful match. Compare with the C<@+> variable.
+
+After a match against some variable $var:
+
+=over 5
+
+=item C<$`> is the same as C<substr($var, 0, $-[0])>
+
+=item C<$&> is the same as C<substr($var, $-[0], $+[0] - $-[0])>
+
+=item C<$'> is the same as C<substr($var, $+[0])>
+
+=item C<$1> is the same as C<substr($var, $-[1], $+[1] - $-[1])>
+
+=item C<$2> is the same as C<substr($var, $-[2], $+[2] - $-[2])>
+
+=item C<$3> is the same as C<substr $var, $-[3], $+[3] - $-[3])>
+
+=back
+
=item format_name HANDLE EXPR
=item $FORMAT_NAME
successful call to wait() or waitpid(), or from the system()
operator. This is just the 16-bit status word returned by the
wait() system call (or else is made up to look like it). Thus, the
-exit value of the subprocess is really (C<$? E<gt>E<gt> 8>), and
+exit value of the subprocess is really (C<<< $? >> 8 >>>), and
C<$? & 127> gives which signal, if any, the process died from, and
C<$? & 128> reports whether there was a core dump. (Mnemonic:
similar to B<sh> and B<ksh>.)
($<,$>) = ($>,$<); # swap real and effective uid
(Mnemonic: it's the uid you went I<to>, if you're running setuid.)
-C<$E<lt>> and C<$E<gt>> can be swapped only on machines
+C<< $< >> and C<< $> >> can be swapped only on machines
supporting setreuid().
=item $REAL_GROUP_ID
(Mnemonic: parentheses are used to I<group> things. The effective gid
is the group that's I<right> for you, if you're running setgid.)
-C<$E<lt>>, C<$E<gt>>, C<$(> and C<$)> can be set only on
+C<< $< >>, C<< $> >>, C<$(> and C<$)> can be set only on
machines that support the corresponding I<set[re][ug]id()> routine. C<$(>
and C<$)> can be swapped only on machines supporting setregid().
directive, and cannot influence the behavior of any other file.
Its use is highly discouraged.
-=item $PERL_VERSION
-
=item $]
The version + patchlevel / 1000 of the Perl interpreter. This variable
See also the documentation of C<use VERSION> and C<require VERSION>
for a convenient way to fail if the running Perl interpreter is too old.
-See C<$^V> for a more modern representation of the Perl version.
+The use of this variable is deprecated. The floating point representation
+can sometimes lead to inaccurate numeric comparisons. See C<$^V> for a
+more modern representation of the Perl version that allows accurate string
+comparisons.
=item $COMPILING
preserved even if the open() fails. (Ordinary file descriptors are
closed before the open() is attempted.) The close-on-exec
status of a file descriptor will be decided according to the value of
-C<$^F> when the open() or pipe() was called, not the time of the exec().
+C<$^F> when the corresponding file, pipe, or socket was opened, not the
+time of the exec().
=item $^H
$^M = 'a' x (1 << 16);
-would allocate a 64K buffer for use when in emergency. See the
+would allocate a 64K buffer for use in an emergency. See the
F<INSTALL> file in the Perl distribution for information on how to
enable this option. To discourage casual use of this advanced
feature, there is no L<English> long name for this variable.
Some bits may be relevant at compile-time only, some at
run-time only. This is a new mechanism and the details may change.
+=item $LAST_REGEXP_CODE_RESULT
+
=item $^R
The result of evaluation of the last successful C<(?{ code })>
regular expression assertion (see L<perlre>). May be written to.
+=item $EXCEPTIONS_BEING_CAUGHT
+
=item $^S
Current state of the interpreter. Undefined if parsing of the current
epoch (beginning of 1970). The values returned by the B<-M>, B<-A>,
and B<-C> filetests are based on this value.
+=item $PERL_VERSION
+
=item $^V
The revision, version, and subversion of the Perl interpreter, represented
-as a "version tuple". Version tuples have both a numeric value and a
-string value. The numeric value is a floating point number that amounts
-to revision + version/1000 + subversion/1000000, and the string value
-is made of characters possibly in the UTF-8 range:
-C<chr($revision) . chr($version) . chr($subversion)>.
+as a string composed of characters with those ordinals. Thus in Perl v5.6.0
+it equals C<chr(5) . chr(6) . chr(0)> and will return true for
+C<$^V eq v5.6.0>. Note that the characters in this string value can
+potentially be in Unicode range.
This can be used to determine whether the Perl interpreter executing a
script is in the right range of versions. (Mnemonic: use ^V for Version
-control.) Example:
+Control.) Example:
- warn "No "our" declarations!\n" if $^V and $^V lt v5.6;
+ warn "No "our" declarations!\n" if $^V and $^V lt v5.6.0;
-See also the documentation of C<use VERSION> and C<require VERSION>
+See the documentation of C<use VERSION> and C<require VERSION>
for a convenient way to fail if the running Perl interpreter is too old.
See also C<$]> for an older representation of the Perl version.
earlier than 5.6, but may be automatically set to C<1> by Perl if the system
provides a user-settable default (e.g., C<$ENV{LC_CTYPE}>).
-The C<byte> pragma always overrides the effect of this flag in the current
-lexical scope. See L<byte>.
+The C<bytes> pragma always overrides the effect of this flag in the current
+lexical scope. See L<bytes>.
=item $EXECUTABLE_NAME
=item $ARGV
-contains the name of the current file when reading from E<lt>E<gt>.
+contains the name of the current file when reading from <>.
=item @ARGV
(which will interpolate C<$!> and C<$?>!). (See also L<Fatal>,
though.)
-When the eval() expression above is executed, open(), C<<PIPEE<gt>>,
+When the eval() expression above is executed, open(), C<< <PIPE> >>,
and C<close> are translated to calls in the C run-time library and
thence to the operating system kernel. C<$!> is set to the C library's
C<errno> if one of these calls fails.
in the scope of C<use English>. For that reason, saying C<use
English> in libraries is strongly discouraged. See the
Devel::SawAmpersand module documentation from CPAN
-(http://www.perl.com/CPAN/modules/by-module/Devel/Devel-SawAmpersand-0.10.readme)
+(http://www.perl.com/CPAN/modules/by-module/Devel/)
for more information.
Having to even think about the C<$^S> variable in your exception
projects / p5sagit/p5-mst-13.2.git / blobdiff