Source.Python/addons/source-python/Python3/distutils/spawn.py at main · CookStar/Source.Python · GitHub

Repository navigation

History

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

"""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':

from distutils import sysconfig

_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:

_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.

"""

if path is None:

path = os.environ['PATH']

paths = path.split(os.pathsep)

base, ext = os.path.splitext(executable)

if (sys.platform == 'win32') and (ext != '.exe'):

executable = executable + '.exe'

if not os.path.isfile(executable):

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

else:

return executable

Source.Python/addons/source-python/Python3/distutils/spawn.py at main · CookStar/Source.Python · GitHub

Repository navigation

Expand file tree

Breadcrumbs

spawn.py

Latest commit

History

Breadcrumbs

spawn.py

File metadata and controls