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