This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
AutoLoader: Remove AutoLoader::can
[perl5.git] / pod / perlvar.pod
CommitLineData
a0d0e21e
LW
1=head1 NAME
2
3perlvar - Perl predefined variables
4
5=head1 DESCRIPTION
6
7=head2 Predefined Names
8
5a964f20 9The following names have special meaning to Perl. Most
14218588
GS
10punctuation names have reasonable mnemonics, or analogs in the
11shells. Nevertheless, if you wish to use long variable names,
12you need only say
a0d0e21e
LW
13
14 use English;
15
a1ce9542
JF
16at the top of your program. This aliases all the short names to the long
17names in the current package. Some even have medium names, generally
18borrowed from B<awk>. In general, it's best to use the
a0d0e21e 19
a1ce9542
JF
20 use English '-no_match_vars';
21
22invocation if you don't need $PREMATCH, $MATCH, or $POSTMATCH, as it avoids
23a certain performance hit with the use of regular expressions. See
24L<English>.
25
26Variables that depend on the currently selected filehandle may be set by
27calling an appropriate object method on the IO::Handle object, although
28this is less efficient than using the regular built-in variables. (Summary
29lines below for this contain the word HANDLE.) First you must say
a0d0e21e 30
19799a22 31 use IO::Handle;
a0d0e21e
LW
32
33after which you may use either
34
35 method HANDLE EXPR
36
5a964f20 37or more safely,
a0d0e21e
LW
38
39 HANDLE->method(EXPR)
40
14218588 41Each method returns the old value of the IO::Handle attribute.
a1ce9542 42The methods each take an optional EXPR, which, if supplied, specifies the
19799a22 43new value for the IO::Handle attribute in question. If not supplied,
14218588 44most methods do nothing to the current value--except for
a0d0e21e 45autoflush(), which will assume a 1 for you, just to be different.
a1ce9542 46
14218588 47Because loading in the IO::Handle class is an expensive operation, you should
19799a22 48learn how to use the regular built-in variables.
a0d0e21e 49
748a9306
LW
50A few of these variables are considered "read-only". This means that if
51you try to assign to this variable, either directly or indirectly through
52a reference, you'll raise a run-time exception.
a0d0e21e 53
22d0716c
SB
54You should be very careful when modifying the default values of most
55special variables described in this document. In most cases you want
56to localize these variables before changing them, since if you don't,
57the change may affect other modules which rely on the default values
58of the special variables that you have changed. This is one of the
59correct ways to read the whole file at once:
60
61 open my $fh, "foo" or die $!;
62 local $/; # enable localized slurp mode
63 my $content = <$fh>;
64 close $fh;
65
66But the following code is quite bad:
67
68 open my $fh, "foo" or die $!;
69 undef $/; # enable slurp mode
70 my $content = <$fh>;
71 close $fh;
72
73since some other module, may want to read data from some file in the
74default "line mode", so if the code we have just presented has been
75executed, the global value of C<$/> is now changed for any other code
76running inside the same Perl interpreter.
77
78Usually when a variable is localized you want to make sure that this
79change affects the shortest scope possible. So unless you are already
80inside some short C<{}> block, you should create one yourself. For
81example:
82
83 my $content = '';
84 open my $fh, "foo" or die $!;
85 {
86 local $/;
87 $content = <$fh>;
88 }
89 close $fh;
90
91Here is an example of how your own code can go broken:
92
93 for (1..5){
94 nasty_break();
95 print "$_ ";
96 }
97 sub nasty_break {
98 $_ = 5;
99 # do something with $_
100 }
101
102You probably expect this code to print:
103
104 1 2 3 4 5
105
106but instead you get:
107
108 5 5 5 5 5
109
110Why? Because nasty_break() modifies C<$_> without localizing it
111first. The fix is to add local():
112
113 local $_ = 5;
114
115It's easy to notice the problem in such a short example, but in more
116complicated code you are looking for trouble if you don't localize
117changes to the special variables.
118
fb73857a 119The following list is ordered by scalar variables first, then the
87275199 120arrays, then the hashes.
fb73857a 121
a0d0e21e
LW
122=over 8
123
124=item $ARG
125
126=item $_
a054c801 127X<$_> X<$ARG>
a0d0e21e
LW
128
129The default input and pattern-searching space. The following pairs are
130equivalent:
131
19799a22 132 while (<>) {...} # equivalent only in while!
54310121 133 while (defined($_ = <>)) {...}
a0d0e21e
LW
134
135 /^Subject:/
136 $_ =~ /^Subject:/
137
138 tr/a-z/A-Z/
139 $_ =~ tr/a-z/A-Z/
140
19799a22
GS
141 chomp
142 chomp($_)
a0d0e21e 143
54310121 144Here are the places where Perl will assume $_ even if you
cb1a09d0
AD
145don't use it:
146
147=over 3
148
149=item *
150
db1511c8
GS
151The following functions:
152
153abs, alarm, chomp chop, chr, chroot, cos, defined, eval, exp, glob,
154hex, int, lc, lcfirst, length, log, lstat, mkdir, ord, pos, print,
155quotemeta, readlink, readpipe, ref, require, reverse, rmdir, sin, split,
156sqrt, stat, study, uc, ucfirst, unlink, unpack.
cb1a09d0
AD
157
158=item *
159
db1511c8
GS
160All file tests (C<-f>, C<-d>) except for C<-t>, which defaults to STDIN.
161See L<perlfunc/-X>
162
cb1a09d0
AD
163
164=item *
165
166The pattern matching operations C<m//>, C<s///>, and C<tr///> when used
167without an C<=~> operator.
168
54310121 169=item *
cb1a09d0
AD
170
171The default iterator variable in a C<foreach> loop if no other
172variable is supplied.
173
54310121 174=item *
cb1a09d0
AD
175
176The implicit iterator variable in the grep() and map() functions.
177
54310121 178=item *
cb1a09d0 179
db1511c8
GS
180The implicit variable of given().
181
182=item *
183
c47ff5f1 184The default place to put an input record when a C<< <FH> >>
cb1a09d0 185operation's result is tested by itself as the sole criterion of a C<while>
14218588 186test. Outside a C<while> test, this will not happen.
cb1a09d0
AD
187
188=back
189
59f00321
RGS
190As C<$_> is a global variable, this may lead in some cases to unwanted
191side-effects. As of perl 5.9.1, you can now use a lexical version of
192C<$_> by declaring it in a file or in a block with C<my>. Moreover,
4fd88bf8 193declaring C<our $_> restores the global C<$_> in the current scope.
59f00321 194
a0d0e21e
LW
195(Mnemonic: underline is understood in certain operations.)
196
6e2995f4
PP
197=back
198
199=over 8
200
a1db74c9
JH
201=item $a
202
203=item $b
a054c801 204X<$a> X<$b>
a1db74c9
JH
205
206Special package variables when using sort(), see L<perlfunc/sort>.
207Because of this specialness $a and $b don't need to be declared
f83912f2
J
208(using use vars, or our()) even when using the C<strict 'vars'> pragma.
209Don't lexicalize them with C<my $a> or C<my $b> if you want to be
210able to use them in the sort() comparison block or function.
a1db74c9
JH
211
212=back
213
214=over 8
215
c47ff5f1 216=item $<I<digits>>
a054c801 217X<$1> X<$2> X<$3>
a0d0e21e 218
19799a22
GS
219Contains the subpattern from the corresponding set of capturing
220parentheses from the last pattern match, not counting patterns
221matched in nested blocks that have been exited already. (Mnemonic:
222like \digits.) These variables are all read-only and dynamically
223scoped to the current BLOCK.
a0d0e21e
LW
224
225=item $MATCH
226
227=item $&
a054c801 228X<$&> X<$MATCH>
a0d0e21e
LW
229
230The string matched by the last successful pattern match (not counting
231any matches hidden within a BLOCK or eval() enclosed by the current
19799a22
GS
232BLOCK). (Mnemonic: like & in some editors.) This variable is read-only
233and dynamically scoped to the current BLOCK.
a0d0e21e 234
19ddd453 235The use of this variable anywhere in a program imposes a considerable
667e1aea 236performance penalty on all regular expression matches. See L</BUGS>.
19ddd453 237
a054c801
GS
238See L</@-> for a replacement.
239
cde0cee5
YO
240=item ${^MATCH}
241X<${^MATCH}>
242
243This is similar to C<$&> (C<$POSTMATCH>) except that it does not incur the
244performance penalty associated with that variable, and is only guaranteed
245to return a defined value when the pattern was compiled or executed with
87e95b7f 246the C</p> modifier.
cde0cee5 247
a0d0e21e
LW
248=item $PREMATCH
249
250=item $`
a054c801 251X<$`> X<$PREMATCH>
a0d0e21e
LW
252
253The string preceding whatever was matched by the last successful
254pattern match (not counting any matches hidden within a BLOCK or eval
a8f8344d 255enclosed by the current BLOCK). (Mnemonic: C<`> often precedes a quoted
a0d0e21e
LW
256string.) This variable is read-only.
257
19ddd453 258The use of this variable anywhere in a program imposes a considerable
667e1aea 259performance penalty on all regular expression matches. See L</BUGS>.
19ddd453 260
a054c801
GS
261See L</@-> for a replacement.
262
cde0cee5
YO
263=item ${^PREMATCH}
264X<${^PREMATCH}>
265
266This is similar to C<$`> ($PREMATCH) except that it does not incur the
267performance penalty associated with that variable, and is only guaranteed
268to return a defined value when the pattern was compiled or executed with
87e95b7f 269the C</p> modifier.
cde0cee5 270
a0d0e21e
LW
271=item $POSTMATCH
272
273=item $'
a054c801 274X<$'> X<$POSTMATCH>
a0d0e21e
LW
275
276The string following whatever was matched by the last successful
277pattern match (not counting any matches hidden within a BLOCK or eval()
a8f8344d 278enclosed by the current BLOCK). (Mnemonic: C<'> often follows a quoted
a0d0e21e
LW
279string.) Example:
280
22d0716c 281 local $_ = 'abcdefghi';
a0d0e21e
LW
282 /def/;
283 print "$`:$&:$'\n"; # prints abc:def:ghi
284
19799a22 285This variable is read-only and dynamically scoped to the current BLOCK.
a0d0e21e 286
19ddd453 287The use of this variable anywhere in a program imposes a considerable
667e1aea 288performance penalty on all regular expression matches. See L</BUGS>.
19ddd453 289
a054c801
GS
290See L</@-> for a replacement.
291
cde0cee5
YO
292=item ${^POSTMATCH}
293X<${^POSTMATCH}>
294
295This is similar to C<$'> (C<$POSTMATCH>) except that it does not incur the
296performance penalty associated with that variable, and is only guaranteed
297to return a defined value when the pattern was compiled or executed with
87e95b7f 298the C</p> modifier.
cde0cee5 299
a0d0e21e
LW
300=item $LAST_PAREN_MATCH
301
302=item $+
a054c801 303X<$+> X<$LAST_PAREN_MATCH>
a0d0e21e 304
a01268b5
JH
305The text matched by the last bracket of the last successful search pattern.
306This is useful if you don't know which one of a set of alternative patterns
307matched. For example:
a0d0e21e
LW
308
309 /Version: (.*)|Revision: (.*)/ && ($rev = $+);
310
311(Mnemonic: be positive and forward looking.)
19799a22 312This variable is read-only and dynamically scoped to the current BLOCK.
a0d0e21e 313
daaddde1
MS
314=item $LAST_SUBMATCH_RESULT
315
a01268b5 316=item $^N
a054c801 317X<$^N>
a01268b5
JH
318
319The text matched by the used group most-recently closed (i.e. the group
320with the rightmost closing parenthesis) of the last successful search
ad83b128
PN
321pattern. (Mnemonic: the (possibly) Nested parenthesis that most
322recently closed.)
323
210b36aa 324This is primarily used inside C<(?{...})> blocks for examining text
a01268b5
JH
325recently matched. For example, to effectively capture text to a variable
326(in addition to C<$1>, C<$2>, etc.), replace C<(...)> with
327
328 (?:(...)(?{ $var = $^N }))
329
330By setting and then using C<$var> in this way relieves you from having to
331worry about exactly which numbered set of parentheses they are.
332
333This variable is dynamically scoped to the current BLOCK.
334
fe307981
GS
335=item @LAST_MATCH_END
336
6cef1e77 337=item @+
a054c801 338X<@+> X<@LAST_MATCH_END>
6cef1e77 339
4ba05bdc
GS
340This array holds the offsets of the ends of the last successful
341submatches in the currently active dynamic scope. C<$+[0]> is
342the offset into the string of the end of the entire match. This
343is the same value as what the C<pos> function returns when called
344on the variable that was matched against. The I<n>th element
345of this array holds the offset of the I<n>th submatch, so
346C<$+[1]> is the offset past where $1 ends, C<$+[2]> the offset
347past where $2 ends, and so on. You can use C<$#+> to determine
348how many subgroups were in the last successful match. See the
349examples given for the C<@-> variable.
6cef1e77 350
81714fb9
YO
351=item %+
352X<%+>
353
354Similar to C<@+>, the C<%+> hash allows access to the named capture
355buffers, should they exist, in the last successful match in the
356currently active dynamic scope.
357
3195cf34 358For example, C<$+{foo}> is equivalent to C<$1> after the following match:
81714fb9 359
3195cf34 360 'foo' =~ /(?<foo>foo)/;
81714fb9 361
3195cf34
RGS
362The keys of the C<%+> hash list only the names of buffers that have
363captured (and that are thus associated to defined values).
44a2ac75 364
3195cf34 365The underlying behaviour of C<%+> is provided by the
80305961 366L<Tie::Hash::NamedCapture> module.
3195cf34
RGS
367
368B<Note:> C<%-> and C<%+> are tied views into a common internal hash
44a2ac75
YO
369associated with the last successful regular expression. Therefore mixing
370iterative access to them via C<each> may have unpredictable results.
3195cf34 371Likewise, if the last successful match changes, then the results may be
44a2ac75
YO
372surprising.
373
fcc7d916 374=item HANDLE->input_line_number(EXPR)
a0d0e21e
LW
375
376=item $INPUT_LINE_NUMBER
377
378=item $NR
379
380=item $.
a054c801 381X<$.> X<$NR> X<$INPUT_LINE_NUMBER> X<line number>
a0d0e21e 382
81714fb9 383Current line number for the last filehandle accessed.
fcc7d916
IK
384
385Each filehandle in Perl counts the number of lines that have been read
386from it. (Depending on the value of C<$/>, Perl's idea of what
387constitutes a line may not match yours.) When a line is read from a
388filehandle (via readline() or C<< <> >>), or when tell() or seek() is
389called on it, C<$.> becomes an alias to the line counter for that
390filehandle.
391
392You can adjust the counter by assigning to C<$.>, but this will not
393actually move the seek pointer. I<Localizing C<$.> will not localize
394the filehandle's line count>. Instead, it will localize perl's notion
395of which filehandle C<$.> is currently aliased to.
396
397C<$.> is reset when the filehandle is closed, but B<not> when an open
398filehandle is reopened without an intervening close(). For more
e48df184 399details, see L<perlop/"IE<sol>O Operators">. Because C<< <> >> never does
fcc7d916
IK
400an explicit close, line numbers increase across ARGV files (but see
401examples in L<perlfunc/eof>).
402
403You can also use C<< HANDLE->input_line_number(EXPR) >> to access the
404line counter for a given filehandle without having to worry about
405which handle you last accessed.
406
407(Mnemonic: many programs use "." to mean the current line number.)
408
409=item IO::Handle->input_record_separator(EXPR)
a0d0e21e
LW
410
411=item $INPUT_RECORD_SEPARATOR
412
413=item $RS
414
415=item $/
a054c801 416X<$/> X<$RS> X<$INPUT_RECORD_SEPARATOR>
a0d0e21e 417
14218588
GS
418The input record separator, newline by default. This
419influences Perl's idea of what a "line" is. Works like B<awk>'s RS
19799a22 420variable, including treating empty lines as a terminator if set to
14218588
GS
421the null string. (An empty line cannot contain any spaces
422or tabs.) You may set it to a multi-character string to match a
19799a22
GS
423multi-character terminator, or to C<undef> to read through the end
424of file. Setting it to C<"\n\n"> means something slightly
425different than setting to C<"">, if the file contains consecutive
426empty lines. Setting to C<""> will treat two or more consecutive
427empty lines as a single empty line. Setting to C<"\n\n"> will
428blindly assume that the next input character belongs to the next
14218588 429paragraph, even if it's a newline. (Mnemonic: / delimits
19799a22 430line boundaries when quoting poetry.)
a0d0e21e 431
22d0716c
SB
432 local $/; # enable "slurp" mode
433 local $_ = <FH>; # whole file now here
a0d0e21e
LW
434 s/\n[ \t]+/ /g;
435
19799a22
GS
436Remember: the value of C<$/> is a string, not a regex. B<awk> has to be
437better for something. :-)
68dc0745 438
19799a22
GS
439Setting C<$/> to a reference to an integer, scalar containing an integer, or
440scalar that's convertible to an integer will attempt to read records
5b2b9c68 441instead of lines, with the maximum record size being the referenced
19799a22 442integer. So this:
5b2b9c68 443
22d0716c
SB
444 local $/ = \32768; # or \"32768", or \$var_containing_32768
445 open my $fh, $myfile or die $!;
446 local $_ = <$fh>;
5b2b9c68 447
19799a22
GS
448will read a record of no more than 32768 bytes from FILE. If you're
449not reading from a record-oriented file (or your OS doesn't have
450record-oriented files), then you'll likely get a full chunk of data
451with every read. If a record is larger than the record size you've
acbd132f
JH
452set, you'll get the record back in pieces. Trying to set the record
453size to zero or less will cause reading in the (rest of the) whole file.
5b2b9c68 454
19799a22
GS
455On VMS, record reads are done with the equivalent of C<sysread>,
456so it's best not to mix record and non-record reads on the same
457file. (This is unlikely to be a problem, because any file you'd
83763826 458want to read in record mode is probably unusable in line mode.)
14218588 459Non-VMS systems do normal I/O, so it's safe to mix record and
19799a22 460non-record reads of a file.
5b2b9c68 461
14218588 462See also L<perlport/"Newlines">. Also see C<$.>.
883faa13 463
fcc7d916 464=item HANDLE->autoflush(EXPR)
a0d0e21e
LW
465
466=item $OUTPUT_AUTOFLUSH
467
468=item $|
a054c801 469X<$|> X<autoflush> X<flush> X<$OUTPUT_AUTOFLUSH>
a0d0e21e 470
19799a22
GS
471If set to nonzero, forces a flush right away and after every write
472or print on the currently selected output channel. Default is 0
14218588 473(regardless of whether the channel is really buffered by the
19799a22
GS
474system or not; C<$|> tells you only whether you've asked Perl
475explicitly to flush after each write). STDOUT will
476typically be line buffered if output is to the terminal and block
477buffered otherwise. Setting this variable is useful primarily when
478you are outputting to a pipe or socket, such as when you are running
479a Perl program under B<rsh> and want to see the output as it's
480happening. This has no effect on input buffering. See L<perlfunc/getc>
481for that. (Mnemonic: when you want your pipes to be piping hot.)
a0d0e21e 482
46550894 483=item IO::Handle->output_field_separator EXPR
a0d0e21e
LW
484
485=item $OUTPUT_FIELD_SEPARATOR
486
487=item $OFS
488
489=item $,
a054c801 490X<$,> X<$OFS> X<$OUTPUT_FIELD_SEPARATOR>
a0d0e21e 491
d6584ed8
XN
492The output field separator for the print operator. If defined, this
493value is printed between each of print's arguments. Default is C<undef>.
494(Mnemonic: what is printed when there is a "," in your print statement.)
a0d0e21e 495
46550894 496=item IO::Handle->output_record_separator EXPR
a0d0e21e
LW
497
498=item $OUTPUT_RECORD_SEPARATOR
499
500=item $ORS
501
502=item $\
a054c801 503X<$\> X<$ORS> X<$OUTPUT_RECORD_SEPARATOR>
a0d0e21e 504
d6584ed8
XN
505The output record separator for the print operator. If defined, this
506value is printed after the last of print's arguments. Default is C<undef>.
507(Mnemonic: you set C<$\> instead of adding "\n" at the end of the print.
508Also, it's just like C<$/>, but it's what you get "back" from Perl.)
a0d0e21e
LW
509
510=item $LIST_SEPARATOR
511
512=item $"
a054c801 513X<$"> X<$LIST_SEPARATOR>
a0d0e21e 514
19799a22
GS
515This is like C<$,> except that it applies to array and slice values
516interpolated into a double-quoted string (or similar interpreted
517string). Default is a space. (Mnemonic: obvious, I think.)
a0d0e21e
LW
518
519=item $SUBSCRIPT_SEPARATOR
520
521=item $SUBSEP
522
523=item $;
a054c801 524X<$;> X<$SUBSEP> X<SUBSCRIPT_SEPARATOR>
a0d0e21e 525
54310121 526The subscript separator for multidimensional array emulation. If you
a0d0e21e
LW
527refer to a hash element as
528
529 $foo{$a,$b,$c}
530
531it really means
532
533 $foo{join($;, $a, $b, $c)}
534
535But don't put
536
537 @foo{$a,$b,$c} # a slice--note the @
538
539which means
540
541 ($foo{$a},$foo{$b},$foo{$c})
542
19799a22
GS
543Default is "\034", the same as SUBSEP in B<awk>. If your
544keys contain binary data there might not be any safe value for C<$;>.
a0d0e21e 545(Mnemonic: comma (the syntactic subscript separator) is a
19799a22 546semi-semicolon. Yeah, I know, it's pretty lame, but C<$,> is already
a0d0e21e
LW
547taken for something more important.)
548
19799a22
GS
549Consider using "real" multidimensional arrays as described
550in L<perllol>.
a0d0e21e 551
fcc7d916 552=item HANDLE->format_page_number(EXPR)
a0d0e21e
LW
553
554=item $FORMAT_PAGE_NUMBER
555
556=item $%
a054c801 557X<$%> X<$FORMAT_PAGE_NUMBER>
a0d0e21e
LW
558
559The current page number of the currently selected output channel.
19799a22 560Used with formats.
a0d0e21e
LW
561(Mnemonic: % is page number in B<nroff>.)
562
fcc7d916 563=item HANDLE->format_lines_per_page(EXPR)
a0d0e21e
LW
564
565=item $FORMAT_LINES_PER_PAGE
566
567=item $=
a054c801 568X<$=> X<$FORMAT_LINES_PER_PAGE>
a0d0e21e
LW
569
570The current page length (printable lines) of the currently selected
19799a22
GS
571output channel. Default is 60.
572Used with formats.
573(Mnemonic: = has horizontal lines.)
a0d0e21e 574
fcc7d916 575=item HANDLE->format_lines_left(EXPR)
a0d0e21e
LW
576
577=item $FORMAT_LINES_LEFT
578
579=item $-
a054c801 580X<$-> X<$FORMAT_LINES_LEFT>
a0d0e21e
LW
581
582The number of lines left on the page of the currently selected output
19799a22
GS
583channel.
584Used with formats.
585(Mnemonic: lines_on_page - lines_printed.)
a0d0e21e 586
fe307981
GS
587=item @LAST_MATCH_START
588
6cef1e77 589=item @-
a054c801 590X<@-> X<@LAST_MATCH_START>
6cef1e77 591
19799a22 592$-[0] is the offset of the start of the last successful match.
6cef1e77 593C<$-[>I<n>C<]> is the offset of the start of the substring matched by
8f580fb8 594I<n>-th subpattern, or undef if the subpattern did not match.
6cef1e77
IZ
595
596Thus after a match against $_, $& coincides with C<substr $_, $-[0],
5060ef7b
RGS
597$+[0] - $-[0]>. Similarly, $I<n> coincides with C<substr $_, $-[n],
598$+[n] - $-[n]> if C<$-[n]> is defined, and $+ coincides with
599C<substr $_, $-[$#-], $+[$#-] - $-[$#-]>. One can use C<$#-> to find the last
14218588
GS
600matched subgroup in the last successful match. Contrast with
601C<$#+>, the number of subgroups in the regular expression. Compare
19799a22 602with C<@+>.
6cef1e77 603
4ba05bdc
GS
604This array holds the offsets of the beginnings of the last
605successful submatches in the currently active dynamic scope.
606C<$-[0]> is the offset into the string of the beginning of the
607entire match. The I<n>th element of this array holds the offset
0926d669
JP
608of the I<n>th submatch, so C<$-[1]> is the offset where $1
609begins, C<$-[2]> the offset where $2 begins, and so on.
4ba05bdc
GS
610
611After a match against some variable $var:
612
613=over 5
614
4375e838 615=item C<$`> is the same as C<substr($var, 0, $-[0])>
4ba05bdc 616
4375e838 617=item C<$&> is the same as C<substr($var, $-[0], $+[0] - $-[0])>
4ba05bdc 618
4375e838 619=item C<$'> is the same as C<substr($var, $+[0])>
4ba05bdc
GS
620
621=item C<$1> is the same as C<substr($var, $-[1], $+[1] - $-[1])>
622
623=item C<$2> is the same as C<substr($var, $-[2], $+[2] - $-[2])>
624
80dc6883 625=item C<$3> is the same as C<substr($var, $-[3], $+[3] - $-[3])>
4ba05bdc
GS
626
627=back
628
44a2ac75
YO
629=item %-
630X<%->
631
3195cf34
RGS
632Similar to C<%+>, this variable allows access to the named capture buffers
633in the last successful match in the currently active dynamic scope. To
634each capture buffer name found in the regular expression, it associates a
635reference to an array containing the list of values captured by all
636buffers with that name (should there be several of them), in the order
637where they appear.
638
639Here's an example:
44a2ac75 640
3195cf34
RGS
641 if ('1234' =~ /(?<A>1)(?<B>2)(?<A>3)(?<B>4)/) {
642 foreach my $bufname (sort keys %-) {
643 my $ary = $-{$bufname};
44a2ac75 644 foreach my $idx (0..$#$ary) {
3195cf34 645 print "\$-{$bufname}[$idx] : ",
44a2ac75
YO
646 (defined($ary->[$idx]) ? "'$ary->[$idx]'" : "undef"),
647 "\n";
648 }
649 }
650 }
651
652would print out:
653
654 $-{A}[0] : '1'
655 $-{A}[1] : '3'
656 $-{B}[0] : '2'
657 $-{B}[1] : '4'
658
3195cf34
RGS
659The keys of the C<%-> hash correspond to all buffer names found in
660the regular expression.
661
662The behaviour of C<%-> is implemented via the
80305961 663L<Tie::Hash::NamedCapture> module.
44a2ac75 664
3195cf34 665B<Note:> C<%-> and C<%+> are tied views into a common internal hash
44a2ac75
YO
666associated with the last successful regular expression. Therefore mixing
667iterative access to them via C<each> may have unpredictable results.
3195cf34 668Likewise, if the last successful match changes, then the results may be
44a2ac75
YO
669surprising.
670
fcc7d916 671=item HANDLE->format_name(EXPR)
a0d0e21e
LW
672
673=item $FORMAT_NAME
674
675=item $~
a054c801 676X<$~> X<$FORMAT_NAME>
a0d0e21e
LW
677
678The name of the current report format for the currently selected output
14218588 679channel. Default is the name of the filehandle. (Mnemonic: brother to
19799a22 680C<$^>.)
a0d0e21e 681
fcc7d916 682=item HANDLE->format_top_name(EXPR)
a0d0e21e
LW
683
684=item $FORMAT_TOP_NAME
685
686=item $^
a054c801 687X<$^> X<$FORMAT_TOP_NAME>
a0d0e21e
LW
688
689The name of the current top-of-page format for the currently selected
14218588 690output channel. Default is the name of the filehandle with _TOP
a0d0e21e
LW
691appended. (Mnemonic: points to top of page.)
692
46550894 693=item IO::Handle->format_line_break_characters EXPR
a0d0e21e
LW
694
695=item $FORMAT_LINE_BREAK_CHARACTERS
696
697=item $:
a054c801 698X<$:> X<FORMAT_LINE_BREAK_CHARACTERS>
a0d0e21e
LW
699
700The current set of characters after which a string may be broken to
54310121 701fill continuation fields (starting with ^) in a format. Default is
a0d0e21e
LW
702S<" \n-">, to break on whitespace or hyphens. (Mnemonic: a "colon" in
703poetry is a part of a line.)
704
46550894 705=item IO::Handle->format_formfeed EXPR
a0d0e21e
LW
706
707=item $FORMAT_FORMFEED
708
709=item $^L
a054c801 710X<$^L> X<$FORMAT_FORMFEED>
a0d0e21e 711
14218588 712What formats output as a form feed. Default is \f.
a0d0e21e
LW
713
714=item $ACCUMULATOR
715
716=item $^A
a054c801 717X<$^A> X<$ACCUMULATOR>
a0d0e21e
LW
718
719The current value of the write() accumulator for format() lines. A format
19799a22 720contains formline() calls that put their result into C<$^A>. After
a0d0e21e 721calling its format, write() prints out the contents of C<$^A> and empties.
14218588 722So you never really see the contents of C<$^A> unless you call
a0d0e21e
LW
723formline() yourself and then look at it. See L<perlform> and
724L<perlfunc/formline()>.
725
726=item $CHILD_ERROR
727
728=item $?
a054c801 729X<$?> X<$CHILD_ERROR>
a0d0e21e 730
54310121 731The status returned by the last pipe close, backtick (C<``>) command,
19799a22
GS
732successful call to wait() or waitpid(), or from the system()
733operator. This is just the 16-bit status word returned by the
e5218da5 734traditional Unix wait() system call (or else is made up to look like it). Thus, the
c47ff5f1 735exit value of the subprocess is really (C<<< $? >> 8 >>>), and
19799a22
GS
736C<$? & 127> gives which signal, if any, the process died from, and
737C<$? & 128> reports whether there was a core dump. (Mnemonic:
738similar to B<sh> and B<ksh>.)
a0d0e21e 739
7b8d334a 740Additionally, if the C<h_errno> variable is supported in C, its value
14218588 741is returned via $? if any C<gethost*()> function fails.
7b8d334a 742
19799a22 743If you have installed a signal handler for C<SIGCHLD>, the
aa689395
PP
744value of C<$?> will usually be wrong outside that handler.
745
a8f8344d
PP
746Inside an C<END> subroutine C<$?> contains the value that is going to be
747given to C<exit()>. You can modify C<$?> in an C<END> subroutine to
19799a22
GS
748change the exit status of your program. For example:
749
750 END {
751 $? = 1 if $? == 255; # die would make it 255
752 }
a8f8344d 753
aa689395 754Under VMS, the pragma C<use vmsish 'status'> makes C<$?> reflect the
ff0cee69 755actual VMS exit status, instead of the default emulation of POSIX
9bc98430 756status; see L<perlvms/$?> for details.
f86702cc 757
55602bd2
IZ
758Also see L<Error Indicators>.
759
e5218da5 760=item ${^CHILD_ERROR_NATIVE}
a054c801 761X<$^CHILD_ERROR_NATIVE>
e5218da5
GA
762
763The native status returned by the last pipe close, backtick (C<``>)
764command, successful call to wait() or waitpid(), or from the system()
765operator. On POSIX-like systems this value can be decoded with the
766WIFEXITED, WEXITSTATUS, WIFSIGNALED, WTERMSIG, WIFSTOPPED, WSTOPSIG
767and WIFCONTINUED functions provided by the L<POSIX> module.
768
769Under VMS this reflects the actual VMS exit status; i.e. it is the same
770as $? when the pragma C<use vmsish 'status'> is in effect.
771
0a378802 772=item ${^ENCODING}
a054c801 773X<$^ENCODING>
0a378802 774
740bd165
PN
775The I<object reference> to the Encode object that is used to convert
776the source code to Unicode. Thanks to this variable your perl script
777does not have to be written in UTF-8. Default is I<undef>. The direct
749e08de 778manipulation of this variable is highly discouraged.
0a378802 779
a0d0e21e
LW
780=item $OS_ERROR
781
782=item $ERRNO
783
784=item $!
a054c801 785X<$!> X<$ERRNO> X<$OS_ERROR>
a0d0e21e 786
19799a22 787If used numerically, yields the current value of the C C<errno>
6ab308ee
JH
788variable, or in other words, if a system or library call fails, it
789sets this variable. This means that the value of C<$!> is meaningful
790only I<immediately> after a B<failure>:
791
792 if (open(FH, $filename)) {
793 # Here $! is meaningless.
794 ...
795 } else {
796 # ONLY here is $! meaningful.
797 ...
798 # Already here $! might be meaningless.
799 }
800 # Since here we might have either success or failure,
801 # here $! is meaningless.
802
803In the above I<meaningless> stands for anything: zero, non-zero,
804C<undef>. A successful system or library call does B<not> set
805the variable to zero.
806
271df126 807If used as a string, yields the corresponding system error string.
19799a22
GS
808You can assign a number to C<$!> to set I<errno> if, for instance,
809you want C<"$!"> to return the string for error I<n>, or you want
810to set the exit value for the die() operator. (Mnemonic: What just
811went bang?)
a0d0e21e 812
55602bd2
IZ
813Also see L<Error Indicators>.
814
daaddde1
MS
815=item %OS_ERROR
816
817=item %ERRNO
818
4c5cef9b 819=item %!
a054c801 820X<%!>
4c5cef9b
MJD
821
822Each element of C<%!> has a true value only if C<$!> is set to that
823value. For example, C<$!{ENOENT}> is true if and only if the current
3be065a1
JH
824value of C<$!> is C<ENOENT>; that is, if the most recent error was
825"No such file or directory" (or its moral equivalent: not all operating
826systems give that exact error, and certainly not all languages).
827To check if a particular key is meaningful on your system, use
828C<exists $!{the_key}>; for a list of legal keys, use C<keys %!>.
829See L<Errno> for more information, and also see above for the
830validity of C<$!>.
4c5cef9b 831
5c055ba3
PP
832=item $EXTENDED_OS_ERROR
833
834=item $^E
a054c801 835X<$^E> X<$EXTENDED_OS_ERROR>
5c055ba3 836
22fae026
TM
837Error information specific to the current operating system. At
838the moment, this differs from C<$!> under only VMS, OS/2, and Win32
839(and for MacPerl). On all other platforms, C<$^E> is always just
840the same as C<$!>.
841
842Under VMS, C<$^E> provides the VMS status value from the last
843system error. This is more specific information about the last
844system error than that provided by C<$!>. This is particularly
d516a115 845important when C<$!> is set to B<EVMSERR>.
22fae026 846
1c1c7f20
GS
847Under OS/2, C<$^E> is set to the error code of the last call to
848OS/2 API either via CRT, or directly from perl.
22fae026
TM
849
850Under Win32, C<$^E> always returns the last error information
851reported by the Win32 call C<GetLastError()> which describes
852the last error from within the Win32 API. Most Win32-specific
19799a22 853code will report errors via C<$^E>. ANSI C and Unix-like calls
22fae026
TM
854set C<errno> and so most portable Perl code will report errors
855via C<$!>.
856
857Caveats mentioned in the description of C<$!> generally apply to
858C<$^E>, also. (Mnemonic: Extra error explanation.)
5c055ba3 859
55602bd2
IZ
860Also see L<Error Indicators>.
861
a0d0e21e
LW
862=item $EVAL_ERROR
863
864=item $@
a054c801 865X<$@> X<$EVAL_ERROR>
a0d0e21e 866
4a280ebe
JG
867The Perl syntax error message from the last eval() operator.
868If $@ is the null string, the last eval() parsed and executed
869correctly (although the operations you invoked may have failed in the
870normal fashion). (Mnemonic: Where was the syntax error "at"?)
a0d0e21e 871
19799a22 872Warning messages are not collected in this variable. You can,
a8f8344d 873however, set up a routine to process warnings by setting C<$SIG{__WARN__}>
54310121 874as described below.
748a9306 875
55602bd2
IZ
876Also see L<Error Indicators>.
877
a0d0e21e
LW
878=item $PROCESS_ID
879
880=item $PID
881
882=item $$
a054c801 883X<$$> X<$PID> X<$PROCESS_ID>
a0d0e21e 884
19799a22
GS
885The process number of the Perl running this script. You should
886consider this variable read-only, although it will be altered
887across fork() calls. (Mnemonic: same as shells.)
a0d0e21e 888
4d76a344
RGS
889Note for Linux users: on Linux, the C functions C<getpid()> and
890C<getppid()> return different values from different threads. In order to
891be portable, this behavior is not reflected by C<$$>, whose value remains
892consistent across threads. If you want to call the underlying C<getpid()>,
e3256f86 893you may use the CPAN module C<Linux::Pid>.
4d76a344 894
a0d0e21e
LW
895=item $REAL_USER_ID
896
897=item $UID
898
899=item $<
a054c801 900X<< $< >> X<$UID> X<$REAL_USER_ID>
a0d0e21e 901
19799a22 902The real uid of this process. (Mnemonic: it's the uid you came I<from>,
a043a685 903if you're running setuid.) You can change both the real uid and
a537debe
SP
904the effective uid at the same time by using POSIX::setuid(). Since
905changes to $< require a system call, check $! after a change attempt to
906detect any possible errors.
a0d0e21e
LW
907
908=item $EFFECTIVE_USER_ID
909
910=item $EUID
911
912=item $>
a054c801 913X<< $> >> X<$EUID> X<$EFFECTIVE_USER_ID>
a0d0e21e
LW
914
915The effective uid of this process. Example:
916
917 $< = $>; # set real to effective uid
918 ($<,$>) = ($>,$<); # swap real and effective uid
919
a043a685 920You can change both the effective uid and the real uid at the same
a537debe
SP
921time by using POSIX::setuid(). Changes to $> require a check to $!
922to detect any possible errors after an attempted change.
a043a685 923
19799a22 924(Mnemonic: it's the uid you went I<to>, if you're running setuid.)
c47ff5f1 925C<< $< >> and C<< $> >> can be swapped only on machines
8cc95fdb 926supporting setreuid().
a0d0e21e
LW
927
928=item $REAL_GROUP_ID
929
930=item $GID
931
932=item $(
a054c801 933X<$(> X<$GID> X<$REAL_GROUP_ID>
a0d0e21e
LW
934
935The real gid of this process. If you are on a machine that supports
936membership in multiple groups simultaneously, gives a space separated
937list of groups you are in. The first number is the one returned by
938getgid(), and the subsequent ones by getgroups(), one of which may be
8cc95fdb
PP
939the same as the first number.
940
19799a22
GS
941However, a value assigned to C<$(> must be a single number used to
942set the real gid. So the value given by C<$(> should I<not> be assigned
2bc0d022
DL
943back to C<$(> without being forced numeric, such as by adding zero. Note
944that this is different to the effective gid (C<$)>) which does take a
945list.
8cc95fdb 946
a043a685 947You can change both the real gid and the effective gid at the same
a537debe
SP
948time by using POSIX::setgid(). Changes to $( require a check to $!
949to detect any possible errors after an attempted change.
a043a685 950
19799a22
GS
951(Mnemonic: parentheses are used to I<group> things. The real gid is the
952group you I<left>, if you're running setgid.)
a0d0e21e
LW
953
954=item $EFFECTIVE_GROUP_ID
955
956=item $EGID
957
958=item $)
a054c801 959X<$)> X<$EGID> X<$EFFECTIVE_GROUP_ID>
a0d0e21e
LW
960
961The effective gid of this process. If you are on a machine that
962supports membership in multiple groups simultaneously, gives a space
963separated list of groups you are in. The first number is the one
964returned by getegid(), and the subsequent ones by getgroups(), one of
8cc95fdb
PP
965which may be the same as the first number.
966
19799a22 967Similarly, a value assigned to C<$)> must also be a space-separated
14218588 968list of numbers. The first number sets the effective gid, and
8cc95fdb
PP
969the rest (if any) are passed to setgroups(). To get the effect of an
970empty list for setgroups(), just repeat the new effective gid; that is,
971to force an effective gid of 5 and an effectively empty setgroups()
972list, say C< $) = "5 5" >.
973
a043a685
GW
974You can change both the effective gid and the real gid at the same
975time by using POSIX::setgid() (use only a single numeric argument).
a537debe
SP
976Changes to $) require a check to $! to detect any possible errors
977after an attempted change.
a043a685 978
19799a22
GS
979(Mnemonic: parentheses are used to I<group> things. The effective gid
980is the group that's I<right> for you, if you're running setgid.)
a0d0e21e 981
c47ff5f1 982C<< $< >>, C<< $> >>, C<$(> and C<$)> can be set only on
19799a22
GS
983machines that support the corresponding I<set[re][ug]id()> routine. C<$(>
984and C<$)> can be swapped only on machines supporting setregid().
a0d0e21e
LW
985
986=item $PROGRAM_NAME
987
988=item $0
a054c801 989X<$0> X<$PROGRAM_NAME>
a0d0e21e 990
80bca1b4
JH
991Contains the name of the program being executed.
992
993On some (read: not all) operating systems assigning to C<$0> modifies
994the argument area that the C<ps> program sees. On some platforms you
995may have to use special C<ps> options or a different C<ps> to see the
996changes. Modifying the $0 is more useful as a way of indicating the
997current program state than it is for hiding the program you're
998running. (Mnemonic: same as B<sh> and B<ksh>.)
f9cbb277 999
cf525c36 1000Note that there are platform specific limitations on the maximum
f9cbb277
JH
1001length of C<$0>. In the most extreme case it may be limited to the
1002space occupied by the original C<$0>.
a0d0e21e 1003
80bca1b4
JH
1004In some platforms there may be arbitrary amount of padding, for
1005example space characters, after the modified name as shown by C<ps>.
dda345b7 1006In some platforms this padding may extend all the way to the original
c80e2480
JH
1007length of the argument area, no matter what you do (this is the case
1008for example with Linux 2.2).
80bca1b4 1009
4bc88a62 1010Note for BSD users: setting C<$0> does not completely remove "perl"
6a4647a3
JH
1011from the ps(1) output. For example, setting C<$0> to C<"foobar"> may
1012result in C<"perl: foobar (perl)"> (whether both the C<"perl: "> prefix
1013and the " (perl)" suffix are shown depends on your exact BSD variant
1014and version). This is an operating system feature, Perl cannot help it.
4bc88a62 1015
e2975953
JH
1016In multithreaded scripts Perl coordinates the threads so that any
1017thread may modify its copy of the C<$0> and the change becomes visible
cf525c36 1018to ps(1) (assuming the operating system plays along). Note that
80bca1b4
JH
1019the view of C<$0> the other threads have will not change since they
1020have their own copies of it.
e2975953 1021
a0d0e21e 1022=item $[
a054c801 1023X<$[>
a0d0e21e
LW
1024
1025The index of the first element in an array, and of the first character
19799a22
GS
1026in a substring. Default is 0, but you could theoretically set it
1027to 1 to make Perl behave more like B<awk> (or Fortran) when
1028subscripting and when evaluating the index() and substr() functions.
1029(Mnemonic: [ begins subscripts.)
a0d0e21e 1030
19799a22
GS
1031As of release 5 of Perl, assignment to C<$[> is treated as a compiler
1032directive, and cannot influence the behavior of any other file.
f83ed198 1033(That's why you can only assign compile-time constants to it.)
19799a22 1034Its use is highly discouraged.
a0d0e21e 1035
f83ed198 1036Note that, unlike other compile-time directives (such as L<strict>),
af7a0647
RGS
1037assignment to C<$[> can be seen from outer lexical scopes in the same file.
1038However, you can use local() on it to strictly bind its value to a
f83ed198
RGS
1039lexical block.
1040
a0d0e21e 1041=item $]
a054c801 1042X<$]>
a0d0e21e 1043
54310121
PP
1044The version + patchlevel / 1000 of the Perl interpreter. This variable
1045can be used to determine whether the Perl interpreter executing a
1046script is in the right range of versions. (Mnemonic: Is this version
1047of perl in the right bracket?) Example:
a0d0e21e
LW
1048
1049 warn "No checksumming!\n" if $] < 3.019;
1050
54310121 1051See also the documentation of C<use VERSION> and C<require VERSION>
19799a22 1052for a convenient way to fail if the running Perl interpreter is too old.
a0d0e21e 1053
0c8d858b
MS
1054The floating point representation can sometimes lead to inaccurate
1055numeric comparisons. See C<$^V> for a more modern representation of
1056the Perl version that allows accurate string comparisons.
16070b82 1057
305aace0
NIS
1058=item $COMPILING
1059
1060=item $^C
a054c801 1061X<$^C> X<$COMPILING>
305aace0 1062
19799a22
GS
1063The current value of the flag associated with the B<-c> switch.
1064Mainly of use with B<-MO=...> to allow code to alter its behavior
1065when being compiled, such as for example to AUTOLOAD at compile
59f521f4 1066time rather than normal, deferred loading. Setting
19799a22 1067C<$^C = 1> is similar to calling C<B::minus_c>.
305aace0 1068
a0d0e21e
LW
1069=item $DEBUGGING
1070
1071=item $^D
a054c801 1072X<$^D> X<$DEBUGGING>
a0d0e21e
LW
1073
1074The current value of the debugging flags. (Mnemonic: value of B<-D>
b4ab917c
DM
1075switch.) May be read or set. Like its command-line equivalent, you can use
1076numeric or symbolic values, eg C<$^D = 10> or C<$^D = "st">.
a0d0e21e 1077
a3621e74
YO
1078=item ${^RE_DEBUG_FLAGS}
1079
1080The current value of the regex debugging flags. Set to 0 for no debug output
1081even when the re 'debug' module is loaded. See L<re> for details.
1082
0111c4fd 1083=item ${^RE_TRIE_MAXBUF}
a3621e74
YO
1084
1085Controls how certain regex optimisations are applied and how much memory they
1086utilize. This value by default is 65536 which corresponds to a 512kB temporary
1087cache. Set this to a higher value to trade memory for speed when matching
1088large alternations. Set it to a lower value if you want the optimisations to
1089be as conservative of memory as possible but still occur, and set it to a
1090negative value to prevent the optimisation and conserve the most memory.
1091Under normal situations this variable should be of no interest to you.
1092
a0d0e21e
LW
1093=item $SYSTEM_FD_MAX
1094
1095=item $^F
a054c801 1096X<$^F> X<$SYSTEM_FD_MAX>
a0d0e21e
LW
1097
1098The maximum system file descriptor, ordinarily 2. System file
1099descriptors are passed to exec()ed processes, while higher file
1100descriptors are not. Also, during an open(), system file descriptors are
1101preserved even if the open() fails. (Ordinary file descriptors are
19799a22 1102closed before the open() is attempted.) The close-on-exec
a0d0e21e 1103status of a file descriptor will be decided according to the value of
8d2a6795
GS
1104C<$^F> when the corresponding file, pipe, or socket was opened, not the
1105time of the exec().
a0d0e21e 1106
6e2995f4
PP
1107=item $^H
1108
0462a1ab
GS
1109WARNING: This variable is strictly for internal use only. Its availability,
1110behavior, and contents are subject to change without notice.
1111
1112This variable contains compile-time hints for the Perl interpreter. At the
1113end of compilation of a BLOCK the value of this variable is restored to the
1114value when the interpreter started to compile the BLOCK.
1115
1116When perl begins to parse any block construct that provides a lexical scope
1117(e.g., eval body, required file, subroutine body, loop body, or conditional
1118block), the existing value of $^H is saved, but its value is left unchanged.
1119When the compilation of the block is completed, it regains the saved value.
1120Between the points where its value is saved and restored, code that
1121executes within BEGIN blocks is free to change the value of $^H.
1122
1123This behavior provides the semantic of lexical scoping, and is used in,
1124for instance, the C<use strict> pragma.
1125
1126The contents should be an integer; different bits of it are used for
1127different pragmatic flags. Here's an example:
1128
1129 sub add_100 { $^H |= 0x100 }
1130
1131 sub foo {
1132 BEGIN { add_100() }
1133 bar->baz($boon);
1134 }
1135
1136Consider what happens during execution of the BEGIN block. At this point
1137the BEGIN block has already been compiled, but the body of foo() is still
1138being compiled. The new value of $^H will therefore be visible only while
1139the body of foo() is being compiled.
1140
1141Substitution of the above BEGIN block with:
1142
1143 BEGIN { require strict; strict->import('vars') }
1144
1145demonstrates how C<use strict 'vars'> is implemented. Here's a conditional
1146version of the same lexical pragma:
1147
1148 BEGIN { require strict; strict->import('vars') if $condition }
1149
1150=item %^H
1151
0462a1ab 1152The %^H hash provides the same scoping semantic as $^H. This makes it
46e5f5f4 1153useful for implementation of lexically scoped pragmas. See L<perlpragma>.
6e2995f4 1154
a0d0e21e
LW
1155=item $INPLACE_EDIT
1156
1157=item $^I
a054c801 1158X<$^I> X<$INPLACE_EDIT>
a0d0e21e
LW
1159
1160The current value of the inplace-edit extension. Use C<undef> to disable
1161inplace editing. (Mnemonic: value of B<-i> switch.)
1162
fb73857a 1163=item $^M
a054c801 1164X<$^M>
fb73857a 1165
19799a22
GS
1166By default, running out of memory is an untrappable, fatal error.
1167However, if suitably built, Perl can use the contents of C<$^M>
1168as an emergency memory pool after die()ing. Suppose that your Perl
0acca065 1169were compiled with C<-DPERL_EMERGENCY_SBRK> and used Perl's malloc.
19799a22 1170Then
fb73857a 1171
19799a22 1172 $^M = 'a' x (1 << 16);
fb73857a 1173
51ee6500 1174would allocate a 64K buffer for use in an emergency. See the
19799a22 1175F<INSTALL> file in the Perl distribution for information on how to
0acca065
RGS
1176add custom C compilation flags when compiling perl. To discourage casual
1177use of this advanced feature, there is no L<English|English> long name for
1178this variable.
fb73857a 1179
5c055ba3 1180=item $OSNAME
6e2995f4 1181
5c055ba3 1182=item $^O
a054c801 1183X<$^O> X<$OSNAME>
5c055ba3
PP
1184
1185The name of the operating system under which this copy of Perl was
1186built, as determined during the configuration process. The value
19799a22
GS
1187is identical to C<$Config{'osname'}>. See also L<Config> and the
1188B<-V> command-line switch documented in L<perlrun>.
5c055ba3 1189
443f6d01 1190In Windows platforms, $^O is not very helpful: since it is always
7f510801
GS
1191C<MSWin32>, it doesn't tell the difference between
119295/98/ME/NT/2000/XP/CE/.NET. Use Win32::GetOSName() or
1193Win32::GetOSVersion() (see L<Win32> and L<perlport>) to distinguish
1194between the variants.
916d64a3 1195
e2e27056
JH
1196=item ${^OPEN}
1197
1198An internal variable used by PerlIO. A string in two parts, separated
fae2c0fb
RGS
1199by a C<\0> byte, the first part describes the input layers, the second
1200part describes the output layers.
e2e27056 1201
a0d0e21e
LW
1202=item $PERLDB
1203
1204=item $^P
a054c801 1205X<$^P> X<$PERLDB>
a0d0e21e 1206
19799a22
GS
1207The internal variable for debugging support. The meanings of the
1208various bits are subject to change, but currently indicate:
84902520
TB
1209
1210=over 6
1211
1212=item 0x01
1213
1214Debug subroutine enter/exit.
1215
1216=item 0x02
1217
1218Line-by-line debugging.
1219
1220=item 0x04
1221
1222Switch off optimizations.
1223
1224=item 0x08
1225
1226Preserve more data for future interactive inspections.
1227
1228=item 0x10
1229
1230Keep info about source lines on which a subroutine is defined.
1231
1232=item 0x20
1233
1234Start with single-step on.
1235
83ee9e09
GS
1236=item 0x40
1237
1238Use subroutine address instead of name when reporting.
1239
1240=item 0x80
1241
1242Report C<goto &subroutine> as well.
1243
1244=item 0x100
1245
1246Provide informative "file" names for evals based on the place they were compiled.
1247
1248=item 0x200
1249
1250Provide informative names to anonymous subroutines based on the place they
1251were compiled.
1252
7619c85e
RG
1253=item 0x400
1254
1255Debug assertion subroutines enter/exit.
1256
84902520
TB
1257=back
1258
19799a22
GS
1259Some bits may be relevant at compile-time only, some at
1260run-time only. This is a new mechanism and the details may change.
a0d0e21e 1261
66558a10
GS
1262=item $LAST_REGEXP_CODE_RESULT
1263
b9ac3b5b 1264=item $^R
a054c801 1265X<$^R> X<$LAST_REGEXP_CODE_RESULT>
b9ac3b5b 1266
19799a22
GS
1267The result of evaluation of the last successful C<(?{ code })>
1268regular expression assertion (see L<perlre>). May be written to.
b9ac3b5b 1269
66558a10
GS
1270=item $EXCEPTIONS_BEING_CAUGHT
1271
fb73857a 1272=item $^S
a054c801 1273X<$^S> X<$EXCEPTIONS_BEING_CAUGHT>
fb73857a 1274
fa05a9fd
IST
1275Current state of the interpreter.
1276
1277 $^S State
1278 --------- -------------------
1279 undef Parsing module/eval
1280 true (1) Executing an eval
1281 false (0) Otherwise
1282
1283The first state may happen in $SIG{__DIE__} and $SIG{__WARN__} handlers.
fb73857a 1284
a0d0e21e
LW
1285=item $BASETIME
1286
1287=item $^T
a054c801 1288X<$^T> X<$BASETIME>
a0d0e21e 1289
19799a22 1290The time at which the program began running, in seconds since the
5f05dabc 1291epoch (beginning of 1970). The values returned by the B<-M>, B<-A>,
19799a22 1292and B<-C> filetests are based on this value.
a0d0e21e 1293
7c36658b
MS
1294=item ${^TAINT}
1295
9aa05f58
RGS
1296Reflects if taint mode is on or off. 1 for on (the program was run with
1297B<-T>), 0 for off, -1 when only taint warnings are enabled (i.e. with
18e8c5b0 1298B<-t> or B<-TU>). This variable is read-only.
7c36658b 1299
a05d7ebb
JH
1300=item ${^UNICODE}
1301
ab9e1bb7
JH
1302Reflects certain Unicode settings of Perl. See L<perlrun>
1303documentation for the C<-C> switch for more information about
1304the possible values. This variable is set during Perl startup
1305and is thereafter read-only.
fde18df1 1306
e07ea26a
NC
1307=item ${^UTF8CACHE}
1308
1309This variable controls the state of the internal UTF-8 offset caching code.
16d9fe92
NC
13101 for on (the default), 0 for off, -1 to debug the caching code by checking
1311all its results against linear scans, and panicking on any discrepancy.
e07ea26a 1312
ea8eae40
RGS
1313=item ${^UTF8LOCALE}
1314
1315This variable indicates whether an UTF-8 locale was detected by perl at
1316startup. This information is used by perl when it's in
1317adjust-utf8ness-to-locale mode (as when run with the C<-CL> command-line
1318switch); see L<perlrun> for more info on this.
1319
44dcb63b 1320=item $PERL_VERSION
b459063d 1321
16070b82 1322=item $^V
a054c801 1323X<$^V> X<$PERL_VERSION>
16070b82
GS
1324
1325The revision, version, and subversion of the Perl interpreter, represented
a32521b7 1326as a C<version> object.
16070b82 1327
7d2b1222 1328This variable first appeared in perl 5.6.0; earlier versions of perl will
a32521b7 1329see an undefined value. Before perl 5.10.0 $^V was represented as a v-string.
7d2b1222 1330
a32521b7 1331$^V can be used to determine whether the Perl interpreter executing a
16070b82 1332script is in the right range of versions. (Mnemonic: use ^V for Version
44dcb63b 1333Control.) Example:
16070b82 1334
7d2b1222 1335 warn "Hashes not randomized!\n" if !$^V or $^V lt v5.8.1
16070b82 1336
aa2f2a36
AMS
1337To convert C<$^V> into its string representation use sprintf()'s
1338C<"%vd"> conversion:
1339
1340 printf "version is v%vd\n", $^V; # Perl's version
1341
44dcb63b 1342See the documentation of C<use VERSION> and C<require VERSION>
16070b82
GS
1343for a convenient way to fail if the running Perl interpreter is too old.
1344
1345See also C<$]> for an older representation of the Perl version.
1346
a0d0e21e
LW
1347=item $WARNING
1348
1349=item $^W
a054c801 1350X<$^W> X<$WARNING>
a0d0e21e 1351
19799a22
GS
1352The current value of the warning switch, initially true if B<-w>
1353was used, false otherwise, but directly modifiable. (Mnemonic:
4438c4b7
JH
1354related to the B<-w> switch.) See also L<warnings>.
1355
6a818117 1356=item ${^WARNING_BITS}
4438c4b7
JH
1357
1358The current set of warning checks enabled by the C<use warnings> pragma.
1359See the documentation of C<warnings> for more details.
a0d0e21e 1360
2a8c8378
JD
1361=item ${^WIN32_SLOPPY_STAT}
1362
1363If this variable is set to a true value, then stat() on Windows will
1364not try to open the file. This means that the link count cannot be
1365determined and file attributes may be out of date if additional
1366hardlinks to the file exist. On the other hand, not opening the file
1367is considerably faster, especially for files on network drives.
1368
1369This variable could be set in the F<sitecustomize.pl> file to
1370configure the local Perl installation to use "sloppy" stat() by
1371default. See L<perlrun> for more information about site
1372customization.
1373
a0d0e21e
LW
1374=item $EXECUTABLE_NAME
1375
1376=item $^X
a054c801 1377X<$^X> X<$EXECUTABLE_NAME>
a0d0e21e 1378
e71940de 1379The name used to execute the current copy of Perl, from C's
21c1191d 1380C<argv[0]> or (where supported) F</proc/self/exe>.
38e4f4ae 1381
e71940de
PG
1382Depending on the host operating system, the value of $^X may be
1383a relative or absolute pathname of the perl program file, or may
1384be the string used to invoke perl but not the pathname of the
1385perl program file. Also, most operating systems permit invoking
1386programs that are not in the PATH environment variable, so there
a10d74f3
PG
1387is no guarantee that the value of $^X is in PATH. For VMS, the
1388value may or may not include a version number.
38e4f4ae 1389
e71940de
PG
1390You usually can use the value of $^X to re-invoke an independent
1391copy of the same perl that is currently running, e.g.,
1392
1393 @first_run = `$^X -le "print int rand 100 for 1..100"`;
1394
1395But recall that not all operating systems support forking or
1396capturing of the output of commands, so this complex statement
1397may not be portable.
38e4f4ae 1398
e71940de
PG
1399It is not safe to use the value of $^X as a path name of a file,
1400as some operating systems that have a mandatory suffix on
1401executable files do not require use of the suffix when invoking
1402a command. To convert the value of $^X to a path name, use the
1403following statements:
1404
304dea91 1405 # Build up a set of file names (not command names).
e71940de 1406 use Config;
68fb0eb7
PG
1407 $this_perl = $^X;
1408 if ($^O ne 'VMS')
1409 {$this_perl .= $Config{_exe}
1410 unless $this_perl =~ m/$Config{_exe}$/i;}
e71940de
PG
1411
1412Because many operating systems permit anyone with read access to
1413the Perl program file to make a copy of it, patch the copy, and
1414then execute the copy, the security-conscious Perl programmer
1415should take care to invoke the installed copy of perl, not the
1416copy referenced by $^X. The following statements accomplish
1417this goal, and produce a pathname that can be invoked as a
1418command or referenced as a file.
38e4f4ae
SB
1419
1420 use Config;
68fb0eb7
PG
1421 $secure_perl_path = $Config{perlpath};
1422 if ($^O ne 'VMS')
1423 {$secure_perl_path .= $Config{_exe}
1424 unless $secure_perl_path =~ m/$Config{_exe}$/i;}
a0d0e21e 1425
2d84a16a 1426=item ARGV
a054c801 1427X<ARGV>
2d84a16a
DM
1428
1429The special filehandle that iterates over command-line filenames in
1430C<@ARGV>. Usually written as the null filehandle in the angle operator
1431C<< <> >>. Note that currently C<ARGV> only has its magical effect
1432within the C<< <> >> operator; elsewhere it is just a plain filehandle
1433corresponding to the last file opened by C<< <> >>. In particular,
1434passing C<\*ARGV> as a parameter to a function that expects a filehandle
1435may not cause your function to automatically read the contents of all the
1436files in C<@ARGV>.
1437
a0d0e21e 1438=item $ARGV
a054c801 1439X<$ARGV>
a0d0e21e 1440
c47ff5f1 1441contains the name of the current file when reading from <>.
a0d0e21e
LW
1442
1443=item @ARGV
a054c801 1444X<@ARGV>
a0d0e21e 1445
19799a22 1446The array @ARGV contains the command-line arguments intended for
14218588 1447the script. C<$#ARGV> is generally the number of arguments minus
19799a22
GS
1448one, because C<$ARGV[0]> is the first argument, I<not> the program's
1449command name itself. See C<$0> for the command name.
a0d0e21e 1450
5ccee41e 1451=item ARGVOUT
a054c801 1452X<ARGVOUT>
5ccee41e
JA
1453
1454The special filehandle that points to the currently open output file
1455when doing edit-in-place processing with B<-i>. Useful when you have
1456to do a lot of inserting and don't want to keep modifying $_. See
1457L<perlrun> for the B<-i> switch.
1458
9b0e6e7a 1459=item @F
a054c801 1460X<@F>
9b0e6e7a
JP
1461
1462The array @F contains the fields of each line read in when autosplit
1463mode is turned on. See L<perlrun> for the B<-a> switch. This array
1464is package-specific, and must be declared or given a full package name
1465if not in package main when running under C<strict 'vars'>.
1466
a0d0e21e 1467=item @INC
a054c801 1468X<@INC>
a0d0e21e 1469
19799a22
GS
1470The array @INC contains the list of places that the C<do EXPR>,
1471C<require>, or C<use> constructs look for their library files. It
1472initially consists of the arguments to any B<-I> command-line
1473switches, followed by the default Perl library, probably
1474F</usr/local/lib/perl>, followed by ".", to represent the current
e48df184
RGS
1475directory. ("." will not be appended if taint checks are enabled, either by
1476C<-T> or by C<-t>.) If you need to modify this at runtime, you should use
19799a22
GS
1477the C<use lib> pragma to get the machine-dependent library properly
1478loaded also:
a0d0e21e 1479
cb1a09d0
AD
1480 use lib '/mypath/libdir/';
1481 use SomeMod;
303f2f76 1482
d54b56d5
RGS
1483You can also insert hooks into the file inclusion system by putting Perl
1484code directly into @INC. Those hooks may be subroutine references, array
1485references or blessed objects. See L<perlfunc/require> for details.
1486
314d39ce
MG
1487=item @ARG
1488
fb73857a 1489=item @_
a054c801 1490X<@_> X<@ARG>
fb73857a
PP
1491
1492Within a subroutine the array @_ contains the parameters passed to that
19799a22 1493subroutine. See L<perlsub>.
fb73857a 1494
a0d0e21e 1495=item %INC
a054c801 1496X<%INC>
a0d0e21e 1497
19799a22
GS
1498The hash %INC contains entries for each filename included via the
1499C<do>, C<require>, or C<use> operators. The key is the filename
1500you specified (with module names converted to pathnames), and the
14218588 1501value is the location of the file found. The C<require>
87275199 1502operator uses this hash to determine whether a particular file has
19799a22 1503already been included.
a0d0e21e 1504
89ccab8c
RGS
1505If the file was loaded via a hook (e.g. a subroutine reference, see
1506L<perlfunc/require> for a description of these hooks), this hook is
9ae8cd5b
RGS
1507by default inserted into %INC in place of a filename. Note, however,
1508that the hook may have set the %INC entry by itself to provide some more
1509specific info.
44f0be63 1510
b687b08b
TC
1511=item %ENV
1512
1513=item $ENV{expr}
a054c801 1514X<%ENV>
a0d0e21e
LW
1515
1516The hash %ENV contains your current environment. Setting a
19799a22
GS
1517value in C<ENV> changes the environment for any child processes
1518you subsequently fork() off.
a0d0e21e 1519
b687b08b
TC
1520=item %SIG
1521
1522=item $SIG{expr}
a054c801 1523X<%SIG>
a0d0e21e 1524
efbd929d 1525The hash C<%SIG> contains signal handlers for signals. For example:
a0d0e21e
LW
1526
1527 sub handler { # 1st argument is signal name
fb73857a 1528 my($sig) = @_;
a0d0e21e
LW
1529 print "Caught a SIG$sig--shutting down\n";
1530 close(LOG);
1531 exit(0);
1532 }
1533
fb73857a
PP
1534 $SIG{'INT'} = \&handler;
1535 $SIG{'QUIT'} = \&handler;
a0d0e21e 1536 ...
19799a22 1537 $SIG{'INT'} = 'DEFAULT'; # restore default action
a0d0e21e
LW
1538 $SIG{'QUIT'} = 'IGNORE'; # ignore SIGQUIT
1539
f648820c
GS
1540Using a value of C<'IGNORE'> usually has the effect of ignoring the
1541signal, except for the C<CHLD> signal. See L<perlipc> for more about
1542this special case.
1543
19799a22 1544Here are some other examples:
a0d0e21e 1545
fb73857a 1546 $SIG{"PIPE"} = "Plumber"; # assumes main::Plumber (not recommended)
a0d0e21e 1547 $SIG{"PIPE"} = \&Plumber; # just fine; assume current Plumber
19799a22 1548 $SIG{"PIPE"} = *Plumber; # somewhat esoteric
a0d0e21e
LW
1549 $SIG{"PIPE"} = Plumber(); # oops, what did Plumber() return??
1550
19799a22
GS
1551Be sure not to use a bareword as the name of a signal handler,
1552lest you inadvertently call it.
748a9306 1553
44a8e56a 1554If your system has the sigaction() function then signal handlers are
9ce5b4ad 1555installed using it. This means you get reliable signal handling.
44a8e56a 1556
9ce5b4ad
SG
1557The default delivery policy of signals changed in Perl 5.8.0 from
1558immediate (also known as "unsafe") to deferred, also known as
1559"safe signals". See L<perlipc> for more information.
45c0772f 1560
748a9306 1561Certain internal hooks can be also set using the %SIG hash. The
a8f8344d 1562routine indicated by C<$SIG{__WARN__}> is called when a warning message is
748a9306 1563about to be printed. The warning message is passed as the first
efbd929d
AT
1564argument. The presence of a C<__WARN__> hook causes the ordinary printing
1565of warnings to C<STDERR> to be suppressed. You can use this to save warnings
748a9306
LW
1566in a variable, or turn warnings into fatal errors, like this:
1567
1568 local $SIG{__WARN__} = sub { die $_[0] };
1569 eval $proggie;
1570
efbd929d
AT
1571As the C<'IGNORE'> hook is not supported by C<__WARN__>, you can
1572disable warnings using the empty subroutine:
1573
1574 local $SIG{__WARN__} = sub {};
1575
a8f8344d 1576The routine indicated by C<$SIG{__DIE__}> is called when a fatal exception
748a9306 1577is about to be thrown. The error message is passed as the first
efbd929d 1578argument. When a C<__DIE__> hook routine returns, the exception
748a9306 1579processing continues as it would have in the absence of the hook,
efbd929d 1580unless the hook routine itself exits via a C<goto>, a loop exit, or a C<die()>.
774d564b 1581The C<__DIE__> handler is explicitly disabled during the call, so that you
fb73857a
PP
1582can die from a C<__DIE__> handler. Similarly for C<__WARN__>.
1583
19799a22
GS
1584Due to an implementation glitch, the C<$SIG{__DIE__}> hook is called
1585even inside an eval(). Do not use this to rewrite a pending exception
efbd929d 1586in C<$@>, or as a bizarre substitute for overriding C<CORE::GLOBAL::die()>.
19799a22
GS
1587This strange action at a distance may be fixed in a future release
1588so that C<$SIG{__DIE__}> is only called if your program is about
1589to exit, as was the original intent. Any other use is deprecated.
1590
1591C<__DIE__>/C<__WARN__> handlers are very special in one respect:
1592they may be called to report (probable) errors found by the parser.
1593In such a case the parser may be in inconsistent state, so any
1594attempt to evaluate Perl code from such a handler will probably
1595result in a segfault. This means that warnings or errors that
1596result from parsing Perl should be used with extreme caution, like
1597this:
fb73857a
PP
1598
1599 require Carp if defined $^S;
1600 Carp::confess("Something wrong") if defined &Carp::confess;
1601 die "Something wrong, but could not load Carp to give backtrace...
1602 To see backtrace try starting Perl with -MCarp switch";
1603
1604Here the first line will load Carp I<unless> it is the parser who
1605called the handler. The second line will print backtrace and die if
1606Carp was available. The third line will be executed only if Carp was
1607not available.
1608
19799a22 1609See L<perlfunc/die>, L<perlfunc/warn>, L<perlfunc/eval>, and
4438c4b7 1610L<warnings> for additional information.
68dc0745 1611
a0d0e21e 1612=back
55602bd2
IZ
1613
1614=head2 Error Indicators
a054c801 1615X<error> X<exception>
55602bd2 1616
19799a22
GS
1617The variables C<$@>, C<$!>, C<$^E>, and C<$?> contain information
1618about different types of error conditions that may appear during
1619execution of a Perl program. The variables are shown ordered by
1620the "distance" between the subsystem which reported the error and
1621the Perl process. They correspond to errors detected by the Perl
1622interpreter, C library, operating system, or an external program,
1623respectively.
55602bd2
IZ
1624
1625To illustrate the differences between these variables, consider the
19799a22 1626following Perl expression, which uses a single-quoted string:
55602bd2 1627
19799a22 1628 eval q{
22d0716c
SB
1629 open my $pipe, "/cdrom/install |" or die $!;
1630 my @res = <$pipe>;
1631 close $pipe or die "bad pipe: $?, $!";
19799a22 1632 };
55602bd2
IZ
1633
1634After execution of this statement all 4 variables may have been set.
1635
19799a22
GS
1636C<$@> is set if the string to be C<eval>-ed did not compile (this
1637may happen if C<open> or C<close> were imported with bad prototypes),
1638or if Perl code executed during evaluation die()d . In these cases
1639the value of $@ is the compile error, or the argument to C<die>
4cb1c523 1640(which will interpolate C<$!> and C<$?>). (See also L<Fatal>,
19799a22
GS
1641though.)
1642
c47ff5f1 1643When the eval() expression above is executed, open(), C<< <PIPE> >>,
19799a22
GS
1644and C<close> are translated to calls in the C run-time library and
1645thence to the operating system kernel. C<$!> is set to the C library's
1646C<errno> if one of these calls fails.
1647
1648Under a few operating systems, C<$^E> may contain a more verbose
1649error indicator, such as in this case, "CDROM tray not closed."
14218588 1650Systems that do not support extended error messages leave C<$^E>
19799a22
GS
1651the same as C<$!>.
1652
1653Finally, C<$?> may be set to non-0 value if the external program
1654F</cdrom/install> fails. The upper eight bits reflect specific
1655error conditions encountered by the program (the program's exit()
1656value). The lower eight bits reflect mode of failure, like signal
1657death and core dump information See wait(2) for details. In
1658contrast to C<$!> and C<$^E>, which are set only if error condition
1659is detected, the variable C<$?> is set on each C<wait> or pipe
1660C<close>, overwriting the old value. This is more like C<$@>, which
1661on every eval() is always set on failure and cleared on success.
2b92dfce 1662
19799a22
GS
1663For more details, see the individual descriptions at C<$@>, C<$!>, C<$^E>,
1664and C<$?>.
2b92dfce
GS
1665
1666=head2 Technical Note on the Syntax of Variable Names
1667
19799a22
GS
1668Variable names in Perl can have several formats. Usually, they
1669must begin with a letter or underscore, in which case they can be
1670arbitrarily long (up to an internal limit of 251 characters) and
1671may contain letters, digits, underscores, or the special sequence
1672C<::> or C<'>. In this case, the part before the last C<::> or
1673C<'> is taken to be a I<package qualifier>; see L<perlmod>.
2b92dfce
GS
1674
1675Perl variable names may also be a sequence of digits or a single
1676punctuation or control character. These names are all reserved for
19799a22
GS
1677special uses by Perl; for example, the all-digits names are used
1678to hold data captured by backreferences after a regular expression
1679match. Perl has a special syntax for the single-control-character
1680names: It understands C<^X> (caret C<X>) to mean the control-C<X>
1681character. For example, the notation C<$^W> (dollar-sign caret
1682C<W>) is the scalar variable whose name is the single character
1683control-C<W>. This is better than typing a literal control-C<W>
1684into your program.
2b92dfce 1685
87275199 1686Finally, new in Perl 5.6, Perl variable names may be alphanumeric
19799a22
GS
1687strings that begin with control characters (or better yet, a caret).
1688These variables must be written in the form C<${^Foo}>; the braces
1689are not optional. C<${^Foo}> denotes the scalar variable whose
1690name is a control-C<F> followed by two C<o>'s. These variables are
1691reserved for future special uses by Perl, except for the ones that
1692begin with C<^_> (control-underscore or caret-underscore). No
1693control-character name that begins with C<^_> will acquire a special
1694meaning in any future version of Perl; such names may therefore be
1695used safely in programs. C<$^_> itself, however, I<is> reserved.
1696
1fcb18de
RGS
1697Perl identifiers that begin with digits, control characters, or
1698punctuation characters are exempt from the effects of the C<package>
1699declaration and are always forced to be in package C<main>; they are
1700also exempt from C<strict 'vars'> errors. A few other names are also
1701exempt in these ways:
2b92dfce
GS
1702
1703 ENV STDIN
1704 INC STDOUT
1705 ARGV STDERR
5b88253b 1706 ARGVOUT _
2b92dfce
GS
1707 SIG
1708
1709In particular, the new special C<${^_XYZ}> variables are always taken
19799a22 1710to be in package C<main>, regardless of any C<package> declarations
747fafda 1711presently in scope.
2b92dfce 1712
19799a22
GS
1713=head1 BUGS
1714
1715Due to an unfortunate accident of Perl's implementation, C<use
1716English> imposes a considerable performance penalty on all regular
1717expression matches in a program, regardless of whether they occur
1718in the scope of C<use English>. For that reason, saying C<use
1719English> in libraries is strongly discouraged. See the
1720Devel::SawAmpersand module documentation from CPAN
1577cd80 1721( http://www.cpan.org/modules/by-module/Devel/ )
a054c801
GS
1722for more information. Writing C<use English '-no_match_vars';>
1723avoids the performance penalty.
2b92dfce 1724
19799a22
GS
1725Having to even think about the C<$^S> variable in your exception
1726handlers is simply wrong. C<$SIG{__DIE__}> as currently implemented
1727invites grievous and difficult to track down errors. Avoid it
1728and use an C<END{}> or CORE::GLOBAL::die override instead.