def doResource(self, message):
task_folder = message['task_folder']
task_data = message['task_data']
tools_env = message['task_tools_env']
cl_argv = task_data['cl_argv']
rc_argv = task_data['rc_argv']
inclusion_pattern = GetMsvcInclusionPattern(self.vars, tools_env)
env = None
if tools_env is not None:
if tools_env.env_cmds is not None:
env = util.BuildEnv(tools_env.env_cmds)
if 'cl' in tools_env.tools:
cl_argv[0] = tools_env.tools['cl']
if 'rc' in tools_env.tools:
rc_argv[0] = tools_env.tools['rc']
with util.FolderChanger(task_folder):
# Includes go to stderr when we preprocess to stdout.
p, out, err = util.Execute(cl_argv, env=env)
out, deps = util.ParseMSVCDeps(err, inclusion_pattern)
paths = self.rewriteDeps(deps)
if p.returncode == 0:
p, out, err = util.Execute(rc_argv, env=env)
reply = {
'ok': p.returncode == 0,
'cmdline': self.task_argv_debug(message),
'stdout': out,
'stderr': err,
'deps': paths,
}
return reply
def doCommand(self, message):
task_folder = message['task_folder']
tools_env = message['task_tools_env']
argv = message['task_data']
env = None
if tools_env is not None:
if tools_env.env_cmds is not None:
env = util.BuildEnv(tools_env.env_cmds)
if argv[0] in tools_env.tools:
argv[0] = tools_env.tools[argv[0]]
with util.FolderChanger(task_folder):
try:
p, stdout, stderr = util.Execute(argv, env=env)
status = p.returncode == 0
except Exception as exn:
status = False
stdout = ''
stderr = '{0}'.format(exn)
reply = {
'ok': status,
'cmdline': self.task_argv_debug(message),
'stdout': stdout,
'stderr': stderr,
}
return reply
def doCompile(self, message):
task_folder = message['task_folder']
task_data = message['task_data']
tools_env = message['task_tools_env']
cc_type = task_data['type']
argv = task_data['argv']
if 'deps' in task_data:
dep_type, dep_info = task_data['deps']
else:
dep_type = cc_type
dep_info = None
env = None
if tools_env is not None:
if tools_env.env_cmds is not None:
env = util.BuildEnv(tools_env.env_cmds)
if 'cl' in tools_env.tools:
argv[0] = tools_env.tools['cl']
with util.FolderChanger(task_folder):
p, out, err = util.Execute(argv, env=env)
out, err, paths = self.parseDependencies(tools_env, out, err,
dep_type, dep_info)
reply = {
'ok': p.returncode == 0,
'cmdline': self.task_argv_debug(message),
'stdout': out,
'stderr': err,
'deps': paths,
}
return reply
def doCompile(self, message):
task_folder = message['task_folder']
task_data = message['task_data']
cc_type = task_data['type']
argv = task_data['argv']
with util.FolderChanger(task_folder):
p, out, err = util.Execute(argv)
if cc_type == 'gcc':
err, deps = util.ParseGCCDeps(err)
elif cc_type == 'msvc':
out, deps = util.ParseMSVCDeps(self.vars, out)
elif cc_type == 'sun':
err, deps = util.ParseSunDeps(err)
elif cc_type == 'fxc':
out, deps = util.ParseFXCDeps(out)
else:
raise Exception('unknown compiler type')
paths = self.rewriteDeps(deps)
reply = {
'ok': p.returncode == 0,
'cmdline': self.task_argv_debug(message),
'stdout': out,
'stderr': err,
'deps': paths,
}
return reply
def detectCompilers(self):
if not self.compiler:
with util.FolderChanger(self.cacheFolder):
self.base_compiler = detect.DetectCxx(os.environ, self.options)
self.compiler = self.base_compiler.clone()
return self.compiler
def doResource(self, message):
task_folder = message['task_folder']
task_data = message['task_data']
cl_argv = task_data['cl_argv']
rc_argv = task_data['rc_argv']
with util.FolderChanger(task_folder):
# Includes go to stderr when we preprocess to stdout.
p, out, err = util.Execute(cl_argv)
out, deps = util.ParseMSVCDeps(self.vars, err)
paths = self.rewriteDeps(deps)
if p.returncode == 0:
p, out, err = util.Execute(rc_argv)
reply = {
'ok':
p.returncode == 0,
'cmdline': (' '.join([arg for arg in cl_argv]) + ' && ' +
' '.join([arg for arg in rc_argv])),
'stdout':
out,
'stderr':
err,
'deps':
paths,
}
return reply
def doCopy(self, message):
task_folder = message['task_folder']
source_path, output_path = message['task_data']
with util.FolderChanger(task_folder):
if os.path.exists(source_path):
shutil.copy(source_path, output_path)
ok = True
stderr = ''
else:
ok = False
stderr = 'File not found: {0}'.format(source_path)
reply = {
'ok':
ok,
'cmdline':
'cp "{0}" "{1}"'.format(source_path,
os.path.join(task_folder, output_path)),
'stdout':
'',
'stderr':
stderr,
}
return reply
def detectCompilers(self, options):
if options is None:
options = {}
if not self.compiler:
with util.FolderChanger(self.cacheFolder):
self.base_compiler = detect.AutoDetectCxx(self.cm.target, self.cm.options, options)
if self.base_compiler is None:
raise Exception('Could not detect a suitable C/C++ compiler')
self.compiler = self.base_compiler.clone()
return self.compiler
def doSymlink(self, message):
task_folder = message['task_folder']
source_path, output_path = message['task_data']
with util.FolderChanger(task_folder):
rcode, stdout, stderr = util.symlink(source_path, output_path)
reply = {
'ok': rcode == 0,
'cmdline': self.task_argv_debug(message),
'stdout': stdout,
'stderr': stderr,
}
return reply
def doBinaryWrite(self, message):
task_folder = message['task_folder']
task_data = message['task_data']
_, filename = os.path.split(task_data['path'])
reply = {
'ok': True,
'cmdline': self.task_argv_debug(message),
'stdout': '',
'stderr': '',
}
with util.FolderChanger(task_folder):
try:
with open(filename, 'wb') as fp:
fp.write(task_data['contents'])
except Exception as e:
reply['ok'] = False
reply['stderr'] = str(e)
return reply
def doCommand(self, message):
task_folder = message['task_folder']
argv = message['task_data']
with util.FolderChanger(task_folder):
try:
p, stdout, stderr = util.Execute(argv)
status = p.returncode == 0
except Exception as exn:
status = False
stdout = ''
stderr = '{0}'.format(exn)
reply = {
'ok': status,
'cmdline': self.task_argv_debug(message),
'stdout': stdout,
'stderr': stderr,
}
return reply
def doCompile(self, message):
task_folder = message['task_folder']
task_data = message['task_data']
tools_env = message['task_tools_env']
cc_type = task_data['type']
argv = task_data['argv']
env = None
if tools_env is not None:
if tools_env.env_cmds is not None:
env = util.BuildEnv(tools_env.env_cmds)
if 'cl' in tools_env.tools:
argv[0] = tools_env.tools['cl']
with util.FolderChanger(task_folder):
p, out, err = util.Execute(argv, env=env)
if cc_type == 'gcc':
err, deps = util.ParseGCCDeps(err)
elif cc_type == 'msvc':
inclusion_pattern = GetMsvcInclusionPattern(
self.vars, tools_env)
out, deps = util.ParseMSVCDeps(out, inclusion_pattern)
elif cc_type == 'sun':
err, deps = util.ParseSunDeps(err)
elif cc_type == 'fxc':
out, deps = util.ParseFXCDeps(out)
else:
raise Exception('unknown compiler type')
paths = self.rewriteDeps(deps)
reply = {
'ok': p.returncode == 0,
'cmdline': self.task_argv_debug(message),
'stdout': out,
'stderr': err,
'deps': paths,
}
return reply
def Build(buildPath, options, argv):
with util.FolderChanger(buildPath):
with Context(buildPath, options, argv) as cx:
return cx.Build()
def detectCompilers(self, **kwargs):
with util.FolderChanger(self.cacheFolder):
return detect.AutoDetectCxx(self.cm.host, self.cm.options,
**kwargs)
def Configure(self):
args = self.options.parse_args()
# In order to support pickling, we need to rewrite |options| to not use
# optparse.Values, since its implementation changes across Python versions.
options = util.Expando()
for attr in vars(args):
setattr(options, attr, getattr(args, attr))
if options.list_gen:
print('Available build system generators:')
print(' {0:24} - AMBuild 2 (default)'.format('ambuild2'))
print(' {0:24} - Visual Studio'.format('vs'))
print('')
print('Extra options:')
print(
' --vs-version=N Visual Studio: IDE version (2015 or 14 default)'
)
print(
' --vs-split Visual Studio: generate one project file per configuration'
)
sys.exit(0)
if options.no_color:
util.DisableConsoleColors()
source_abspath = os.path.normpath(os.path.abspath(self.sourcePath))
build_abspath = os.path.normpath(os.path.abspath(self.buildPath))
if source_abspath == build_abspath:
if util.IsString(self.default_build_folder):
objfolder = self.default_build_folder
else:
objfolder = self.default_build_folder(self)
new_buildpath = os.path.join(self.buildPath, objfolder)
util.con_err(
util.ConsoleHeader,
'Warning: build is being configured in the source tree.',
util.ConsoleNormal)
if os.path.exists(os.path.join(new_buildpath)):
has_amb2 = os.path.exists(
os.path.join(new_buildpath, '.ambuild2'))
if not has_amb2 and len(os.listdir(
new_buildpath)) and options.generator == 'ambuild2':
util.con_err(util.ConsoleRed, 'Tried to use ',
util.ConsoleBlue, objfolder, util.ConsoleRed,
' as a build folder, but it is not empty!',
util.ConsoleNormal)
raise Exception('build folder has unrecognized files')
util.con_err(util.ConsoleHeader, 'Re-using build folder: ',
util.ConsoleBlue, '{0}'.format(objfolder),
util.ConsoleNormal)
else:
util.con_err(util.ConsoleHeader, 'Creating "',
util.ConsoleBlue, '{0}'.format(objfolder),
util.ConsoleHeader, '" as a build folder.',
util.ConsoleNormal)
os.mkdir(new_buildpath)
self.buildPath = new_buildpath
from ambuild2.frontend.v2_2.context_manager import ContextManager
cm = ContextManager(self.sourcePath, self.buildPath, os.getcwd(),
options, args)
with util.FolderChanger(self.buildPath):
try:
if not cm.generate(options.generator):
sys.stderr.write('Configure failed.\n')
sys.exit(1)
except Exception as e:
traceback.print_exc()
util.con_err(util.ConsoleRed, 'Configure failed: {}'.format(e),
util.ConsoleNormal)
def Configure(self):
if self.target_arch is None:
self.options.add_option("--target-arch",
type="string",
dest="target_arch",
default=None,
help="Override the target architecture.")
v_options, args = self.options.parse_args()
# In order to support pickling, we need to rewrite |options| to not use
# optparse.Values, since its implementation changes across Python versions.
options = util.Expando()
ignore_attrs = set(dir(Values))
for attr in dir(v_options):
if attr in ignore_attrs:
continue
setattr(options, attr, getattr(v_options, attr))
# Propagate the overridden architecture.
if self.target_arch is not None:
assert getattr(options, 'target_arch', None) is None
options.target_arch = self.target_arch
if options.list_gen:
print('Available build system generators:')
print(' {0:24} - AMBuild 2 (default)'.format('ambuild2'))
print(' {0:24} - Visual Studio'.format('vs'))
print('')
print('Extra options:')
print(
' --vs-version=N Visual Studio: IDE version (2010 or 10 default)'
)
print(
' --vs-split Visual Studio: generate one project file per configuration'
)
sys.exit(0)
if options.no_color:
util.DisableConsoleColors()
source_abspath = os.path.normpath(os.path.abspath(self.sourcePath))
build_abspath = os.path.normpath(os.path.abspath(self.buildPath))
if source_abspath == build_abspath:
if util.IsString(self.default_build_folder):
objfolder = self.default_build_folder
else:
objfolder = self.default_build_folder(self)
new_buildpath = os.path.join(self.buildPath, objfolder)
util.con_err(
util.ConsoleHeader,
'Warning: build is being configured in the source tree.',
util.ConsoleNormal)
if os.path.exists(os.path.join(new_buildpath)):
has_amb2 = os.path.exists(
os.path.join(new_buildpath, '.ambuild2'))
if not has_amb2 and len(os.listdir(new_buildpath)):
util.con_err(util.ConsoleRed, 'Tried to use ',
util.ConsoleBlue, objfolder, util.ConsoleRed,
' as a build folder, but it is not empty!',
util.ConsoleNormal)
raise Exception('build folder has unrecognized files')
util.con_err(util.ConsoleHeader, 'Re-using build folder: ',
util.ConsoleBlue, '{0}'.format(objfolder),
util.ConsoleNormal)
else:
util.con_err(util.ConsoleHeader, 'Creating "',
util.ConsoleBlue, '{0}'.format(objfolder),
util.ConsoleHeader, '" as a build folder.',
util.ConsoleNormal)
os.mkdir(new_buildpath)
self.buildPath = new_buildpath
if options.generator == 'ambuild2':
from ambuild2.frontend.v2_1.amb2 import gen
builder = gen.Generator(self.sourcePath, self.buildPath,
os.getcwd(), options, args)
elif options.generator == 'vs':
from ambuild2.frontend.v2_1.vs import gen
builder = gen.Generator(self.sourcePath, self.buildPath,
os.getcwd(), options, args)
else:
sys.stderr.write('Unrecognized build generator: ' +
options.generator + '\n')
sys.exit(1)
with util.FolderChanger(self.buildPath):
if not builder.generate():
sys.stderr.write('Configure failed.\n')
sys.exit(1)
