Upon startup, Perl looks for your script in one of the following places:
-
Specified line by line via -e switches on the command line.
-
Contained in the file specified by the first filename on the command line.
(Note that systems supporting the #! notation invoke interpreters this
way.)
-
Passed in implicitly via standard input. This works only if there are no filename arguments--to pass arguments to a
STDIN script you must explicitly specify a ``-'' for the script name.
With methods 2 and 3, Perl starts parsing the input file from the
beginning, unless you've specified a
-x switch, in
which case it scans for the first line starting with #! and containing
the word ``perl'', and starts there instead. This is useful for running a
script embedded in a larger message. (In this case you would indicate
the end of the script using the
__END__ token.)
The #! line is always examined for switches as the line is being parsed.
Thus, if you're on a machine that allows only one argument with the #!
line, or worse, doesn't even recognize the #! line, you still can get
consistent switch behavior regardless of how Perl was invoked, even if
-x was used to find the beginning of the script.
Because many operating systems silently chop off kernel interpretation of
the #! line after 32 characters, some switches may be passed in on the
command line, and some may not; you could even get a ``-'' without its
letter, if you're not careful. You probably want to make sure that all your
switches fall either before or after that 32 character boundary. Most
switches don't actually care if they're processed redundantly, but getting
a - instead of a complete switch could cause Perl to try to execute
standard input instead of your script. And a partial
-I switch could also cause odd results.
Parsing of the #! switches starts wherever ``perl'' is mentioned in the
line. The sequences ``-*'' and ``- '' are specifically ignored so that you
could, if you were so inclined, say
#!/bin/sh -- # -*- perl -*- -p
eval 'exec /usr/bin/perl $0 -S ${1+"$@"}'
if $running_under_some_shell;
to let Perl see the
-p switch.
If the #! line does not contain the word ``perl'', the program named
after the #! is executed instead of the Perl interpreter. This is
slightly bizarre, but it helps people on machines that don't do #!,
because they can tell a program that their
SHELL is /usr/bin/perl, and Perl will then dispatch the program to the correct interpreter for them.
After locating your script, Perl compiles the entire script to an internal
form. If there are any compilation errors, execution of the script is not
attempted. (This is unlike the typical shell script, which might run
partway through before finding a syntax error.)
If the script is syntactically correct, it is executed. If the script runs
off the end without hitting an
exit or
die
operator, an implicit
exit is provided to indicate successful completion.
