Perl5 リファレンス

       exec LIST

       exec PROGRAM LIST
               The `exec' function executes a system command and
               never returns-- use `system' instead of `exec' if
               you want it to return.  It fails and returns false
               only if the command does not exist and it is
               executed directly instead of via your system's
               command shell (see below).

               Since it's a common mistake to use `exec' instead
               of `system', Perl warns you if there is a
               following statement which isn't `die', `warn', or
               `exit' (if `-w' is set  -  but you always do
               that).   If you really want to follow an `exec'
               with some other statement, you can use one of
               these styles to avoid the warning:

                   exec ('foo')   or print STDERR "couldn't exec foo: $!";
                   { exec ('foo') }; print STDERR "couldn't exec foo: $!";

               If there is more than one argument in LIST, or if
               LIST is an array with more than one value, calls
               execvp(3) with the arguments in LIST.  If there is
               only one scalar argument or an array with one
               element in it, the argument is checked for shell
               metacharacters, and if there are any, the entire
               argument is passed to the system's command shell
               for parsing (this is `/bin/sh -c' on Unix
               platforms, but varies on other platforms).  If
               there are no shell metacharacters in the argument,
               it is split into words and passed directly to
               `execvp', which is more efficient.  Examples:

                   exec '/bin/echo', 'Your arguments are: ', @ARGV;
                   exec "sort $outfile | uniq";

               If you don't really want to execute the first
               argument, but want to lie to the program you are
               executing about its own name, you can specify the
               program you actually want to run as an "indirect
               object" (without a comma) in front of the LIST.
               (This always forces interpretation of the LIST as
               a multivalued list, even if there is only a single
               scalar in the list.)  Example:

                   $shell = '/bin/csh';
                   exec $shell '-sh';          # pretend it's a login shell

               or, more directly,

                   exec {'/bin/csh'} '-sh';    # pretend it's a login shell

               When the arguments get executed via the system
               shell, results will be subject to its quirks and
               capabilities.  See the section on "`STRING`" in
               the perlop manpage for details.

               Using an indirect object with `exec' or `system'
               is also more secure.  This usage (which also works
               fine with system()) forces interpretation of the
               arguments as a multivalued list, even if the list
               had just one argument.  That way you're safe from
               the shell expanding wildcards or splitting up
               words with whitespace in them.

                   @args = ( "echo surprise" );

                   exec @args;               # subject to shell escapes
                                               # if @args == 1
                   exec { $args[0] } @args;  # safe even with one-arg list

               The first version, the one without the indirect
               object, ran the echo program, passing it
               `"surprise"' an argument.  The second version
               didn't--it tried to run a program literally called
               "echo surprise", didn't find it, and set `$?' to a
               non-zero value indicating failure.

               Beginning with v5.6.0, Perl will attempt to flush
               all files opened for output before the exec, but
               this may not be supported on some platforms (see
               the perlport manpage).  To be safe, you may need
               to set `$|' ($AUTOFLUSH in English) or call the
               `autoflush()' method of `IO::Handle' on any open
               handles in order to avoid lost output.

               Note that `exec' will not call your `END' blocks,
               nor will it call any `DESTROY' methods in your