def _setup_compile(self, sources, macros, include_dirs, extra, depends):
"""Process arguments and decide which source files to compile."""
if macros is None:
macros = self.macros
elif typecheck.is_list(macros):
macros = macros + (self.macros or [])
else:
raise TypeError("'macros' (if supplied) must be a list of tuples")
if include_dirs is None:
include_dirs = self._include_dirs
elif typecheck.is_sequence(include_dirs):
include_dirs = list(include_dirs) + (self._include_dirs or [])
else:
raise TypeError("'include_dirs' (if supplied) must be a list of strings")
if extra is None:
extra = []
# List of expected output files
objects = self.get_object_filenames(sources)
assert len(objects) == len(sources)
pp_options = self._gen_preprocess_options(macros, include_dirs)
build = {}
for i in range(len(sources)):
src = sources[i]
obj = objects[i]
ext = path_utils.splitext(src)[1]
path_utils.mkpath(path_utils.dirname(obj), 0777)
build[obj] = (src, ext)
return macros, objects, extra, pp_options, build
def _link(self, objects, output_dir=None, libraries=None, library_dirs=None,
debug=False, extra_preargs=None, extra_postargs=None,
target_lang=None):
"""Linking."""
objects, output_dir, libraries, library_dirs = \
self._setup_link(objects, output_dir, libraries, library_dirs)
lib_options = self._gen_lib_options(library_dirs, libraries)
# Finalize linker options
ld_options = self._gen_ld_options(debug, extra_preargs)
if extra_postargs:
ld_options.extend(extra_postargs)
ld_options += (objects + lib_options + ['-o', self.get_output_filename()])
path_utils.mkpath(path_utils.dirname(self.get_output_filename()))
try:
linker = self.get_executable()
# skip over environment variable settings if /usr/bin/env is used to set
# up the linker's environment. This is needed on OSX. Note: this
# assumes that the normal and C++ compiler have the same environment
# settings.
i = 0
if path_utils.basename(linker[0]) == "env":
i = 1
while "=" in linker[i]:
i = i + 1
# TODO: resolve this
#linker[i] = self.get_executable('compiler_cxx')[i]
spawn.spawn([linker] + ld_options, debug=self.get_verbosity_level(),
dry_run=self.is_dry_run_mode_enabled())
except Exception, e:
raise Exception, e
def identify_home_dir(cls):
for record in inspect.stack():
(frame, filename, lineno, code_ctx, _, index) = record
path = path_utils.dirname(path_utils.abspath(filename))
home_dir = cls.find_home_dir(path)
if home_dir:
return home_dir
return cls.find_home_dir(path_utils.realpath(os.curdir)) or os.getcwd()
def read_params(self, params):
if not isinstance(params, self.Parameters):
params = self.Parameters(params)
if not "basedir" in params.context:
caller_frame = inspect.getouterframes(inspect.currentframe(), 2)
params.context["basedir"] = path_utils.dirname(inspect.getsourcefile(
caller_frame[1][0])) or "."
self.__processing_params = params
if self.__param_handlers:
for param, handler_name in self.__param_handlers.items():
if not param in params:
continue
value = params[param]
handler = getattr(self, handler_name)
handler(value)
self.__processing_params = None
def add_file(self, path):
"""Adds file to the list of files. The path will be normalized by using
:func:`os.path.abspath`.
:param path: A string that represents file path.
:returns: A normalized string path.
:raises: TypeError
"""
if typecheck.is_string(path):
if not path_utils.exists(path):
caller_frame = inspect.getouterframes(inspect.currentframe(), 2)
filename = inspect.getsourcefile(caller_frame[2][0])
possible_dir = path_utils.dirname(filename)
alternative_path = path_utils.join(possible_dir, path)
if path_utils.exists(alternative_path):
return self.add_file(alternative_path)
path = path_utils.abspath(path)
if not path_utils.exists(path):
raise Exception("Path doesn't exist: %s" % path)
if not path in self._files:
self._files.append(path)
return path
elif typecheck.is_callable(path):
result = path()
if not result:
return
elif typecheck.is_list(result):
self.add_files(result)
else:
self.add_file(result)
elif not path:
return None
else:
raise TypeError("Unknown path type '%s' of '%s'" % (type(path), path))
