def buildpath(self, path, recursive=True):
"""Path will be created if it doesn't exist."""
if typecheck.is_list(path):
path = path_utils.join(*path)
elif not typecheck.is_string(path):
raise TypeError("path can be only a string or list")
path = path_utils.join(self.get_build_dir(), path)
if path_utils.exists(path):
return path
return path_utils.touch(path, recursive=recursive)
def __init__(self, root_dir, parser, argv):
Command.__init__(self, root_dir, parser, argv)
if not self.args:
self.args = [DEFAULT_TARGET]
self.rules = []
addresses = []
# TODO: the following injection has to be fixed
if os.path.exists(bb.config.user_settings.get("bbos", "homedir")):
bbos_src = path_utils.join(bb.config.user_settings.get("bbos", "homedir"),
"src", "main")
bbos_buildfile = buildfile.BuildFile(bbos_src, ".")
buildfile.Context(bbos_buildfile).parse()
#
for target in self.args[0:]:
try:
address = buildfile.get_address(root_dir, target)
except:
self.error("Problem parsing target %s: %s" %
(target, traceback.format_exc()))
if not address:
print("Cannot find BUILD file for", target, file=sys.stderr)
continue
addresses.append(address)
for address in addresses:
try:
print(buildfile.get_rule(address))
rule = buildfile.get_rule(address)
except:
self.error("Problem parsing BUILD rule %s: %s" %
(address, traceback.format_exc()))
if not rule:
self.error("Rule %s does not exist" % address)
self.rules.append(rule)
def link(self, objects, output_filename, *list_args, **dict_args):
# Adopt output file name to output directory
if self.get_output_dir() is not None:
self.set_output_filename(path_utils.join(self.get_output_dir(),
output_filename))
binary_filename = path_utils.relpath(output_filename, self.output_dir)
logger.info("Linking executable: %s" % binary_filename)
self._link(objects, *list_args, **dict_args)
def init_home_dir(cls, home_dir):
"""Initializes passed home directory if such wasn't already initialized.
:returns: Path to home directory.
"""
if not path_utils.exists(home_dir):
raise IOError("'%s' doesn't exist" % home_dir)
settings_dir = path_utils.join(home_dir, SETTINGS_DIR)
path_utils.mkpath(settings_dir)
return home_dir
def get_object_filenames(self, src_filenames):
obj_filenames = []
for src_filename in src_filenames:
base, ext = path_utils.splitext(src_filename)
base = path_utils.splitdrive(base)[1]
base = base[path_utils.isabs(base):]
if ext not in self.get_source_extensions():
raise Exception("unknown file type '%s' of '%s'" % (ext, src_filename))
obj_filenames.append(
path_utils.join(self.get_output_dir(),
base + self.get_object_extension()))
return obj_filenames
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))
def __init__(self, target=None, name=None, execute=None, deps=[]):
"""Each rule has a name that identifies it within existed context. In case
name wasn't provided, it becomes a target and vice-versa.
"""
if not target and not name:
raise Exception("target and/or name have to be provided")
if name and not typecheck.is_string(name):
raise TypeError("name has to be a string: %s,%s" % (name, target))
self._target = target
if not name:
if typecheck.is_string(target):
name = target
elif typecheck.is_class(target) or typecheck.is_function(target):
name = target.__name__
else:
name = "i%d" % id(target)
self._name = name
self._description = None
self._address = None
self._address = self.locate()
self._dependencies = [] # TODO: deprecated
self._properties = dict()
self._build_dir = None
# TODO: test on windows and other systems!
self.set_build_dir(path_utils.join(
bb.config.user_settings.get("b3", "builddir"), os.getcwd()[1:]))
if hasattr(self.__class__, "properties"):
self.add_properties(self.__class__.properties)
register_rule(self)
if execute:
if not callable(execute):
raise TypeError()
self.execute = types.MethodType(execute, self)
# Defer dependency resolution after parsing the current BUILD file to
# allow for forward references
self._post_init(self._finalize_deps, deps)
