Commit | Line | Data |
a0d0e21e |
1 | =head1 NAME |
2 | |
3 | perlvar - Perl predefined variables |
4 | |
5 | =head1 DESCRIPTION |
6 | |
7 | =head2 Predefined Names |
8 | |
9 | The following names have special meaning to Perl. Most of the |
10 | punctuational names have reasonable mnemonics, or analogues in one of |
11 | the shells. Nevertheless, if you wish to use the long variable names, |
12 | you just need to say |
13 | |
14 | use English; |
15 | |
16 | at the top of your program. This will alias all the short names to the |
17 | long names in the current package. Some of them even have medium names, |
18 | generally borrowed from B<awk>. |
19 | |
20 | To go a step further, those variables that depend on the currently |
21 | selected filehandle may instead be set by calling an object method on |
22 | the FileHandle object. (Summary lines below for this contain the word |
23 | HANDLE.) First you must say |
24 | |
25 | use FileHandle; |
26 | |
27 | after which you may use either |
28 | |
29 | method HANDLE EXPR |
30 | |
31 | or |
32 | |
33 | HANDLE->method(EXPR) |
34 | |
35 | Each of the methods returns the old value of the FileHandle attribute. |
36 | The methods each take an optional EXPR, which if supplied specifies the |
37 | new value for the FileHandle attribute in question. If not supplied, |
38 | most of the methods do nothing to the current value, except for |
39 | autoflush(), which will assume a 1 for you, just to be different. |
40 | |
748a9306 |
41 | A few of these variables are considered "read-only". This means that if |
42 | you try to assign to this variable, either directly or indirectly through |
43 | a reference, you'll raise a run-time exception. |
a0d0e21e |
44 | |
45 | =over 8 |
46 | |
47 | =item $ARG |
48 | |
49 | =item $_ |
50 | |
51 | The default input and pattern-searching space. The following pairs are |
52 | equivalent: |
53 | |
54 | while (<>) {...} # only equivalent in while! |
55 | while ($_ = <>) {...} |
56 | |
57 | /^Subject:/ |
58 | $_ =~ /^Subject:/ |
59 | |
60 | tr/a-z/A-Z/ |
61 | $_ =~ tr/a-z/A-Z/ |
62 | |
63 | chop |
64 | chop($_) |
65 | |
cb1a09d0 |
66 | Here are the places where Perl will assume $_ even if you |
67 | don't use it: |
68 | |
69 | =over 3 |
70 | |
71 | =item * |
72 | |
73 | Various unary functions, including functions like ord() and int(), as well |
74 | as the all file tests (C<-f>, C<-d>) except for C<-t>, which defaults to |
75 | STDIN. |
76 | |
77 | =item * |
78 | |
79 | Various list functions like print() and unlink(). |
80 | |
81 | =item * |
82 | |
83 | The pattern matching operations C<m//>, C<s///>, and C<tr///> when used |
84 | without an C<=~> operator. |
85 | |
86 | =item * |
87 | |
88 | The default iterator variable in a C<foreach> loop if no other |
89 | variable is supplied. |
90 | |
91 | =item * |
92 | |
93 | The implicit iterator variable in the grep() and map() functions. |
94 | |
95 | =item * |
96 | |
97 | The default place to put an input record when a C<E<lt>FHE<gt>> |
98 | operation's result is tested by itself as the sole criterion of a C<while> |
99 | test. Note that outside of a C<while> test, this will not happen. |
100 | |
101 | =back |
102 | |
a0d0e21e |
103 | (Mnemonic: underline is understood in certain operations.) |
104 | |
6e2995f4 |
105 | =back |
106 | |
107 | =over 8 |
108 | |
a0d0e21e |
109 | =item $<I<digit>> |
110 | |
111 | Contains the subpattern from the corresponding set of parentheses in |
112 | the last pattern matched, not counting patterns matched in nested |
113 | blocks that have been exited already. (Mnemonic: like \digit.) |
114 | These variables are all read-only. |
115 | |
116 | =item $MATCH |
117 | |
118 | =item $& |
119 | |
120 | The string matched by the last successful pattern match (not counting |
121 | any matches hidden within a BLOCK or eval() enclosed by the current |
122 | BLOCK). (Mnemonic: like & in some editors.) This variable is read-only. |
123 | |
124 | =item $PREMATCH |
125 | |
126 | =item $` |
127 | |
128 | The string preceding whatever was matched by the last successful |
129 | pattern match (not counting any matches hidden within a BLOCK or eval |
130 | enclosed by the current BLOCK). (Mnemonic: ` often precedes a quoted |
131 | string.) This variable is read-only. |
132 | |
133 | =item $POSTMATCH |
134 | |
135 | =item $' |
136 | |
137 | The string following whatever was matched by the last successful |
138 | pattern match (not counting any matches hidden within a BLOCK or eval() |
139 | enclosed by the current BLOCK). (Mnemonic: ' often follows a quoted |
140 | string.) Example: |
141 | |
142 | $_ = 'abcdefghi'; |
143 | /def/; |
144 | print "$`:$&:$'\n"; # prints abc:def:ghi |
145 | |
146 | This variable is read-only. |
147 | |
148 | =item $LAST_PAREN_MATCH |
149 | |
150 | =item $+ |
151 | |
152 | The last bracket matched by the last search pattern. This is useful if |
153 | you don't know which of a set of alternative patterns matched. For |
154 | example: |
155 | |
156 | /Version: (.*)|Revision: (.*)/ && ($rev = $+); |
157 | |
158 | (Mnemonic: be positive and forward looking.) |
159 | This variable is read-only. |
160 | |
161 | =item $MULTILINE_MATCHING |
162 | |
163 | =item $* |
164 | |
165 | Set to 1 to do multiline matching within a string, 0 to tell Perl |
166 | that it can assume that strings contain a single line, for the purpose |
167 | of optimizing pattern matches. Pattern matches on strings containing |
168 | multiple newlines can produce confusing results when "C<$*>" is 0. Default |
169 | is 0. (Mnemonic: * matches multiple things.) Note that this variable |
170 | only influences the interpretation of "C<^>" and "C<$>". A literal newline can |
171 | be searched for even when C<$* == 0>. |
172 | |
173 | Use of "C<$*>" is deprecated in Perl 5. |
174 | |
175 | =item input_line_number HANDLE EXPR |
176 | |
177 | =item $INPUT_LINE_NUMBER |
178 | |
179 | =item $NR |
180 | |
181 | =item $. |
182 | |
6e2995f4 |
183 | The current input line number for the last file handle from |
184 | which you read (or performed a C<seek> or <tell> on). An |
185 | explicit close on a filehandle resets the line number. Since |
4633a7c4 |
186 | "C<E<lt>E<gt>>" never does an explicit close, line numbers increase |
187 | across ARGV files (but see examples under eof()). Localizing C<$.> has |
188 | the effect of also localizing Perl's notion of "the last read |
189 | filehandle". (Mnemonic: many programs use "." to mean the current line |
190 | number.) |
a0d0e21e |
191 | |
192 | =item input_record_separator HANDLE EXPR |
193 | |
194 | =item $INPUT_RECORD_SEPARATOR |
195 | |
196 | =item $RS |
197 | |
198 | =item $/ |
199 | |
200 | The input record separator, newline by default. Works like B<awk>'s RS |
201 | variable, including treating blank lines as delimiters if set to the |
202 | null string. You may set it to a multicharacter string to match a |
203 | multi-character delimiter. Note that setting it to C<"\n\n"> means |
204 | something slightly different than setting it to C<"">, if the file |
205 | contains consecutive blank lines. Setting it to C<""> will treat two or |
206 | more consecutive blank lines as a single blank line. Setting it to |
207 | C<"\n\n"> will blindly assume that the next input character belongs to the |
208 | next paragraph, even if it's a newline. (Mnemonic: / is used to |
209 | delimit line boundaries when quoting poetry.) |
210 | |
211 | undef $/; |
212 | $_ = <FH>; # whole file now here |
213 | s/\n[ \t]+/ /g; |
214 | |
215 | =item autoflush HANDLE EXPR |
216 | |
217 | =item $OUTPUT_AUTOFLUSH |
218 | |
219 | =item $| |
220 | |
221 | If set to nonzero, forces a flush after every write or print on the |
6e2995f4 |
222 | currently selected output channel. Default is 0 (regardless of whether |
223 | the channel is actually buffered by the system or not; C<$|> only tells |
224 | you whether you've asked Perl to explicitly flush after each write). |
225 | Note that STDOUT will typically be line buffered if output is to the |
226 | terminal and block buffered otherwise. Setting this variable is useful |
227 | primarily when you are outputting to a pipe, such as when you are running |
228 | a Perl script under rsh and want to see the output as it's happening. This |
229 | has no effect on input buffering. |
cb1a09d0 |
230 | (Mnemonic: when you want your pipes to be piping hot.) |
a0d0e21e |
231 | |
232 | =item output_field_separator HANDLE EXPR |
233 | |
234 | =item $OUTPUT_FIELD_SEPARATOR |
235 | |
236 | =item $OFS |
237 | |
238 | =item $, |
239 | |
240 | The output field separator for the print operator. Ordinarily the |
241 | print operator simply prints out the comma separated fields you |
242 | specify. In order to get behavior more like B<awk>, set this variable |
243 | as you would set B<awk>'s OFS variable to specify what is printed |
244 | between fields. (Mnemonic: what is printed when there is a , in your |
245 | print statement.) |
246 | |
247 | =item output_record_separator HANDLE EXPR |
248 | |
249 | =item $OUTPUT_RECORD_SEPARATOR |
250 | |
251 | =item $ORS |
252 | |
253 | =item $\ |
254 | |
255 | The output record separator for the print operator. Ordinarily the |
256 | print operator simply prints out the comma separated fields you |
257 | specify, with no trailing newline or record separator assumed. In |
258 | order to get behavior more like B<awk>, set this variable as you would |
259 | set B<awk>'s ORS variable to specify what is printed at the end of the |
260 | print. (Mnemonic: you set "C<$\>" instead of adding \n at the end of the |
261 | print. Also, it's just like /, but it's what you get "back" from |
262 | Perl.) |
263 | |
264 | =item $LIST_SEPARATOR |
265 | |
266 | =item $" |
267 | |
268 | This is like "C<$,>" except that it applies to array values interpolated |
269 | into a double-quoted string (or similar interpreted string). Default |
270 | is a space. (Mnemonic: obvious, I think.) |
271 | |
272 | =item $SUBSCRIPT_SEPARATOR |
273 | |
274 | =item $SUBSEP |
275 | |
276 | =item $; |
277 | |
278 | The subscript separator for multi-dimensional array emulation. If you |
279 | refer to a hash element as |
280 | |
281 | $foo{$a,$b,$c} |
282 | |
283 | it really means |
284 | |
285 | $foo{join($;, $a, $b, $c)} |
286 | |
287 | But don't put |
288 | |
289 | @foo{$a,$b,$c} # a slice--note the @ |
290 | |
291 | which means |
292 | |
293 | ($foo{$a},$foo{$b},$foo{$c}) |
294 | |
295 | Default is "\034", the same as SUBSEP in B<awk>. Note that if your |
296 | keys contain binary data there might not be any safe value for "C<$;>". |
297 | (Mnemonic: comma (the syntactic subscript separator) is a |
298 | semi-semicolon. Yeah, I know, it's pretty lame, but "C<$,>" is already |
299 | taken for something more important.) |
300 | |
301 | Consider using "real" multi-dimensional arrays in Perl 5. |
302 | |
303 | =item $OFMT |
304 | |
305 | =item $# |
306 | |
307 | The output format for printed numbers. This variable is a half-hearted |
308 | attempt to emulate B<awk>'s OFMT variable. There are times, however, |
309 | when B<awk> and Perl have differing notions of what is in fact |
6e2995f4 |
310 | numeric. The initial value is %.I<n>g, where I<n> is the value |
311 | of the macro DBL_DIG from your system's F<float.h>. This is different from |
312 | B<awk>'s default OFMT setting of %.6g, so you need to set "C<$#>" |
313 | explicitly to get B<awk>'s value. (Mnemonic: # is the number sign.) |
a0d0e21e |
314 | |
315 | Use of "C<$#>" is deprecated in Perl 5. |
316 | |
317 | =item format_page_number HANDLE EXPR |
318 | |
319 | =item $FORMAT_PAGE_NUMBER |
320 | |
321 | =item $% |
322 | |
323 | The current page number of the currently selected output channel. |
324 | (Mnemonic: % is page number in B<nroff>.) |
325 | |
326 | =item format_lines_per_page HANDLE EXPR |
327 | |
328 | =item $FORMAT_LINES_PER_PAGE |
329 | |
330 | =item $= |
331 | |
332 | The current page length (printable lines) of the currently selected |
333 | output channel. Default is 60. (Mnemonic: = has horizontal lines.) |
334 | |
335 | =item format_lines_left HANDLE EXPR |
336 | |
337 | =item $FORMAT_LINES_LEFT |
338 | |
339 | =item $- |
340 | |
341 | The number of lines left on the page of the currently selected output |
342 | channel. (Mnemonic: lines_on_page - lines_printed.) |
343 | |
344 | =item format_name HANDLE EXPR |
345 | |
346 | =item $FORMAT_NAME |
347 | |
348 | =item $~ |
349 | |
350 | The name of the current report format for the currently selected output |
351 | channel. Default is name of the filehandle. (Mnemonic: brother to |
352 | "C<$^>".) |
353 | |
354 | =item format_top_name HANDLE EXPR |
355 | |
356 | =item $FORMAT_TOP_NAME |
357 | |
358 | =item $^ |
359 | |
360 | The name of the current top-of-page format for the currently selected |
361 | output channel. Default is name of the filehandle with _TOP |
362 | appended. (Mnemonic: points to top of page.) |
363 | |
364 | =item format_line_break_characters HANDLE EXPR |
365 | |
366 | =item $FORMAT_LINE_BREAK_CHARACTERS |
367 | |
368 | =item $: |
369 | |
370 | The current set of characters after which a string may be broken to |
371 | fill continuation fields (starting with ^) in a format. Default is |
372 | S<" \n-">, to break on whitespace or hyphens. (Mnemonic: a "colon" in |
373 | poetry is a part of a line.) |
374 | |
375 | =item format_formfeed HANDLE EXPR |
376 | |
377 | =item $FORMAT_FORMFEED |
378 | |
379 | =item $^L |
380 | |
381 | What formats output to perform a formfeed. Default is \f. |
382 | |
383 | =item $ACCUMULATOR |
384 | |
385 | =item $^A |
386 | |
387 | The current value of the write() accumulator for format() lines. A format |
388 | contains formline() commands that put their result into C<$^A>. After |
389 | calling its format, write() prints out the contents of C<$^A> and empties. |
390 | So you never actually see the contents of C<$^A> unless you call |
391 | formline() yourself and then look at it. See L<perlform> and |
392 | L<perlfunc/formline()>. |
393 | |
394 | =item $CHILD_ERROR |
395 | |
396 | =item $? |
397 | |
398 | The status returned by the last pipe close, backtick (C<``>) command, |
399 | or system() operator. Note that this is the status word returned by |
400 | the wait() system call, so the exit value of the subprocess is actually |
401 | (C<$? E<gt>E<gt> 8>). Thus on many systems, C<$? & 255> gives which signal, |
402 | if any, the process died from, and whether there was a core dump. |
403 | (Mnemonic: similar to B<sh> and B<ksh>.) |
404 | |
405 | =item $OS_ERROR |
406 | |
407 | =item $ERRNO |
408 | |
409 | =item $! |
410 | |
411 | If used in a numeric context, yields the current value of errno, with |
412 | all the usual caveats. (This means that you shouldn't depend on the |
413 | value of "C<$!>" to be anything in particular unless you've gotten a |
414 | specific error return indicating a system error.) If used in a string |
415 | context, yields the corresponding system error string. You can assign |
416 | to "C<$!>" in order to set I<errno> if, for instance, you want "C<$!>" to return the |
417 | string for error I<n>, or you want to set the exit value for the die() |
418 | operator. (Mnemonic: What just went bang?) |
419 | |
5c055ba3 |
420 | =item $EXTENDED_OS_ERROR |
421 | |
422 | =item $^E |
423 | |
424 | More specific information about the last system error than that |
425 | provided by C<$!>, if available. (If not, it's just C<$!> again.) |
426 | At the moment, this differs from C<$!> only under VMS, where it |
427 | provides the VMS status value from the last system error. The |
428 | caveats mentioned in the description of C<$!> apply here, too. |
429 | (Mnemonic: Extra error explanation.) |
430 | |
431 | |
a0d0e21e |
432 | =item $EVAL_ERROR |
433 | |
434 | =item $@ |
435 | |
436 | The Perl syntax error message from the last eval() command. If null, the |
437 | last eval() parsed and executed correctly (although the operations you |
438 | invoked may have failed in the normal fashion). (Mnemonic: Where was |
439 | the syntax error "at"?) |
440 | |
748a9306 |
441 | Note that warning messages are not collected in this variable. You can, |
442 | however, set up a routine to process warnings by setting $SIG{__WARN__} below. |
443 | |
a0d0e21e |
444 | =item $PROCESS_ID |
445 | |
446 | =item $PID |
447 | |
448 | =item $$ |
449 | |
450 | The process number of the Perl running this script. (Mnemonic: same |
451 | as shells.) |
452 | |
453 | =item $REAL_USER_ID |
454 | |
455 | =item $UID |
456 | |
457 | =item $< |
458 | |
459 | The real uid of this process. (Mnemonic: it's the uid you came I<FROM>, |
460 | if you're running setuid.) |
461 | |
462 | =item $EFFECTIVE_USER_ID |
463 | |
464 | =item $EUID |
465 | |
466 | =item $> |
467 | |
468 | The effective uid of this process. Example: |
469 | |
470 | $< = $>; # set real to effective uid |
471 | ($<,$>) = ($>,$<); # swap real and effective uid |
472 | |
473 | (Mnemonic: it's the uid you went I<TO>, if you're running setuid.) Note: |
474 | "C<$E<lt>>" and "C<$E<gt>>" can only be swapped on machines supporting setreuid(). |
475 | |
476 | =item $REAL_GROUP_ID |
477 | |
478 | =item $GID |
479 | |
480 | =item $( |
481 | |
482 | The real gid of this process. If you are on a machine that supports |
483 | membership in multiple groups simultaneously, gives a space separated |
484 | list of groups you are in. The first number is the one returned by |
485 | getgid(), and the subsequent ones by getgroups(), one of which may be |
486 | the same as the first number. (Mnemonic: parentheses are used to I<GROUP> |
487 | things. The real gid is the group you I<LEFT>, if you're running setgid.) |
488 | |
489 | =item $EFFECTIVE_GROUP_ID |
490 | |
491 | =item $EGID |
492 | |
493 | =item $) |
494 | |
495 | The effective gid of this process. If you are on a machine that |
496 | supports membership in multiple groups simultaneously, gives a space |
497 | separated list of groups you are in. The first number is the one |
498 | returned by getegid(), and the subsequent ones by getgroups(), one of |
499 | which may be the same as the first number. (Mnemonic: parentheses are |
500 | used to I<GROUP> things. The effective gid is the group that's I<RIGHT> for |
501 | you, if you're running setgid.) |
502 | |
503 | Note: "C<$E<lt>>", "C<$E<gt>>", "C<$(>" and "C<$)>" can only be set on machines |
504 | that support the corresponding I<set[re][ug]id()> routine. "C<$(>" and "C<$)>" |
cb1a09d0 |
505 | can only be swapped on machines supporting setregid(). Because Perl doesn't |
506 | currently use initgroups(), you can't set your group vector to multiple groups. |
a0d0e21e |
507 | |
508 | =item $PROGRAM_NAME |
509 | |
510 | =item $0 |
511 | |
512 | Contains the name of the file containing the Perl script being |
513 | executed. Assigning to "C<$0>" modifies the argument area that the ps(1) |
514 | program sees. This is more useful as a way of indicating the |
515 | current program state than it is for hiding the program you're running. |
516 | (Mnemonic: same as B<sh> and B<ksh>.) |
517 | |
518 | =item $[ |
519 | |
520 | The index of the first element in an array, and of the first character |
521 | in a substring. Default is 0, but you could set it to 1 to make |
522 | Perl behave more like B<awk> (or Fortran) when subscripting and when |
523 | evaluating the index() and substr() functions. (Mnemonic: [ begins |
524 | subscripts.) |
525 | |
526 | As of Perl 5, assignment to "C<$[>" is treated as a compiler directive, |
527 | and cannot influence the behavior of any other file. Its use is |
528 | discouraged. |
529 | |
530 | =item $PERL_VERSION |
531 | |
532 | =item $] |
533 | |
cb1a09d0 |
534 | The string printed out when you say C<perl -v>. |
535 | (This is currently I<BROKEN>). |
536 | It can be used to |
a0d0e21e |
537 | determine at the beginning of a script whether the perl interpreter |
538 | executing the script is in the right range of versions. If used in a |
539 | numeric context, returns the version + patchlevel / 1000. Example: |
540 | |
541 | # see if getc is available |
542 | ($version,$patchlevel) = |
543 | $] =~ /(\d+\.\d+).*\nPatch level: (\d+)/; |
544 | print STDERR "(No filename completion available.)\n" |
545 | if $version * 1000 + $patchlevel < 2016; |
546 | |
547 | or, used numerically, |
548 | |
549 | warn "No checksumming!\n" if $] < 3.019; |
550 | |
551 | (Mnemonic: Is this version of perl in the right bracket?) |
552 | |
553 | =item $DEBUGGING |
554 | |
555 | =item $^D |
556 | |
557 | The current value of the debugging flags. (Mnemonic: value of B<-D> |
558 | switch.) |
559 | |
560 | =item $SYSTEM_FD_MAX |
561 | |
562 | =item $^F |
563 | |
564 | The maximum system file descriptor, ordinarily 2. System file |
565 | descriptors are passed to exec()ed processes, while higher file |
566 | descriptors are not. Also, during an open(), system file descriptors are |
567 | preserved even if the open() fails. (Ordinary file descriptors are |
568 | closed before the open() is attempted.) Note that the close-on-exec |
569 | status of a file descriptor will be decided according to the value of |
570 | C<$^F> at the time of the open, not the time of the exec. |
571 | |
6e2995f4 |
572 | =item $^H |
573 | |
574 | The current set of syntax checks enabled by C<use strict>. See the |
575 | documentation of C<strict> for more details. |
576 | |
a0d0e21e |
577 | =item $INPLACE_EDIT |
578 | |
579 | =item $^I |
580 | |
581 | The current value of the inplace-edit extension. Use C<undef> to disable |
582 | inplace editing. (Mnemonic: value of B<-i> switch.) |
583 | |
5c055ba3 |
584 | =item $OSNAME |
6e2995f4 |
585 | |
5c055ba3 |
586 | =item $^O |
587 | |
588 | The name of the operating system under which this copy of Perl was |
589 | built, as determined during the configuration process. The value |
590 | is identical to C<$Config{'osname'}>. |
591 | |
a0d0e21e |
592 | =item $PERLDB |
593 | |
594 | =item $^P |
595 | |
596 | The internal flag that the debugger clears so that it doesn't debug |
5c055ba3 |
597 | itself. You could conceivably disable debugging yourself by clearing |
a0d0e21e |
598 | it. |
599 | |
600 | =item $BASETIME |
601 | |
602 | =item $^T |
603 | |
604 | The time at which the script began running, in seconds since the |
605 | epoch (beginning of 1970). The values returned by the B<-M>, B<-A> |
606 | and B<-C> filetests are |
607 | based on this value. |
608 | |
609 | =item $WARNING |
610 | |
611 | =item $^W |
612 | |
613 | The current value of the warning switch, either TRUE or FALSE. (Mnemonic: related to the |
614 | B<-w> switch.) |
615 | |
616 | =item $EXECUTABLE_NAME |
617 | |
618 | =item $^X |
619 | |
620 | The name that the Perl binary itself was executed as, from C's C<argv[0]>. |
621 | |
622 | =item $ARGV |
623 | |
624 | contains the name of the current file when reading from <>. |
625 | |
626 | =item @ARGV |
627 | |
628 | The array @ARGV contains the command line arguments intended for the |
629 | script. Note that C<$#ARGV> is the generally number of arguments minus |
630 | one, since C<$ARGV[0]> is the first argument, I<NOT> the command name. See |
631 | "C<$0>" for the command name. |
632 | |
633 | =item @INC |
634 | |
635 | The array @INC contains the list of places to look for Perl scripts to |
636 | be evaluated by the C<do EXPR>, C<require>, or C<use> constructs. It |
637 | initially consists of the arguments to any B<-I> command line switches, |
6e2995f4 |
638 | followed by the default Perl library, probably F</usr/local/lib/perl>, |
cb1a09d0 |
639 | followed by ".", to represent the current directory. If you need to |
640 | modify this at runtime, you should use the C<use lib> pragma in order |
641 | to also get the machine-dependent library properly loaded: |
a0d0e21e |
642 | |
cb1a09d0 |
643 | use lib '/mypath/libdir/'; |
644 | use SomeMod; |
645 | |
a0d0e21e |
646 | =item %INC |
647 | |
648 | The hash %INC contains entries for each filename that has |
649 | been included via C<do> or C<require>. The key is the filename you |
650 | specified, and the value is the location of the file actually found. |
651 | The C<require> command uses this array to determine whether a given file |
652 | has already been included. |
653 | |
654 | =item $ENV{expr} |
655 | |
656 | The hash %ENV contains your current environment. Setting a |
657 | value in C<ENV> changes the environment for child processes. |
658 | |
659 | =item $SIG{expr} |
660 | |
661 | The hash %SIG is used to set signal handlers for various |
662 | signals. Example: |
663 | |
664 | sub handler { # 1st argument is signal name |
665 | local($sig) = @_; |
666 | print "Caught a SIG$sig--shutting down\n"; |
667 | close(LOG); |
668 | exit(0); |
669 | } |
670 | |
671 | $SIG{'INT'} = 'handler'; |
672 | $SIG{'QUIT'} = 'handler'; |
673 | ... |
674 | $SIG{'INT'} = 'DEFAULT'; # restore default action |
675 | $SIG{'QUIT'} = 'IGNORE'; # ignore SIGQUIT |
676 | |
677 | The %SIG array only contains values for the signals actually set within |
678 | the Perl script. Here are some other examples: |
679 | |
680 | $SIG{PIPE} = Plumber; # SCARY!! |
681 | $SIG{"PIPE"} = "Plumber"; # just fine, assumes main::Plumber |
682 | $SIG{"PIPE"} = \&Plumber; # just fine; assume current Plumber |
683 | $SIG{"PIPE"} = Plumber(); # oops, what did Plumber() return?? |
684 | |
685 | The one marked scary is problematic because it's a bareword, which means |
686 | sometimes it's a string representing the function, and sometimes it's |
687 | going to call the subroutine call right then and there! Best to be sure |
748a9306 |
688 | and quote it or take a reference to it. *Plumber works too. See L<perlsubs>. |
689 | |
690 | Certain internal hooks can be also set using the %SIG hash. The |
691 | routine indicated by $SIG{__WARN__} is called when a warning message is |
692 | about to be printed. The warning message is passed as the first |
693 | argument. The presence of a __WARN__ hook causes the ordinary printing |
694 | of warnings to STDERR to be suppressed. You can use this to save warnings |
695 | in a variable, or turn warnings into fatal errors, like this: |
696 | |
697 | local $SIG{__WARN__} = sub { die $_[0] }; |
698 | eval $proggie; |
699 | |
700 | The routine indicated by $SIG{__DIE__} is called when a fatal exception |
701 | is about to be thrown. The error message is passed as the first |
702 | argument. When a __DIE__ hook routine returns, the exception |
703 | processing continues as it would have in the absence of the hook, |
cb1a09d0 |
704 | unless the hook routine itself exits via a C<goto>, a loop exit, or a die(). |
705 | The __DIE__ handler is explicitly disabled during the call, so that you |
706 | can die from a __DIE__ handler. Similarly for __WARN__. |
a0d0e21e |
707 | |
708 | =back |