1PERLRUN(1) Perl Programmers Reference Guide PERLRUN(1)
2
6 perlrun - how to execute the Perl interpreter
7
9 perl [ -sTtuUWX ] [ -hv ] [ -V[:configvar] ]
10 [ -cw ] [ -d[t][:debugger] ] [ -D[number/list] ]
11 [ -pna ] [ -Fpattern ] [ -l[octal] ] [ -0[octal/hexadecimal] ]
12 [ -Idir ] [ -m[-]module ] [ -M[-]'module...' ] [ -f ]
13 [ -C [number/list] ] [ -S ] [ -x[dir] ]
14 [ -i[extension] ]
15 [ [-e|-E] 'command' ] [ -- ] [ programfile ] [ argument ]...
16
18 The normal way to run a Perl program is by making it directly
19 executable, or else by passing the name of the source file as an
20 argument on the command line. (An interactive Perl environment is also
21 possible--see perldebug for details on how to do that.) Upon startup,
22 Perl looks for your program in one of the following places:
23 1. Specified line by line via -e or -E switches on the command line.
25 2. Contained in the file specified by the first filename on the
27 command line. (Note that systems supporting the "#!" notation
28 invoke interpreters this way. See "Location of Perl".)
29 3. Passed in implicitly via standard input. This works only if there
31 are no filename arguments--to pass arguments to a STDIN-read
32 program you must explicitly specify a "-" for the program name.
33 With methods 2 and 3, Perl starts parsing the input file from the
35 beginning, unless you've specified a -x switch, in which case it scans
36 for the first line starting with "#!" and containing the word "perl",
37 and starts there instead. This is useful for running a program
38 embedded in a larger message. (In this case you would indicate the end
39 of the program using the "__END__" token.)
40 The "#!" line is always examined for switches as the line is being
42 parsed. Thus, if you're on a machine that allows only one argument
43 with the "#!" line, or worse, doesn't even recognize the "#!" line, you
44 still can get consistent switch behaviour regardless of how Perl was
45 invoked, even if -x was used to find the beginning of the program.
46 Because historically some operating systems silently chopped off kernel
48 interpretation of the "#!" line after 32 characters, some switches may
49 be passed in on the command line, and some may not; you could even get
50 a "-" without its letter, if you're not careful. You probably want to
51 make sure that all your switches fall either before or after that
52 32-character boundary. Most switches don't actually care if they're
53 processed redundantly, but getting a "-" instead of a complete switch
54 could cause Perl to try to execute standard input instead of your
55 program. And a partial -I switch could also cause odd results.
56 Some switches do care if they are processed twice, for instance
58 combinations of -l and -0. Either put all the switches after the
59 32-character boundary (if applicable), or replace the use of -0digits
60 by "BEGIN{ $/ = "\0digits"; }".
61 Parsing of the "#!" switches starts wherever "perl" is mentioned in the
63 line. The sequences "-*" and "- " are specifically ignored so that you
64 could, if you were so inclined, say
65 #!/bin/sh
67 #! -*-perl-*-
68 eval 'exec perl -x -wS $0 ${1+"$@"}'
69 if 0;
70 to let Perl see the -p switch.
72 A similar trick involves the env program, if you have it.
74 #!/usr/bin/env perl
76 The examples above use a relative path to the perl interpreter, getting
78 whatever version is first in the user's path. If you want a specific
79 version of Perl, say, perl5.14.1, you should place that directly in the
80 "#!" line's path.
81 If the "#!" line does not contain the word "perl" nor the word "indir",
83 the program named after the "#!" is executed instead of the Perl
84 interpreter. This is slightly bizarre, but it helps people on machines
85 that don't do "#!", because they can tell a program that their SHELL is
86 /usr/bin/perl, and Perl will then dispatch the program to the correct
87 interpreter for them.
88 After locating your program, Perl compiles the entire program to an
90 internal form. If there are any compilation errors, execution of the
91 program is not attempted. (This is unlike the typical shell script,
92 which might run part-way through before finding a syntax error.)
93 If the program is syntactically correct, it is executed. If the
95 program runs off the end without hitting an exit() or die() operator,
96 an implicit exit(0) is provided to indicate successful completion.
97 #! and quoting on non-Unix systems
99 Unix's "#!" technique can be simulated on other systems:
100 OS/2
102 Put
103 extproc perl -S -your_switches
105 as the first line in "*.cmd" file (-S due to a bug in cmd.exe's
107 `extproc' handling).
108 MS-DOS
110 Create a batch file to run your program, and codify it in
111 "ALTERNATE_SHEBANG" (see the dosish.h file in the source
112 distribution for more information).
113 Win95/NT
115 The Win95/NT installation, when using the ActiveState installer for
116 Perl, will modify the Registry to associate the .pl extension with
117 the perl interpreter. If you install Perl by other means
118 (including building from the sources), you may have to modify the
119 Registry yourself. Note that this means you can no longer tell the
120 difference between an executable Perl program and a Perl library
121 file.
122 VMS Put
124 $ perl -mysw 'f$env("procedure")' 'p1' 'p2' 'p3' 'p4' 'p5' 'p6' 'p7' 'p8' !
126 $ exit++ + ++$status != 0 and $exit = $status = undef;
127 at the top of your program, where -mysw are any command line
129 switches you want to pass to Perl. You can now invoke the program
130 directly, by saying "perl program", or as a DCL procedure, by
131 saying @program (or implicitly via DCL$PATH by just using the name
132 of the program).
133 This incantation is a bit much to remember, but Perl will display
135 it for you if you say "perl "-V:startperl"".
136 Command-interpreters on non-Unix systems have rather different ideas on
138 quoting than Unix shells. You'll need to learn the special characters
139 in your command-interpreter ("*", "\" and """ are common) and how to
140 protect whitespace and these characters to run one-liners (see -e
141 below).
142 On some systems, you may have to change single-quotes to double ones,
144 which you must not do on Unix or Plan 9 systems. You might also have
145 to change a single % to a %%.
146 For example:
148 # Unix
150 perl -e 'print "Hello world\n"'
151 # MS-DOS, etc.
153 perl -e "print \"Hello world\n\""
154 # VMS
156 perl -e "print ""Hello world\n"""
157 The problem is that none of this is reliable: it depends on the command
159 and it is entirely possible neither works. If 4DOS were the command
160 shell, this would probably work better:
161 perl -e "print <Ctrl-x>"Hello world\n<Ctrl-x>""
163 CMD.EXE in Windows NT slipped a lot of standard Unix functionality in
165 when nobody was looking, but just try to find documentation for its
166 quoting rules.
167 There is no general solution to all of this. It's just a mess.
169 Location of Perl
171 It may seem obvious to say, but Perl is useful only when users can
172 easily find it. When possible, it's good for both /usr/bin/perl and
173 /usr/local/bin/perl to be symlinks to the actual binary. If that can't
174 be done, system administrators are strongly encouraged to put (symlinks
175 to) perl and its accompanying utilities into a directory typically
176 found along a user's PATH, or in some other obvious and convenient
177 place.
178 In this documentation, "#!/usr/bin/perl" on the first line of the
180 program will stand in for whatever method works on your system. You
181 are advised to use a specific path if you care about a specific
182 version.
183 #!/usr/local/bin/perl5.14
185 or if you just want to be running at least version, place a statement
187 like this at the top of your program:
188 use 5.014;
190 Command Switches
192 As with all standard commands, a single-character switch may be
193 clustered with the following switch, if any.
194 #!/usr/bin/perl -spi.orig # same as -s -p -i.orig
196 A "--" signals the end of options and disables further option
198 processing. Any arguments after the "--" are treated as filenames and
199 arguments.
200 Switches include:
202 -0[octal/hexadecimal]
204 specifies the input record separator ($/) as an octal or
205 hexadecimal number. If there are no digits, the null character is
206 the separator. Other switches may precede or follow the digits.
207 For example, if you have a version of find which can print
208 filenames terminated by the null character, you can say this:
209 find . -name '*.orig' -print0 | perl -n0e unlink
211 The special value 00 will cause Perl to slurp files in paragraph
213 mode. Any value 0400 or above will cause Perl to slurp files
214 whole, but by convention the value 0777 is the one normally used
215 for this purpose.
216 You can also specify the separator character using hexadecimal
218 notation: -0xHHH..., where the "H" are valid hexadecimal digits.
219 Unlike the octal form, this one may be used to specify any Unicode
220 character, even those beyond 0xFF. So if you really want a record
221 separator of 0777, specify it as -0x1FF. (This means that you
222 cannot use the -x option with a directory name that consists of
223 hexadecimal digits, or else Perl will think you have specified a
224 hex number to -0.)
225 -a turns on autosplit mode when used with a -n or -p. An implicit
227 split command to the @F array is done as the first thing inside
228 the implicit while loop produced by the -n or -p.
229 perl -ane 'print pop(@F), "\n";'
231 is equivalent to
233 while (<>) {
235 @F = split(' ');
236 print pop(@F), "\n";
237 }
238 An alternate delimiter may be specified using -F.
240 -a implicitly sets -n.
242 -C [number/list]
244 The -C flag controls some of the Perl Unicode features.
245 As of 5.8.1, the -C can be followed either by a number or a list
247 of option letters. The letters, their numeric values, and effects
248 are as follows; listing the letters is equal to summing the
249 numbers.
250 I 1 STDIN is assumed to be in UTF-8
252 O 2 STDOUT will be in UTF-8
253 E 4 STDERR will be in UTF-8
254 S 7 I + O + E
255 i 8 UTF-8 is the default PerlIO layer for input streams
256 o 16 UTF-8 is the default PerlIO layer for output streams
257 D 24 i + o
258 A 32 the @ARGV elements are expected to be strings encoded
259 in UTF-8
260 L 64 normally the "IOEioA" are unconditional, the L makes
261 them conditional on the locale environment variables
262 (the LC_ALL, LC_CTYPE, and LANG, in the order of
263 decreasing precedence) -- if the variables indicate
264 UTF-8, then the selected "IOEioA" are in effect
265 a 256 Set ${^UTF8CACHE} to -1, to run the UTF-8 caching
266 code in debugging mode.
267 For example, -COE and -C6 will both turn on UTF-8-ness on both
269 STDOUT and STDERR. Repeating letters is just redundant, not
270 cumulative nor toggling.
271 The "io" options mean that any subsequent open() (or similar I/O
273 operations) in the current file scope will have the ":utf8" PerlIO
274 layer implicitly applied to them, in other words, UTF-8 is
275 expected from any input stream, and UTF-8 is produced to any
276 output stream. This is just the default, with explicit layers in
277 open() and with binmode() one can manipulate streams as usual.
278 -C on its own (not followed by any number or option list), or the
280 empty string "" for the "PERL_UNICODE" environment variable, has
281 the same effect as -CSDL. In other words, the standard I/O
282 handles and the default "open()" layer are UTF-8-fied but only if
283 the locale environment variables indicate a UTF-8 locale. This
284 behaviour follows the implicit (and problematic) UTF-8 behaviour
285 of Perl 5.8.0. (See "UTF-8 no longer default under UTF-8 locales"
286 in perl581delta.)
287 You can use -C0 (or "0" for "PERL_UNICODE") to explicitly disable
289 all the above Unicode features.
290 The read-only magic variable "${^UNICODE}" reflects the numeric
292 value of this setting. This variable is set during Perl startup
293 and is thereafter read-only. If you want runtime effects, use the
294 three-arg open() (see "open" in perlfunc), the two-arg binmode()
295 (see "binmode" in perlfunc), and the "open" pragma (see open).
296 (In Perls earlier than 5.8.1 the -C switch was a Win32-only switch
298 that enabled the use of Unicode-aware "wide system call" Win32
299 APIs. This feature was practically unused, however, and the
300 command line switch was therefore "recycled".)
301 Note: Since perl 5.10.1, if the -C option is used on the "#!"
303 line, it must be specified on the command line as well, since the
304 standard streams are already set up at this point in the execution
305 of the perl interpreter. You can also use binmode() to set the
306 encoding of an I/O stream.
307 -c causes Perl to check the syntax of the program and then exit
309 without executing it. Actually, it will execute any "BEGIN",
310 "UNITCHECK", or "CHECK" blocks and any "use" statements: these are
311 considered as occurring outside the execution of your program.
312 "INIT" and "END" blocks, however, will be skipped.
313 -d
315 -dt runs the program under the Perl debugger. See perldebug. If t is
316 specified, it indicates to the debugger that threads will be used
317 in the code being debugged.
318 -d:MOD[=bar,baz]
320 -dt:MOD[=bar,baz]
321 runs the program under the control of a debugging, profiling, or
322 tracing module installed as "Devel::MOD". E.g., -d:DProf executes
323 the program using the "Devel::DProf" profiler. As with the -M
324 flag, options may be passed to the "Devel::MOD" package where they
325 will be received and interpreted by the "Devel::MOD::import"
326 routine. Again, like -M, use --d:-MOD to call
327 "Devel::MOD::unimport" instead of import. The comma-separated
328 list of options must follow a "=" character. If t is specified,
329 it indicates to the debugger that threads will be used in the code
330 being debugged. See perldebug.
331 -Dletters
333 -Dnumber
334 sets debugging flags. This switch is enabled only if your perl
335 binary has been built with debugging enabled: normal production
336 perls won't have been.
337 For example, to watch how perl executes your program, use -Dtls.
339 Another nice value is -Dx, which lists your compiled syntax tree,
340 and -Dr displays compiled regular expressions; the format of the
341 output is explained in perldebguts.
342 As an alternative, specify a number instead of list of letters
344 (e.g., -D14 is equivalent to -Dtls):
345 1 p Tokenizing and parsing (with v, displays parse
347 stack)
348 2 s Stack snapshots (with v, displays all stacks)
349 4 l Context (loop) stack processing
350 8 t Trace execution
351 16 o Method and overloading resolution
352 32 c String/numeric conversions
353 64 P Print profiling info, source file input state
354 128 m Memory and SV allocation
355 256 f Format processing
356 512 r Regular expression parsing and execution
357 1024 x Syntax tree dump
358 2048 u Tainting checks
359 4096 U Unofficial, User hacking (reserved for private,
360 unreleased use)
361 16384 X Scratchpad allocation
362 32768 D Cleaning up
363 65536 S Op slab allocation
364 131072 T Tokenizing
365 262144 R Include reference counts of dumped variables
366 (eg when using -Ds)
367 524288 J show s,t,P-debug (don't Jump over) on opcodes within
368 package DB
369 1048576 v Verbose: use in conjunction with other flags to
370 increase the verbosity of the output. Is a no-op on
371 many of the other flags
372 2097152 C Copy On Write
373 4194304 A Consistency checks on internal structures
374 8388608 q quiet - currently only suppresses the "EXECUTING"
375 message
376 16777216 M trace smart match resolution
377 33554432 B dump suBroutine definitions, including special
378 Blocks like BEGIN
379 67108864 L trace Locale-related info; what gets output is very
380 subject to change
381 134217728 i trace PerlIO layer processing. Set PERLIO_DEBUG to
382 the filename to trace to.
383 All these flags require -DDEBUGGING when you compile the Perl
385 executable (but see ":opd" in Devel::Peek or "'debug' mode" in re
386 which may change this). See the INSTALL file in the Perl source
387 distribution for how to do this.
388 If you're just trying to get a print out of each line of Perl code
390 as it executes, the way that "sh -x" provides for shell scripts,
391 you can't use Perl's -D switch. Instead do this
392 # If you have "env" utility
394 env PERLDB_OPTS="NonStop=1 AutoTrace=1 frame=2" perl -dS program
395 # Bourne shell syntax
397 $ PERLDB_OPTS="NonStop=1 AutoTrace=1 frame=2" perl -dS program
398 # csh syntax
400 % (setenv PERLDB_OPTS "NonStop=1 AutoTrace=1 frame=2"; perl -dS program)
401 See perldebug for details and variations.
403 -e commandline
405 may be used to enter one line of program. If -e is given, Perl
406 will not look for a filename in the argument list. Multiple -e
407 commands may be given to build up a multi-line script. Make sure
408 to use semicolons where you would in a normal program.
409 -E commandline
411 behaves just like -e, except that it implicitly enables all
412 optional features (in the main compilation unit). See feature.
413 -f Disable executing $Config{sitelib}/sitecustomize.pl at startup.
415 Perl can be built so that it by default will try to execute
417 $Config{sitelib}/sitecustomize.pl at startup (in a BEGIN block).
418 This is a hook that allows the sysadmin to customize how Perl
419 behaves. It can for instance be used to add entries to the @INC
420 array to make Perl find modules in non-standard locations.
421 Perl actually inserts the following code:
423 BEGIN {
425 do { local $!; -f "$Config{sitelib}/sitecustomize.pl"; }
426 && do "$Config{sitelib}/sitecustomize.pl";
427 }
428 Since it is an actual "do" (not a "require"), sitecustomize.pl
430 doesn't need to return a true value. The code is run in package
431 "main", in its own lexical scope. However, if the script dies, $@
432 will not be set.
433 The value of $Config{sitelib} is also determined in C code and not
435 read from "Config.pm", which is not loaded.
436 The code is executed very early. For example, any changes made to
438 @INC will show up in the output of `perl -V`. Of course, "END"
439 blocks will be likewise executed very late.
440 To determine at runtime if this capability has been compiled in
442 your perl, you can check the value of $Config{usesitecustomize}.
443 -Fpattern
445 specifies the pattern to split on for -a. The pattern may be
446 surrounded by "//", "", or '', otherwise it will be put in single
447 quotes. You can't use literal whitespace or NUL characters in the
448 pattern.
449 -F implicitly sets both -a and -n.
451 -h prints a summary of the options.
453 -i[extension]
455 specifies that files processed by the "<>" construct are to be
456 edited in-place. It does this by renaming the input file, opening
457 the output file by the original name, and selecting that output
458 file as the default for print() statements. The extension, if
459 supplied, is used to modify the name of the old file to make a
460 backup copy, following these rules:
461 If no extension is supplied, and your system supports it, the
463 original file is kept open without a name while the output is
464 redirected to a new file with the original filename. When perl
465 exits, cleanly or not, the original file is unlinked.
466 If the extension doesn't contain a "*", then it is appended to the
468 end of the current filename as a suffix. If the extension does
469 contain one or more "*" characters, then each "*" is replaced with
470 the current filename. In Perl terms, you could think of this as:
471 ($backup = $extension) =~ s/\*/$file_name/g;
473 This allows you to add a prefix to the backup file, instead of (or
475 in addition to) a suffix:
476 $ perl -pi'orig_*' -e 's/bar/baz/' fileA # backup to
478 # 'orig_fileA'
479 Or even to place backup copies of the original files into another
481 directory (provided the directory already exists):
482 $ perl -pi'old/*.orig' -e 's/bar/baz/' fileA # backup to
484 # 'old/fileA.orig'
485 These sets of one-liners are equivalent:
487 $ perl -pi -e 's/bar/baz/' fileA # overwrite current file
489 $ perl -pi'*' -e 's/bar/baz/' fileA # overwrite current file
490 $ perl -pi'.orig' -e 's/bar/baz/' fileA # backup to 'fileA.orig'
492 $ perl -pi'*.orig' -e 's/bar/baz/' fileA # backup to 'fileA.orig'
493 From the shell, saying
495 $ perl -p -i.orig -e "s/foo/bar/; ... "
497 is the same as using the program:
499 #!/usr/bin/perl -pi.orig
501 s/foo/bar/;
502 which is equivalent to
504 #!/usr/bin/perl
506 $extension = '.orig';
507 LINE: while (<>) {
508 if ($ARGV ne $oldargv) {
509 if ($extension !~ /\*/) {
510 $backup = $ARGV . $extension;
511 }
512 else {
513 ($backup = $extension) =~ s/\*/$ARGV/g;
514 }
515 rename($ARGV, $backup);
516 open(ARGVOUT, ">$ARGV");
517 select(ARGVOUT);
518 $oldargv = $ARGV;
519 }
520 s/foo/bar/;
521 }
522 continue {
523 print; # this prints to original filename
524 }
525 select(STDOUT);
526 except that the -i form doesn't need to compare $ARGV to $oldargv
528 to know when the filename has changed. It does, however, use
529 ARGVOUT for the selected filehandle. Note that STDOUT is restored
530 as the default output filehandle after the loop.
531 As shown above, Perl creates the backup file whether or not any
533 output is actually changed. So this is just a fancy way to copy
534 files:
535 $ perl -p -i'/some/file/path/*' -e 1 file1 file2 file3...
537 or
538 $ perl -p -i'.orig' -e 1 file1 file2 file3...
539 You can use "eof" without parentheses to locate the end of each
541 input file, in case you want to append to each file, or reset line
542 numbering (see example in "eof" in perlfunc).
543 If, for a given file, Perl is unable to create the backup file as
545 specified in the extension then it will skip that file and
546 continue on with the next one (if it exists).
547 For a discussion of issues surrounding file permissions and -i,
549 see "Why does Perl let me delete read-only files? Why does -i
550 clobber protected files? Isn't this a bug in Perl?" in perlfaq5.
551 You cannot use -i to create directories or to strip extensions
553 from files.
554 Perl does not expand "~" in filenames, which is good, since some
556 folks use it for their backup files:
557 $ perl -pi~ -e 's/foo/bar/' file1 file2 file3...
559 Note that because -i renames or deletes the original file before
561 creating a new file of the same name, Unix-style soft and hard
562 links will not be preserved.
563 Finally, the -i switch does not impede execution when no files are
565 given on the command line. In this case, no backup is made (the
566 original file cannot, of course, be determined) and processing
567 proceeds from STDIN to STDOUT as might be expected.
568 -Idirectory
570 Directories specified by -I are prepended to the search path for
571 modules (@INC).
572 -l[octnum]
574 enables automatic line-ending processing. It has two separate
575 effects. First, it automatically chomps $/ (the input record
576 separator) when used with -n or -p. Second, it assigns "$\" (the
577 output record separator) to have the value of octnum so that any
578 print statements will have that separator added back on. If
579 octnum is omitted, sets "$\" to the current value of $/. For
580 instance, to trim lines to 80 columns:
581 perl -lpe 'substr($_, 80) = ""'
583 Note that the assignment "$\ = $/" is done when the switch is
585 processed, so the input record separator can be different than the
586 output record separator if the -l switch is followed by a -0
587 switch:
588 gnufind / -print0 | perl -ln0e 'print "found $_" if -p'
590 This sets "$\" to newline and then sets $/ to the null character.
592 -m[-]module
594 -M[-]module
595 -M[-]'module ...'
596 -[mM][-]module=arg[,arg]...
597 -mmodule executes "use" module "();" before executing your
598 program. This loads the module, but does not call its "import"
599 method, so does not import subroutines and does not give effect to
600 a pragma.
601 -Mmodule executes "use" module ";" before executing your program.
603 This loads the module and calls its "import" method, causing the
604 module to have its default effect, typically importing subroutines
605 or giving effect to a pragma. You can use quotes to add extra
606 code after the module name, e.g., '-MMODULE qw(foo bar)'.
607 If the first character after the -M or -m is a dash (-) then the
609 'use' is replaced with 'no'. This makes no difference for -m.
610 A little builtin syntactic sugar means you can also say
612 -mMODULE=foo,bar or -MMODULE=foo,bar as a shortcut for '-MMODULE
613 qw(foo bar)'. This avoids the need to use quotes when importing
614 symbols. The actual code generated by -MMODULE=foo,bar is "use
615 module split(/,/,q{foo,bar})". Note that the "=" form removes the
616 distinction between -m and -M; that is, -mMODULE=foo,bar is the
617 same as -MMODULE=foo,bar.
618 A consequence of the "split" formulation is that -MMODULE=number
620 never does a version check, unless "MODULE::import()" itself is
621 set up to do a version check, which could happen for example if
622 MODULE inherits from Exporter.
623 -n causes Perl to assume the following loop around your program,
625 which makes it iterate over filename arguments somewhat like sed
626 -n or awk:
627 LINE:
629 while (<>) {
630 ... # your program goes here
631 }
632 Note that the lines are not printed by default. See "-p" to have
634 lines printed. If a file named by an argument cannot be opened
635 for some reason, Perl warns you about it and moves on to the next
636 file.
637 Also note that "<>" passes command line arguments to "open" in
639 perlfunc, which doesn't necessarily interpret them as file names.
640 See perlop for possible security implications.
641 Here is an efficient way to delete all files that haven't been
643 modified for at least a week:
644 find . -mtime +7 -print | perl -nle unlink
646 This is faster than using the -exec switch of find because you
648 don't have to start a process on every filename found (but it's
649 not faster than using the -delete switch available in newer
650 versions of find. It does suffer from the bug of mishandling
651 newlines in pathnames, which you can fix if you follow the example
652 under -0.
653 "BEGIN" and "END" blocks may be used to capture control before or
655 after the implicit program loop, just as in awk.
656 -p causes Perl to assume the following loop around your program,
658 which makes it iterate over filename arguments somewhat like sed:
659 LINE:
661 while (<>) {
662 ... # your program goes here
663 } continue {
664 print or die "-p destination: $!\n";
665 }
666 If a file named by an argument cannot be opened for some reason,
668 Perl warns you about it, and moves on to the next file. Note that
669 the lines are printed automatically. An error occurring during
670 printing is treated as fatal. To suppress printing use the -n
671 switch. A -p overrides a -n switch.
672 "BEGIN" and "END" blocks may be used to capture control before or
674 after the implicit loop, just as in awk.
675 -s enables rudimentary switch parsing for switches on the command
677 line after the program name but before any filename arguments (or
678 before an argument of --). Any switch found there is removed from
679 @ARGV and sets the corresponding variable in the Perl program.
680 The following program prints "1" if the program is invoked with a
681 -xyz switch, and "abc" if it is invoked with -xyz=abc.
682 #!/usr/bin/perl -s
684 if ($xyz) { print "$xyz\n" }
685 Do note that a switch like --help creates the variable "${-help}",
687 which is not compliant with "use strict "refs"". Also, when using
688 this option on a script with warnings enabled you may get a lot of
689 spurious "used only once" warnings.
690 -S makes Perl use the PATH environment variable to search for the
692 program unless the name of the program contains path separators.
693 On some platforms, this also makes Perl append suffixes to the
695 filename while searching for it. For example, on Win32 platforms,
696 the ".bat" and ".cmd" suffixes are appended if a lookup for the
697 original name fails, and if the name does not already end in one
698 of those suffixes. If your Perl was compiled with "DEBUGGING"
699 turned on, using the -Dp switch to Perl shows how the search
700 progresses.
701 Typically this is used to emulate "#!" startup on platforms that
703 don't support "#!". It's also convenient when debugging a script
704 that uses "#!", and is thus normally found by the shell's $PATH
705 search mechanism.
706 This example works on many platforms that have a shell compatible
708 with Bourne shell:
709 #!/usr/bin/perl
711 eval 'exec /usr/bin/perl -wS $0 ${1+"$@"}'
712 if $running_under_some_shell;
713 The system ignores the first line and feeds the program to
715 /bin/sh, which proceeds to try to execute the Perl program as a
716 shell script. The shell executes the second line as a normal
717 shell command, and thus starts up the Perl interpreter. On some
718 systems $0 doesn't always contain the full pathname, so the -S
719 tells Perl to search for the program if necessary. After Perl
720 locates the program, it parses the lines and ignores them because
721 the variable $running_under_some_shell is never true. If the
722 program will be interpreted by csh, you will need to replace
723 "${1+"$@"}" with $*, even though that doesn't understand embedded
724 spaces (and such) in the argument list. To start up sh rather
725 than csh, some systems may have to replace the "#!" line with a
726 line containing just a colon, which will be politely ignored by
727 Perl. Other systems can't control that, and need a totally
728 devious construct that will work under any of csh, sh, or Perl,
729 such as the following:
730 eval '(exit $?0)' && eval 'exec perl -wS $0 ${1+"$@"}'
732 & eval 'exec /usr/bin/perl -wS $0 $argv:q'
733 if $running_under_some_shell;
734 If the filename supplied contains directory separators (and so is
736 an absolute or relative pathname), and if that file is not found,
737 platforms that append file extensions will do so and try to look
738 for the file with those extensions added, one by one.
739 On DOS-like platforms, if the program does not contain directory
741 separators, it will first be searched for in the current directory
742 before being searched for on the PATH. On Unix platforms, the
743 program will be searched for strictly on the PATH.
744 -t Like -T, but taint checks will issue warnings rather than fatal
746 errors. These warnings can now be controlled normally with "no
747 warnings qw(taint)".
748 Note: This is not a substitute for "-T"! This is meant to be used
750 only as a temporary development aid while securing legacy code:
751 for real production code and for new secure code written from
752 scratch, always use the real -T.
753 -T turns on "taint" so you can test them. Ordinarily these checks
755 are done only when running setuid or setgid. It's a good idea to
756 turn them on explicitly for programs that run on behalf of someone
757 else whom you might not necessarily trust, such as CGI programs or
758 any internet servers you might write in Perl. See perlsec for
759 details. For security reasons, this option must be seen by Perl
760 quite early; usually this means it must appear early on the
761 command line or in the "#!" line for systems which support that
762 construct.
763 -u This switch causes Perl to dump core after compiling your program.
765 You can then in theory take this core dump and turn it into an
766 executable file by using the undump program (not supplied). This
767 speeds startup at the expense of some disk space (which you can
768 minimize by stripping the executable). (Still, a "hello world"
769 executable comes out to about 200K on my machine.) If you want to
770 execute a portion of your program before dumping, use the
771 "CORE::dump()" function instead. Note: availability of undump is
772 platform specific and may not be available for a specific port of
773 Perl.
774 -U allows Perl to do unsafe operations. Currently the only "unsafe"
776 operations are attempting to unlink directories while running as
777 superuser and running setuid programs with fatal taint checks
778 turned into warnings. Note that warnings must be enabled along
779 with this option to actually generate the taint-check warnings.
780 -v prints the version and patchlevel of your perl executable.
782 -V prints summary of the major perl configuration values and the
784 current values of @INC.
785 -V:configvar
787 Prints to STDOUT the value of the named configuration variable(s),
788 with multiples when your "configvar" argument looks like a regex
789 (has non-letters). For example:
790 $ perl -V:libc
792 libc='/lib/libc-2.2.4.so';
793 $ perl -V:lib.
794 libs='-lnsl -lgdbm -ldb -ldl -lm -lcrypt -lutil -lc';
795 libc='/lib/libc-2.2.4.so';
796 $ perl -V:lib.*
797 libpth='/usr/local/lib /lib /usr/lib';
798 libs='-lnsl -lgdbm -ldb -ldl -lm -lcrypt -lutil -lc';
799 lib_ext='.a';
800 libc='/lib/libc-2.2.4.so';
801 libperl='libperl.a';
802 ....
803 Additionally, extra colons can be used to control formatting. A
805 trailing colon suppresses the linefeed and terminator ";",
806 allowing you to embed queries into shell commands. (mnemonic:
807 PATH separator ":".)
808 $ echo "compression-vars: " `perl -V:z.*: ` " are here !"
810 compression-vars: zcat='' zip='zip' are here !
811 A leading colon removes the "name=" part of the response, this
813 allows you to map to the name you need. (mnemonic: empty label)
814 $ echo "goodvfork="`./perl -Ilib -V::usevfork`
816 goodvfork=false;
817 Leading and trailing colons can be used together if you need
819 positional parameter values without the names. Note that in the
820 case below, the "PERL_API" params are returned in alphabetical
821 order.
822 $ echo building_on `perl -V::osname: -V::PERL_API_.*:` now
824 building_on 'linux' '5' '1' '9' now
825 -w prints warnings about dubious constructs, such as variable names
827 mentioned only once and scalar variables used before being set;
828 redefined subroutines; references to undefined filehandles;
829 filehandles opened read-only that you are attempting to write on;
830 values used as a number that don't look like numbers; using an
831 array as though it were a scalar; if your subroutines recurse more
832 than 100 deep; and innumerable other things.
833 This switch really just enables the global $^W variable; normally,
835 the lexically scoped "use warnings" pragma is preferred. You can
836 disable or promote into fatal errors specific warnings using
837 "__WARN__" hooks, as described in perlvar and "warn" in perlfunc.
838 See also perldiag and perltrap. A fine-grained warning facility
839 is also available if you want to manipulate entire classes of
840 warnings; see warnings.
841 -W Enables all warnings regardless of "no warnings" or $^W. See
843 warnings.
844 -X Disables all warnings regardless of "use warnings" or $^W. See
846 warnings.
847 -x
849 -xdirectory
850 tells Perl that the program is embedded in a larger chunk of
851 unrelated text, such as in a mail message. Leading garbage will
852 be discarded until the first line that starts with "#!" and
853 contains the string "perl". Any meaningful switches on that line
854 will be applied.
855 All references to line numbers by the program (warnings, errors,
857 ...) will treat the "#!" line as the first line. Thus a warning
858 on the 2nd line of the program, which is on the 100th line in the
859 file will be reported as line 2, not as line 100. This can be
860 overridden by using the "#line" directive. (See "Plain Old
861 Comments (Not!)" in perlsyn)
862 If a directory name is specified, Perl will switch to that
864 directory before running the program. The -x switch controls only
865 the disposal of leading garbage. The program must be terminated
866 with "__END__" if there is trailing garbage to be ignored; the
867 program can process any or all of the trailing garbage via the
868 "DATA" filehandle if desired.
869 The directory, if specified, must appear immediately following the
871 -x with no intervening whitespace.
872
874 HOME Used if "chdir" has no argument.
875 LOGDIR Used if "chdir" has no argument and HOME is not set.
877 PATH Used in executing subprocesses, and in finding the program
879 if -S is used.
880 PERL5LIB A list of directories in which to look for Perl library
882 files before looking in the standard library. Any
883 architecture-specific and version-specific directories,
884 such as version/archname/, version/, or archname/ under the
885 specified locations are automatically included if they
886 exist, with this lookup done at interpreter startup time.
887 In addition, any directories matching the entries in
888 $Config{inc_version_list} are added. (These typically
889 would be for older compatible perl versions installed in
890 the same directory tree.)
891 If PERL5LIB is not defined, PERLLIB is used. Directories
893 are separated (like in PATH) by a colon on Unixish
894 platforms and by a semicolon on Windows (the proper path
895 separator being given by the command "perl -V:path_sep").
896 When running taint checks, either because the program was
898 running setuid or setgid, or the -T or -t switch was
899 specified, neither PERL5LIB nor PERLLIB is consulted. The
900 program should instead say:
901 use lib "/my/directory";
903 PERL5OPT Command-line options (switches). Switches in this variable
905 are treated as if they were on every Perl command line.
906 Only the -[CDIMTUWdmtw] switches are allowed. When running
907 taint checks (either because the program was running setuid
908 or setgid, or because the -T or -t switch was used), this
909 variable is ignored. If PERL5OPT begins with -T, tainting
910 will be enabled and subsequent options ignored. If
911 PERL5OPT begins with -t, tainting will be enabled, a
912 writable dot removed from @INC, and subsequent options
913 honored.
914 PERLIO A space (or colon) separated list of PerlIO layers. If perl
916 is built to use PerlIO system for IO (the default) these
917 layers affect Perl's IO.
918 It is conventional to start layer names with a colon (for
920 example, ":perlio") to emphasize their similarity to
921 variable "attributes". But the code that parses layer
922 specification strings, which is also used to decode the
923 PERLIO environment variable, treats the colon as a
924 separator.
925 An unset or empty PERLIO is equivalent to the default set
927 of layers for your platform; for example, ":unix:perlio" on
928 Unix-like systems and ":unix:crlf" on Windows and other
929 DOS-like systems.
930 The list becomes the default for all Perl's IO.
932 Consequently only built-in layers can appear in this list,
933 as external layers (such as ":encoding()") need IO in order
934 to load them! See "open pragma" for how to add external
935 encodings as defaults.
936 Layers it makes sense to include in the PERLIO environment
938 variable are briefly summarized below. For more details see
939 PerlIO.
940 :bytes A pseudolayer that turns the ":utf8" flag off for
942 the layer below; unlikely to be useful on its own
943 in the global PERLIO environment variable. You
944 perhaps were thinking of ":crlf:bytes" or
945 ":perlio:bytes".
946 :crlf A layer which does CRLF to "\n" translation
948 distinguishing "text" and "binary" files in the
949 manner of MS-DOS and similar operating systems.
950 (It currently does not mimic MS-DOS as far as
951 treating of Control-Z as being an end-of-file
952 marker.)
953 :mmap A layer that implements "reading" of files by using
955 mmap(2) to make an entire file appear in the
956 process's address space, and then using that as
957 PerlIO's "buffer".
958 :perlio This is a re-implementation of stdio-like buffering
960 written as a PerlIO layer. As such it will call
961 whatever layer is below it for its operations,
962 typically ":unix".
963 :pop An experimental pseudolayer that removes the
965 topmost layer. Use with the same care as is
966 reserved for nitroglycerine.
967 :raw A pseudolayer that manipulates other layers.
969 Applying the ":raw" layer is equivalent to calling
970 "binmode($fh)". It makes the stream pass each byte
971 as-is without translation. In particular, both
972 CRLF translation and intuiting ":utf8" from the
973 locale are disabled.
974 Unlike in earlier versions of Perl, ":raw" is not
976 just the inverse of ":crlf": other layers which
977 would affect the binary nature of the stream are
978 also removed or disabled.
979 :stdio This layer provides a PerlIO interface by wrapping
981 system's ANSI C "stdio" library calls. The layer
982 provides both buffering and IO. Note that the
983 ":stdio" layer does not do CRLF translation even if
984 that is the platform's normal behaviour. You will
985 need a ":crlf" layer above it to do that.
986 :unix Low-level layer that calls "read", "write",
988 "lseek", etc.
989 :utf8 A pseudolayer that enables a flag in the layer
991 below to tell Perl that output should be in utf8
992 and that input should be regarded as already in
993 valid utf8 form. WARNING: It does not check for
994 validity and as such should be handled with extreme
995 caution for input, because security violations can
996 occur with non-shortest UTF-8 encodings, etc.
997 Generally ":encoding(UTF-8)" is the best option
998 when reading UTF-8 encoded data.
999 :win32 On Win32 platforms this experimental layer uses
1001 native "handle" IO rather than a Unix-like numeric
1002 file descriptor layer. Known to be buggy in this
1003 release (5.14).
1004 The default set of layers should give acceptable results on
1006 all platforms
1007 For Unix platforms that will be the equivalent of "unix
1009 perlio" or "stdio". Configure is set up to prefer the
1010 "stdio" implementation if the system's library provides for
1011 fast access to the buffer; otherwise, it uses the "unix
1012 perlio" implementation.
1013 On Win32 the default in this release (5.14) is "unix crlf".
1015 Win32's "stdio" has a number of bugs/mis-features for Perl
1016 IO which are somewhat depending on the version and vendor
1017 of the C compiler. Using our own "crlf" layer as the buffer
1018 avoids those issues and makes things more uniform. The
1019 "crlf" layer provides CRLF conversion as well as buffering.
1020 This release (5.14) uses "unix" as the bottom layer on
1022 Win32, and so still uses the C compiler's numeric file
1023 descriptor routines. There is an experimental native
1024 "win32" layer, which is expected to be enhanced and should
1025 eventually become the default under Win32.
1026 The PERLIO environment variable is completely ignored when
1028 Perl is run in taint mode.
1029 PERLIO_DEBUG
1031 If set to the name of a file or device when Perl is run
1032 with the -Di command-line switch, the logging of certain
1033 operations of the PerlIO subsystem will be redirected to
1034 the specified file rather than going to stderr, which is
1035 the default. The file is opened in append mode. Typical
1036 uses are in Unix:
1037 % env PERLIO_DEBUG=/tmp/perlio.log perl -Di script ...
1039 and under Win32, the approximately equivalent:
1041 > set PERLIO_DEBUG=CON
1043 perl -Di script ...
1044 This functionality is disabled for setuid scripts, for
1046 scripts run with -T, and for scripts run on a Perl built
1047 without "-DDEBUGGING" support.
1048 PERLLIB A list of directories in which to look for Perl library
1050 files before looking in the standard library. If PERL5LIB
1051 is defined, PERLLIB is not used.
1052 The PERLLIB environment variable is completely ignored when
1054 Perl is run in taint mode.
1055 PERL5DB The command used to load the debugger code. The default
1057 is:
1058 BEGIN { require "perl5db.pl" }
1060 The PERL5DB environment variable is only used when Perl is
1062 started with a bare -d switch.
1063 PERL5DB_THREADED
1065 If set to a true value, indicates to the debugger that the
1066 code being debugged uses threads.
1067 PERL5SHELL (specific to the Win32 port)
1069 On Win32 ports only, may be set to an alternative shell
1070 that Perl must use internally for executing "backtick"
1071 commands or system(). Default is "cmd.exe /x/d/c" on
1072 WindowsNT and "command.com /c" on Windows95. The value is
1073 considered space-separated. Precede any character that
1074 needs to be protected, like a space or backslash, with
1075 another backslash.
1076 Note that Perl doesn't use COMSPEC for this purpose because
1078 COMSPEC has a high degree of variability among users,
1079 leading to portability concerns. Besides, Perl can use a
1080 shell that may not be fit for interactive use, and setting
1081 COMSPEC to such a shell may interfere with the proper
1082 functioning of other programs (which usually look in
1083 COMSPEC to find a shell fit for interactive use).
1084 Before Perl 5.10.0 and 5.8.8, PERL5SHELL was not taint
1086 checked when running external commands. It is recommended
1087 that you explicitly set (or delete) $ENV{PERL5SHELL} when
1088 running in taint mode under Windows.
1089 PERL_ALLOW_NON_IFS_LSP (specific to the Win32 port)
1091 Set to 1 to allow the use of non-IFS compatible LSPs
1092 (Layered Service Providers). Perl normally searches for an
1093 IFS-compatible LSP because this is required for its
1094 emulation of Windows sockets as real filehandles. However,
1095 this may cause problems if you have a firewall such as
1096 McAfee Guardian, which requires that all applications use
1097 its LSP but which is not IFS-compatible, because clearly
1098 Perl will normally avoid using such an LSP.
1099 Setting this environment variable to 1 means that Perl will
1101 simply use the first suitable LSP enumerated in the
1102 catalog, which keeps McAfee Guardian happy--and in that
1103 particular case Perl still works too because McAfee
1104 Guardian's LSP actually plays other games which allow
1105 applications requiring IFS compatibility to work.
1106 PERL_DEBUG_MSTATS
1108 Relevant only if Perl is compiled with the "malloc"
1109 included with the Perl distribution; that is, if "perl
1110 -V:d_mymalloc" is "define".
1111 If set, this dumps out memory statistics after execution.
1113 If set to an integer greater than one, also dumps out
1114 memory statistics after compilation.
1115 PERL_DESTRUCT_LEVEL
1117 Relevant only if your Perl executable was built with
1118 -DDEBUGGING, this controls the behaviour of global
1119 destruction of objects and other references. See
1120 "PERL_DESTRUCT_LEVEL" in perlhacktips for more information.
1121 PERL_DL_NONLAZY
1123 Set to "1" to have Perl resolve all undefined symbols when
1124 it loads a dynamic library. The default behaviour is to
1125 resolve symbols when they are used. Setting this variable
1126 is useful during testing of extensions, as it ensures that
1127 you get an error on misspelled function names even if the
1128 test suite doesn't call them.
1129 PERL_ENCODING
1131 If using the "use encoding" pragma without an explicit
1132 encoding name, the PERL_ENCODING environment variable is
1133 consulted for an encoding name.
1134 PERL_HASH_SEED
1136 (Since Perl 5.8.1, new semantics in Perl 5.18.0) Used to
1137 override the randomization of Perl's internal hash
1138 function. The value is expressed in hexadecimal, and may
1139 include a leading 0x. Truncated patterns are treated as
1140 though they are suffixed with sufficient 0's as required.
1141 If the option is provided, and "PERL_PERTURB_KEYS" is NOT
1143 set, then a value of '0' implies "PERL_PERTURB_KEYS=0" and
1144 any other value implies "PERL_PERTURB_KEYS=2".
1145 PLEASE NOTE: The hash seed is sensitive information. Hashes
1147 are randomized to protect against local and remote attacks
1148 against Perl code. By manually setting a seed, this
1149 protection may be partially or completely lost.
1150 See "Algorithmic Complexity Attacks" in perlsec,
1152 "PERL_PERTURB_KEYS", and "PERL_HASH_SEED_DEBUG" for more
1153 information.
1154 PERL_PERTURB_KEYS
1156 (Since Perl 5.18.0) Set to "0" or "NO" then traversing
1157 keys will be repeatable from run to run for the same
1158 PERL_HASH_SEED. Insertion into a hash will not change the
1159 order, except to provide for more space in the hash. When
1160 combined with setting PERL_HASH_SEED this mode is as close
1161 to pre 5.18 behavior as you can get.
1162 When set to "1" or "RANDOM" then traversing keys will be
1164 randomized. Every time a hash is inserted into the key
1165 order will change in a random fashion. The order may not be
1166 repeatable in a following program run even if the
1167 PERL_HASH_SEED has been specified. This is the default mode
1168 for perl.
1169 When set to "2" or "DETERMINISTIC" then inserting keys into
1171 a hash will cause the key order to change, but in a way
1172 that is repeatable from program run to program run.
1173 NOTE: Use of this option is considered insecure, and is
1175 intended only for debugging non-deterministic behavior in
1176 Perl's hash function. Do not use it in production.
1177 See "Algorithmic Complexity Attacks" in perlsec and
1179 "PERL_HASH_SEED" and "PERL_HASH_SEED_DEBUG" for more
1180 information. You can get and set the key traversal mask for
1181 a specific hash by using the "hash_traversal_mask()"
1182 function from Hash::Util.
1183 PERL_HASH_SEED_DEBUG
1185 (Since Perl 5.8.1.) Set to "1" to display (to STDERR)
1186 information about the hash function, seed, and what type of
1187 key traversal randomization is in effect at the beginning
1188 of execution. This, combined with "PERL_HASH_SEED" and
1189 "PERL_PERTURB_KEYS" is intended to aid in debugging
1190 nondeterministic behaviour caused by hash randomization.
1191 Note that any information about the hash function,
1193 especially the hash seed is sensitive information: by
1194 knowing it, one can craft a denial-of-service attack
1195 against Perl code, even remotely; see "Algorithmic
1196 Complexity Attacks" in perlsec for more information. Do not
1197 disclose the hash seed to people who don't need to know it.
1198 See also "hash_seed()" and "key_traversal_mask()" in
1199 Hash::Util.
1200 An example output might be:
1202 HASH_FUNCTION = ONE_AT_A_TIME_HARD HASH_SEED = 0x652e9b9349a7a032 PERTURB_KEYS = 1 (RANDOM)
1204 PERL_MEM_LOG
1206 If your Perl was configured with -Accflags=-DPERL_MEM_LOG,
1207 setting the environment variable "PERL_MEM_LOG" enables
1208 logging debug messages. The value has the form
1209 "<number>[m][s][t]", where "number" is the file descriptor
1210 number you want to write to (2 is default), and the
1211 combination of letters specifies that you want information
1212 about (m)emory and/or (s)v, optionally with (t)imestamps.
1213 For example, "PERL_MEM_LOG=1mst" logs all information to
1214 stdout. You can write to other opened file descriptors in a
1215 variety of ways:
1216 $ 3>foo3 PERL_MEM_LOG=3m perl ...
1218 PERL_ROOT (specific to the VMS port)
1220 A translation-concealed rooted logical name that contains
1221 Perl and the logical device for the @INC path on VMS only.
1222 Other logical names that affect Perl on VMS include
1223 PERLSHR, PERL_ENV_TABLES, and SYS$TIMEZONE_DIFFERENTIAL,
1224 but are optional and discussed further in perlvms and in
1225 README.vms in the Perl source distribution.
1226 PERL_SIGNALS
1228 Available in Perls 5.8.1 and later. If set to "unsafe",
1229 the pre-Perl-5.8.0 signal behaviour (which is immediate but
1230 unsafe) is restored. If set to "safe", then safe (but
1231 deferred) signals are used. See "Deferred Signals (Safe
1232 Signals)" in perlipc.
1233 PERL_UNICODE
1235 Equivalent to the -C command-line switch. Note that this
1236 is not a boolean variable. Setting this to "1" is not the
1237 right way to "enable Unicode" (whatever that would mean).
1238 You can use "0" to "disable Unicode", though (or
1239 alternatively unset PERL_UNICODE in your shell before
1240 starting Perl). See the description of the -C switch for
1241 more information.
1242 PERL_USE_UNSAFE_INC
1244 If perl has been configured to not have the current
1245 directory in @INC by default, this variable can be set to
1246 "1" to reinstate it. It's primarily intended for use while
1247 building and testing modules that have not been updated to
1248 deal with "." not being in @INC and should not be set in
1249 the environment for day-to-day use.
1250 SYS$LOGIN (specific to the VMS port)
1252 Used if chdir has no argument and HOME and LOGDIR are not
1253 set.
1254 PERL_INTERNAL_RAND_SEED
1256 Set to a non-negative integer to seed the random number
1257 generator used internally by perl for a variety of
1258 purposes.
1259 Ignored if perl is run setuid or setgid. Used only for
1261 some limited startup randomization (hash keys) if "-T" or
1262 "-t" perl is started with tainting enabled.
1263 Perl may be built to ignore this variable.
1265 Perl also has environment variables that control how Perl handles data
1267 specific to particular natural languages; see perllocale.
1268 Perl and its various modules and components, including its test
1270 frameworks, may sometimes make use of certain other environment
1271 variables. Some of these are specific to a particular platform.
1272 Please consult the appropriate module documentation and any
1273 documentation for your platform (like perlsolaris, perllinux,
1274 perlmacosx, perlwin32, etc) for variables peculiar to those specific
1275 situations.
1276 Perl makes all environment variables available to the program being
1278 executed, and passes these along to any child processes it starts.
1279 However, programs running setuid would do well to execute the following
1280 lines before doing anything else, just to keep people honest:
1281 $ENV{PATH} = "/bin:/usr/bin"; # or whatever you need
1283 $ENV{SHELL} = "/bin/sh" if exists $ENV{SHELL};
1284 delete @ENV{qw(IFS CDPATH ENV BASH_ENV)};
1285perl v5.30.1 2019-11-29 PERLRUN(1)