PERLRUN(1)       Perl Programmers Reference Guide      PERLRUN(1)

NNAAMMEE
       perlrun - how to execute the Perl interpreter

SSYYNNOOPPSSIISS
       ppeerrll [ --ssTTuuUU ]      [ --hhvv ] [ --VV[:configvar] ]
            [ --ccww ] [ --dd[:debugger] ] [ --DD[number/list] ]
            [ --ppnnaa ] [ --FFpattern ] [ --ll[octal] ] [ --00[octal] ]
            [ --IIdir ] [ --mm[--]module ] [ --MM[--]'module...' ]
            [ --PP ]      [ --SS ]      [ --xx[dir] ]
            [ --ii[extension] ]
            [ --ee 'command' ] [ ---- ] [ programfile ] [ argument ]...

DDEESSCCRRIIPPTTIIOONN
       Upon startup, Perl looks for your script in one of the
       following places:

       1.  Specified line by line via --ee switches on the command
           line.

       2.  Contained in the file specified by the first filename
           on the command line.  (Note that systems supporting
           the #! notation invoke interpreters this way. See the
           section on Location of Perl.)

       3.  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 --xx 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 --xx
       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 --II
       switch could also cause odd results.

       Some switches do care if they are processed twice, for
       instance combinations of --ll and --00.  Either put all the
       switches after the 32 character boundary (if applicable),
       or replace the use of --00digits by BEGIN{ $/ = "\0digits";
       }.

       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 -wS $0 ${1+"$@"}'
               if $running_under_some_shell;

       to let Perl see the --pp 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 part-
       way 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(0) is provided to
       indicate successful completion.

       ##!! aanndd qquuoottiinngg oonn nnoonn--UUnniixx ssyysstteemmss

       Unix's #! technique can be simulated on other systems:

       OS/2
           Put

               extproc perl -S -your_switches

           as the first line in *.cmd file (-S due to a bug in
           cmd.exe's `extproc' handling).

       MS-DOS
           Create a batch file to run your script, and codify it
           in ALTERNATIVE_SHEBANG (see the dosish.h file in the
           source distribution for more information).

       Win95/NT
           The Win95/NT installation, when using the Activeware
           port of Perl, will modify the Registry to associate
           the .pl extension with the perl interpreter.  If you
           install another port of Perl, including the one in the
           Win32 directory of the Perl distribution, then you'll
           have to modify the Registry yourself.  Note that this
           means you can no longer tell the difference between an
           executable Perl program and a Perl library file.

       Macintosh
           Macintosh perl scripts will have the appropriate
           Creator and Type, so that double-clicking them will
           invoke the perl application.

       VMS Put

               $ perl -mysw 'f$env("procedure")' 'p1' 'p2' 'p3' 'p4' 'p5' 'p6' 'p7' 'p8' !
               $ exit++ + ++$status != 0 and $exit = $status = undef;

           at the top of your script, where -mysw are any command
           line switches you want to pass to Perl.  You can now
           invoke the script directly, by saying perl script, or
           as a DCL procedure, by saying @script (or implicitly
           via DCL$PATH by just using the name of the script).

           This incantation is a bit much to remember, but Perl
           will display it for you if you say perl
           "-V:startperl".

       Command-interpreters on non-Unix systems have rather
       different ideas on quoting than Unix shells.  You'll need
       to learn the special characters in your command-
       interpreter (*, \ and " are common) and how to protect
       whitespace and these characters to run one-liners (see -e
       below).

       On some systems, you may have to change single-quotes to
       double ones, which you must NOT do on Unix or Plan9
       systems.  You might also have to change a single % to a
       %%.

       For example:

           # Unix
           perl -e 'print "Hello world\n"'

           # MS-DOS, etc.
           perl -e "print \"Hello world\n\""

           # Macintosh
           print "Hello world\n"
            (then Run "Myscript" or Shift-Command-R)

           # VMS
           perl -e "print ""Hello world\n"""

       The problem is that none of this is reliable: it depends
       on the command and it is entirely possible neither works.
       If 4DOS was the command shell, this would probably work
       better:

           perl -e "print <Ctrl-x>"Hello world\n<Ctrl-x>""

       CMD.EXE in Windows NT slipped a lot of standard Unix
       functionality in when nobody was looking, but just try to
       find documentation for its quoting rules.

       Under the Macintosh, it depends which environment you are
       using.  The MacPerl shell, or MPW, is much like Unix
       shells in its support for several quoting variants, except
       that it makes free use of the Macintosh's non-ASCII
       characters as control characters.

       There is no general solution to all of this.  It's just a
       mess.

       LLooccaattiioonn ooff PPeerrll

       It may seem obvious to say, but Perl is useful only when
       users can easily find it. When possible, it's good for
       both //uussrr//bbiinn//ppeerrll and //uussrr//llooccaall//bbiinn//ppeerrll to be symlinks
       to the actual binary. If that can't be done, system
       administrators are strongly encouraged to put (symlinks
       to) perl and its accompanying utilities, such as perldoc,
       into a directory typically found along a user's PATH, or
       in another obvious and convenient place.

       In this documentation, #!/usr/bin/perl on the first line
       of the script will stand in for whatever method works on
       your system.

       SSwwiittcchheess

       A single-character switch may be combined with the
       following switch, if any.

           #!/usr/bin/perl -spi.bak    # same as -s -p -i.bak

       Switches include:

       --00[digits]
            specifies the input record separator ($/) as an octal
            number.  If there are no digits, the null character
            is the separator.  Other switches may precede or
            follow the digits.  For example, if you have a
            version of ffiinndd which can print filenames terminated
            by the null character, you can say this:

                find . -name '*.bak' -print0 | perl -n0e unlink

            The special value 00 will cause Perl to slurp files
            in paragraph mode.  The value 0777 will cause Perl to
            slurp files whole because there is no legal character
            with that value.

       --aa   turns on autosplit mode when used with a --nn or --pp.
            An implicit split command to the @F array is done as
            the first thing inside the implicit while loop
            produced by the --nn or --pp.

                perl -ane 'print pop(@F), "\n";'

            is equivalent to

                while (<>) {
                    @F = split(' ');
                    print pop(@F), "\n";
                }

            An alternate delimiter may be specified using --FF.

       --cc   causes Perl to check the syntax of the script and
            then exit without executing it.  Actually, it will
            execute BEGIN, END, and use blocks, because these are
            considered as occurring outside the execution of your
            program.

       --dd   runs the script under the Perl debugger.  See the
            perldebug manpage.

       --dd::foo
            runs the script under the control of a debugging or
            tracing module installed as Devel::foo. E.g.,
            --dd::DDPPrrooff executes the script using the Devel::DProf
            profiler.  See the perldebug manpage.

       --DDletters

       --DDnumber
            sets debugging flags.  To watch how it executes your
            script, use --DDttllss.  (This works only if debugging is
            compiled into your Perl.)  Another nice value is --DDxx,
            which lists your compiled syntax tree.  And --DDrr
            displays compiled regular expressions. As an
            alternative, specify a number instead of list of
            letters (e.g., --DD1144 is equivalent to --DDttllss):

                    1  p  Tokenizing and parsing
                    2  s  Stack snapshots
                    4  l  Context (loop) stack processing
                    8  t  Trace execution
                   16  o  Method and overloading resolution
                   32  c  String/numeric conversions
                   64  P  Print preprocessor command for -P
                  128  m  Memory allocation
                  256  f  Format processing
                  512  r  Regular expression parsing and execution
                 1024  x  Syntax tree dump
                 2048  u  Tainting checks
                 4096  L  Memory leaks (needs C<-DLEAKTEST> when compiling Perl)
                 8192  H  Hash dump -- usurps values()
                16384  X  Scratchpad allocation
                32768  D  Cleaning up
                65536  S  Thread synchronization

            All these flags require -DDEBUGGING when you compile
            the Perl executable.  This flag is automatically set
            if you include -g option when Configure asks you
            about optimizer/debugger flags.

       --ee commandline
            may be used to enter one line of script.  If --ee is
            given, Perl will not look for a script filename in
            the argument list.  Multiple --ee commands may be given
            to build up a multi-line script.  Make sure to use
            semicolons where you would in a normal program.

       --FFpattern
            specifies the pattern to split on if --aa is also in
            effect.  The pattern may be surrounded by //, "", or
            '', otherwise it will be put in single quotes.

       --hh   prints a summary of the options.

       --ii[extension]
            specifies that files processed by the <> construct
            are to be edited in-place.  It does this by renaming
            the input file, opening the output file by the
            original name, and selecting that output file as the
            default for print() statements.  The extension, if
            supplied, is used to modify the name of the old file
            to make a backup copy, following these rules:

            If no extension is supplied, no backup is made and
            the current file is overwritten.

            If the extension doesn't contain a * then it is
            appended to the end of the current filename as a
            suffix.

            If the extension does contain one or more *
            characters, then each * is replaced with the current
            filename.  In perl terms you could think of this as:

                ($backup = $extension) =~ s/\*/$file_name/g;

            This allows you to add a prefix to the backup file,
            instead of (or in addition to) a suffix:

                $ perl -pi'bak_*' -e 's/bar/baz/' fileA     # backup to 'bak_fileA'

            Or even to place backup copies of the original files
            into another directory (provided the directory
            already exists):

                $ perl -pi'old/*.bak' -e 's/bar/baz/' fileA # backup to 'old/fileA.bak'

            These sets of one-liners are equivalent:

                $ perl -pi -e 's/bar/baz/' fileA            # overwrite current file
                $ perl -pi'*' -e 's/bar/baz/' fileA         # overwrite current file

                $ perl -pi'.bak' -e 's/bar/baz/' fileA      # backup to 'fileA.bak'
                $ perl -pi'*.bak' -e 's/bar/baz/' fileA     # backup to 'fileA.bak'

            From the shell, saying

                $ perl -p -i.bak -e "s/foo/bar/; ... "

            is the same as using the script:

                #!/usr/bin/perl -pi.bak
                s/foo/bar/;

            which is equivalent to

                #!/usr/bin/perl
                $extension = '.bak';
                while (<>) {
                    if ($ARGV ne $oldargv) {
                        if ($extension !~ /\*/) {
                            $backup = $ARGV . $extension;
                        }
                        else {
                            ($backup = $extension) =~ s/\*/$ARGV/g;
                        }
                        rename($ARGV, $backup);
                        open(ARGVOUT, ">$ARGV");
                        select(ARGVOUT);
                        $oldargv = $ARGV;
                    }
                    s/foo/bar/;
                }
                continue {
                    print;  # this prints to original filename
                }
                select(STDOUT);

            except that the --ii form doesn't need to compare $ARGV
            to $oldargv to know when the filename has changed.
            It does, however, use ARGVOUT for the selected
            filehandle.  Note that STDOUT is restored as the
            default output filehandle after the loop.

            As shown above, Perl creates the backup file whether
            or not any output is actually changed.  So this is
            just a fancy way to copy files:

                $ perl -p -i'/some/file/path/*' -e 1 file1 file2 file3...
              or
                $ perl -p -i'.bak' -e 1 file1 file2 file3...

            You can use eof without parentheses to locate the end
            of each input file, in case you want to append to
            each file, or reset line numbering (see example in
            the eof entry in the perlfunc manpage).

            If, for a given file, Perl is unable to create the
            backup file as specified in the extension then it
            will skip that file and continue on with the next one
            (if it exists).

            For a discussion of issues surrounding file
            permissions and -i, see the section on Why does Perl
            let me delete read-only files?  Why does -i clobber
            protected files?  Isn't this a bug in Perl? in the
            perlfaq5 manpage.

            You cannot use --ii to create directories or to strip
            extensions from files.

            Perl does not expand ~, so don't do that.

            Finally, note that the --ii switch does not impede
            execution when no files are given on the command
            line.  In this case, no backup is made (the original
            file cannot, of course, be determined) and processing
            proceeds from STDIN to STDOUT as might be expected.

       --IIdirectory
            Directories specified by --II are prepended to the
            search path for modules (@INC), and also tells the C
            preprocessor where to search for include files.  The
            C preprocessor is invoked with --PP; by default it
            searches /usr/include and /usr/lib/perl.

       --ll[octnum]
            enables automatic line-ending processing.  It has two
            effects:  first, it automatically chomps "$/" (the
            input record separator) when used with --nn or --pp, and
            second, it assigns "$\" (the output record separator)
            to have the value of octnum so that any print
            statements will have that separator added back on.
            If octnum is omitted, sets "$\" to the current value
            of "$/".  For instance, to trim lines to 80 columns:

                perl -lpe 'substr($_, 80) = ""'

            Note that the assignment $\ = $/ is done when the
            switch is processed, so the input record separator
            can be different than the output record separator if
            the --ll switch is followed by a --00 switch:

                gnufind / -print0 | perl -ln0e 'print "found $_" if -p'

            This sets $\ to newline and then sets $/ to the null
            character.

       --mm[--]module

       --MM[--]module

       --MM[--]'module ...'

       --[[mmMM]][--]module=arg[,arg]...
            -mmodule executes use module (); before executing
            your script.

            -Mmodule executes use module ; before executing your
            script.  You can use quotes to add extra code after
            the module name, e.g., -M'module qw(foo bar)'.

            If the first character after the -M or -m is a dash
            (-) then the 'use' is replaced with 'no'.

            A little builtin syntactic sugar means you can also
            say -mmodule=foo,bar or -Mmodule=foo,bar as a
            shortcut for -M'module qw(foo bar)'.  This avoids the
            need to use quotes when importing symbols.  The
            actual code generated by -Mmodule=foo,bar is use
            module split(/,/,q{foo,bar}).  Note that the = form
            removes the distinction between -m and -M.

       --nn   causes Perl to assume the following loop around your
            script, which makes it iterate over filename
            arguments somewhat like sseedd --nn or aawwkk:

                while (<>) {
                    ...             # your script goes here
                }

            Note that the lines are not printed by default.  See
            --pp to have lines printed.  If a file named by an
            argument cannot be opened for some reason, Perl warns
            you about it, and moves on to the next file.

            Here is an efficient way to delete all files older
            than a week:

                find . -mtime +7 -print | perl -nle 'unlink;'

            This is faster than using the -exec switch of ffiinndd
            because you don't have to start a process on every
            filename found.

            BEGIN and END blocks may be used to capture control
            before or after the implicit loop, just as in aawwkk.

       --pp   causes Perl to assume the following loop around your
            script, which makes it iterate over filename
            arguments somewhat like sseedd:

                while (<>) {
                    ...             # your script goes here
                } continue {
                    print or die "-p destination: $!\n";
                }

            If a file named by an argument cannot be opened for
            some reason, Perl warns you about it, and moves on to
            the next file.  Note that the lines are printed
            automatically.  An error occurring during printing is
            treated as fatal.  To suppress printing use the --nn
            switch.  A --pp overrides a --nn switch.

            BEGIN and END blocks may be used to capture control
            before or after the implicit loop, just as in awk.

       --PP   causes your script to be run through the C
            preprocessor before compilation by Perl.  (Because
            both comments and cpp directives begin with the #
            character, you should avoid starting comments with
            any words recognized by the C preprocessor such as
            "if", "else", or "define".)

       --ss   enables some rudimentary switch parsing for switches
            on the command line after the script name but before
            any filename arguments (or before a ----).  Any switch
            found there is removed from @ARGV and sets the
            corresponding variable in the Perl script.  The
            following script prints "true" if and only if the
            script is invoked with a --xxyyzz switch.

                #!/usr/bin/perl -s
                if ($xyz) { print "true\n"; }

       --SS   makes Perl use the PATH environment variable to
            search for the script (unless the name of the script
            contains directory separators).  On some platforms,
            this also makes Perl append suffixes to the filename
            while searching for it.  For example, on Win32
            platforms, the ".bat" and ".cmd" suffixes are
            appended if a lookup for the original name fails, and
            if the name does not already end in one of those
            suffixes.  If your Perl was compiled with DEBUGGING
            turned on, using the -Dp switch to Perl shows how the
            search progresses.

            If the filename supplied contains directory
            separators (i.e. it is an absolute or relative
            pathname), and if the file is not found, platforms
            that append file extensions will do so and try to
            look for the file with those extensions added, one by
            one.

            On DOS-like platforms, if the script does not contain
            directory separators, it will first be searched for
            in the current directory before being searched for on
            the PATH.  On Unix platforms, the script will be
            searched for strictly on the PATH.

            Typically this is used to emulate #! startup on
            platforms that don't support #!.  This example works
            on many platforms that have a shell compatible with
            Bourne shell:

                #!/usr/bin/perl
                eval 'exec /usr/bin/perl -wS $0 ${1+"$@"}'
                        if $running_under_some_shell;

            The system ignores the first line and feeds the
            script to /bin/sh, which proceeds to try to execute
            the Perl script as a shell script.  The shell
            executes the second line as a normal shell command,
            and thus starts up the Perl interpreter.  On some
            systems $0 doesn't always contain the full pathname,
            so the --SS tells Perl to search for the script if
            necessary.  After Perl locates the script, it parses
            the lines and ignores them because the variable
            $running_under_some_shell is never true. If the
            script will be interpreted by csh, you will need to
            replace ${1+"$@"} with $*, even though that doesn't
            understand embedded spaces (and such) in the argument
            list.  To start up sh rather than csh, some systems
            may have to replace the #! line with a line
            containing just a colon, which will be politely
            ignored by Perl.  Other systems can't control that,
            and need a totally devious construct that will work
            under any of csh, sh, or Perl, such as the following:

                    eval '(exit $?0)' && eval 'exec /usr/bin/perl -wS $0 ${1+"$@"}'
                    & eval 'exec /usr/bin/perl -wS $0 $argv:q'
                            if $running_under_some_shell;

       --TT   forces "taint" checks to be turned on so you can test
            them.  Ordinarily these checks are done only when
            running setuid or setgid.  It's a good idea to turn
            them on explicitly for programs run on another's
            behalf, such as CGI programs.  See the perlsec
            manpage.  Note that (for security reasons) this
            option must be seen by Perl quite early; usually this
            means it must appear early on the command line or in
            the #! line (for systems which support that).

       --uu   causes Perl to dump core after compiling your script.
            You can then in theory take this core dump and turn
            it into an executable file by using the uunndduummpp
            program (not supplied).  This speeds startup at the
            expense of some disk space (which you can minimize by
            stripping the executable).  (Still, a "hello world"
            executable comes out to about 200K on my machine.)
            If you want to execute a portion of your script
            before dumping, use the dump() operator instead.
            Note: availability of uunndduummpp is platform specific and
            may not be available for a specific port of Perl.  It
            has been superseded by the new perl-to-C compiler,
            which is more portable, even though it's still only
            considered beta.

       --UU   allows Perl to do unsafe operations.  Currently the
            only "unsafe" operations are the unlinking of
            directories while running as superuser, and running
            setuid programs with fatal taint checks turned into
            warnings. Note that the --ww switch (or the $^W
            variable) must be used along with this option to
            actually ggeenneerraattee the taint-check warnings.

       --vv   prints the version and patchlevel of your Perl
            executable.

       --VV   prints summary of the major perl configuration values
            and the current value of @INC.

       --VV::name
            Prints to STDOUT the value of the named configuration
            variable.

       --ww   prints warnings about variable names that are
            mentioned only once, and scalar variables that are
            used before being set.  Also warns about redefined
            subroutines, and references to undefined filehandles
            or filehandles opened read-only that you are
            attempting to write on.  Also warns you if you use
            values as a number that doesn't look like numbers,
            using an array as though it were a scalar, if your
            subroutines recurse more than 100 deep, and
            innumerable other things.

            You can disable specific warnings using __WARN__
            hooks, as described in the perlvar manpage and the
            warn entry in the perlfunc manpage. See also the
            perldiag manpage and the perltrap manpage.

       --xx directory
            tells Perl that the script is embedded in a message.
            Leading garbage will be discarded until the first
            line that starts with #! and contains the string
            "perl".  Any meaningful switches on that line will be
            applied.  If a directory name is specified, Perl will
            switch to that directory before running the script.
            The --xx switch controls only the disposal of leading
            garbage.  The script must be terminated with __END__
            if there is trailing garbage to be ignored (the
            script can process any or all of the trailing garbage
            via the DATA filehandle if desired).

EENNVVIIRROONNMMEENNTT
       HOME        Used if chdir has no argument.

       LOGDIR      Used if chdir has no argument and HOME is not
                   set.

       PATH        Used in executing subprocesses, and in finding
                   the script if --SS is used.

       PERL5LIB    A colon-separated list of directories in which
                   to look for Perl library files before looking
                   in the standard library and the current
                   directory.  If PERL5LIB is not defined,
                   PERLLIB is used.  When running taint checks
                   (because the script was running setuid or
                   setgid, or the --TT switch was used), neither
                   variable is used.  The script should instead
                   say

                       use lib "/my/directory";

       PERL5OPT    Command-line options (switches).  Switches in
                   this variable are taken as if they were on
                   every Perl command line.  Only the --[[DDIIMMUUddmmww]]
                   switches are allowed.  When running taint
                   checks (because the script was running setuid
                   or setgid, or the --TT switch was used), this
                   variable is ignored.  If PERL5OPT begins with
                   --TT, tainting will be enabled, and any
                   subsequent options ignored.

       PERLLIB     A colon-separated list of directories in which
                   to look for Perl library files before looking
                   in the standard library and the current
                   directory.  If PERL5LIB is defined, PERLLIB is
                   not used.

       PERL5DB     The command used to load the debugger code.
                   The default is:

                           BEGIN { require 'perl5db.pl' }

       PERL5SHELL (specific to WIN32 port)
                   May be set to an alternative shell that perl
                   must use internally for executing "backtick"
                   commands or system().  Default is cmd.exe /x/c
                   on WindowsNT and command.com /c on Windows95.
                   The value is considered to be space delimited.
                   Precede any character that needs to be
                   protected (like a space or backslash) with a
                   backslash.

                   Note that Perl doesn't use COMSPEC for this
                   purpose because COMSPEC has a high degree of
                   variability among users, leading to
                   portability concerns.  Besides, perl can use a
                   shell that may not be fit for interactive use,
                   and setting COMSPEC to such a shell may
                   interfere with the proper functioning of other
                   programs (which usually look in COMSPEC to
                   find a shell fit for interactive use).

       PERL_DEBUG_MSTATS
                   Relevant only if perl is compiled with the
                   malloc included with the perl distribution
                   (that is, if perl -V:d_mymalloc is 'define').
                   If set, this causes memory statistics to be
                   dumped after execution.  If set to an integer
                   greater than one, also causes memory
                   statistics to be dumped after compilation.

       PERL_DESTRUCT_LEVEL
                   Relevant only if your perl executable was
                   built with --DDDDEEBBUUGGGGIINNGG, this controls the
                   behavior of global destruction of objects and
                   other references.

       Perl also has environment variables that control how Perl
       handles data specific to particular natural languages.
       See the perllocale manpage.

       Apart from these, Perl uses no other environment
       variables, except to make them available to the script
       being executed, and to child processes.  However, scripts
       running setuid would do well to execute the following
       lines before doing anything else, just to keep people
       honest:

           $ENV{PATH} = '/bin:/usr/bin';    # or whatever you need
           $ENV{SHELL} = '/bin/sh' if exists $ENV{SHELL};
           delete @ENV{qw(IFS CDPATH ENV BASH_ENV)};

27/Mar/1999            perl 5.005, patch 03                     1