"""distutils.spawn

Provides the 'spawn()' function, a front-end to various platform-
specific functions for launching another program in a sub-process.
Also provides the 'find_executable()' to search the path for a given
executable name.
"""

import sys
import os

from distutils.errors import DistutilsPlatformError, DistutilsExecError
from distutils.debug import DEBUG
from distutils import log

def spawn(cmd, search_path=1, verbose=0, dry_run=0):
 """Run another program, specified as a command list 'cmd', in a new process.

 'cmd' is just the argument list for the new process, ie.
 cmd[0] is the program to run and cmd[1:] are the rest of its arguments.
 There is no way to run a program with a name different from that of its
 executable.

 If 'search_path' is true (the default), the system's executable
 search path will be used to find the program; otherwise, cmd[0]
 must be the exact path to the executable. If 'dry_run' is true,
 the command will not actually be run.

 Raise DistutilsExecError if running the program fails in any way; just
 return on success.
 """
 # cmd is documented as a list, but just in case some code passes a tuple
 # in, protect our %-formatting code against horrible death
 cmd = list(cmd)
 if os.name == 'posix':
 _spawn_posix(cmd, search_path, dry_run=dry_run)
 elif os.name == 'nt':
 _spawn_nt(cmd, search_path, dry_run=dry_run)
 else:
 raise DistutilsPlatformError(
 "don't know how to spawn programs on platform '%s'" % os.name)

def _nt_quote_args(args):
 """Quote command-line arguments for DOS/Windows conventions.

 Just wraps every argument which contains blanks in double quotes, and
 returns a new argument list.
 """
 # XXX this doesn't seem very robust to me -- but if the Windows guys
 # say it'll work, I guess I'll have to accept it. (What if an arg
 # contains quotes? What other magic characters, other than spaces,
 # have to be escaped? Is there an escaping mechanism other than
 # quoting?)
 for i, arg in enumerate(args):
 if ' ' in arg:
 args[i] = '"%s"' % arg
 return args

def _spawn_nt(cmd, search_path=1, verbose=0, dry_run=0):
 executable = cmd[0]
 cmd = _nt_quote_args(cmd)
 if search_path:
 # either we find one or it stays the same
 executable = find_executable(executable) or executable
 log.info(' '.join([executable] + cmd[1:]))
 if not dry_run:
 # spawn for NT requires a full path to the .exe
 try:
 rc = os.spawnv(os.P_WAIT, executable, cmd)
 except OSError as exc:
 # this seems to happen when the command isn't found
 if not DEBUG:
 cmd = executable
 raise DistutilsExecError(
 "command %r failed: %s" % (cmd, exc.args[-1]))
 if rc != 0:
 # and this reflects the command running but failing
 if not DEBUG:
 cmd = executable
 raise DistutilsExecError(
 "command %r failed with exit status %d" % (cmd, rc))

if sys.platform == 'darwin':
 _cfg_target = None
 _cfg_target_split = None

def _spawn_posix(cmd, search_path=1, verbose=0, dry_run=0):
 log.info(' '.join(cmd))
 if dry_run:
 return
 executable = cmd[0]
 exec_fn = search_path and os.execvp or os.execv
 env = None
 if sys.platform == 'darwin':
 global _cfg_target, _cfg_target_split
 if _cfg_target is None:
 from distutils import sysconfig
 _cfg_target = sysconfig.get_config_var(
 'MACOSX_DEPLOYMENT_TARGET') or ''
 if _cfg_target:
 _cfg_target_split = [int(x) for x in _cfg_target.split('.')]
 if _cfg_target:
 # ensure that the deployment target of build process is not less
 # than that used when the interpreter was built. This ensures
 # extension modules are built with correct compatibility values
 cur_target = os.environ.get('MACOSX_DEPLOYMENT_TARGET', _cfg_target)
 if _cfg_target_split > [int(x) for x in cur_target.split('.')]:
 my_msg = ('$MACOSX_DEPLOYMENT_TARGET mismatch: '
 'now "%s" but "%s" during configure'
 % (cur_target, _cfg_target))
 raise DistutilsPlatformError(my_msg)
 env = dict(os.environ,
 MACOSX_DEPLOYMENT_TARGET=cur_target)
 exec_fn = search_path and os.execvpe or os.execve
 pid = os.fork()
 if pid == 0: # in the child
 try:
 if env is None:
 exec_fn(executable, cmd)
 else:
 exec_fn(executable, cmd, env)
 except OSError as e:
 if not DEBUG:
 cmd = executable
 sys.stderr.write("unable to execute %r: %s\n"
 % (cmd, e.strerror))
 os._exit(1)

 if not DEBUG:
 cmd = executable
 sys.stderr.write("unable to execute %r for unknown reasons" % cmd)
 os._exit(1)
 else: # in the parent
 # Loop until the child either exits or is terminated by a signal
 # (ie. keep waiting if it's merely stopped)
 while True:
 try:
 pid, status = os.waitpid(pid, 0)
 except OSError as exc:
 if not DEBUG:
 cmd = executable
 raise DistutilsExecError(
 "command %r failed: %s" % (cmd, exc.args[-1]))
 if os.WIFSIGNALED(status):
 if not DEBUG:
 cmd = executable
 raise DistutilsExecError(
 "command %r terminated by signal %d"
 % (cmd, os.WTERMSIG(status)))
 elif os.WIFEXITED(status):
 exit_status = os.WEXITSTATUS(status)
 if exit_status == 0:
 return # hey, it succeeded!
 else:
 if not DEBUG:
 cmd = executable
 raise DistutilsExecError(
 "command %r failed with exit status %d"
 % (cmd, exit_status))
 elif os.WIFSTOPPED(status):
 continue
 else:
 if not DEBUG:
 cmd = executable
 raise DistutilsExecError(
 "unknown error executing %r: termination status %d"
 % (cmd, status))

def find_executable(executable, path=None):
 """Tries to find 'executable' in the directories listed in 'path'.

 A string listing directories separated by 'os.pathsep'; defaults to
 os.environ['PATH']. Returns the complete filename or None if not found.
 """
 _, ext = os.path.splitext(executable)
 if (sys.platform == 'win32') and (ext != '.exe'):
 executable = executable + '.exe'

 if os.path.isfile(executable):
 return executable

 if path is None:
 path = os.environ.get('PATH', None)
 if path is None:
 try:
 path = os.confstr("CS_PATH")
 except (AttributeError, ValueError):
 # os.confstr() or CS_PATH is not available
 path = os.defpath
 # bpo-35755: Don't use os.defpath if the PATH environment variable is
 # set to an empty string

 # PATH='' doesn't match, whereas PATH=':' looks in the current directory
 if not path:
 return None

 paths = path.split(os.pathsep)
 for p in paths:
 f = os.path.join(p, executable)
 if os.path.isfile(f):
 # the file exists, we have a shot at spawn working
 return f
 return None