Commit | Line | Data |
a0d0e21e |
1 | =head1 NAME |
2 | |
3 | perlrun - how to execute the Perl interpreter |
4 | |
5 | =head1 SYNOPSIS |
6 | |
672fde27 |
7 | B<perl> S<[ B<-sTtuUWX> ]> |
e0ebc809 |
8 | S<[ B<-hv> ] [ B<-V>[:I<configvar>] ]> |
2cbb2ee1 |
9 | S<[ B<-cw> ] [ B<-d>[B<t>][:I<debugger>] ] [ B<-D>[I<number/list>] ]> |
f2095865 |
10 | S<[ B<-pna> ] [ B<-F>I<pattern> ] [ B<-l>[I<octal>] ] [ B<-0>[I<octal/hexadecimal>] ]> |
df451b2a |
11 | S<[ B<-I>I<dir> ] [ B<-m>[B<->]I<module> ] [ B<-M>[B<->]I<'module...'> ] [ B<-f> ]> |
aefc56c5 |
12 | S<[ B<-A>[I<module>][=I<assertions>] ]> |
c630fe62 |
13 | S<[ B<-C [I<number/list>] >]> |
e0ebc809 |
14 | S<[ B<-P> ]> |
15 | S<[ B<-S> ]> |
16 | S<[ B<-x>[I<dir>] ]> |
17 | S<[ B<-i>[I<extension>] ]> |
bc9b29db |
18 | S<[ B<-eE> I<'command'> ] [ B<--> ] [ I<programfile> ] [ I<argument> ]...> |
a0d0e21e |
19 | |
20 | =head1 DESCRIPTION |
21 | |
19799a22 |
22 | The normal way to run a Perl program is by making it directly |
23 | executable, or else by passing the name of the source file as an |
24 | argument on the command line. (An interactive Perl environment |
25 | is also possible--see L<perldebug> for details on how to do that.) |
26 | Upon startup, Perl looks for your program in one of the following |
a0d0e21e |
27 | places: |
28 | |
29 | =over 4 |
30 | |
31 | =item 1. |
32 | |
bc9b29db |
33 | Specified line by line via B<-e> or B<-E> switches on the command line. |
a0d0e21e |
34 | |
35 | =item 2. |
36 | |
37 | Contained in the file specified by the first filename on the command line. |
a3cb178b |
38 | (Note that systems supporting the #! notation invoke interpreters this |
39 | way. See L<Location of Perl>.) |
a0d0e21e |
40 | |
41 | =item 3. |
42 | |
5f05dabc |
43 | Passed in implicitly via standard input. This works only if there are |
19799a22 |
44 | no filename arguments--to pass arguments to a STDIN-read program you |
45 | must explicitly specify a "-" for the program name. |
a0d0e21e |
46 | |
47 | =back |
48 | |
49 | With methods 2 and 3, Perl starts parsing the input file from the |
50 | beginning, unless you've specified a B<-x> switch, in which case it |
51 | scans for the first line starting with #! and containing the word |
19799a22 |
52 | "perl", and starts there instead. This is useful for running a program |
a0d0e21e |
53 | embedded in a larger message. (In this case you would indicate the end |
19799a22 |
54 | of the program using the C<__END__> token.) |
a0d0e21e |
55 | |
5f05dabc |
56 | The #! line is always examined for switches as the line is being |
57 | parsed. Thus, if you're on a machine that allows only one argument |
58 | with the #! line, or worse, doesn't even recognize the #! line, you |
59 | still can get consistent switch behavior regardless of how Perl was |
19799a22 |
60 | invoked, even if B<-x> was used to find the beginning of the program. |
61 | |
62 | Because historically some operating systems silently chopped off |
63 | kernel interpretation of the #! line after 32 characters, some |
64 | switches may be passed in on the command line, and some may not; |
65 | you could even get a "-" without its letter, if you're not careful. |
66 | You probably want to make sure that all your switches fall either |
67 | before or after that 32-character boundary. Most switches don't |
68 | actually care if they're processed redundantly, but getting a "-" |
69 | instead of a complete switch could cause Perl to try to execute |
70 | standard input instead of your program. And a partial B<-I> switch |
a0d0e21e |
71 | could also cause odd results. |
72 | |
19799a22 |
73 | Some switches do care if they are processed twice, for instance |
74 | combinations of B<-l> and B<-0>. Either put all the switches after |
75 | the 32-character boundary (if applicable), or replace the use of |
76 | B<-0>I<digits> by C<BEGIN{ $/ = "\0digits"; }>. |
fb73857a |
77 | |
a0d0e21e |
78 | Parsing of the #! switches starts wherever "perl" is mentioned in the line. |
79 | The sequences "-*" and "- " are specifically ignored so that you could, |
80 | if you were so inclined, say |
81 | |
82 | #!/bin/sh -- # -*- perl -*- -p |
19799a22 |
83 | eval 'exec perl -wS $0 ${1+"$@"}' |
5f05dabc |
84 | if $running_under_some_shell; |
a0d0e21e |
85 | |
44a4342c |
86 | to let Perl see the B<-p> switch. |
19799a22 |
87 | |
88 | A similar trick involves the B<env> program, if you have it. |
89 | |
90 | #!/usr/bin/env perl |
91 | |
92 | The examples above use a relative path to the perl interpreter, |
93 | getting whatever version is first in the user's path. If you want |
94 | a specific version of Perl, say, perl5.005_57, you should place |
95 | that directly in the #! line's path. |
a0d0e21e |
96 | |
97 | If the #! line does not contain the word "perl", the program named after |
98 | the #! is executed instead of the Perl interpreter. This is slightly |
99 | bizarre, but it helps people on machines that don't do #!, because they |
19799a22 |
100 | can tell a program that their SHELL is F</usr/bin/perl>, and Perl will then |
a0d0e21e |
101 | dispatch the program to the correct interpreter for them. |
102 | |
19799a22 |
103 | After locating your program, Perl compiles the entire program to an |
a0d0e21e |
104 | internal form. If there are any compilation errors, execution of the |
19799a22 |
105 | program is not attempted. (This is unlike the typical shell script, |
54310121 |
106 | which might run part-way through before finding a syntax error.) |
a0d0e21e |
107 | |
19799a22 |
108 | If the program is syntactically correct, it is executed. If the program |
a0d0e21e |
109 | runs off the end without hitting an exit() or die() operator, an implicit |
110 | C<exit(0)> is provided to indicate successful completion. |
111 | |
68dc0745 |
112 | =head2 #! and quoting on non-Unix systems |
d74e8afc |
113 | X<hashbang> X<#!> |
68dc0745 |
114 | |
115 | Unix's #! technique can be simulated on other systems: |
116 | |
117 | =over 4 |
118 | |
119 | =item OS/2 |
120 | |
121 | Put |
122 | |
123 | extproc perl -S -your_switches |
124 | |
19799a22 |
125 | as the first line in C<*.cmd> file (B<-S> due to a bug in cmd.exe's |
68dc0745 |
126 | `extproc' handling). |
127 | |
54310121 |
128 | =item MS-DOS |
68dc0745 |
129 | |
19799a22 |
130 | Create a batch file to run your program, and codify it in |
fd1adc71 |
131 | C<ALTERNATE_SHEBANG> (see the F<dosish.h> file in the source |
68dc0745 |
132 | distribution for more information). |
133 | |
134 | =item Win95/NT |
135 | |
6c6a61e2 |
136 | The Win95/NT installation, when using the ActiveState installer for Perl, |
c8db1d39 |
137 | will modify the Registry to associate the F<.pl> extension with the perl |
6c6a61e2 |
138 | interpreter. If you install Perl by other means (including building from |
139 | the sources), you may have to modify the Registry yourself. Note that |
140 | this means you can no longer tell the difference between an executable |
141 | Perl program and a Perl library file. |
68dc0745 |
142 | |
143 | =item Macintosh |
144 | |
8e30f651 |
145 | Under "Classic" MacOS, a perl program will have the appropriate Creator and |
146 | Type, so that double-clicking them will invoke the MacPerl application. |
147 | Under Mac OS X, clickable apps can be made from any C<#!> script using Wil |
148 | Sanchez' DropScript utility: http://www.wsanchez.net/software/ . |
68dc0745 |
149 | |
bd3fa61c |
150 | =item VMS |
151 | |
152 | Put |
153 | |
154 | $ perl -mysw 'f$env("procedure")' 'p1' 'p2' 'p3' 'p4' 'p5' 'p6' 'p7' 'p8' ! |
155 | $ exit++ + ++$status != 0 and $exit = $status = undef; |
156 | |
19799a22 |
157 | at the top of your program, where B<-mysw> are any command line switches you |
158 | want to pass to Perl. You can now invoke the program directly, by saying |
159 | C<perl program>, or as a DCL procedure, by saying C<@program> (or implicitly |
160 | via F<DCL$PATH> by just using the name of the program). |
bd3fa61c |
161 | |
162 | This incantation is a bit much to remember, but Perl will display it for |
163 | you if you say C<perl "-V:startperl">. |
164 | |
68dc0745 |
165 | =back |
166 | |
167 | Command-interpreters on non-Unix systems have rather different ideas |
168 | on quoting than Unix shells. You'll need to learn the special |
169 | characters in your command-interpreter (C<*>, C<\> and C<"> are |
170 | common) and how to protect whitespace and these characters to run |
19799a22 |
171 | one-liners (see B<-e> below). |
68dc0745 |
172 | |
173 | On some systems, you may have to change single-quotes to double ones, |
e6f03d26 |
174 | which you must I<not> do on Unix or Plan 9 systems. You might also |
68dc0745 |
175 | have to change a single % to a %%. |
176 | |
177 | For example: |
178 | |
179 | # Unix |
180 | perl -e 'print "Hello world\n"' |
181 | |
54310121 |
182 | # MS-DOS, etc. |
68dc0745 |
183 | perl -e "print \"Hello world\n\"" |
184 | |
54310121 |
185 | # Macintosh |
68dc0745 |
186 | print "Hello world\n" |
187 | (then Run "Myscript" or Shift-Command-R) |
188 | |
189 | # VMS |
190 | perl -e "print ""Hello world\n""" |
191 | |
19799a22 |
192 | The problem is that none of this is reliable: it depends on the |
193 | command and it is entirely possible neither works. If B<4DOS> were |
194 | the command shell, this would probably work better: |
68dc0745 |
195 | |
196 | perl -e "print <Ctrl-x>"Hello world\n<Ctrl-x>"" |
197 | |
19799a22 |
198 | B<CMD.EXE> in Windows NT slipped a lot of standard Unix functionality in |
68dc0745 |
199 | when nobody was looking, but just try to find documentation for its |
200 | quoting rules. |
201 | |
54310121 |
202 | Under the Macintosh, it depends which environment you are using. The MacPerl |
68dc0745 |
203 | shell, or MPW, is much like Unix shells in its support for several |
54310121 |
204 | quoting variants, except that it makes free use of the Macintosh's non-ASCII |
68dc0745 |
205 | characters as control characters. |
206 | |
207 | There is no general solution to all of this. It's just a mess. |
208 | |
a3cb178b |
209 | =head2 Location of Perl |
d74e8afc |
210 | X<perl, location of interpreter> |
a3cb178b |
211 | |
212 | It may seem obvious to say, but Perl is useful only when users can |
19799a22 |
213 | easily find it. When possible, it's good for both F</usr/bin/perl> |
214 | and F</usr/local/bin/perl> to be symlinks to the actual binary. If |
215 | that can't be done, system administrators are strongly encouraged |
216 | to put (symlinks to) perl and its accompanying utilities into a |
217 | directory typically found along a user's PATH, or in some other |
218 | obvious and convenient place. |
219 | |
220 | In this documentation, C<#!/usr/bin/perl> on the first line of the program |
221 | will stand in for whatever method works on your system. You are |
222 | advised to use a specific path if you care about a specific version. |
a3cb178b |
223 | |
19799a22 |
224 | #!/usr/local/bin/perl5.00554 |
a3cb178b |
225 | |
19799a22 |
226 | or if you just want to be running at least version, place a statement |
227 | like this at the top of your program: |
a0d0e21e |
228 | |
19799a22 |
229 | use 5.005_54; |
a0d0e21e |
230 | |
19799a22 |
231 | =head2 Command Switches |
d74e8afc |
232 | X<perl, command switches> X<command switches> |
19799a22 |
233 | |
234 | As with all standard commands, a single-character switch may be |
235 | clustered with the following switch, if any. |
236 | |
237 | #!/usr/bin/perl -spi.orig # same as -s -p -i.orig |
a0d0e21e |
238 | |
239 | Switches include: |
240 | |
241 | =over 5 |
242 | |
f2095865 |
243 | =item B<-0>[I<octal/hexadecimal>] |
d74e8afc |
244 | X<-0> X<$/> |
a0d0e21e |
245 | |
f2095865 |
246 | specifies the input record separator (C<$/>) as an octal or |
247 | hexadecimal number. If there are no digits, the null character is the |
248 | separator. Other switches may precede or follow the digits. For |
249 | example, if you have a version of B<find> which can print filenames |
250 | terminated by the null character, you can say this: |
a0d0e21e |
251 | |
19799a22 |
252 | find . -name '*.orig' -print0 | perl -n0e unlink |
a0d0e21e |
253 | |
254 | The special value 00 will cause Perl to slurp files in paragraph mode. |
5f05dabc |
255 | The value 0777 will cause Perl to slurp files whole because there is no |
f2095865 |
256 | legal byte with that value. |
257 | |
258 | If you want to specify any Unicode character, use the hexadecimal |
259 | format: C<-0xHHH...>, where the C<H> are valid hexadecimal digits. |
260 | (This means that you cannot use the C<-x> with a directory name that |
261 | consists of hexadecimal digits.) |
a0d0e21e |
262 | |
aefc56c5 |
263 | =item B<-A[I<module>][=I<assertions>]> |
d74e8afc |
264 | X<-A> |
702815ca |
265 | |
aefc56c5 |
266 | Activates the assertions given after the equal sign as a comma-separated |
267 | list of assertion names or regular expressions. If no assertion name |
268 | is given, activates all assertions. |
269 | |
270 | The module L<assertions::activate> is used by default to activate the |
271 | selected assertions. An alternate module may be specified including |
272 | its name between the switch and the equal sign. |
273 | |
274 | See L<assertions> and L<assertions::activate>. |
702815ca |
275 | |
a0d0e21e |
276 | =item B<-a> |
d74e8afc |
277 | X<-a> X<autosplit> |
a0d0e21e |
278 | |
279 | turns on autosplit mode when used with a B<-n> or B<-p>. An implicit |
280 | split command to the @F array is done as the first thing inside the |
281 | implicit while loop produced by the B<-n> or B<-p>. |
282 | |
283 | perl -ane 'print pop(@F), "\n";' |
284 | |
285 | is equivalent to |
286 | |
287 | while (<>) { |
288 | @F = split(' '); |
289 | print pop(@F), "\n"; |
290 | } |
291 | |
292 | An alternate delimiter may be specified using B<-F>. |
293 | |
a05d7ebb |
294 | =item B<-C [I<number/list>]> |
d74e8afc |
295 | X<-C> |
46487f74 |
296 | |
a05d7ebb |
297 | The C<-C> flag controls some Unicode of the Perl Unicode features. |
298 | |
299 | As of 5.8.1, the C<-C> can be followed either by a number or a list |
f3f8427d |
300 | of option letters. The letters, their numeric values, and effects |
8aa8f774 |
301 | are as follows; listing the letters is equal to summing the numbers. |
9f21530f |
302 | |
73e12209 |
303 | I 1 STDIN is assumed to be in UTF-8 |
304 | O 2 STDOUT will be in UTF-8 |
305 | E 4 STDERR will be in UTF-8 |
306 | S 7 I + O + E |
307 | i 8 UTF-8 is the default PerlIO layer for input streams |
308 | o 16 UTF-8 is the default PerlIO layer for output streams |
309 | D 24 i + o |
310 | A 32 the @ARGV elements are expected to be strings encoded |
311 | in UTF-8 |
312 | L 64 normally the "IOEioA" are unconditional, |
313 | the L makes them conditional on the locale environment |
314 | variables (the LC_ALL, LC_TYPE, and LANG, in the order |
315 | of decreasing precedence) -- if the variables indicate |
316 | UTF-8, then the selected "IOEioA" are in effect |
5a22a2bb |
317 | a 256 Set ${^UTF8CACHE} to -1, to run the UTF-8 caching code in |
318 | debugging mode. |
319 | |
320 | =for documenting_the_underdocumented |
321 | perl.h gives W/128 as PERL_UNICODE_WIDESYSCALLS "/* for Sarathy */" |
9f21530f |
322 | |
f23930d5 |
323 | =for todo |
324 | perltodo mentions Unicode in %ENV and filenames. I guess that these will be |
325 | options e and f (or F). |
326 | |
9f21530f |
327 | For example, C<-COE> and C<-C6> will both turn on UTF-8-ness on both |
328 | STDOUT and STDERR. Repeating letters is just redundant, not cumulative |
329 | nor toggling. |
a05d7ebb |
330 | |
44505768 |
331 | The C<io> options mean that any subsequent open() (or similar I/O |
332 | operations) will have the C<:utf8> PerlIO layer implicitly applied |
333 | to them, in other words, UTF-8 is expected from any input stream, |
334 | and UTF-8 is produced to any output stream. This is just the default, |
335 | with explicit layers in open() and with binmode() one can manipulate |
336 | streams as usual. |
337 | |
8aa8f774 |
338 | C<-C> on its own (not followed by any number or option list), or the |
47427c4e |
339 | empty string C<""> for the C<PERL_UNICODE> environment variable, has the |
340 | same effect as C<-CSDL>. In other words, the standard I/O handles and |
341 | the default C<open()> layer are UTF-8-fied B<but> only if the locale |
342 | environment variables indicate a UTF-8 locale. This behaviour follows |
343 | the I<implicit> (and problematic) UTF-8 behaviour of Perl 5.8.0. |
a05d7ebb |
344 | |
47427c4e |
345 | You can use C<-C0> (or C<"0"> for C<PERL_UNICODE>) to explicitly |
5b4f334e |
346 | disable all the above Unicode features. |
fde18df1 |
347 | |
8aa8f774 |
348 | The read-only magic variable C<${^UNICODE}> reflects the numeric value |
ab9e1bb7 |
349 | of this setting. This is variable is set during Perl startup and is |
350 | thereafter read-only. If you want runtime effects, use the three-arg |
2307c6d0 |
351 | open() (see L<perlfunc/open>), the two-arg binmode() (see L<perlfunc/binmode>), |
ab9e1bb7 |
352 | and the C<open> pragma (see L<open>). |
fde18df1 |
353 | |
354 | (In Perls earlier than 5.8.1 the C<-C> switch was a Win32-only switch |
355 | that enabled the use of Unicode-aware "wide system call" Win32 APIs. |
356 | This feature was practically unused, however, and the command line |
357 | switch was therefore "recycled".) |
46487f74 |
358 | |
a0d0e21e |
359 | =item B<-c> |
d74e8afc |
360 | X<-c> |
a0d0e21e |
361 | |
19799a22 |
362 | causes Perl to check the syntax of the program and then exit without |
7d30b5c4 |
363 | executing it. Actually, it I<will> execute C<BEGIN>, C<CHECK>, and |
4f25aa18 |
364 | C<use> blocks, because these are considered as occurring outside the |
365 | execution of your program. C<INIT> and C<END> blocks, however, will |
366 | be skipped. |
a0d0e21e |
367 | |
368 | =item B<-d> |
d74e8afc |
369 | X<-d> X<-dt> |
a0d0e21e |
370 | |
2cbb2ee1 |
371 | =item B<-dt> |
372 | |
19799a22 |
373 | runs the program under the Perl debugger. See L<perldebug>. |
2cbb2ee1 |
374 | If B<t> is specified, it indicates to the debugger that threads |
375 | will be used in the code being debugged. |
a0d0e21e |
376 | |
70c94a19 |
377 | =item B<-d:>I<foo[=bar,baz]> |
d74e8afc |
378 | X<-d> X<-dt> |
3c81428c |
379 | |
2cbb2ee1 |
380 | =item B<-dt:>I<foo[=bar,baz]> |
381 | |
19799a22 |
382 | runs the program under the control of a debugging, profiling, or |
383 | tracing module installed as Devel::foo. E.g., B<-d:DProf> executes |
70c94a19 |
384 | the program using the Devel::DProf profiler. As with the B<-M> |
385 | flag, options may be passed to the Devel::foo package where they |
386 | will be received and interpreted by the Devel::foo::import routine. |
387 | The comma-separated list of options must follow a C<=> character. |
2cbb2ee1 |
388 | If B<t> is specified, it indicates to the debugger that threads |
389 | will be used in the code being debugged. |
70c94a19 |
390 | See L<perldebug>. |
3c81428c |
391 | |
db2ba183 |
392 | =item B<-D>I<letters> |
d74e8afc |
393 | X<-D> X<DEBUGGING> X<-DDEBUGGING> |
a0d0e21e |
394 | |
db2ba183 |
395 | =item B<-D>I<number> |
a0d0e21e |
396 | |
19799a22 |
397 | sets debugging flags. To watch how it executes your program, use |
db2ba183 |
398 | B<-Dtls>. (This works only if debugging is compiled into your |
399 | Perl.) Another nice value is B<-Dx>, which lists your compiled |
4197b13f |
400 | syntax tree. And B<-Dr> displays compiled regular expressions; |
44a4342c |
401 | the format of the output is explained in L<perldebguts>. |
4197b13f |
402 | |
403 | As an alternative, specify a number instead of list of letters (e.g., |
404 | B<-D14> is equivalent to B<-Dtls>): |
a0d0e21e |
405 | |
9388183f |
406 | 1 p Tokenizing and parsing (with v, displays parse stack) |
3679267a |
407 | 2 s Stack snapshots (with v, displays all stacks) |
db2ba183 |
408 | 4 l Context (loop) stack processing |
409 | 8 t Trace execution |
410 | 16 o Method and overloading resolution |
411 | 32 c String/numeric conversions |
1045810a |
412 | 64 P Print profiling info, preprocessor command for -P, source file input state |
db2ba183 |
413 | 128 m Memory allocation |
414 | 256 f Format processing |
415 | 512 r Regular expression parsing and execution |
416 | 1024 x Syntax tree dump |
417 | 2048 u Tainting checks |
7bab3ede |
418 | 4096 (Obsolete, previously used for LEAKTEST) |
db2ba183 |
419 | 8192 H Hash dump -- usurps values() |
420 | 16384 X Scratchpad allocation |
421 | 32768 D Cleaning up |
8b73bbec |
422 | 65536 S Thread synchronization |
607df283 |
423 | 131072 T Tokenising |
04932ac8 |
424 | 262144 R Include reference counts of dumped variables (eg when using -Ds) |
1045810a |
425 | 524288 J Do not s,t,P-debug (Jump over) opcodes within package DB |
d6721266 |
426 | 1048576 v Verbose: use in conjunction with other flags |
46187eeb |
427 | 2097152 C Copy On Write |
ecae49c0 |
428 | 4194304 A Consistency checks on internal structures |
3679267a |
429 | 8388608 q quiet - currently only suppresses the "EXECUTING" message |
a0d0e21e |
430 | |
19799a22 |
431 | All these flags require B<-DDEBUGGING> when you compile the Perl |
1045810a |
432 | executable (but see L<Devel::Peek>, L<re> which may change this). |
44a4342c |
433 | See the F<INSTALL> file in the Perl source distribution |
19799a22 |
434 | for how to do this. This flag is automatically set if you include B<-g> |
8c52afec |
435 | option when C<Configure> asks you about optimizer/debugger flags. |
436 | |
19799a22 |
437 | If you're just trying to get a print out of each line of Perl code |
438 | as it executes, the way that C<sh -x> provides for shell scripts, |
44a4342c |
439 | you can't use Perl's B<-D> switch. Instead do this |
19799a22 |
440 | |
c406981e |
441 | # If you have "env" utility |
fdac53cd |
442 | env PERLDB_OPTS="NonStop=1 AutoTrace=1 frame=2" perl -dS program |
c406981e |
443 | |
19799a22 |
444 | # Bourne shell syntax |
445 | $ PERLDB_OPTS="NonStop=1 AutoTrace=1 frame=2" perl -dS program |
446 | |
447 | # csh syntax |
448 | % (setenv PERLDB_OPTS "NonStop=1 AutoTrace=1 frame=2"; perl -dS program) |
449 | |
450 | See L<perldebug> for details and variations. |
451 | |
a0d0e21e |
452 | =item B<-e> I<commandline> |
d74e8afc |
453 | X<-e> |
a0d0e21e |
454 | |
19799a22 |
455 | may be used to enter one line of program. If B<-e> is given, Perl |
456 | will not look for a filename in the argument list. Multiple B<-e> |
457 | commands may be given to build up a multi-line script. Make sure |
458 | to use semicolons where you would in a normal program. |
a0d0e21e |
459 | |
bc9b29db |
460 | =item B<-E> I<commandline> |
461 | X<-E> |
462 | |
463 | behaves just like B<-e>, except that it implicitly enables all |
464 | optional features (in the main compilation unit). See L<feature>. |
465 | |
20ef40cf |
466 | =item B<-f> |
d74e8afc |
467 | X<-f> |
20ef40cf |
468 | |
4a42f219 |
469 | Disable executing F<$Config{sitelib}/sitecustomize.pl> at startup. |
20ef40cf |
470 | |
471 | Perl can be built so that it by default will try to execute |
4a42f219 |
472 | F<$Config{sitelib}/sitecustomize.pl> at startup. This is a hook that |
20ef40cf |
473 | allows the sysadmin to customize how perl behaves. It can for |
474 | instance be used to add entries to the @INC array to make perl find |
475 | modules in non-standard locations. |
476 | |
e0ebc809 |
477 | =item B<-F>I<pattern> |
d74e8afc |
478 | X<-F> |
a0d0e21e |
479 | |
e0ebc809 |
480 | specifies the pattern to split on if B<-a> is also in effect. The |
5f05dabc |
481 | pattern may be surrounded by C<//>, C<"">, or C<''>, otherwise it will be |
d52fe7da |
482 | put in single quotes. You can't use literal whitespace in the pattern. |
a0d0e21e |
483 | |
e0ebc809 |
484 | =item B<-h> |
d74e8afc |
485 | X<-h> |
e0ebc809 |
486 | |
487 | prints a summary of the options. |
488 | |
489 | =item B<-i>[I<extension>] |
d74e8afc |
490 | X<-i> X<in-place> |
a0d0e21e |
491 | |
2d259d92 |
492 | specifies that files processed by the C<E<lt>E<gt>> construct are to be |
493 | edited in-place. It does this by renaming the input file, opening the |
494 | output file by the original name, and selecting that output file as the |
495 | default for print() statements. The extension, if supplied, is used to |
496 | modify the name of the old file to make a backup copy, following these |
497 | rules: |
498 | |
499 | If no extension is supplied, no backup is made and the current file is |
500 | overwritten. |
501 | |
19799a22 |
502 | If the extension doesn't contain a C<*>, then it is appended to the |
503 | end of the current filename as a suffix. If the extension does |
504 | contain one or more C<*> characters, then each C<*> is replaced |
505 | with the current filename. In Perl terms, you could think of this |
506 | as: |
2d259d92 |
507 | |
66606d78 |
508 | ($backup = $extension) =~ s/\*/$file_name/g; |
2d259d92 |
509 | |
510 | This allows you to add a prefix to the backup file, instead of (or in |
511 | addition to) a suffix: |
512 | |
ddffceb7 |
513 | $ perl -pi'orig_*' -e 's/bar/baz/' fileA # backup to 'orig_fileA' |
2d259d92 |
514 | |
515 | Or even to place backup copies of the original files into another |
516 | directory (provided the directory already exists): |
517 | |
ddffceb7 |
518 | $ perl -pi'old/*.orig' -e 's/bar/baz/' fileA # backup to 'old/fileA.orig' |
2d259d92 |
519 | |
66606d78 |
520 | These sets of one-liners are equivalent: |
521 | |
522 | $ perl -pi -e 's/bar/baz/' fileA # overwrite current file |
ddffceb7 |
523 | $ perl -pi'*' -e 's/bar/baz/' fileA # overwrite current file |
66606d78 |
524 | |
ddffceb7 |
525 | $ perl -pi'.orig' -e 's/bar/baz/' fileA # backup to 'fileA.orig' |
526 | $ perl -pi'*.orig' -e 's/bar/baz/' fileA # backup to 'fileA.orig' |
66606d78 |
527 | |
2d259d92 |
528 | From the shell, saying |
a0d0e21e |
529 | |
19799a22 |
530 | $ perl -p -i.orig -e "s/foo/bar/; ... " |
a0d0e21e |
531 | |
19799a22 |
532 | is the same as using the program: |
a0d0e21e |
533 | |
19799a22 |
534 | #!/usr/bin/perl -pi.orig |
a0d0e21e |
535 | s/foo/bar/; |
536 | |
537 | which is equivalent to |
538 | |
539 | #!/usr/bin/perl |
19799a22 |
540 | $extension = '.orig'; |
541 | LINE: while (<>) { |
a0d0e21e |
542 | if ($ARGV ne $oldargv) { |
66606d78 |
543 | if ($extension !~ /\*/) { |
544 | $backup = $ARGV . $extension; |
545 | } |
546 | else { |
547 | ($backup = $extension) =~ s/\*/$ARGV/g; |
548 | } |
549 | rename($ARGV, $backup); |
a0d0e21e |
550 | open(ARGVOUT, ">$ARGV"); |
551 | select(ARGVOUT); |
552 | $oldargv = $ARGV; |
553 | } |
554 | s/foo/bar/; |
555 | } |
556 | continue { |
557 | print; # this prints to original filename |
558 | } |
559 | select(STDOUT); |
560 | |
561 | except that the B<-i> form doesn't need to compare $ARGV to $oldargv to |
562 | know when the filename has changed. It does, however, use ARGVOUT for |
66606d78 |
563 | the selected filehandle. Note that STDOUT is restored as the default |
564 | output filehandle after the loop. |
565 | |
566 | As shown above, Perl creates the backup file whether or not any output |
567 | is actually changed. So this is just a fancy way to copy files: |
568 | |
cd2d1bac |
569 | $ perl -p -i'/some/file/path/*' -e 1 file1 file2 file3... |
19799a22 |
570 | or |
cd2d1bac |
571 | $ perl -p -i'.orig' -e 1 file1 file2 file3... |
66606d78 |
572 | |
573 | You can use C<eof> without parentheses to locate the end of each input |
574 | file, in case you want to append to each file, or reset line numbering |
575 | (see example in L<perlfunc/eof>). |
576 | |
577 | If, for a given file, Perl is unable to create the backup file as |
578 | specified in the extension then it will skip that file and continue on |
579 | with the next one (if it exists). |
580 | |
19799a22 |
581 | For a discussion of issues surrounding file permissions and B<-i>, |
cea6626f |
582 | see L<perlfaq5/Why does Perl let me delete read-only files? Why does -i clobber protected files? Isn't this a bug in Perl?>. |
66606d78 |
583 | |
584 | You cannot use B<-i> to create directories or to strip extensions from |
585 | files. |
a0d0e21e |
586 | |
19799a22 |
587 | Perl does not expand C<~> in filenames, which is good, since some |
588 | folks use it for their backup files: |
a0d0e21e |
589 | |
19799a22 |
590 | $ perl -pi~ -e 's/foo/bar/' file1 file2 file3... |
591 | |
a66b22ca |
592 | Note that because B<-i> renames or deletes the original file before |
0cb0633f |
593 | creating a new file of the same name, UNIX-style soft and hard links will |
594 | not be preserved. |
a66b22ca |
595 | |
19799a22 |
596 | Finally, the B<-i> switch does not impede execution when no |
a2008d6d |
597 | files are given on the command line. In this case, no backup is made |
598 | (the original file cannot, of course, be determined) and processing |
599 | proceeds from STDIN to STDOUT as might be expected. |
600 | |
a0d0e21e |
601 | =item B<-I>I<directory> |
d74e8afc |
602 | X<-I> X<@INC> |
a0d0e21e |
603 | |
e0ebc809 |
604 | Directories specified by B<-I> are prepended to the search path for |
1fef88e7 |
605 | modules (C<@INC>), and also tells the C preprocessor where to search for |
e0ebc809 |
606 | include files. The C preprocessor is invoked with B<-P>; by default it |
607 | searches /usr/include and /usr/lib/perl. |
a0d0e21e |
608 | |
e0ebc809 |
609 | =item B<-l>[I<octnum>] |
d74e8afc |
610 | X<-l> X<$/> X<$\> |
a0d0e21e |
611 | |
19799a22 |
612 | enables automatic line-ending processing. It has two separate |
613 | effects. First, it automatically chomps C<$/> (the input record |
614 | separator) when used with B<-n> or B<-p>. Second, it assigns C<$\> |
615 | (the output record separator) to have the value of I<octnum> so |
616 | that any print statements will have that separator added back on. |
617 | If I<octnum> is omitted, sets C<$\> to the current value of |
618 | C<$/>. For instance, to trim lines to 80 columns: |
a0d0e21e |
619 | |
620 | perl -lpe 'substr($_, 80) = ""' |
621 | |
622 | Note that the assignment C<$\ = $/> is done when the switch is processed, |
623 | so the input record separator can be different than the output record |
624 | separator if the B<-l> switch is followed by a B<-0> switch: |
625 | |
626 | gnufind / -print0 | perl -ln0e 'print "found $_" if -p' |
627 | |
1fef88e7 |
628 | This sets C<$\> to newline and then sets C<$/> to the null character. |
a0d0e21e |
629 | |
e0ebc809 |
630 | =item B<-m>[B<->]I<module> |
d74e8afc |
631 | X<-m> X<-M> |
e0ebc809 |
632 | |
633 | =item B<-M>[B<->]I<module> |
c07a80fd |
634 | |
e0ebc809 |
635 | =item B<-M>[B<->]I<'module ...'> |
636 | |
637 | =item B<-[mM]>[B<->]I<module=arg[,arg]...> |
3c81428c |
638 | |
19799a22 |
639 | B<-m>I<module> executes C<use> I<module> C<();> before executing your |
640 | program. |
3c81428c |
641 | |
19799a22 |
642 | B<-M>I<module> executes C<use> I<module> C<;> before executing your |
643 | program. You can use quotes to add extra code after the module name, |
644 | e.g., C<'-Mmodule qw(foo bar)'>. |
3c81428c |
645 | |
19799a22 |
646 | If the first character after the B<-M> or B<-m> is a dash (C<->) |
a5f75d66 |
647 | then the 'use' is replaced with 'no'. |
648 | |
54310121 |
649 | A little builtin syntactic sugar means you can also say |
19799a22 |
650 | B<-mmodule=foo,bar> or B<-Mmodule=foo,bar> as a shortcut for |
651 | C<'-Mmodule qw(foo bar)'>. This avoids the need to use quotes when |
652 | importing symbols. The actual code generated by B<-Mmodule=foo,bar> is |
e0ebc809 |
653 | C<use module split(/,/,q{foo,bar})>. Note that the C<=> form |
19799a22 |
654 | removes the distinction between B<-m> and B<-M>. |
3c81428c |
655 | |
642d0c2f |
656 | A consequence of this is that B<-MFoo=number> never does a version check |
657 | (unless C<Foo::import()> itself is set up to do a version check, which |
658 | could happen for example if Foo inherits from Exporter.) |
659 | |
a0d0e21e |
660 | =item B<-n> |
d74e8afc |
661 | X<-n> |
a0d0e21e |
662 | |
19799a22 |
663 | causes Perl to assume the following loop around your program, which |
a0d0e21e |
664 | makes it iterate over filename arguments somewhat like B<sed -n> or |
665 | B<awk>: |
666 | |
19799a22 |
667 | LINE: |
a0d0e21e |
668 | while (<>) { |
19799a22 |
669 | ... # your program goes here |
a0d0e21e |
670 | } |
671 | |
672 | Note that the lines are not printed by default. See B<-p> to have |
08e9d68e |
673 | lines printed. If a file named by an argument cannot be opened for |
19799a22 |
674 | some reason, Perl warns you about it and moves on to the next file. |
08e9d68e |
675 | |
fa11829f |
676 | Here is an efficient way to delete all files that haven't been modified for |
9976c5c7 |
677 | at least a week: |
a0d0e21e |
678 | |
19799a22 |
679 | find . -mtime +7 -print | perl -nle unlink |
a0d0e21e |
680 | |
19799a22 |
681 | This is faster than using the B<-exec> switch of B<find> because you don't |
682 | have to start a process on every filename found. It does suffer from |
683 | the bug of mishandling newlines in pathnames, which you can fix if |
44a4342c |
684 | you follow the example under B<-0>. |
a0d0e21e |
685 | |
686 | C<BEGIN> and C<END> blocks may be used to capture control before or after |
19799a22 |
687 | the implicit program loop, just as in B<awk>. |
a0d0e21e |
688 | |
689 | =item B<-p> |
d74e8afc |
690 | X<-p> |
a0d0e21e |
691 | |
19799a22 |
692 | causes Perl to assume the following loop around your program, which |
a0d0e21e |
693 | makes it iterate over filename arguments somewhat like B<sed>: |
694 | |
695 | |
19799a22 |
696 | LINE: |
a0d0e21e |
697 | while (<>) { |
19799a22 |
698 | ... # your program goes here |
a0d0e21e |
699 | } continue { |
08e9d68e |
700 | print or die "-p destination: $!\n"; |
a0d0e21e |
701 | } |
702 | |
08e9d68e |
703 | If a file named by an argument cannot be opened for some reason, Perl |
704 | warns you about it, and moves on to the next file. Note that the |
c2611fb3 |
705 | lines are printed automatically. An error occurring during printing is |
08e9d68e |
706 | treated as fatal. To suppress printing use the B<-n> switch. A B<-p> |
707 | overrides a B<-n> switch. |
a0d0e21e |
708 | |
709 | C<BEGIN> and C<END> blocks may be used to capture control before or after |
19799a22 |
710 | the implicit loop, just as in B<awk>. |
a0d0e21e |
711 | |
712 | =item B<-P> |
d74e8afc |
713 | X<-P> |
a0d0e21e |
714 | |
079a94c4 |
715 | B<NOTE: Use of -P is strongly discouraged because of its inherent |
716 | problems, including poor portability.> |
717 | |
718 | This option causes your program to be run through the C preprocessor before |
efdf3af0 |
719 | compilation by Perl. Because both comments and B<cpp> directives begin |
a0d0e21e |
720 | with the # character, you should avoid starting comments with any words |
efdf3af0 |
721 | recognized by the C preprocessor such as C<"if">, C<"else">, or C<"define">. |
079a94c4 |
722 | |
723 | If you're considering using C<-P>, you might also want to look at the |
724 | Filter::cpp module from CPAN. |
725 | |
726 | The problems of -P include, but are not limited to: |
727 | |
728 | =over 10 |
729 | |
730 | =item * |
731 | |
732 | The C<#!> line is stripped, so any switches there don't apply. |
733 | |
734 | =item * |
735 | |
736 | A C<-P> on a C<#!> line doesn't work. |
737 | |
738 | =item * |
739 | |
740 | B<All> lines that begin with (whitespace and) a C<#> but |
741 | do not look like cpp commands, are stripped, including anything |
44a4342c |
742 | inside Perl strings, regular expressions, and here-docs . |
079a94c4 |
743 | |
744 | =item * |
745 | |
746 | In some platforms the C preprocessor knows too much: it knows about |
747 | the C++ -style until-end-of-line comments starting with C<"//">. |
efdf3af0 |
748 | This will cause problems with common Perl constructs like |
749 | |
750 | s/foo//; |
751 | |
752 | because after -P this will became illegal code |
753 | |
754 | s/foo |
755 | |
756 | The workaround is to use some other quoting separator than C<"/">, |
757 | like for example C<"!">: |
758 | |
759 | s!foo!!; |
a0d0e21e |
760 | |
079a94c4 |
761 | |
762 | |
763 | =item * |
764 | |
765 | It requires not only a working C preprocessor but also a working |
766 | F<sed>. If not on UNIX, you are probably out of luck on this. |
767 | |
768 | =item * |
769 | |
770 | Script line numbers are not preserved. |
771 | |
772 | =item * |
773 | |
774 | The C<-x> does not work with C<-P>. |
775 | |
776 | =back |
9a1f07e7 |
777 | |
a0d0e21e |
778 | =item B<-s> |
d74e8afc |
779 | X<-s> |
a0d0e21e |
780 | |
19799a22 |
781 | enables rudimentary switch parsing for switches on the command |
782 | line after the program name but before any filename arguments (or before |
74ac850a |
783 | an argument of B<-->). Any switch found there is removed from @ARGV and sets the |
19799a22 |
784 | corresponding variable in the Perl program. The following program |
3c0facb2 |
785 | prints "1" if the program is invoked with a B<-xyz> switch, and "abc" |
786 | if it is invoked with B<-xyz=abc>. |
a0d0e21e |
787 | |
788 | #!/usr/bin/perl -s |
3c0facb2 |
789 | if ($xyz) { print "$xyz\n" } |
a0d0e21e |
790 | |
74ac850a |
791 | Do note that a switch like B<--help> creates the variable ${-help}, which is not compliant |
50b5b186 |
792 | with C<strict refs>. Also, when using this option on a script with |
793 | warnings enabled you may get a lot of spurious "used only once" warnings. |
3bbcc830 |
794 | |
a0d0e21e |
795 | =item B<-S> |
d74e8afc |
796 | X<-S> |
a0d0e21e |
797 | |
798 | makes Perl use the PATH environment variable to search for the |
19799a22 |
799 | program (unless the name of the program contains directory separators). |
800 | |
2a92aaa0 |
801 | On some platforms, this also makes Perl append suffixes to the |
802 | filename while searching for it. For example, on Win32 platforms, |
803 | the ".bat" and ".cmd" suffixes are appended if a lookup for the |
804 | original name fails, and if the name does not already end in one |
805 | of those suffixes. If your Perl was compiled with DEBUGGING turned |
806 | on, using the -Dp switch to Perl shows how the search progresses. |
807 | |
fa3aa65a |
808 | Typically this is used to emulate #! startup on platforms that don't |
809 | support #!. Its also convenient when debugging a script that uses #!, |
810 | and is thus normally found by the shell's $PATH search mechanism. |
811 | |
812 | This example works on many platforms that have a shell compatible with |
813 | Bourne shell: |
a0d0e21e |
814 | |
815 | #!/usr/bin/perl |
a3cb178b |
816 | eval 'exec /usr/bin/perl -wS $0 ${1+"$@"}' |
a0d0e21e |
817 | if $running_under_some_shell; |
818 | |
19799a22 |
819 | The system ignores the first line and feeds the program to F</bin/sh>, |
820 | which proceeds to try to execute the Perl program as a shell script. |
a0d0e21e |
821 | The shell executes the second line as a normal shell command, and thus |
822 | starts up the Perl interpreter. On some systems $0 doesn't always |
823 | contain the full pathname, so the B<-S> tells Perl to search for the |
19799a22 |
824 | program if necessary. After Perl locates the program, it parses the |
a0d0e21e |
825 | lines and ignores them because the variable $running_under_some_shell |
19799a22 |
826 | is never true. If the program will be interpreted by csh, you will need |
a3cb178b |
827 | to replace C<${1+"$@"}> with C<$*>, even though that doesn't understand |
828 | embedded spaces (and such) in the argument list. To start up sh rather |
a0d0e21e |
829 | than csh, some systems may have to replace the #! line with a line |
830 | containing just a colon, which will be politely ignored by Perl. Other |
831 | systems can't control that, and need a totally devious construct that |
19799a22 |
832 | will work under any of B<csh>, B<sh>, or Perl, such as the following: |
a0d0e21e |
833 | |
19799a22 |
834 | eval '(exit $?0)' && eval 'exec perl -wS $0 ${1+"$@"}' |
a3cb178b |
835 | & eval 'exec /usr/bin/perl -wS $0 $argv:q' |
5f05dabc |
836 | if $running_under_some_shell; |
a0d0e21e |
837 | |
19799a22 |
838 | If the filename supplied contains directory separators (i.e., is an |
839 | absolute or relative pathname), and if that file is not found, |
840 | platforms that append file extensions will do so and try to look |
841 | for the file with those extensions added, one by one. |
842 | |
843 | On DOS-like platforms, if the program does not contain directory |
844 | separators, it will first be searched for in the current directory |
845 | before being searched for on the PATH. On Unix platforms, the |
846 | program will be searched for strictly on the PATH. |
847 | |
6537fe72 |
848 | =item B<-t> |
d74e8afc |
849 | X<-t> |
6537fe72 |
850 | |
851 | Like B<-T>, but taint checks will issue warnings rather than fatal |
317ea90d |
852 | errors. These warnings can be controlled normally with C<no warnings |
853 | qw(taint)>. |
1dbad523 |
854 | |
855 | B<NOTE: this is not a substitute for -T.> This is meant only to be |
856 | used as a temporary development aid while securing legacy code: |
857 | for real production code and for new secure code written from scratch |
858 | always use the real B<-T>. |
6537fe72 |
859 | |
a0d0e21e |
860 | =item B<-T> |
d74e8afc |
861 | X<-T> |
a0d0e21e |
862 | |
a3cb178b |
863 | forces "taint" checks to be turned on so you can test them. Ordinarily |
19799a22 |
864 | these checks are done only when running setuid or setgid. It's a |
865 | good idea to turn them on explicitly for programs that run on behalf |
866 | of someone else whom you might not necessarily trust, such as CGI |
867 | programs or any internet servers you might write in Perl. See |
868 | L<perlsec> for details. For security reasons, this option must be |
869 | seen by Perl quite early; usually this means it must appear early |
870 | on the command line or in the #! line for systems which support |
871 | that construct. |
a0d0e21e |
872 | |
873 | =item B<-u> |
d74e8afc |
874 | X<-u> |
a0d0e21e |
875 | |
19799a22 |
876 | This obsolete switch causes Perl to dump core after compiling your |
877 | program. You can then in theory take this core dump and turn it |
878 | into an executable file by using the B<undump> program (not supplied). |
879 | This speeds startup at the expense of some disk space (which you |
880 | can minimize by stripping the executable). (Still, a "hello world" |
881 | executable comes out to about 200K on my machine.) If you want to |
882 | execute a portion of your program before dumping, use the dump() |
883 | operator instead. Note: availability of B<undump> is platform |
884 | specific and may not be available for a specific port of Perl. |
885 | |
886 | This switch has been superseded in favor of the new Perl code |
887 | generator backends to the compiler. See L<B> and L<B::Bytecode> |
888 | for details. |
a0d0e21e |
889 | |
890 | =item B<-U> |
d74e8afc |
891 | X<-U> |
a0d0e21e |
892 | |
893 | allows Perl to do unsafe operations. Currently the only "unsafe" |
c69adce3 |
894 | operations are attempting to unlink directories while running as |
895 | superuser, and running setuid programs with fatal taint checks turned |
896 | into warnings. Note that the B<-w> switch (or the C<$^W> variable) |
897 | must be used along with this option to actually I<generate> the |
898 | taint-check warnings. |
a0d0e21e |
899 | |
900 | =item B<-v> |
d74e8afc |
901 | X<-v> |
a0d0e21e |
902 | |
19799a22 |
903 | prints the version and patchlevel of your perl executable. |
a0d0e21e |
904 | |
3c81428c |
905 | =item B<-V> |
d74e8afc |
906 | X<-V> |
3c81428c |
907 | |
908 | prints summary of the major perl configuration values and the current |
19799a22 |
909 | values of @INC. |
3c81428c |
910 | |
307dc113 |
911 | =item B<-V:>I<configvar> |
3c81428c |
912 | |
4a305f6a |
913 | Prints to STDOUT the value of the named configuration variable(s), |
307dc113 |
914 | with multiples when your configvar argument looks like a regex (has |
915 | non-letters). For example: |
3c81428c |
916 | |
307dc113 |
917 | $ perl -V:libc |
918 | libc='/lib/libc-2.2.4.so'; |
4a305f6a |
919 | $ perl -V:lib. |
920 | libs='-lnsl -lgdbm -ldb -ldl -lm -lcrypt -lutil -lc'; |
921 | libc='/lib/libc-2.2.4.so'; |
922 | $ perl -V:lib.* |
923 | libpth='/usr/local/lib /lib /usr/lib'; |
924 | libs='-lnsl -lgdbm -ldb -ldl -lm -lcrypt -lutil -lc'; |
925 | lib_ext='.a'; |
926 | libc='/lib/libc-2.2.4.so'; |
927 | libperl='libperl.a'; |
928 | .... |
929 | |
930 | Additionally, extra colons can be used to control formatting. A |
931 | trailing colon suppresses the linefeed and terminator ';', allowing |
932 | you to embed queries into shell commands. (mnemonic: PATH separator |
933 | ':'.) |
934 | |
935 | $ echo "compression-vars: " `perl -V:z.*: ` " are here !" |
936 | compression-vars: zcat='' zip='zip' are here ! |
937 | |
938 | A leading colon removes the 'name=' part of the response, this allows |
307dc113 |
939 | you to map to the name you need. (mnemonic: empty label) |
4a305f6a |
940 | |
941 | $ echo "goodvfork="`./perl -Ilib -V::usevfork` |
942 | goodvfork=false; |
943 | |
944 | Leading and trailing colons can be used together if you need |
945 | positional parameter values without the names. Note that in the case |
946 | below, the PERL_API params are returned in alphabetical order. |
947 | |
948 | $ echo building_on `perl -V::osname: -V::PERL_API_.*:` now |
949 | building_on 'linux' '5' '1' '9' now |
a0d0e21e |
950 | |
19799a22 |
951 | =item B<-w> |
d74e8afc |
952 | X<-w> |
774d564b |
953 | |
19799a22 |
954 | prints warnings about dubious constructs, such as variable names |
955 | that are mentioned only once and scalar variables that are used |
956 | before being set, redefined subroutines, references to undefined |
957 | filehandles or filehandles opened read-only that you are attempting |
a4d9c8a6 |
958 | to write on, values used as a number that don't look like numbers, |
19799a22 |
959 | using an array as though it were a scalar, if your subroutines |
960 | recurse more than 100 deep, and innumerable other things. |
961 | |
b40da996 |
962 | This switch really just enables the internal C<$^W> variable. You |
19799a22 |
963 | can disable or promote into fatal errors specific warnings using |
964 | C<__WARN__> hooks, as described in L<perlvar> and L<perlfunc/warn>. |
965 | See also L<perldiag> and L<perltrap>. A new, fine-grained warning |
966 | facility is also available if you want to manipulate entire classes |
9f1b1f2d |
967 | of warnings; see L<warnings> or L<perllexwarn>. |
a0d0e21e |
968 | |
0453d815 |
969 | =item B<-W> |
d74e8afc |
970 | X<-W> |
0453d815 |
971 | |
3c0facb2 |
972 | Enables all warnings regardless of C<no warnings> or C<$^W>. |
0453d815 |
973 | See L<perllexwarn>. |
974 | |
975 | =item B<-X> |
d74e8afc |
976 | X<-X> |
0453d815 |
977 | |
3c0facb2 |
978 | Disables all warnings regardless of C<use warnings> or C<$^W>. |
0453d815 |
979 | See L<perllexwarn>. |
980 | |
136e4fd6 |
981 | =item B<-x> |
d74e8afc |
982 | X<-x> |
136e4fd6 |
983 | |
a0d0e21e |
984 | =item B<-x> I<directory> |
985 | |
19799a22 |
986 | tells Perl that the program is embedded in a larger chunk of unrelated |
987 | ASCII text, such as in a mail message. Leading garbage will be |
988 | discarded until the first line that starts with #! and contains the |
989 | string "perl". Any meaningful switches on that line will be applied. |
990 | If a directory name is specified, Perl will switch to that directory |
991 | before running the program. The B<-x> switch controls only the |
992 | disposal of leading garbage. The program must be terminated with |
993 | C<__END__> if there is trailing garbage to be ignored (the program |
994 | can process any or all of the trailing garbage via the DATA filehandle |
995 | if desired). |
a0d0e21e |
996 | |
1e422769 |
997 | =back |
998 | |
999 | =head1 ENVIRONMENT |
d74e8afc |
1000 | X<perl, environment variables> |
1e422769 |
1001 | |
1002 | =over 12 |
1003 | |
1004 | =item HOME |
d74e8afc |
1005 | X<HOME> |
1e422769 |
1006 | |
1007 | Used if chdir has no argument. |
1008 | |
1009 | =item LOGDIR |
d74e8afc |
1010 | X<LOGDIR> |
1e422769 |
1011 | |
1012 | Used if chdir has no argument and HOME is not set. |
1013 | |
1014 | =item PATH |
d74e8afc |
1015 | X<PATH> |
1e422769 |
1016 | |
19799a22 |
1017 | Used in executing subprocesses, and in finding the program if B<-S> is |
1e422769 |
1018 | used. |
1019 | |
1020 | =item PERL5LIB |
d74e8afc |
1021 | X<PERL5LIB> |
1e422769 |
1022 | |
48b971ca |
1023 | A list of directories in which to look for Perl library |
1e422769 |
1024 | files before looking in the standard library and the current |
951ba7fe |
1025 | directory. Any architecture-specific directories under the specified |
1026 | locations are automatically included if they exist. If PERL5LIB is not |
48b971ca |
1027 | defined, PERLLIB is used. Directories are separated (like in PATH) by |
1028 | a colon on unixish platforms and by a semicolon on Windows (the proper |
1029 | path separator being given by the command C<perl -V:path_sep>). |
951ba7fe |
1030 | |
1031 | When running taint checks (either because the program was running setuid |
1032 | or setgid, or the B<-T> switch was used), neither variable is used. |
1033 | The program should instead say: |
1e422769 |
1034 | |
1035 | use lib "/my/directory"; |
1036 | |
54310121 |
1037 | =item PERL5OPT |
d74e8afc |
1038 | X<PERL5OPT> |
54310121 |
1039 | |
1040 | Command-line options (switches). Switches in this variable are taken |
e4af53b0 |
1041 | as if they were on every Perl command line. Only the B<-[CDIMUdmtwA]> |
19799a22 |
1042 | switches are allowed. When running taint checks (because the program |
54310121 |
1043 | was running setuid or setgid, or the B<-T> switch was used), this |
74288ac8 |
1044 | variable is ignored. If PERL5OPT begins with B<-T>, tainting will be |
1045 | enabled, and any subsequent options ignored. |
54310121 |
1046 | |
16537909 |
1047 | =item PERLIO |
d74e8afc |
1048 | X<PERLIO> |
16537909 |
1049 | |
44a4342c |
1050 | A space (or colon) separated list of PerlIO layers. If perl is built |
03d9e98a |
1051 | to use PerlIO system for IO (the default) these layers effect perl's IO. |
44a4342c |
1052 | |
1053 | It is conventional to start layer names with a colon e.g. C<:perlio> to |
1054 | emphasise their similarity to variable "attributes". But the code that parses |
1055 | layer specification strings (which is also used to decode the PERLIO |
1056 | environment variable) treats the colon as a separator. |
1057 | |
3b0db4f9 |
1058 | An unset or empty PERLIO is equivalent to C<:stdio>. |
1059 | |
44a4342c |
1060 | The list becomes the default for I<all> perl's IO. Consequently only built-in |
1061 | layers can appear in this list, as external layers (such as :encoding()) need |
1062 | IO in order to load them!. See L<"open pragma"|open> for how to add external |
1063 | encodings as defaults. |
1064 | |
1065 | The layers that it makes sense to include in the PERLIO environment |
3d897973 |
1066 | variable are briefly summarised below. For more details see L<PerlIO>. |
16537909 |
1067 | |
1068 | =over 8 |
1069 | |
1070 | =item :bytes |
d74e8afc |
1071 | X<:bytes> |
16537909 |
1072 | |
18aba96f |
1073 | A pseudolayer that turns I<off> the C<:utf8> flag for the layer below. |
1074 | Unlikely to be useful on its own in the global PERLIO environment variable. |
1075 | You perhaps were thinking of C<:crlf:bytes> or C<:perlio:bytes>. |
16537909 |
1076 | |
1077 | =item :crlf |
d74e8afc |
1078 | X<:crlf> |
16537909 |
1079 | |
3d897973 |
1080 | A layer which does CRLF to "\n" translation distinguishing "text" and |
1081 | "binary" files in the manner of MS-DOS and similar operating systems. |
1082 | (It currently does I<not> mimic MS-DOS as far as treating of Control-Z |
1083 | as being an end-of-file marker.) |
44a4342c |
1084 | |
1085 | =item :mmap |
d74e8afc |
1086 | X<:mmap> |
44a4342c |
1087 | |
1088 | A layer which implements "reading" of files by using C<mmap()> to |
1089 | make (whole) file appear in the process's address space, and then |
3d897973 |
1090 | using that as PerlIO's "buffer". |
16537909 |
1091 | |
44a4342c |
1092 | =item :perlio |
d74e8afc |
1093 | X<:perlio> |
16537909 |
1094 | |
3d897973 |
1095 | This is a re-implementation of "stdio-like" buffering written as a |
1096 | PerlIO "layer". As such it will call whatever layer is below it for |
1097 | its operations (typically C<:unix>). |
16537909 |
1098 | |
18aba96f |
1099 | =item :pop |
d74e8afc |
1100 | X<:pop> |
18aba96f |
1101 | |
1102 | An experimental pseudolayer that removes the topmost layer. |
3d897973 |
1103 | Use with the same care as is reserved for nitroglycerin. |
18aba96f |
1104 | |
44a4342c |
1105 | =item :raw |
d74e8afc |
1106 | X<:raw> |
16537909 |
1107 | |
136e4fd6 |
1108 | A pseudolayer that manipulates other layers. Applying the C<:raw> |
18aba96f |
1109 | layer is equivalent to calling C<binmode($fh)>. It makes the stream |
1110 | pass each byte as-is without any translation. In particular CRLF |
1111 | translation, and/or :utf8 intuited from locale are disabled. |
1cbfc93d |
1112 | |
3d897973 |
1113 | Unlike in the earlier versions of Perl C<:raw> is I<not> |
1114 | just the inverse of C<:crlf> - other layers which would affect the |
1115 | binary nature of the stream are also removed or disabled. |
16537909 |
1116 | |
44a4342c |
1117 | =item :stdio |
d74e8afc |
1118 | X<:stdio> |
44a4342c |
1119 | |
1120 | This layer provides PerlIO interface by wrapping system's ANSI C "stdio" |
1121 | library calls. The layer provides both buffering and IO. |
1122 | Note that C<:stdio> layer does I<not> do CRLF translation even if that |
1123 | is platforms normal behaviour. You will need a C<:crlf> layer above it |
1124 | to do that. |
1125 | |
1126 | =item :unix |
d74e8afc |
1127 | X<:unix> |
44a4342c |
1128 | |
3d897973 |
1129 | Low level layer which calls C<read>, C<write> and C<lseek> etc. |
16537909 |
1130 | |
1131 | =item :utf8 |
d74e8afc |
1132 | X<:utf8> |
16537909 |
1133 | |
18aba96f |
1134 | A pseudolayer that turns on a flag on the layer below to tell perl |
3d897973 |
1135 | that output should be in utf8 and that input should be regarded as |
1136 | already in utf8 form. May be useful in PERLIO environment |
1137 | variable to make UTF-8 the default. (To turn off that behaviour |
1138 | use C<:bytes> layer.) |
44a4342c |
1139 | |
1140 | =item :win32 |
d74e8afc |
1141 | X<:win32> |
44a4342c |
1142 | |
ab4f7683 |
1143 | On Win32 platforms this I<experimental> layer uses native "handle" IO |
44a4342c |
1144 | rather than unix-like numeric file descriptor layer. Known to be |
1145 | buggy in this release. |
16537909 |
1146 | |
1147 | =back |
1148 | |
44a4342c |
1149 | On all platforms the default set of layers should give acceptable results. |
1150 | |
ab4f7683 |
1151 | For UNIX platforms that will equivalent of "unix perlio" or "stdio". |
44a4342c |
1152 | Configure is setup to prefer "stdio" implementation if system's library |
1153 | provides for fast access to the buffer, otherwise it uses the "unix perlio" |
1154 | implementation. |
1155 | |
1156 | On Win32 the default in this release is "unix crlf". Win32's "stdio" |
1157 | has a number of bugs/mis-features for perl IO which are somewhat |
99366417 |
1158 | C compiler vendor/version dependent. Using our own C<crlf> layer as |
44a4342c |
1159 | the buffer avoids those issues and makes things more uniform. |
1160 | The C<crlf> layer provides CRLF to/from "\n" conversion as well as |
1161 | buffering. |
1162 | |
1163 | This release uses C<unix> as the bottom layer on Win32 and so still uses C |
1164 | compiler's numeric file descriptor routines. There is an experimental native |
3d897973 |
1165 | C<win32> layer which is expected to be enhanced and should eventually be |
1166 | the default under Win32. |
44a4342c |
1167 | |
1168 | =item PERLIO_DEBUG |
d74e8afc |
1169 | X<PERLIO_DEBUG> |
44a4342c |
1170 | |
1171 | If set to the name of a file or device then certain operations of PerlIO |
1172 | sub-system will be logged to that file (opened as append). Typical uses |
1173 | are UNIX: |
1174 | |
1175 | PERLIO_DEBUG=/dev/tty perl script ... |
1176 | |
1177 | and Win32 approximate equivalent: |
1178 | |
1179 | set PERLIO_DEBUG=CON |
1180 | perl script ... |
1181 | |
923e8b21 |
1182 | This functionality is disabled for setuid scripts and for scripts run |
1183 | with B<-T>. |
16537909 |
1184 | |
1e422769 |
1185 | =item PERLLIB |
d74e8afc |
1186 | X<PERLLIB> |
1e422769 |
1187 | |
48b971ca |
1188 | A list of directories in which to look for Perl library |
1e422769 |
1189 | files before looking in the standard library and the current directory. |
1190 | If PERL5LIB is defined, PERLLIB is not used. |
1191 | |
1192 | =item PERL5DB |
d74e8afc |
1193 | X<PERL5DB> |
1e422769 |
1194 | |
1195 | The command used to load the debugger code. The default is: |
1196 | |
1197 | BEGIN { require 'perl5db.pl' } |
1198 | |
2cbb2ee1 |
1199 | =item PERL5DB_THREADED |
d74e8afc |
1200 | X<PERL5DB_THREADED> |
2cbb2ee1 |
1201 | |
1202 | If set to a true value, indicates to the debugger that the code being |
1203 | debugged uses threads. |
1204 | |
19799a22 |
1205 | =item PERL5SHELL (specific to the Win32 port) |
d74e8afc |
1206 | X<PERL5SHELL> |
174c211a |
1207 | |
1208 | May be set to an alternative shell that perl must use internally for |
11998fdb |
1209 | executing "backtick" commands or system(). Default is C<cmd.exe /x/d/c> |
ce1da67e |
1210 | on WindowsNT and C<command.com /c> on Windows95. The value is considered |
19799a22 |
1211 | to be space-separated. Precede any character that needs to be protected |
ce1da67e |
1212 | (like a space or backslash) with a backslash. |
1213 | |
1214 | Note that Perl doesn't use COMSPEC for this purpose because |
1215 | COMSPEC has a high degree of variability among users, leading to |
1216 | portability concerns. Besides, perl can use a shell that may not be |
1217 | fit for interactive use, and setting COMSPEC to such a shell may |
1218 | interfere with the proper functioning of other programs (which usually |
1219 | look in COMSPEC to find a shell fit for interactive use). |
174c211a |
1220 | |
1c972609 |
1221 | =item PERL_ALLOW_NON_IFS_LSP (specific to the Win32 port) |
d74e8afc |
1222 | X<PERL_ALLOW_NON_IFS_LSP> |
1c972609 |
1223 | |
1224 | Set to 1 to allow the use of non-IFS compatible LSP's. |
1225 | Perl normally searches for an IFS-compatible LSP because this is required |
1226 | for its emulation of Windows sockets as real filehandles. However, this may |
1227 | cause problems if you have a firewall such as McAfee Guardian which requires |
1228 | all applications to use its LSP which is not IFS-compatible, because clearly |
1229 | Perl will normally avoid using such an LSP. |
1230 | Setting this environment variable to 1 means that Perl will simply use the |
1231 | first suitable LSP enumerated in the catalog, which keeps McAfee Guardian |
1232 | happy (and in that particular case Perl still works too because McAfee |
1233 | Guardian's LSP actually plays some other games which allow applications |
1234 | requiring IFS compatibility to work). |
1235 | |
1e422769 |
1236 | =item PERL_DEBUG_MSTATS |
d74e8afc |
1237 | X<PERL_DEBUG_MSTATS> |
1e422769 |
1238 | |
67ce8856 |
1239 | Relevant only if perl is compiled with the malloc included with the perl |
a3cb178b |
1240 | distribution (that is, if C<perl -V:d_mymalloc> is 'define'). |
1241 | If set, this causes memory statistics to be dumped after execution. If set |
1e422769 |
1242 | to an integer greater than one, also causes memory statistics to be dumped |
1243 | after compilation. |
1244 | |
1245 | =item PERL_DESTRUCT_LEVEL |
d74e8afc |
1246 | X<PERL_DESTRUCT_LEVEL> |
1e422769 |
1247 | |
1248 | Relevant only if your perl executable was built with B<-DDEBUGGING>, |
1249 | this controls the behavior of global destruction of objects and other |
64cea5fd |
1250 | references. See L<perlhack/PERL_DESTRUCT_LEVEL> for more information. |
a0d0e21e |
1251 | |
02c7413a |
1252 | =item PERL_DL_NONLAZY |
d74e8afc |
1253 | X<PERL_DL_NONLAZY> |
02c7413a |
1254 | |
1255 | Set to one to have perl resolve B<all> undefined symbols when it loads |
1256 | a dynamic library. The default behaviour is to resolve symbols when |
1257 | they are used. Setting this variable is useful during testing of |
1258 | extensions as it ensures that you get an error on misspelled function |
1259 | names even if the test suite doesn't call it. |
1260 | |
5d170f3a |
1261 | =item PERL_ENCODING |
d74e8afc |
1262 | X<PERL_ENCODING> |
5d170f3a |
1263 | |
1264 | If using the C<encoding> pragma without an explicit encoding name, the |
1265 | PERL_ENCODING environment variable is consulted for an encoding name. |
1266 | |
504f80c1 |
1267 | =item PERL_HASH_SEED |
d74e8afc |
1268 | X<PERL_HASH_SEED> |
504f80c1 |
1269 | |
183c3da1 |
1270 | (Since Perl 5.8.1.) Used to randomise Perl's internal hash function. |
4546b9e6 |
1271 | To emulate the pre-5.8.1 behaviour, set to an integer (zero means |
1272 | exactly the same order as 5.8.0). "Pre-5.8.1" means, among other |
1273 | things, that hash keys will be ordered the same between different runs |
1274 | of Perl. |
504f80c1 |
1275 | |
4546b9e6 |
1276 | The default behaviour is to randomise unless the PERL_HASH_SEED is set. |
1277 | If Perl has been compiled with C<-DUSE_HASH_SEED_EXPLICIT>, the default |
1278 | behaviour is B<not> to randomise unless the PERL_HASH_SEED is set. |
504f80c1 |
1279 | |
1280 | If PERL_HASH_SEED is unset or set to a non-numeric string, Perl uses |
1281 | the pseudorandom seed supplied by the operating system and libraries. |
4546b9e6 |
1282 | This means that each different run of Perl will have a different |
1283 | ordering of the results of keys(), values(), and each(). |
504f80c1 |
1284 | |
26a2d347 |
1285 | B<Please note that the hash seed is sensitive information>. Hashes are |
1286 | randomized to protect against local and remote attacks against Perl |
1287 | code. By manually setting a seed this protection may be partially or |
1288 | completely lost. |
1289 | |
1290 | See L<perlsec/"Algorithmic Complexity Attacks"> and |
1291 | L</PERL_HASH_SEED_DEBUG> for more information. |
504f80c1 |
1292 | |
2191697e |
1293 | =item PERL_HASH_SEED_DEBUG |
d74e8afc |
1294 | X<PERL_HASH_SEED_DEBUG> |
2191697e |
1295 | |
e67b9e52 |
1296 | (Since Perl 5.8.1.) Set to one to display (to STDERR) the value of |
26a2d347 |
1297 | the hash seed at the beginning of execution. This, combined with |
1298 | L</PERL_HASH_SEED> is intended to aid in debugging nondeterministic |
1299 | behavior caused by hash randomization. |
1300 | |
1301 | B<Note that the hash seed is sensitive information>: by knowing it one |
1302 | can craft a denial-of-service attack against Perl code, even remotely, |
1303 | see L<perlsec/"Algorithmic Complexity Attacks"> for more information. |
e67b9e52 |
1304 | B<Do not disclose the hash seed> to people who don't need to know it. |
9a7034eb |
1305 | See also hash_seed() of L<Hash::Util>. |
2191697e |
1306 | |
3d0ae7ba |
1307 | =item PERL_ROOT (specific to the VMS port) |
d74e8afc |
1308 | X<PERL_ROOT> |
3d0ae7ba |
1309 | |
1310 | A translation concealed rooted logical name that contains perl and the |
1311 | logical device for the @INC path on VMS only. Other logical names that |
44a4342c |
1312 | affect perl on VMS include PERLSHR, PERL_ENV_TABLES, and |
1313 | SYS$TIMEZONE_DIFFERENTIAL but are optional and discussed further in |
3d0ae7ba |
1314 | L<perlvms> and in F<README.vms> in the Perl source distribution. |
1315 | |
4ffa73a3 |
1316 | =item PERL_SIGNALS |
d74e8afc |
1317 | X<PERL_SIGNALS> |
4ffa73a3 |
1318 | |
1319 | In Perls 5.8.1 and later. If set to C<unsafe> the pre-Perl-5.8.0 |
1320 | signals behaviour (immediate but unsafe) is restored. If set to |
ec488bcf |
1321 | C<safe> the safe (or deferred) signals are used. |
65c3f8ef |
1322 | See L<perlipc/"Deferred Signals (Safe Signals)">. |
4ffa73a3 |
1323 | |
a05d7ebb |
1324 | =item PERL_UNICODE |
d74e8afc |
1325 | X<PERL_UNICODE> |
acae81db |
1326 | |
bf61ac64 |
1327 | Equivalent to the B<-C> command-line switch. Note that this is not |
1328 | a boolean variable-- setting this to C<"1"> is not the right way to |
5b4f334e |
1329 | "enable Unicode" (whatever that would mean). You can use C<"0"> to |
e654d908 |
1330 | "disable Unicode", though (or alternatively unset PERL_UNICODE in |
1331 | your shell before starting Perl). See the description of the C<-C> |
1332 | switch for more information. |
acae81db |
1333 | |
3d0ae7ba |
1334 | =item SYS$LOGIN (specific to the VMS port) |
d74e8afc |
1335 | X<SYS$LOGIN> |
3d0ae7ba |
1336 | |
1337 | Used if chdir has no argument and HOME and LOGDIR are not set. |
1338 | |
a0d0e21e |
1339 | =back |
1e422769 |
1340 | |
1341 | Perl also has environment variables that control how Perl handles data |
1342 | specific to particular natural languages. See L<perllocale>. |
1343 | |
1344 | Apart from these, Perl uses no other environment variables, except |
19799a22 |
1345 | to make them available to the program being executed, and to child |
1346 | processes. However, programs running setuid would do well to execute |
1e422769 |
1347 | the following lines before doing anything else, just to keep people |
1348 | honest: |
1349 | |
19799a22 |
1350 | $ENV{PATH} = '/bin:/usr/bin'; # or whatever you need |
7bac28a0 |
1351 | $ENV{SHELL} = '/bin/sh' if exists $ENV{SHELL}; |
c90c0ff4 |
1352 | delete @ENV{qw(IFS CDPATH ENV BASH_ENV)}; |