Commit | Line | Data |
a0d0e21e |
1 | =head1 NAME |
2 | |
3 | perlrun - how to execute the Perl interpreter |
4 | |
5 | =head1 SYNOPSIS |
6 | |
e0ebc809 |
7 | B<perl> S<[ B<-sTuU> ]> |
8 | S<[ B<-hv> ] [ B<-V>[:I<configvar>] ]> |
9 | S<[ B<-cw> ] [ B<-d>[:I<debugger>] ] [ B<-D>[I<number/list>] ]> |
10 | S<[ B<-pna> ] [ B<-F>I<pattern> ] [ B<-l>[I<octal>] ] [ B<-0>[I<octal>] ]> |
11 | S<[ B<-I>I<dir> ] [ B<-m>[B<->]I<module> ] [ B<-M>[B<->]I<'module...'> ]> |
12 | S<[ B<-P> ]> |
13 | S<[ B<-S> ]> |
14 | S<[ B<-x>[I<dir>] ]> |
15 | S<[ B<-i>[I<extension>] ]> |
16 | S<[ B<-e> I<'command'> ] [ B<--> ] [ I<programfile> ] [ I<argument> ]...> |
a0d0e21e |
17 | |
18 | =head1 DESCRIPTION |
19 | |
20 | Upon startup, Perl looks for your script in one of the following |
21 | places: |
22 | |
23 | =over 4 |
24 | |
25 | =item 1. |
26 | |
27 | Specified line by line via B<-e> switches on the command line. |
28 | |
29 | =item 2. |
30 | |
31 | Contained in the file specified by the first filename on the command line. |
32 | (Note that systems supporting the #! notation invoke interpreters this way.) |
33 | |
34 | =item 3. |
35 | |
5f05dabc |
36 | Passed in implicitly via standard input. This works only if there are |
a0d0e21e |
37 | no filename arguments--to pass arguments to a STDIN script you |
38 | must explicitly specify a "-" for the script name. |
39 | |
40 | =back |
41 | |
42 | With methods 2 and 3, Perl starts parsing the input file from the |
43 | beginning, unless you've specified a B<-x> switch, in which case it |
44 | scans for the first line starting with #! and containing the word |
45 | "perl", and starts there instead. This is useful for running a script |
46 | embedded in a larger message. (In this case you would indicate the end |
47 | of the script using the __END__ token.) |
48 | |
5f05dabc |
49 | The #! line is always examined for switches as the line is being |
50 | parsed. Thus, if you're on a machine that allows only one argument |
51 | with the #! line, or worse, doesn't even recognize the #! line, you |
52 | still can get consistent switch behavior regardless of how Perl was |
53 | invoked, even if B<-x> was used to find the beginning of the script. |
a0d0e21e |
54 | |
55 | Because many operating systems silently chop off kernel interpretation of |
56 | the #! line after 32 characters, some switches may be passed in on the |
57 | command line, and some may not; you could even get a "-" without its |
58 | letter, if you're not careful. You probably want to make sure that all |
59 | your switches fall either before or after that 32 character boundary. |
60 | Most switches don't actually care if they're processed redundantly, but |
61 | getting a - instead of a complete switch could cause Perl to try to |
62 | execute standard input instead of your script. And a partial B<-I> switch |
63 | could also cause odd results. |
64 | |
65 | Parsing of the #! switches starts wherever "perl" is mentioned in the line. |
66 | The sequences "-*" and "- " are specifically ignored so that you could, |
67 | if you were so inclined, say |
68 | |
69 | #!/bin/sh -- # -*- perl -*- -p |
5f05dabc |
70 | eval 'exec /usr/bin/perl $0 -S ${1+"$@"}' |
71 | if $running_under_some_shell; |
a0d0e21e |
72 | |
73 | to let Perl see the B<-p> switch. |
74 | |
75 | If the #! line does not contain the word "perl", the program named after |
76 | the #! is executed instead of the Perl interpreter. This is slightly |
77 | bizarre, but it helps people on machines that don't do #!, because they |
78 | can tell a program that their SHELL is /usr/bin/perl, and Perl will then |
79 | dispatch the program to the correct interpreter for them. |
80 | |
81 | After locating your script, Perl compiles the entire script to an |
82 | internal form. If there are any compilation errors, execution of the |
83 | script is not attempted. (This is unlike the typical shell script, |
84 | which might run partway through before finding a syntax error.) |
85 | |
86 | If the script is syntactically correct, it is executed. If the script |
87 | runs off the end without hitting an exit() or die() operator, an implicit |
88 | C<exit(0)> is provided to indicate successful completion. |
89 | |
3c10ad8e |
90 | =head2 #! and quoting on non-Unix systems |
91 | |
92 | Unix's #! technique can be simulated on other systems: |
93 | |
94 | =over 4 |
95 | |
96 | =item OS/2 |
97 | |
98 | Put |
99 | |
100 | extproc perl -S -your_switches |
101 | |
102 | as the first line in C<*.cmd> file (C<-S> due to a bug in cmd.exe's |
103 | `extproc' handling). |
104 | |
105 | =item DOS |
106 | |
107 | Create a batch file to run your script, and codify it in |
108 | C<ALTERNATIVE_SHEBANG> (see the F<dosish.h> file in the source |
109 | distribution for more information). |
110 | |
111 | =item Win95/NT |
112 | |
113 | The Win95/NT installation, when using the Activeware port of Perl, |
114 | will modify the Registry to associate the .pl extension with the perl |
115 | interpreter. If you install another port, or (eventually) build your |
116 | own Win95/NT Perl using WinGCC, then you'll have to modify the |
117 | Registry yourself. |
118 | |
119 | =item Macintosh |
120 | |
121 | Macintosh perl scripts will have the the appropriate Creator and |
122 | Type, so that double-clicking them will invoke the perl application. |
123 | |
124 | =back |
125 | |
126 | Command-interpreters on non-Unix systems have rather different ideas |
127 | on quoting than Unix shells. You'll need to learn the special |
128 | characters in your command-interpreter (C<*>, C<\> and C<"> are |
129 | common) and how to protect whitespace and these characters to run |
130 | one-liners (see C<-e> below). |
131 | |
132 | On some systems, you may have to change single-quotes to double ones, |
133 | which you must I<NOT> do on Unix or Plan9 systems. You might also |
134 | have to change a single % to a %%. |
135 | |
136 | For example: |
137 | |
138 | # Unix |
139 | perl -e 'print "Hello world\n"' |
140 | |
141 | # DOS, etc. |
142 | perl -e "print \"Hello world\n\"" |
143 | |
144 | # Mac |
145 | print "Hello world\n" |
146 | (then Run "Myscript" or Shift-Command-R) |
147 | |
148 | # VMS |
149 | perl -e "print ""Hello world\n""" |
150 | |
151 | The problem is that none of this is reliable: it depends on the command |
152 | tirely possible neither works. If 4DOS was the command shell, I'd |
153 | probably have better luck like this: |
154 | |
155 | perl -e "print <Ctrl-x>"Hello world\n<Ctrl-x>"" |
156 | |
157 | CMD.EXE in Windows NT slipped a lot of standard Unix functionality in |
158 | when nobody was looking, but just try to find documentation for its |
159 | quoting rules. |
160 | |
161 | Under the Mac, it depends which environment you are using. The MacPerl |
162 | shell, or MPW, is much like Unix shells in its support for several |
163 | quoting variants, except that it makes free use of the Mac's non-ASCII |
164 | characters as control characters. |
165 | |
166 | I'm afraid that there is no general solution to all of this. It is a |
167 | mess, pure and simple. |
168 | |
169 | [Some of this answer was contributed by Kenneth Albanowski.] |
170 | |
a0d0e21e |
171 | =head2 Switches |
172 | |
173 | A single-character switch may be combined with the following switch, if |
174 | any. |
175 | |
176 | #!/usr/bin/perl -spi.bak # same as -s -p -i.bak |
177 | |
178 | Switches include: |
179 | |
180 | =over 5 |
181 | |
e0ebc809 |
182 | =item B<-0>[I<digits>] |
a0d0e21e |
183 | |
55497cff |
184 | specifies the input record separator (C<$/>) as an octal number. If there are |
a0d0e21e |
185 | no digits, the null character is the separator. Other switches may |
186 | precede or follow the digits. For example, if you have a version of |
187 | B<find> which can print filenames terminated by the null character, you |
188 | can say this: |
189 | |
190 | find . -name '*.bak' -print0 | perl -n0e unlink |
191 | |
192 | The special value 00 will cause Perl to slurp files in paragraph mode. |
5f05dabc |
193 | The value 0777 will cause Perl to slurp files whole because there is no |
a0d0e21e |
194 | legal character with that value. |
195 | |
196 | =item B<-a> |
197 | |
198 | turns on autosplit mode when used with a B<-n> or B<-p>. An implicit |
199 | split command to the @F array is done as the first thing inside the |
200 | implicit while loop produced by the B<-n> or B<-p>. |
201 | |
202 | perl -ane 'print pop(@F), "\n";' |
203 | |
204 | is equivalent to |
205 | |
206 | while (<>) { |
207 | @F = split(' '); |
208 | print pop(@F), "\n"; |
209 | } |
210 | |
211 | An alternate delimiter may be specified using B<-F>. |
212 | |
213 | =item B<-c> |
214 | |
215 | causes Perl to check the syntax of the script and then exit without |
cb1a09d0 |
216 | executing it. Actually, it I<will> execute C<BEGIN>, C<END>, and C<use> blocks, |
5f05dabc |
217 | because these are considered as occurring outside the execution of |
cb1a09d0 |
218 | your program. |
a0d0e21e |
219 | |
220 | =item B<-d> |
221 | |
222 | runs the script under the Perl debugger. See L<perldebug>. |
223 | |
e0ebc809 |
224 | =item B<-d:>I<foo> |
3c81428c |
225 | |
226 | runs the script under the control of a debugging or tracing module |
a77489aa |
227 | installed as Devel::foo. E.g., B<-d:DProf> executes the script using the |
3c81428c |
228 | Devel::DProf profiler. See L<perldebug>. |
229 | |
a0d0e21e |
230 | =item B<-D>I<number> |
231 | |
232 | =item B<-D>I<list> |
233 | |
234 | sets debugging flags. To watch how it executes your script, use |
5f05dabc |
235 | B<-D14>. (This works only if debugging is compiled into your |
a0d0e21e |
236 | Perl.) Another nice value is B<-D1024>, which lists your compiled |
237 | syntax tree. And B<-D512> displays compiled regular expressions. As an |
5f05dabc |
238 | alternative specify a list of letters instead of numbers (e.g., B<-D14> is |
a0d0e21e |
239 | equivalent to B<-Dtls>): |
240 | |
241 | 1 p Tokenizing and Parsing |
242 | 2 s Stack Snapshots |
243 | 4 l Label Stack Processing |
244 | 8 t Trace Execution |
245 | 16 o Operator Node Construction |
246 | 32 c String/Numeric Conversions |
247 | 64 P Print Preprocessor Command for -P |
248 | 128 m Memory Allocation |
249 | 256 f Format Processing |
250 | 512 r Regular Expression Parsing |
251 | 1024 x Syntax Tree Dump |
252 | 2048 u Tainting Checks |
253 | 4096 L Memory Leaks (not supported anymore) |
254 | 8192 H Hash Dump -- usurps values() |
255 | 16384 X Scratchpad Allocation |
256 | 32768 D Cleaning Up |
257 | |
258 | =item B<-e> I<commandline> |
259 | |
260 | may be used to enter one line of script. |
261 | If B<-e> is given, Perl |
262 | will not look for a script filename in the argument list. |
263 | Multiple B<-e> commands may |
264 | be given to build up a multi-line script. |
265 | Make sure to use semicolons where you would in a normal program. |
266 | |
e0ebc809 |
267 | =item B<-F>I<pattern> |
a0d0e21e |
268 | |
e0ebc809 |
269 | specifies the pattern to split on if B<-a> is also in effect. The |
5f05dabc |
270 | pattern may be surrounded by C<//>, C<"">, or C<''>, otherwise it will be |
e0ebc809 |
271 | put in single quotes. |
a0d0e21e |
272 | |
e0ebc809 |
273 | =item B<-h> |
274 | |
275 | prints a summary of the options. |
276 | |
277 | =item B<-i>[I<extension>] |
a0d0e21e |
278 | |
279 | specifies that files processed by the C<E<lt>E<gt>> construct are to be edited |
280 | in-place. It does this by renaming the input file, opening the output |
281 | file by the original name, and selecting that output file as the default |
282 | for print() statements. The extension, if supplied, is added to the name |
283 | of the old file to make a backup copy. If no extension is supplied, no |
284 | backup is made. From the shell, saying |
285 | |
286 | $ perl -p -i.bak -e "s/foo/bar/; ... " |
287 | |
288 | is the same as using the script: |
289 | |
290 | #!/usr/bin/perl -pi.bak |
291 | s/foo/bar/; |
292 | |
293 | which is equivalent to |
294 | |
295 | #!/usr/bin/perl |
296 | while (<>) { |
297 | if ($ARGV ne $oldargv) { |
298 | rename($ARGV, $ARGV . '.bak'); |
299 | open(ARGVOUT, ">$ARGV"); |
300 | select(ARGVOUT); |
301 | $oldargv = $ARGV; |
302 | } |
303 | s/foo/bar/; |
304 | } |
305 | continue { |
306 | print; # this prints to original filename |
307 | } |
308 | select(STDOUT); |
309 | |
310 | except that the B<-i> form doesn't need to compare $ARGV to $oldargv to |
311 | know when the filename has changed. It does, however, use ARGVOUT for |
312 | the selected filehandle. Note that STDOUT is restored as the |
313 | default output filehandle after the loop. |
314 | |
315 | You can use C<eof> without parenthesis to locate the end of each input file, |
316 | in case you want to append to each file, or reset line numbering (see |
317 | example in L<perlfunc/eof>). |
318 | |
319 | =item B<-I>I<directory> |
320 | |
e0ebc809 |
321 | Directories specified by B<-I> are prepended to the search path for |
1fef88e7 |
322 | modules (C<@INC>), and also tells the C preprocessor where to search for |
e0ebc809 |
323 | include files. The C preprocessor is invoked with B<-P>; by default it |
324 | searches /usr/include and /usr/lib/perl. |
a0d0e21e |
325 | |
e0ebc809 |
326 | =item B<-l>[I<octnum>] |
a0d0e21e |
327 | |
328 | enables automatic line-ending processing. It has two effects: first, |
55497cff |
329 | it automatically chomps "C<$/>" (the input record separator) when used |
330 | with B<-n> or B<-p>, and second, it assigns "C<$\>" |
331 | (the output record separator) to have the value of I<octnum> so that |
332 | any print statements will have that separator added back on. If |
a0d0e21e |
333 | I<octnum> is omitted, sets "C<$\>" to the current value of "C<$/>". For |
334 | instance, to trim lines to 80 columns: |
335 | |
336 | perl -lpe 'substr($_, 80) = ""' |
337 | |
338 | Note that the assignment C<$\ = $/> is done when the switch is processed, |
339 | so the input record separator can be different than the output record |
340 | separator if the B<-l> switch is followed by a B<-0> switch: |
341 | |
342 | gnufind / -print0 | perl -ln0e 'print "found $_" if -p' |
343 | |
1fef88e7 |
344 | This sets C<$\> to newline and then sets C<$/> to the null character. |
a0d0e21e |
345 | |
e0ebc809 |
346 | =item B<-m>[B<->]I<module> |
347 | |
348 | =item B<-M>[B<->]I<module> |
c07a80fd |
349 | |
e0ebc809 |
350 | =item B<-M>[B<->]I<'module ...'> |
351 | |
352 | =item B<-[mM]>[B<->]I<module=arg[,arg]...> |
3c81428c |
353 | |
c07a80fd |
354 | C<-m>I<module> executes C<use> I<module> C<();> before executing your |
355 | script. |
3c81428c |
356 | |
c07a80fd |
357 | C<-M>I<module> executes C<use> I<module> C<;> before executing your |
358 | script. You can use quotes to add extra code after the module name, |
359 | e.g., C<-M'module qw(foo bar)'>. |
3c81428c |
360 | |
a5f75d66 |
361 | If the first character after the C<-M> or C<-m> is a dash (C<->) |
362 | then the 'use' is replaced with 'no'. |
363 | |
c07a80fd |
364 | A little built-in syntactic sugar means you can also say |
e0ebc809 |
365 | C<-mmodule=foo,bar> or C<-Mmodule=foo,bar> as a shortcut for |
366 | C<-M'module qw(foo bar)'>. This avoids the need to use quotes when |
367 | importing symbols. The actual code generated by C<-Mmodule=foo,bar> is |
368 | C<use module split(/,/,q{foo,bar})>. Note that the C<=> form |
a77489aa |
369 | removes the distinction between C<-m> and C<-M>. |
3c81428c |
370 | |
a0d0e21e |
371 | =item B<-n> |
372 | |
373 | causes Perl to assume the following loop around your script, which |
374 | makes it iterate over filename arguments somewhat like B<sed -n> or |
375 | B<awk>: |
376 | |
377 | while (<>) { |
378 | ... # your script goes here |
379 | } |
380 | |
381 | Note that the lines are not printed by default. See B<-p> to have |
382 | lines printed. Here is an efficient way to delete all files older than |
383 | a week: |
384 | |
385 | find . -mtime +7 -print | perl -nle 'unlink;' |
386 | |
387 | This is faster than using the C<-exec> switch of B<find> because you don't |
388 | have to start a process on every filename found. |
389 | |
390 | C<BEGIN> and C<END> blocks may be used to capture control before or after |
391 | the implicit loop, just as in B<awk>. |
392 | |
393 | =item B<-p> |
394 | |
395 | causes Perl to assume the following loop around your script, which |
396 | makes it iterate over filename arguments somewhat like B<sed>: |
397 | |
398 | |
399 | while (<>) { |
400 | ... # your script goes here |
401 | } continue { |
402 | print; |
403 | } |
404 | |
405 | Note that the lines are printed automatically. To suppress printing |
406 | use the B<-n> switch. A B<-p> overrides a B<-n> switch. |
407 | |
408 | C<BEGIN> and C<END> blocks may be used to capture control before or after |
409 | the implicit loop, just as in awk. |
410 | |
411 | =item B<-P> |
412 | |
413 | causes your script to be run through the C preprocessor before |
5f05dabc |
414 | compilation by Perl. (Because both comments and cpp directives begin |
a0d0e21e |
415 | with the # character, you should avoid starting comments with any words |
5f05dabc |
416 | recognized by the C preprocessor such as "if", "else", or "define".) |
a0d0e21e |
417 | |
418 | =item B<-s> |
419 | |
420 | enables some rudimentary switch parsing for switches on the command |
421 | line after the script name but before any filename arguments (or before |
422 | a B<-->). Any switch found there is removed from @ARGV and sets the |
423 | corresponding variable in the Perl script. The following script |
424 | prints "true" if and only if the script is invoked with a B<-xyz> switch. |
425 | |
426 | #!/usr/bin/perl -s |
427 | if ($xyz) { print "true\n"; } |
428 | |
429 | =item B<-S> |
430 | |
431 | makes Perl use the PATH environment variable to search for the |
432 | script (unless the name of the script starts with a slash). Typically |
433 | this is used to emulate #! startup on machines that don't support #!, |
434 | in the following manner: |
435 | |
436 | #!/usr/bin/perl |
5f05dabc |
437 | eval 'exec /usr/bin/perl -S $0 ${1+"$@"}' |
a0d0e21e |
438 | if $running_under_some_shell; |
439 | |
440 | The system ignores the first line and feeds the script to /bin/sh, |
441 | which proceeds to try to execute the Perl script as a shell script. |
442 | The shell executes the second line as a normal shell command, and thus |
443 | starts up the Perl interpreter. On some systems $0 doesn't always |
444 | contain the full pathname, so the B<-S> tells Perl to search for the |
445 | script if necessary. After Perl locates the script, it parses the |
446 | lines and ignores them because the variable $running_under_some_shell |
447 | is never true. A better construct than C<$*> would be C<${1+"$@"}>, which |
448 | handles embedded spaces and such in the filenames, but doesn't work if |
5f05dabc |
449 | the script is being interpreted by csh. To start up sh rather |
a0d0e21e |
450 | than csh, some systems may have to replace the #! line with a line |
451 | containing just a colon, which will be politely ignored by Perl. Other |
452 | systems can't control that, and need a totally devious construct that |
5f05dabc |
453 | will work under any of csh, sh, or Perl, such as the following: |
a0d0e21e |
454 | |
455 | eval '(exit $?0)' && eval 'exec /usr/bin/perl -S $0 ${1+"$@"}' |
456 | & eval 'exec /usr/bin/perl -S $0 $argv:q' |
5f05dabc |
457 | if $running_under_some_shell; |
a0d0e21e |
458 | |
459 | =item B<-T> |
460 | |
cb1a09d0 |
461 | forces "taint" checks to be turned on so you can test them. Ordinarily these checks are |
462 | done only when running setuid or setgid. It's a good idea to turn |
463 | them on explicitly for programs run on another's behalf, such as CGI |
464 | programs. See L<perlsec>. |
a0d0e21e |
465 | |
466 | =item B<-u> |
467 | |
468 | causes Perl to dump core after compiling your script. You can then |
469 | take this core dump and turn it into an executable file by using the |
470 | B<undump> program (not supplied). This speeds startup at the expense of |
471 | some disk space (which you can minimize by stripping the executable). |
472 | (Still, a "hello world" executable comes out to about 200K on my |
473 | machine.) If you want to execute a portion of your script before dumping, |
474 | use the dump() operator instead. Note: availability of B<undump> is |
475 | platform specific and may not be available for a specific port of |
476 | Perl. |
477 | |
478 | =item B<-U> |
479 | |
480 | allows Perl to do unsafe operations. Currently the only "unsafe" |
481 | operations are the unlinking of directories while running as superuser, |
482 | and running setuid programs with fatal taint checks turned into |
483 | warnings. |
484 | |
485 | =item B<-v> |
486 | |
487 | prints the version and patchlevel of your Perl executable. |
488 | |
3c81428c |
489 | =item B<-V> |
490 | |
491 | prints summary of the major perl configuration values and the current |
492 | value of @INC. |
493 | |
e0ebc809 |
494 | =item B<-V:>I<name> |
3c81428c |
495 | |
496 | Prints to STDOUT the value of the named configuration variable. |
497 | |
a0d0e21e |
498 | =item B<-w> |
499 | |
049cd8b0 |
500 | prints warnings about variable names that are mentioned only once, and |
a0d0e21e |
501 | scalar variables that are used before being set. Also warns about |
502 | redefined subroutines, and references to undefined filehandles or |
5f05dabc |
503 | filehandles opened read-only that you are attempting to write on. Also |
774d564b |
504 | warns you if you use values as a number that doesn't look like numbers, |
505 | using an array as though it were a scalar, if your subroutines recurse |
506 | more than 100 deep, and innumerable other things. |
507 | |
508 | You can disable specific warnings using C<__WARN__> hooks, as described |
509 | in L<perlvar> and L<perlfunc/warn>. See also L<perldiag> and L<perltrap>. |
a0d0e21e |
510 | |
511 | =item B<-x> I<directory> |
512 | |
513 | tells Perl that the script is embedded in a message. Leading |
514 | garbage will be discarded until the first line that starts with #! and |
515 | contains the string "perl". Any meaningful switches on that line will |
ff0cee69 |
516 | be applied. If a directory name is specified, Perl will switch to |
5f05dabc |
517 | that directory before running the script. The B<-x> switch controls |
518 | only the disposal of leading garbage. The script must be |
a0d0e21e |
519 | terminated with C<__END__> if there is trailing garbage to be ignored (the |
520 | script can process any or all of the trailing garbage via the DATA |
521 | filehandle if desired). |
522 | |
1e422769 |
523 | =back |
524 | |
525 | =head1 ENVIRONMENT |
526 | |
527 | =over 12 |
528 | |
529 | =item HOME |
530 | |
531 | Used if chdir has no argument. |
532 | |
533 | =item LOGDIR |
534 | |
535 | Used if chdir has no argument and HOME is not set. |
536 | |
537 | =item PATH |
538 | |
539 | Used in executing subprocesses, and in finding the script if B<-S> is |
540 | used. |
541 | |
542 | =item PERL5LIB |
543 | |
544 | A colon-separated list of directories in which to look for Perl library |
545 | files before looking in the standard library and the current |
546 | directory. If PERL5LIB is not defined, PERLLIB is used. When running |
547 | taint checks (because the script was running setuid or setgid, or the |
548 | B<-T> switch was used), neither variable is used. The script should |
549 | instead say |
550 | |
551 | use lib "/my/directory"; |
552 | |
553 | =item PERLLIB |
554 | |
555 | A colon-separated list of directories in which to look for Perl library |
556 | files before looking in the standard library and the current directory. |
557 | If PERL5LIB is defined, PERLLIB is not used. |
558 | |
559 | =item PERL5DB |
560 | |
561 | The command used to load the debugger code. The default is: |
562 | |
563 | BEGIN { require 'perl5db.pl' } |
564 | |
565 | =item PERL_DEBUG_MSTATS |
566 | |
567 | Relevant only if your perl executable was built with B<-DDEBUGGING_MSTATS>, |
568 | if set, this causes memory statistics to be dumped after execution. If set |
569 | to an integer greater than one, also causes memory statistics to be dumped |
570 | after compilation. |
571 | |
572 | =item PERL_DESTRUCT_LEVEL |
573 | |
574 | Relevant only if your perl executable was built with B<-DDEBUGGING>, |
575 | this controls the behavior of global destruction of objects and other |
576 | references. |
a0d0e21e |
577 | |
578 | =back |
1e422769 |
579 | |
580 | Perl also has environment variables that control how Perl handles data |
581 | specific to particular natural languages. See L<perllocale>. |
582 | |
583 | Apart from these, Perl uses no other environment variables, except |
584 | to make them available to the script being executed, and to child |
585 | processes. However, scripts running setuid would do well to execute |
586 | the following lines before doing anything else, just to keep people |
587 | honest: |
588 | |
589 | $ENV{'PATH'} = '/bin:/usr/bin'; # or whatever you need |
590 | $ENV{'SHELL'} = '/bin/sh' if defined $ENV{'SHELL'}; |
591 | $ENV{'IFS'} = '' if defined $ENV{'IFS'}; |
592 | |