This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
perlvar.pod -- why isn't @F here?
[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
16at the top of your program. This will alias all the short names to the
5a964f20 17long names in the current package. Some even have medium names,
a0d0e21e
LW
18generally borrowed from B<awk>.
19
19799a22
GS
20If you don't mind the performance hit, variables that depend on the
21currently selected filehandle may instead be set by calling an
22appropriate object method on the IO::Handle object. (Summary lines
23below for this contain the word HANDLE.) First you must say
a0d0e21e 24
19799a22 25 use IO::Handle;
a0d0e21e
LW
26
27after which you may use either
28
29 method HANDLE EXPR
30
5a964f20 31or more safely,
a0d0e21e
LW
32
33 HANDLE->method(EXPR)
34
14218588 35Each method returns the old value of the IO::Handle attribute.
a0d0e21e 36The methods each take an optional EXPR, which if supplied specifies the
19799a22 37new value for the IO::Handle attribute in question. If not supplied,
14218588 38most methods do nothing to the current value--except for
a0d0e21e 39autoflush(), which will assume a 1 for you, just to be different.
14218588 40Because loading in the IO::Handle class is an expensive operation, you should
19799a22 41learn how to use the regular built-in variables.
a0d0e21e 42
748a9306
LW
43A few of these variables are considered "read-only". This means that if
44you try to assign to this variable, either directly or indirectly through
45a reference, you'll raise a run-time exception.
a0d0e21e 46
fb73857a 47The following list is ordered by scalar variables first, then the
87275199 48arrays, then the hashes.
fb73857a 49
a0d0e21e
LW
50=over 8
51
52=item $ARG
53
54=item $_
55
56The default input and pattern-searching space. The following pairs are
57equivalent:
58
19799a22 59 while (<>) {...} # equivalent only in while!
54310121 60 while (defined($_ = <>)) {...}
a0d0e21e
LW
61
62 /^Subject:/
63 $_ =~ /^Subject:/
64
65 tr/a-z/A-Z/
66 $_ =~ tr/a-z/A-Z/
67
19799a22
GS
68 chomp
69 chomp($_)
a0d0e21e 70
54310121 71Here are the places where Perl will assume $_ even if you
cb1a09d0
AD
72don't use it:
73
74=over 3
75
76=item *
77
78Various unary functions, including functions like ord() and int(), as well
79as the all file tests (C<-f>, C<-d>) except for C<-t>, which defaults to
80STDIN.
81
82=item *
83
84Various list functions like print() and unlink().
85
86=item *
87
88The pattern matching operations C<m//>, C<s///>, and C<tr///> when used
89without an C<=~> operator.
90
54310121 91=item *
cb1a09d0
AD
92
93The default iterator variable in a C<foreach> loop if no other
94variable is supplied.
95
54310121 96=item *
cb1a09d0
AD
97
98The implicit iterator variable in the grep() and map() functions.
99
54310121 100=item *
cb1a09d0 101
c47ff5f1 102The default place to put an input record when a C<< <FH> >>
cb1a09d0 103operation's result is tested by itself as the sole criterion of a C<while>
14218588 104test. Outside a C<while> test, this will not happen.
cb1a09d0
AD
105
106=back
107
a0d0e21e
LW
108(Mnemonic: underline is understood in certain operations.)
109
6e2995f4
PP
110=back
111
112=over 8
113
c47ff5f1 114=item $<I<digits>>
a0d0e21e 115
19799a22
GS
116Contains the subpattern from the corresponding set of capturing
117parentheses from the last pattern match, not counting patterns
118matched in nested blocks that have been exited already. (Mnemonic:
119like \digits.) These variables are all read-only and dynamically
120scoped to the current BLOCK.
a0d0e21e
LW
121
122=item $MATCH
123
124=item $&
125
126The string matched by the last successful pattern match (not counting
127any matches hidden within a BLOCK or eval() enclosed by the current
19799a22
GS
128BLOCK). (Mnemonic: like & in some editors.) This variable is read-only
129and dynamically scoped to the current BLOCK.
a0d0e21e 130
19ddd453 131The use of this variable anywhere in a program imposes a considerable
19799a22 132performance penalty on all regular expression matches. See L<BUGS>.
19ddd453 133
a0d0e21e
LW
134=item $PREMATCH
135
136=item $`
137
138The string preceding whatever was matched by the last successful
139pattern match (not counting any matches hidden within a BLOCK or eval
a8f8344d 140enclosed by the current BLOCK). (Mnemonic: C<`> often precedes a quoted
a0d0e21e
LW
141string.) This variable is read-only.
142
19ddd453 143The use of this variable anywhere in a program imposes a considerable
19799a22 144performance penalty on all regular expression matches. See L<BUGS>.
19ddd453 145
a0d0e21e
LW
146=item $POSTMATCH
147
148=item $'
149
150The string following whatever was matched by the last successful
151pattern match (not counting any matches hidden within a BLOCK or eval()
a8f8344d 152enclosed by the current BLOCK). (Mnemonic: C<'> often follows a quoted
a0d0e21e
LW
153string.) Example:
154
155 $_ = 'abcdefghi';
156 /def/;
157 print "$`:$&:$'\n"; # prints abc:def:ghi
158
19799a22 159This variable is read-only and dynamically scoped to the current BLOCK.
a0d0e21e 160
19ddd453 161The use of this variable anywhere in a program imposes a considerable
19799a22 162performance penalty on all regular expression matches. See L<BUGS>.
19ddd453 163
a0d0e21e
LW
164=item $LAST_PAREN_MATCH
165
166=item $+
167
168The last bracket matched by the last search pattern. This is useful if
19799a22 169you don't know which one of a set of alternative patterns matched. For
a0d0e21e
LW
170example:
171
172 /Version: (.*)|Revision: (.*)/ && ($rev = $+);
173
174(Mnemonic: be positive and forward looking.)
19799a22 175This variable is read-only and dynamically scoped to the current BLOCK.
a0d0e21e 176
fe307981
GS
177=item @LAST_MATCH_END
178
6cef1e77
IZ
179=item @+
180
4ba05bdc
GS
181This array holds the offsets of the ends of the last successful
182submatches in the currently active dynamic scope. C<$+[0]> is
183the offset into the string of the end of the entire match. This
184is the same value as what the C<pos> function returns when called
185on the variable that was matched against. The I<n>th element
186of this array holds the offset of the I<n>th submatch, so
187C<$+[1]> is the offset past where $1 ends, C<$+[2]> the offset
188past where $2 ends, and so on. You can use C<$#+> to determine
189how many subgroups were in the last successful match. See the
190examples given for the C<@-> variable.
6cef1e77 191
a0d0e21e
LW
192=item $MULTILINE_MATCHING
193
194=item $*
195
1555b0cb
A
196Set to a non-zero integer value to do multi-line matching within a
197string, 0 (or undefined) to tell Perl that it can assume that strings
198contain a single line, for the purpose of optimizing pattern matches.
199Pattern matches on strings containing multiple newlines can produce
200confusing results when C<$*> is 0 or undefined. Default is undefined.
201(Mnemonic: * matches multiple things.) This variable influences the
202interpretation of only C<^> and C<$>. A literal newline can be searched
203for even when C<$* == 0>.
a0d0e21e 204
19799a22 205Use of C<$*> is deprecated in modern Perl, supplanted by
5a964f20 206the C</s> and C</m> modifiers on pattern matching.
a0d0e21e 207
1555b0cb
A
208Assigning a non-numerical value to C<$*> triggers a warning (and makes
209C<$*> act if C<$* == 0>), while assigning a numerical value to C<$*>
210makes that an implicit C<int> is applied on the value.
211
a0d0e21e
LW
212=item input_line_number HANDLE EXPR
213
214=item $INPUT_LINE_NUMBER
215
216=item $NR
217
218=item $.
219
19799a22 220The current input record number for the last file handle from which
14218588 221you just read() (or called a C<seek> or C<tell> on). The value
883faa13 222may be different from the actual physical line number in the file,
19799a22
GS
223depending on what notion of "line" is in effect--see C<$/> on how
224to change that. An explicit close on a filehandle resets the line
c47ff5f1 225number. Because C<< <> >> never does an explicit close, line
19799a22
GS
226numbers increase across ARGV files (but see examples in L<perlfunc/eof>).
227Consider this variable read-only: setting it does not reposition
1e374101
PJ
228the seek pointer; you'll have to do that on your own. Localizing C<$.>
229has the effect of also localizing Perl's notion of "the last read
230filehandle". (Mnemonic: many programs use "." to mean the current line
231number.)
a0d0e21e
LW
232
233=item input_record_separator HANDLE EXPR
234
235=item $INPUT_RECORD_SEPARATOR
236
237=item $RS
238
239=item $/
240
14218588
GS
241The input record separator, newline by default. This
242influences Perl's idea of what a "line" is. Works like B<awk>'s RS
19799a22 243variable, including treating empty lines as a terminator if set to
14218588
GS
244the null string. (An empty line cannot contain any spaces
245or tabs.) You may set it to a multi-character string to match a
19799a22
GS
246multi-character terminator, or to C<undef> to read through the end
247of file. Setting it to C<"\n\n"> means something slightly
248different than setting to C<"">, if the file contains consecutive
249empty lines. Setting to C<""> will treat two or more consecutive
250empty lines as a single empty line. Setting to C<"\n\n"> will
251blindly assume that the next input character belongs to the next
14218588 252paragraph, even if it's a newline. (Mnemonic: / delimits
19799a22 253line boundaries when quoting poetry.)
a0d0e21e 254
fbad3eb5
GS
255 undef $/; # enable "slurp" mode
256 $_ = <FH>; # whole file now here
a0d0e21e
LW
257 s/\n[ \t]+/ /g;
258
19799a22
GS
259Remember: the value of C<$/> is a string, not a regex. B<awk> has to be
260better for something. :-)
68dc0745 261
19799a22
GS
262Setting C<$/> to a reference to an integer, scalar containing an integer, or
263scalar that's convertible to an integer will attempt to read records
5b2b9c68 264instead of lines, with the maximum record size being the referenced
19799a22 265integer. So this:
5b2b9c68
HM
266
267 $/ = \32768; # or \"32768", or \$var_containing_32768
268 open(FILE, $myfile);
269 $_ = <FILE>;
270
19799a22
GS
271will read a record of no more than 32768 bytes from FILE. If you're
272not reading from a record-oriented file (or your OS doesn't have
273record-oriented files), then you'll likely get a full chunk of data
274with every read. If a record is larger than the record size you've
275set, you'll get the record back in pieces.
5b2b9c68 276
19799a22
GS
277On VMS, record reads are done with the equivalent of C<sysread>,
278so it's best not to mix record and non-record reads on the same
279file. (This is unlikely to be a problem, because any file you'd
83763826 280want to read in record mode is probably unusable in line mode.)
14218588 281Non-VMS systems do normal I/O, so it's safe to mix record and
19799a22 282non-record reads of a file.
5b2b9c68 283
14218588 284See also L<perlport/"Newlines">. Also see C<$.>.
883faa13 285
a0d0e21e
LW
286=item autoflush HANDLE EXPR
287
288=item $OUTPUT_AUTOFLUSH
289
290=item $|
291
19799a22
GS
292If set to nonzero, forces a flush right away and after every write
293or print on the currently selected output channel. Default is 0
14218588 294(regardless of whether the channel is really buffered by the
19799a22
GS
295system or not; C<$|> tells you only whether you've asked Perl
296explicitly to flush after each write). STDOUT will
297typically be line buffered if output is to the terminal and block
298buffered otherwise. Setting this variable is useful primarily when
299you are outputting to a pipe or socket, such as when you are running
300a Perl program under B<rsh> and want to see the output as it's
301happening. This has no effect on input buffering. See L<perlfunc/getc>
302for that. (Mnemonic: when you want your pipes to be piping hot.)
a0d0e21e
LW
303
304=item output_field_separator HANDLE EXPR
305
306=item $OUTPUT_FIELD_SEPARATOR
307
308=item $OFS
309
310=item $,
311
312The output field separator for the print operator. Ordinarily the
19799a22
GS
313print operator simply prints out its arguments without further
314adornment. To get behavior more like B<awk>, set this variable as
315you would set B<awk>'s OFS variable to specify what is printed
316between fields. (Mnemonic: what is printed when there is a "," in
317your print statement.)
a0d0e21e
LW
318
319=item output_record_separator HANDLE EXPR
320
321=item $OUTPUT_RECORD_SEPARATOR
322
323=item $ORS
324
325=item $\
326
327The output record separator for the print operator. Ordinarily the
19799a22
GS
328print operator simply prints out its arguments as is, with no
329trailing newline or other end-of-record string added. To get
330behavior more like B<awk>, set this variable as you would set
331B<awk>'s ORS variable to specify what is printed at the end of the
332print. (Mnemonic: you set C<$\> instead of adding "\n" at the
333end of the print. Also, it's just like C<$/>, but it's what you
334get "back" from Perl.)
a0d0e21e
LW
335
336=item $LIST_SEPARATOR
337
338=item $"
339
19799a22
GS
340This is like C<$,> except that it applies to array and slice values
341interpolated into a double-quoted string (or similar interpreted
342string). Default is a space. (Mnemonic: obvious, I think.)
a0d0e21e
LW
343
344=item $SUBSCRIPT_SEPARATOR
345
346=item $SUBSEP
347
348=item $;
349
54310121 350The subscript separator for multidimensional array emulation. If you
a0d0e21e
LW
351refer to a hash element as
352
353 $foo{$a,$b,$c}
354
355it really means
356
357 $foo{join($;, $a, $b, $c)}
358
359But don't put
360
361 @foo{$a,$b,$c} # a slice--note the @
362
363which means
364
365 ($foo{$a},$foo{$b},$foo{$c})
366
19799a22
GS
367Default is "\034", the same as SUBSEP in B<awk>. If your
368keys contain binary data there might not be any safe value for C<$;>.
a0d0e21e 369(Mnemonic: comma (the syntactic subscript separator) is a
19799a22 370semi-semicolon. Yeah, I know, it's pretty lame, but C<$,> is already
a0d0e21e
LW
371taken for something more important.)
372
19799a22
GS
373Consider using "real" multidimensional arrays as described
374in L<perllol>.
a0d0e21e
LW
375
376=item $OFMT
377
378=item $#
379
380The output format for printed numbers. This variable is a half-hearted
381attempt to emulate B<awk>'s OFMT variable. There are times, however,
14218588 382when B<awk> and Perl have differing notions of what counts as
19799a22 383numeric. The initial value is "%.I<n>g", where I<n> is the value
6e2995f4 384of the macro DBL_DIG from your system's F<float.h>. This is different from
19799a22 385B<awk>'s default OFMT setting of "%.6g", so you need to set C<$#>
6e2995f4 386explicitly to get B<awk>'s value. (Mnemonic: # is the number sign.)
a0d0e21e 387
19799a22 388Use of C<$#> is deprecated.
a0d0e21e
LW
389
390=item format_page_number HANDLE EXPR
391
392=item $FORMAT_PAGE_NUMBER
393
394=item $%
395
396The current page number of the currently selected output channel.
19799a22 397Used with formats.
a0d0e21e
LW
398(Mnemonic: % is page number in B<nroff>.)
399
400=item format_lines_per_page HANDLE EXPR
401
402=item $FORMAT_LINES_PER_PAGE
403
404=item $=
405
406The current page length (printable lines) of the currently selected
19799a22
GS
407output channel. Default is 60.
408Used with formats.
409(Mnemonic: = has horizontal lines.)
a0d0e21e
LW
410
411=item format_lines_left HANDLE EXPR
412
413=item $FORMAT_LINES_LEFT
414
415=item $-
416
417The number of lines left on the page of the currently selected output
19799a22
GS
418channel.
419Used with formats.
420(Mnemonic: lines_on_page - lines_printed.)
a0d0e21e 421
fe307981
GS
422=item @LAST_MATCH_START
423
6cef1e77
IZ
424=item @-
425
19799a22 426$-[0] is the offset of the start of the last successful match.
6cef1e77 427C<$-[>I<n>C<]> is the offset of the start of the substring matched by
8f580fb8 428I<n>-th subpattern, or undef if the subpattern did not match.
6cef1e77
IZ
429
430Thus after a match against $_, $& coincides with C<substr $_, $-[0],
8f580fb8
IZ
431$+[0] - $-[0]>. Similarly, C<$>I<n> coincides with C<substr $_, $-[>I<n>C<],
432$+[>I<n>C<] - $-[>I<n>C<]> if C<$-[>I<n>C<]> is defined, and $+ coincides with
c47ff5f1 433C<substr $_, $-[$#-], $+[$#-]>. One can use C<$#-> to find the last
14218588
GS
434matched subgroup in the last successful match. Contrast with
435C<$#+>, the number of subgroups in the regular expression. Compare
19799a22 436with C<@+>.
6cef1e77 437
4ba05bdc
GS
438This array holds the offsets of the beginnings of the last
439successful submatches in the currently active dynamic scope.
440C<$-[0]> is the offset into the string of the beginning of the
441entire match. The I<n>th element of this array holds the offset
442of the I<n>th submatch, so C<$+[1]> is the offset where $1
443begins, C<$+[2]> the offset where $2 begins, and so on.
444You can use C<$#-> to determine how many subgroups were in the
445last successful match. Compare with the C<@+> variable.
446
447After a match against some variable $var:
448
449=over 5
450
4375e838 451=item C<$`> is the same as C<substr($var, 0, $-[0])>
4ba05bdc 452
4375e838 453=item C<$&> is the same as C<substr($var, $-[0], $+[0] - $-[0])>
4ba05bdc 454
4375e838 455=item C<$'> is the same as C<substr($var, $+[0])>
4ba05bdc
GS
456
457=item C<$1> is the same as C<substr($var, $-[1], $+[1] - $-[1])>
458
459=item C<$2> is the same as C<substr($var, $-[2], $+[2] - $-[2])>
460
4375e838 461=item C<$3> is the same as C<substr $var, $-[3], $+[3] - $-[3])>
4ba05bdc
GS
462
463=back
464
a0d0e21e
LW
465=item format_name HANDLE EXPR
466
467=item $FORMAT_NAME
468
469=item $~
470
471The name of the current report format for the currently selected output
14218588 472channel. Default is the name of the filehandle. (Mnemonic: brother to
19799a22 473C<$^>.)
a0d0e21e
LW
474
475=item format_top_name HANDLE EXPR
476
477=item $FORMAT_TOP_NAME
478
479=item $^
480
481The name of the current top-of-page format for the currently selected
14218588 482output channel. Default is the name of the filehandle with _TOP
a0d0e21e
LW
483appended. (Mnemonic: points to top of page.)
484
485=item format_line_break_characters HANDLE EXPR
486
487=item $FORMAT_LINE_BREAK_CHARACTERS
488
489=item $:
490
491The current set of characters after which a string may be broken to
54310121 492fill continuation fields (starting with ^) in a format. Default is
a0d0e21e
LW
493S<" \n-">, to break on whitespace or hyphens. (Mnemonic: a "colon" in
494poetry is a part of a line.)
495
496=item format_formfeed HANDLE EXPR
497
498=item $FORMAT_FORMFEED
499
500=item $^L
501
14218588 502What formats output as a form feed. Default is \f.
a0d0e21e
LW
503
504=item $ACCUMULATOR
505
506=item $^A
507
508The current value of the write() accumulator for format() lines. A format
19799a22 509contains formline() calls that put their result into C<$^A>. After
a0d0e21e 510calling its format, write() prints out the contents of C<$^A> and empties.
14218588 511So you never really see the contents of C<$^A> unless you call
a0d0e21e
LW
512formline() yourself and then look at it. See L<perlform> and
513L<perlfunc/formline()>.
514
515=item $CHILD_ERROR
516
517=item $?
518
54310121 519The status returned by the last pipe close, backtick (C<``>) command,
19799a22
GS
520successful call to wait() or waitpid(), or from the system()
521operator. This is just the 16-bit status word returned by the
522wait() system call (or else is made up to look like it). Thus, the
c47ff5f1 523exit value of the subprocess is really (C<<< $? >> 8 >>>), and
19799a22
GS
524C<$? & 127> gives which signal, if any, the process died from, and
525C<$? & 128> reports whether there was a core dump. (Mnemonic:
526similar to B<sh> and B<ksh>.)
a0d0e21e 527
7b8d334a 528Additionally, if the C<h_errno> variable is supported in C, its value
14218588 529is returned via $? if any C<gethost*()> function fails.
7b8d334a 530
19799a22 531If you have installed a signal handler for C<SIGCHLD>, the
aa689395
PP
532value of C<$?> will usually be wrong outside that handler.
533
a8f8344d
PP
534Inside an C<END> subroutine C<$?> contains the value that is going to be
535given to C<exit()>. You can modify C<$?> in an C<END> subroutine to
19799a22
GS
536change the exit status of your program. For example:
537
538 END {
539 $? = 1 if $? == 255; # die would make it 255
540 }
a8f8344d 541
aa689395 542Under VMS, the pragma C<use vmsish 'status'> makes C<$?> reflect the
ff0cee69
PP
543actual VMS exit status, instead of the default emulation of POSIX
544status.
f86702cc 545
55602bd2
IZ
546Also see L<Error Indicators>.
547
a0d0e21e
LW
548=item $OS_ERROR
549
550=item $ERRNO
551
552=item $!
553
19799a22
GS
554If used numerically, yields the current value of the C C<errno>
555variable, with all the usual caveats. (This means that you shouldn't
556depend on the value of C<$!> to be anything in particular unless
557you've gotten a specific error return indicating a system error.)
558If used an a string, yields the corresponding system error string.
559You can assign a number to C<$!> to set I<errno> if, for instance,
560you want C<"$!"> to return the string for error I<n>, or you want
561to set the exit value for the die() operator. (Mnemonic: What just
562went bang?)
a0d0e21e 563
55602bd2
IZ
564Also see L<Error Indicators>.
565
5c055ba3
PP
566=item $EXTENDED_OS_ERROR
567
568=item $^E
569
22fae026
TM
570Error information specific to the current operating system. At
571the moment, this differs from C<$!> under only VMS, OS/2, and Win32
572(and for MacPerl). On all other platforms, C<$^E> is always just
573the same as C<$!>.
574
575Under VMS, C<$^E> provides the VMS status value from the last
576system error. This is more specific information about the last
577system error than that provided by C<$!>. This is particularly
d516a115 578important when C<$!> is set to B<EVMSERR>.
22fae026 579
1c1c7f20
GS
580Under OS/2, C<$^E> is set to the error code of the last call to
581OS/2 API either via CRT, or directly from perl.
22fae026
TM
582
583Under Win32, C<$^E> always returns the last error information
584reported by the Win32 call C<GetLastError()> which describes
585the last error from within the Win32 API. Most Win32-specific
19799a22 586code will report errors via C<$^E>. ANSI C and Unix-like calls
22fae026
TM
587set C<errno> and so most portable Perl code will report errors
588via C<$!>.
589
590Caveats mentioned in the description of C<$!> generally apply to
591C<$^E>, also. (Mnemonic: Extra error explanation.)
5c055ba3 592
55602bd2
IZ
593Also see L<Error Indicators>.
594
a0d0e21e
LW
595=item $EVAL_ERROR
596
597=item $@
598
19799a22 599The Perl syntax error message from the last eval() operator. If null, the
a0d0e21e
LW
600last eval() parsed and executed correctly (although the operations you
601invoked may have failed in the normal fashion). (Mnemonic: Where was
602the syntax error "at"?)
603
19799a22 604Warning messages are not collected in this variable. You can,
a8f8344d 605however, set up a routine to process warnings by setting C<$SIG{__WARN__}>
54310121 606as described below.
748a9306 607
55602bd2
IZ
608Also see L<Error Indicators>.
609
a0d0e21e
LW
610=item $PROCESS_ID
611
612=item $PID
613
614=item $$
615
19799a22
GS
616The process number of the Perl running this script. You should
617consider this variable read-only, although it will be altered
618across fork() calls. (Mnemonic: same as shells.)
a0d0e21e
LW
619
620=item $REAL_USER_ID
621
622=item $UID
623
624=item $<
625
19799a22 626The real uid of this process. (Mnemonic: it's the uid you came I<from>,
a043a685
GW
627if you're running setuid.) You can change both the real uid and
628the effective uid at the same time by using POSIX::setuid().
a0d0e21e
LW
629
630=item $EFFECTIVE_USER_ID
631
632=item $EUID
633
634=item $>
635
636The effective uid of this process. Example:
637
638 $< = $>; # set real to effective uid
639 ($<,$>) = ($>,$<); # swap real and effective uid
640
a043a685
GW
641You can change both the effective uid and the real uid at the same
642time by using POSIX::setuid().
643
19799a22 644(Mnemonic: it's the uid you went I<to>, if you're running setuid.)
c47ff5f1 645C<< $< >> and C<< $> >> can be swapped only on machines
8cc95fdb 646supporting setreuid().
a0d0e21e
LW
647
648=item $REAL_GROUP_ID
649
650=item $GID
651
652=item $(
653
654The real gid of this process. If you are on a machine that supports
655membership in multiple groups simultaneously, gives a space separated
656list of groups you are in. The first number is the one returned by
657getgid(), and the subsequent ones by getgroups(), one of which may be
8cc95fdb
PP
658the same as the first number.
659
19799a22
GS
660However, a value assigned to C<$(> must be a single number used to
661set the real gid. So the value given by C<$(> should I<not> be assigned
662back to C<$(> without being forced numeric, such as by adding zero.
8cc95fdb 663
a043a685
GW
664You can change both the real gid and the effective gid at the same
665time by using POSIX::setgid().
666
19799a22
GS
667(Mnemonic: parentheses are used to I<group> things. The real gid is the
668group you I<left>, if you're running setgid.)
a0d0e21e
LW
669
670=item $EFFECTIVE_GROUP_ID
671
672=item $EGID
673
674=item $)
675
676The effective gid of this process. If you are on a machine that
677supports membership in multiple groups simultaneously, gives a space
678separated list of groups you are in. The first number is the one
679returned by getegid(), and the subsequent ones by getgroups(), one of
8cc95fdb
PP
680which may be the same as the first number.
681
19799a22 682Similarly, a value assigned to C<$)> must also be a space-separated
14218588 683list of numbers. The first number sets the effective gid, and
8cc95fdb
PP
684the rest (if any) are passed to setgroups(). To get the effect of an
685empty list for setgroups(), just repeat the new effective gid; that is,
686to force an effective gid of 5 and an effectively empty setgroups()
687list, say C< $) = "5 5" >.
688
a043a685
GW
689You can change both the effective gid and the real gid at the same
690time by using POSIX::setgid() (use only a single numeric argument).
691
19799a22
GS
692(Mnemonic: parentheses are used to I<group> things. The effective gid
693is the group that's I<right> for you, if you're running setgid.)
a0d0e21e 694
c47ff5f1 695C<< $< >>, C<< $> >>, C<$(> and C<$)> can be set only on
19799a22
GS
696machines that support the corresponding I<set[re][ug]id()> routine. C<$(>
697and C<$)> can be swapped only on machines supporting setregid().
a0d0e21e
LW
698
699=item $PROGRAM_NAME
700
701=item $0
702
19799a22
GS
703Contains the name of the program being executed. On some operating
704systems assigning to C<$0> modifies the argument area that the B<ps>
705program sees. This is more useful as a way of indicating the current
706program state than it is for hiding the program you're running.
a0d0e21e
LW
707(Mnemonic: same as B<sh> and B<ksh>.)
708
4bc88a62
PS
709Note for BSD users: setting C<$0> does not completely remove "perl"
710from the ps(1) output. For example, setting C<$0> to C<"foobar"> will
711result in C<"perl: foobar (perl)">. This is an operating system
712feature.
713
a0d0e21e
LW
714=item $[
715
716The index of the first element in an array, and of the first character
19799a22
GS
717in a substring. Default is 0, but you could theoretically set it
718to 1 to make Perl behave more like B<awk> (or Fortran) when
719subscripting and when evaluating the index() and substr() functions.
720(Mnemonic: [ begins subscripts.)
a0d0e21e 721
19799a22
GS
722As of release 5 of Perl, assignment to C<$[> is treated as a compiler
723directive, and cannot influence the behavior of any other file.
724Its use is highly discouraged.
a0d0e21e 725
a0d0e21e
LW
726=item $]
727
54310121
PP
728The version + patchlevel / 1000 of the Perl interpreter. This variable
729can be used to determine whether the Perl interpreter executing a
730script is in the right range of versions. (Mnemonic: Is this version
731of perl in the right bracket?) Example:
a0d0e21e
LW
732
733 warn "No checksumming!\n" if $] < 3.019;
734
54310121 735See also the documentation of C<use VERSION> and C<require VERSION>
19799a22 736for a convenient way to fail if the running Perl interpreter is too old.
a0d0e21e 737
44dcb63b
GS
738The use of this variable is deprecated. The floating point representation
739can sometimes lead to inaccurate numeric comparisons. See C<$^V> for a
740more modern representation of the Perl version that allows accurate string
741comparisons.
16070b82 742
305aace0
NIS
743=item $COMPILING
744
745=item $^C
746
19799a22
GS
747The current value of the flag associated with the B<-c> switch.
748Mainly of use with B<-MO=...> to allow code to alter its behavior
749when being compiled, such as for example to AUTOLOAD at compile
750time rather than normal, deferred loading. See L<perlcc>. Setting
751C<$^C = 1> is similar to calling C<B::minus_c>.
305aace0 752
a0d0e21e
LW
753=item $DEBUGGING
754
755=item $^D
756
757The current value of the debugging flags. (Mnemonic: value of B<-D>
758switch.)
759
760=item $SYSTEM_FD_MAX
761
762=item $^F
763
764The maximum system file descriptor, ordinarily 2. System file
765descriptors are passed to exec()ed processes, while higher file
766descriptors are not. Also, during an open(), system file descriptors are
767preserved even if the open() fails. (Ordinary file descriptors are
19799a22 768closed before the open() is attempted.) The close-on-exec
a0d0e21e 769status of a file descriptor will be decided according to the value of
8d2a6795
GS
770C<$^F> when the corresponding file, pipe, or socket was opened, not the
771time of the exec().
a0d0e21e 772
6e2995f4
PP
773=item $^H
774
0462a1ab
GS
775WARNING: This variable is strictly for internal use only. Its availability,
776behavior, and contents are subject to change without notice.
777
778This variable contains compile-time hints for the Perl interpreter. At the
779end of compilation of a BLOCK the value of this variable is restored to the
780value when the interpreter started to compile the BLOCK.
781
782When perl begins to parse any block construct that provides a lexical scope
783(e.g., eval body, required file, subroutine body, loop body, or conditional
784block), the existing value of $^H is saved, but its value is left unchanged.
785When the compilation of the block is completed, it regains the saved value.
786Between the points where its value is saved and restored, code that
787executes within BEGIN blocks is free to change the value of $^H.
788
789This behavior provides the semantic of lexical scoping, and is used in,
790for instance, the C<use strict> pragma.
791
792The contents should be an integer; different bits of it are used for
793different pragmatic flags. Here's an example:
794
795 sub add_100 { $^H |= 0x100 }
796
797 sub foo {
798 BEGIN { add_100() }
799 bar->baz($boon);
800 }
801
802Consider what happens during execution of the BEGIN block. At this point
803the BEGIN block has already been compiled, but the body of foo() is still
804being compiled. The new value of $^H will therefore be visible only while
805the body of foo() is being compiled.
806
807Substitution of the above BEGIN block with:
808
809 BEGIN { require strict; strict->import('vars') }
810
811demonstrates how C<use strict 'vars'> is implemented. Here's a conditional
812version of the same lexical pragma:
813
814 BEGIN { require strict; strict->import('vars') if $condition }
815
816=item %^H
817
818WARNING: This variable is strictly for internal use only. Its availability,
819behavior, and contents are subject to change without notice.
820
821The %^H hash provides the same scoping semantic as $^H. This makes it
822useful for implementation of lexically scoped pragmas.
6e2995f4 823
a0d0e21e
LW
824=item $INPLACE_EDIT
825
826=item $^I
827
828The current value of the inplace-edit extension. Use C<undef> to disable
829inplace editing. (Mnemonic: value of B<-i> switch.)
830
fb73857a
PP
831=item $^M
832
19799a22
GS
833By default, running out of memory is an untrappable, fatal error.
834However, if suitably built, Perl can use the contents of C<$^M>
835as an emergency memory pool after die()ing. Suppose that your Perl
836were compiled with -DPERL_EMERGENCY_SBRK and used Perl's malloc.
837Then
fb73857a 838
19799a22 839 $^M = 'a' x (1 << 16);
fb73857a 840
51ee6500 841would allocate a 64K buffer for use in an emergency. See the
19799a22
GS
842F<INSTALL> file in the Perl distribution for information on how to
843enable this option. To discourage casual use of this advanced
4ec0190b 844feature, there is no L<English|English> long name for this variable.
fb73857a 845
5c055ba3 846=item $OSNAME
6e2995f4 847
5c055ba3
PP
848=item $^O
849
850The name of the operating system under which this copy of Perl was
851built, as determined during the configuration process. The value
19799a22
GS
852is identical to C<$Config{'osname'}>. See also L<Config> and the
853B<-V> command-line switch documented in L<perlrun>.
5c055ba3 854
a0d0e21e
LW
855=item $PERLDB
856
857=item $^P
858
19799a22
GS
859The internal variable for debugging support. The meanings of the
860various bits are subject to change, but currently indicate:
84902520
TB
861
862=over 6
863
864=item 0x01
865
866Debug subroutine enter/exit.
867
868=item 0x02
869
870Line-by-line debugging.
871
872=item 0x04
873
874Switch off optimizations.
875
876=item 0x08
877
878Preserve more data for future interactive inspections.
879
880=item 0x10
881
882Keep info about source lines on which a subroutine is defined.
883
884=item 0x20
885
886Start with single-step on.
887
83ee9e09
GS
888=item 0x40
889
890Use subroutine address instead of name when reporting.
891
892=item 0x80
893
894Report C<goto &subroutine> as well.
895
896=item 0x100
897
898Provide informative "file" names for evals based on the place they were compiled.
899
900=item 0x200
901
902Provide informative names to anonymous subroutines based on the place they
903were compiled.
904
84902520
TB
905=back
906
19799a22
GS
907Some bits may be relevant at compile-time only, some at
908run-time only. This is a new mechanism and the details may change.
a0d0e21e 909
66558a10
GS
910=item $LAST_REGEXP_CODE_RESULT
911
b9ac3b5b
GS
912=item $^R
913
19799a22
GS
914The result of evaluation of the last successful C<(?{ code })>
915regular expression assertion (see L<perlre>). May be written to.
b9ac3b5b 916
66558a10
GS
917=item $EXCEPTIONS_BEING_CAUGHT
918
fb73857a
PP
919=item $^S
920
921Current state of the interpreter. Undefined if parsing of the current
922module/eval is not finished (may happen in $SIG{__DIE__} and
19799a22 923$SIG{__WARN__} handlers). True if inside an eval(), otherwise false.
fb73857a 924
a0d0e21e
LW
925=item $BASETIME
926
927=item $^T
928
19799a22 929The time at which the program began running, in seconds since the
5f05dabc 930epoch (beginning of 1970). The values returned by the B<-M>, B<-A>,
19799a22 931and B<-C> filetests are based on this value.
a0d0e21e 932
44dcb63b 933=item $PERL_VERSION
b459063d 934
16070b82
GS
935=item $^V
936
937The revision, version, and subversion of the Perl interpreter, represented
da2094fd 938as a string composed of characters with those ordinals. Thus in Perl v5.6.0
44dcb63b
GS
939it equals C<chr(5) . chr(6) . chr(0)> and will return true for
940C<$^V eq v5.6.0>. Note that the characters in this string value can
941potentially be in Unicode range.
16070b82
GS
942
943This can be used to determine whether the Perl interpreter executing a
944script is in the right range of versions. (Mnemonic: use ^V for Version
44dcb63b 945Control.) Example:
16070b82 946
3fd4402b 947 warn "No \"our\" declarations!\n" if $^V and $^V lt v5.6.0;
16070b82 948
44dcb63b 949See the documentation of C<use VERSION> and C<require VERSION>
16070b82
GS
950for a convenient way to fail if the running Perl interpreter is too old.
951
952See also C<$]> for an older representation of the Perl version.
953
a0d0e21e
LW
954=item $WARNING
955
956=item $^W
957
19799a22
GS
958The current value of the warning switch, initially true if B<-w>
959was used, false otherwise, but directly modifiable. (Mnemonic:
4438c4b7
JH
960related to the B<-w> switch.) See also L<warnings>.
961
6a818117 962=item ${^WARNING_BITS}
4438c4b7
JH
963
964The current set of warning checks enabled by the C<use warnings> pragma.
965See the documentation of C<warnings> for more details.
a0d0e21e 966
46487f74
GS
967=item ${^WIDE_SYSTEM_CALLS}
968
969Global flag that enables system calls made by Perl to use wide character
970APIs native to the system, if available. This is currently only implemented
971on the Windows platform.
972
973This can also be enabled from the command line using the C<-C> switch.
974
975The initial value is typically C<0> for compatibility with Perl versions
976earlier than 5.6, but may be automatically set to C<1> by Perl if the system
977provides a user-settable default (e.g., C<$ENV{LC_CTYPE}>).
978
8058d7ab
GS
979The C<bytes> pragma always overrides the effect of this flag in the current
980lexical scope. See L<bytes>.
46487f74 981
a0d0e21e
LW
982=item $EXECUTABLE_NAME
983
984=item $^X
985
986The name that the Perl binary itself was executed as, from C's C<argv[0]>.
19799a22 987This may not be a full pathname, nor even necessarily in your path.
a0d0e21e
LW
988
989=item $ARGV
990
c47ff5f1 991contains the name of the current file when reading from <>.
a0d0e21e
LW
992
993=item @ARGV
994
19799a22 995The array @ARGV contains the command-line arguments intended for
14218588 996the script. C<$#ARGV> is generally the number of arguments minus
19799a22
GS
997one, because C<$ARGV[0]> is the first argument, I<not> the program's
998command name itself. See C<$0> for the command name.
a0d0e21e 999
9b0e6e7a
JP
1000=item @F
1001
1002The array @F contains the fields of each line read in when autosplit
1003mode is turned on. See L<perlrun> for the B<-a> switch. This array
1004is package-specific, and must be declared or given a full package name
1005if not in package main when running under C<strict 'vars'>.
1006
a0d0e21e
LW
1007=item @INC
1008
19799a22
GS
1009The array @INC contains the list of places that the C<do EXPR>,
1010C<require>, or C<use> constructs look for their library files. It
1011initially consists of the arguments to any B<-I> command-line
1012switches, followed by the default Perl library, probably
1013F</usr/local/lib/perl>, followed by ".", to represent the current
1014directory. If you need to modify this at runtime, you should use
1015the C<use lib> pragma to get the machine-dependent library properly
1016loaded also:
a0d0e21e 1017
cb1a09d0
AD
1018 use lib '/mypath/libdir/';
1019 use SomeMod;
303f2f76 1020
fb73857a
PP
1021=item @_
1022
1023Within a subroutine the array @_ contains the parameters passed to that
19799a22 1024subroutine. See L<perlsub>.
fb73857a 1025
a0d0e21e
LW
1026=item %INC
1027
19799a22
GS
1028The hash %INC contains entries for each filename included via the
1029C<do>, C<require>, or C<use> operators. The key is the filename
1030you specified (with module names converted to pathnames), and the
14218588 1031value is the location of the file found. The C<require>
87275199 1032operator uses this hash to determine whether a particular file has
19799a22 1033already been included.
a0d0e21e 1034
b687b08b
TC
1035=item %ENV
1036
1037=item $ENV{expr}
a0d0e21e
LW
1038
1039The hash %ENV contains your current environment. Setting a
19799a22
GS
1040value in C<ENV> changes the environment for any child processes
1041you subsequently fork() off.
a0d0e21e 1042
b687b08b
TC
1043=item %SIG
1044
1045=item $SIG{expr}
a0d0e21e 1046
14218588 1047The hash %SIG contains signal handlers for signals. For example:
a0d0e21e
LW
1048
1049 sub handler { # 1st argument is signal name
fb73857a 1050 my($sig) = @_;
a0d0e21e
LW
1051 print "Caught a SIG$sig--shutting down\n";
1052 close(LOG);
1053 exit(0);
1054 }
1055
fb73857a
PP
1056 $SIG{'INT'} = \&handler;
1057 $SIG{'QUIT'} = \&handler;
a0d0e21e 1058 ...
19799a22 1059 $SIG{'INT'} = 'DEFAULT'; # restore default action
a0d0e21e
LW
1060 $SIG{'QUIT'} = 'IGNORE'; # ignore SIGQUIT
1061
f648820c
GS
1062Using a value of C<'IGNORE'> usually has the effect of ignoring the
1063signal, except for the C<CHLD> signal. See L<perlipc> for more about
1064this special case.
1065
19799a22 1066Here are some other examples:
a0d0e21e 1067
fb73857a 1068 $SIG{"PIPE"} = "Plumber"; # assumes main::Plumber (not recommended)
a0d0e21e 1069 $SIG{"PIPE"} = \&Plumber; # just fine; assume current Plumber
19799a22 1070 $SIG{"PIPE"} = *Plumber; # somewhat esoteric
a0d0e21e
LW
1071 $SIG{"PIPE"} = Plumber(); # oops, what did Plumber() return??
1072
19799a22
GS
1073Be sure not to use a bareword as the name of a signal handler,
1074lest you inadvertently call it.
748a9306 1075
44a8e56a
PP
1076If your system has the sigaction() function then signal handlers are
1077installed using it. This means you get reliable signal handling. If
1078your system has the SA_RESTART flag it is used when signals handlers are
19799a22 1079installed. This means that system calls for which restarting is supported
44a8e56a
PP
1080continue rather than returning when a signal arrives. If you want your
1081system calls to be interrupted by signal delivery then do something like
1082this:
1083
1084 use POSIX ':signal_h';
1085
1086 my $alarm = 0;
1087 sigaction SIGALRM, new POSIX::SigAction sub { $alarm = 1 }
1088 or die "Error setting SIGALRM handler: $!\n";
1089
1090See L<POSIX>.
1091
748a9306 1092Certain internal hooks can be also set using the %SIG hash. The
a8f8344d 1093routine indicated by C<$SIG{__WARN__}> is called when a warning message is
748a9306
LW
1094about to be printed. The warning message is passed as the first
1095argument. The presence of a __WARN__ hook causes the ordinary printing
1096of warnings to STDERR to be suppressed. You can use this to save warnings
1097in a variable, or turn warnings into fatal errors, like this:
1098
1099 local $SIG{__WARN__} = sub { die $_[0] };
1100 eval $proggie;
1101
a8f8344d 1102The routine indicated by C<$SIG{__DIE__}> is called when a fatal exception
748a9306
LW
1103is about to be thrown. The error message is passed as the first
1104argument. When a __DIE__ hook routine returns, the exception
1105processing continues as it would have in the absence of the hook,
cb1a09d0 1106unless the hook routine itself exits via a C<goto>, a loop exit, or a die().
774d564b 1107The C<__DIE__> handler is explicitly disabled during the call, so that you
fb73857a
PP
1108can die from a C<__DIE__> handler. Similarly for C<__WARN__>.
1109
19799a22
GS
1110Due to an implementation glitch, the C<$SIG{__DIE__}> hook is called
1111even inside an eval(). Do not use this to rewrite a pending exception
1112in C<$@>, or as a bizarre substitute for overriding CORE::GLOBAL::die().
1113This strange action at a distance may be fixed in a future release
1114so that C<$SIG{__DIE__}> is only called if your program is about
1115to exit, as was the original intent. Any other use is deprecated.
1116
1117C<__DIE__>/C<__WARN__> handlers are very special in one respect:
1118they may be called to report (probable) errors found by the parser.
1119In such a case the parser may be in inconsistent state, so any
1120attempt to evaluate Perl code from such a handler will probably
1121result in a segfault. This means that warnings or errors that
1122result from parsing Perl should be used with extreme caution, like
1123this:
fb73857a
PP
1124
1125 require Carp if defined $^S;
1126 Carp::confess("Something wrong") if defined &Carp::confess;
1127 die "Something wrong, but could not load Carp to give backtrace...
1128 To see backtrace try starting Perl with -MCarp switch";
1129
1130Here the first line will load Carp I<unless> it is the parser who
1131called the handler. The second line will print backtrace and die if
1132Carp was available. The third line will be executed only if Carp was
1133not available.
1134
19799a22 1135See L<perlfunc/die>, L<perlfunc/warn>, L<perlfunc/eval>, and
4438c4b7 1136L<warnings> for additional information.
68dc0745 1137
a0d0e21e 1138=back
55602bd2
IZ
1139
1140=head2 Error Indicators
1141
19799a22
GS
1142The variables C<$@>, C<$!>, C<$^E>, and C<$?> contain information
1143about different types of error conditions that may appear during
1144execution of a Perl program. The variables are shown ordered by
1145the "distance" between the subsystem which reported the error and
1146the Perl process. They correspond to errors detected by the Perl
1147interpreter, C library, operating system, or an external program,
1148respectively.
55602bd2
IZ
1149
1150To illustrate the differences between these variables, consider the
19799a22 1151following Perl expression, which uses a single-quoted string:
55602bd2 1152
19799a22
GS
1153 eval q{
1154 open PIPE, "/cdrom/install |";
1155 @res = <PIPE>;
1156 close PIPE or die "bad pipe: $?, $!";
1157 };
55602bd2
IZ
1158
1159After execution of this statement all 4 variables may have been set.
1160
19799a22
GS
1161C<$@> is set if the string to be C<eval>-ed did not compile (this
1162may happen if C<open> or C<close> were imported with bad prototypes),
1163or if Perl code executed during evaluation die()d . In these cases
1164the value of $@ is the compile error, or the argument to C<die>
1165(which will interpolate C<$!> and C<$?>!). (See also L<Fatal>,
1166though.)
1167
c47ff5f1 1168When the eval() expression above is executed, open(), C<< <PIPE> >>,
19799a22
GS
1169and C<close> are translated to calls in the C run-time library and
1170thence to the operating system kernel. C<$!> is set to the C library's
1171C<errno> if one of these calls fails.
1172
1173Under a few operating systems, C<$^E> may contain a more verbose
1174error indicator, such as in this case, "CDROM tray not closed."
14218588 1175Systems that do not support extended error messages leave C<$^E>
19799a22
GS
1176the same as C<$!>.
1177
1178Finally, C<$?> may be set to non-0 value if the external program
1179F</cdrom/install> fails. The upper eight bits reflect specific
1180error conditions encountered by the program (the program's exit()
1181value). The lower eight bits reflect mode of failure, like signal
1182death and core dump information See wait(2) for details. In
1183contrast to C<$!> and C<$^E>, which are set only if error condition
1184is detected, the variable C<$?> is set on each C<wait> or pipe
1185C<close>, overwriting the old value. This is more like C<$@>, which
1186on every eval() is always set on failure and cleared on success.
2b92dfce 1187
19799a22
GS
1188For more details, see the individual descriptions at C<$@>, C<$!>, C<$^E>,
1189and C<$?>.
2b92dfce
GS
1190
1191=head2 Technical Note on the Syntax of Variable Names
1192
19799a22
GS
1193Variable names in Perl can have several formats. Usually, they
1194must begin with a letter or underscore, in which case they can be
1195arbitrarily long (up to an internal limit of 251 characters) and
1196may contain letters, digits, underscores, or the special sequence
1197C<::> or C<'>. In this case, the part before the last C<::> or
1198C<'> is taken to be a I<package qualifier>; see L<perlmod>.
2b92dfce
GS
1199
1200Perl variable names may also be a sequence of digits or a single
1201punctuation or control character. These names are all reserved for
19799a22
GS
1202special uses by Perl; for example, the all-digits names are used
1203to hold data captured by backreferences after a regular expression
1204match. Perl has a special syntax for the single-control-character
1205names: It understands C<^X> (caret C<X>) to mean the control-C<X>
1206character. For example, the notation C<$^W> (dollar-sign caret
1207C<W>) is the scalar variable whose name is the single character
1208control-C<W>. This is better than typing a literal control-C<W>
1209into your program.
2b92dfce 1210
87275199 1211Finally, new in Perl 5.6, Perl variable names may be alphanumeric
19799a22
GS
1212strings that begin with control characters (or better yet, a caret).
1213These variables must be written in the form C<${^Foo}>; the braces
1214are not optional. C<${^Foo}> denotes the scalar variable whose
1215name is a control-C<F> followed by two C<o>'s. These variables are
1216reserved for future special uses by Perl, except for the ones that
1217begin with C<^_> (control-underscore or caret-underscore). No
1218control-character name that begins with C<^_> will acquire a special
1219meaning in any future version of Perl; such names may therefore be
1220used safely in programs. C<$^_> itself, however, I<is> reserved.
1221
1222Perl identifiers that begin with digits, control characters, or
2b92dfce
GS
1223punctuation characters are exempt from the effects of the C<package>
1224declaration and are always forced to be in package C<main>. A few
1225other names are also exempt:
1226
1227 ENV STDIN
1228 INC STDOUT
1229 ARGV STDERR
1230 ARGVOUT
1231 SIG
1232
1233In particular, the new special C<${^_XYZ}> variables are always taken
19799a22 1234to be in package C<main>, regardless of any C<package> declarations
2b92dfce
GS
1235presently in scope.
1236
19799a22
GS
1237=head1 BUGS
1238
1239Due to an unfortunate accident of Perl's implementation, C<use
1240English> imposes a considerable performance penalty on all regular
1241expression matches in a program, regardless of whether they occur
1242in the scope of C<use English>. For that reason, saying C<use
1243English> in libraries is strongly discouraged. See the
1244Devel::SawAmpersand module documentation from CPAN
6cecdcac 1245(http://www.perl.com/CPAN/modules/by-module/Devel/)
19799a22 1246for more information.
2b92dfce 1247
19799a22
GS
1248Having to even think about the C<$^S> variable in your exception
1249handlers is simply wrong. C<$SIG{__DIE__}> as currently implemented
1250invites grievous and difficult to track down errors. Avoid it
1251and use an C<END{}> or CORE::GLOBAL::die override instead.