diff options
Diffstat (limited to 'jam-files/boost-build/build/project.py')
| -rw-r--r-- | jam-files/boost-build/build/project.py | 1120 |
1 files changed, 0 insertions, 1120 deletions
diff --git a/jam-files/boost-build/build/project.py b/jam-files/boost-build/build/project.py deleted file mode 100644 index 1e1e16fa..00000000 --- a/jam-files/boost-build/build/project.py +++ /dev/null @@ -1,1120 +0,0 @@ -# Status: ported. -# Base revision: 64488 - -# Copyright 2002, 2003 Dave Abrahams -# Copyright 2002, 2005, 2006 Rene Rivera -# Copyright 2002, 2003, 2004, 2005, 2006 Vladimir Prus -# Distributed under the Boost Software License, Version 1.0. -# (See accompanying file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt) - -# Implements project representation and loading. -# Each project is represented by -# - a module where all the Jamfile content live. -# - an instance of 'project-attributes' class. -# (given module name, can be obtained by 'attributes' rule) -# - an instance of 'project-target' class (from targets.jam) -# (given a module name, can be obtained by 'target' rule) -# -# Typically, projects are created as result of loading Jamfile, which is -# do by rules 'load' and 'initialize', below. First, module for Jamfile -# is loaded and new project-attributes instance is created. Some rules -# necessary for project are added to the module (see 'project-rules' module) -# at the bottom of this file. -# Default project attributes are set (inheriting attributes of parent project, if -# it exists). After that, Jamfile is read. It can declare its own attributes, -# via 'project' rule, which will be combined with already set attributes. -# -# -# The 'project' rule can also declare project id, which will be associated with -# the project module. -# -# There can also be 'standalone' projects. They are created by calling 'initialize' -# on arbitrary module, and not specifying location. After the call, the module can -# call 'project' rule, declare main target and behave as regular projects. However, -# since it's not associated with any location, it's better declare only prebuilt -# targets. -# -# The list of all loaded Jamfile is stored in variable .project-locations. It's possible -# to obtain module name for a location using 'module-name' rule. The standalone projects -# are not recorded, the only way to use them is by project id. - -import b2.util.path -from b2.build import property_set, property -from b2.build.errors import ExceptionWithUserContext -import b2.build.targets - -import bjam - -import re -import sys -import os -import string -import imp -import traceback -import b2.util.option as option - -from b2.util import record_jam_to_value_mapping, qualify_jam_action - -class ProjectRegistry: - - def __init__(self, manager, global_build_dir): - self.manager = manager - self.global_build_dir = global_build_dir - self.project_rules_ = ProjectRules(self) - - # The target corresponding to the project being loaded now - self.current_project = None - - # The set of names of loaded project modules - self.jamfile_modules = {} - - # Mapping from location to module name - self.location2module = {} - - # Mapping from project id to project module - self.id2module = {} - - # Map from Jamfile directory to parent Jamfile/Jamroot - # location. - self.dir2parent_jamfile = {} - - # Map from directory to the name of Jamfile in - # that directory (or None). - self.dir2jamfile = {} - - # Map from project module to attributes object. - self.module2attributes = {} - - # Map from project module to target for the project - self.module2target = {} - - # Map from names to Python modules, for modules loaded - # via 'using' and 'import' rules in Jamfiles. - self.loaded_tool_modules_ = {} - - self.loaded_tool_module_path_ = {} - - # Map from project target to the list of - # (id,location) pairs corresponding to all 'use-project' - # invocations. - # TODO: should not have a global map, keep this - # in ProjectTarget. - self.used_projects = {} - - self.saved_current_project = [] - - self.JAMROOT = self.manager.getenv("JAMROOT"); - - # Note the use of character groups, as opposed to listing - # 'Jamroot' and 'jamroot'. With the latter, we'd get duplicate - # matches on windows and would have to eliminate duplicates. - if not self.JAMROOT: - self.JAMROOT = ["project-root.jam", "[Jj]amroot", "[Jj]amroot.jam"] - - # Default patterns to search for the Jamfiles to use for build - # declarations. - self.JAMFILE = self.manager.getenv("JAMFILE") - - if not self.JAMFILE: - self.JAMFILE = ["[Bb]uild.jam", "[Jj]amfile.v2", "[Jj]amfile", - "[Jj]amfile.jam"] - - - def load (self, jamfile_location): - """Loads jamfile at the given location. After loading, project global - file and jamfile needed by the loaded one will be loaded recursively. - If the jamfile at that location is loaded already, does nothing. - Returns the project module for the Jamfile.""" - - absolute = os.path.join(os.getcwd(), jamfile_location) - absolute = os.path.normpath(absolute) - jamfile_location = b2.util.path.relpath(os.getcwd(), absolute) - - if "--debug-loading" in self.manager.argv(): - print "Loading Jamfile at '%s'" % jamfile_location - - - mname = self.module_name(jamfile_location) - # If Jamfile is already loaded, don't try again. - if not mname in self.jamfile_modules: - - self.load_jamfile(jamfile_location, mname) - - # We want to make sure that child project are loaded only - # after parent projects. In particular, because parent projects - # define attributes whch are inherited by children, and we don't - # want children to be loaded before parents has defined everything. - # - # While "build-project" and "use-project" can potentially refer - # to child projects from parent projects, we don't immediately - # load child projects when seing those attributes. Instead, - # we record the minimal information that will be used only later. - - self.load_used_projects(mname) - - return mname - - def load_used_projects(self, module_name): - # local used = [ modules.peek $(module-name) : .used-projects ] ; - used = self.used_projects[module_name] - - location = self.attribute(module_name, "location") - for u in used: - id = u[0] - where = u[1] - - self.use(id, os.path.join(location, where)) - - def load_parent(self, location): - """Loads parent of Jamfile at 'location'. - Issues an error if nothing is found.""" - - found = b2.util.path.glob_in_parents( - location, self.JAMROOT + self.JAMFILE) - - if not found: - print "error: Could not find parent for project at '%s'" % location - print "error: Did not find Jamfile or project-root.jam in any parent directory." - sys.exit(1) - - return self.load(os.path.dirname(found[0])) - - def act_as_jamfile(self, module, location): - """Makes the specified 'module' act as if it were a regularly loaded Jamfile - at 'location'. If Jamfile is already located for that location, it's an - error.""" - - if self.module_name(location) in self.jamfile_modules: - self.manager.errors()( - "Jamfile was already loaded for '%s'" % location) - - # Set up non-default mapping from location to module. - self.location2module[location] = module - - # Add the location to the list of project locations - # so that we don't try to load Jamfile in future - self.jamfile_modules.append(location) - - self.initialize(module, location) - - def find(self, name, current_location): - """Given 'name' which can be project-id or plain directory name, - return project module corresponding to that id or directory. - Returns nothing of project is not found.""" - - project_module = None - - # Try interpreting name as project id. - if name[0] == '/': - project_module = self.id2module.get(name) - - if not project_module: - location = os.path.join(current_location, name) - # If no project is registered for the given location, try to - # load it. First see if we have Jamfile. If not we might have project - # root, willing to act as Jamfile. In that case, project-root - # must be placed in the directory referred by id. - - project_module = self.module_name(location) - if not project_module in self.jamfile_modules: - if b2.util.path.glob([location], self.JAMROOT + self.JAMFILE): - project_module = self.load(location) - else: - project_module = None - - return project_module - - def module_name(self, jamfile_location): - """Returns the name of module corresponding to 'jamfile-location'. - If no module corresponds to location yet, associates default - module name with that location.""" - module = self.location2module.get(jamfile_location) - if not module: - # Root the path, so that locations are always umbiguious. - # Without this, we can't decide if '../../exe/program1' and '.' - # are the same paths, or not. - jamfile_location = os.path.realpath( - os.path.join(os.getcwd(), jamfile_location)) - module = "Jamfile<%s>" % jamfile_location - self.location2module[jamfile_location] = module - return module - - def find_jamfile (self, dir, parent_root=0, no_errors=0): - """Find the Jamfile at the given location. This returns the - exact names of all the Jamfiles in the given directory. The optional - parent-root argument causes this to search not the given directory - but the ones above it up to the directory given in it.""" - - # Glob for all the possible Jamfiles according to the match pattern. - # - jamfile_glob = None - if parent_root: - parent = self.dir2parent_jamfile.get(dir) - if not parent: - parent = b2.util.path.glob_in_parents(dir, - self.JAMFILE) - self.dir2parent_jamfile[dir] = parent - jamfile_glob = parent - else: - jamfile = self.dir2jamfile.get(dir) - if not jamfile: - jamfile = b2.util.path.glob([dir], self.JAMFILE) - self.dir2jamfile[dir] = jamfile - jamfile_glob = jamfile - - if len(jamfile_glob) > 1: - # Multiple Jamfiles found in the same place. Warn about this. - # And ensure we use only one of them. - # As a temporary convenience measure, if there's Jamfile.v2 amount - # found files, suppress the warning and use it. - # - pattern = "(.*[Jj]amfile\\.v2)|(.*[Bb]uild\\.jam)" - v2_jamfiles = [x for x in jamfile_glob if re.match(pattern, x)] - if len(v2_jamfiles) == 1: - jamfile_glob = v2_jamfiles - else: - print """warning: Found multiple Jamfiles at '%s'!""" % (dir) - for j in jamfile_glob: - print " -", j - print "Loading the first one" - - # Could not find it, error. - if not no_errors and not jamfile_glob: - self.manager.errors()( - """Unable to load Jamfile. -Could not find a Jamfile in directory '%s' -Attempted to find it with pattern '%s'. -Please consult the documentation at 'http://boost.org/boost-build2'.""" - % (dir, string.join(self.JAMFILE))) - - if jamfile_glob: - return jamfile_glob[0] - - def load_jamfile(self, dir, jamfile_module): - """Load a Jamfile at the given directory. Returns nothing. - Will attempt to load the file as indicated by the JAMFILE patterns. - Effect of calling this rule twice with the same 'dir' is underfined.""" - - # See if the Jamfile is where it should be. - is_jamroot = False - jamfile_to_load = b2.util.path.glob([dir], self.JAMROOT) - if not jamfile_to_load: - jamfile_to_load = self.find_jamfile(dir) - else: - if len(jamfile_to_load) > 1: - get_manager().errors()("Multiple Jamfiles found at '%s'\n" +\ - "Filenames are: %s" - % (dir, [os.path.basename(j) for j in jamfile_to_load])) - - is_jamroot = True - jamfile_to_load = jamfile_to_load[0] - - dir = os.path.dirname(jamfile_to_load) - if not dir: - dir = "." - - self.used_projects[jamfile_module] = [] - - # Now load the Jamfile in it's own context. - # The call to 'initialize' may load parent Jamfile, which might have - # 'use-project' statement that causes a second attempt to load the - # same project we're loading now. Checking inside .jamfile-modules - # prevents that second attempt from messing up. - if not jamfile_module in self.jamfile_modules: - self.jamfile_modules[jamfile_module] = True - - # Initialize the jamfile module before loading. - # - self.initialize(jamfile_module, dir, os.path.basename(jamfile_to_load)) - - saved_project = self.current_project - - bjam.call("load", jamfile_module, jamfile_to_load) - basename = os.path.basename(jamfile_to_load) - - if is_jamroot: - jamfile = self.find_jamfile(dir, no_errors=True) - if jamfile: - bjam.call("load", jamfile_module, jamfile) - - # Now do some checks - if self.current_project != saved_project: - self.manager.errors()( -"""The value of the .current-project variable -has magically changed after loading a Jamfile. -This means some of the targets might be defined a the wrong project. -after loading %s -expected value %s -actual value %s""" % (jamfile_module, saved_project, self.current_project)) - - if self.global_build_dir: - id = self.attributeDefault(jamfile_module, "id", None) - project_root = self.attribute(jamfile_module, "project-root") - location = self.attribute(jamfile_module, "location") - - if location and project_root == dir: - # This is Jamroot - if not id: - # FIXME: go via errors module, so that contexts are - # shown? - print "warning: the --build-dir option was specified" - print "warning: but Jamroot at '%s'" % dir - print "warning: specified no project id" - print "warning: the --build-dir option will be ignored" - - - def load_standalone(self, jamfile_module, file): - """Loads 'file' as standalone project that has no location - associated with it. This is mostly useful for user-config.jam, - which should be able to define targets, but although it has - some location in filesystem, we don't want any build to - happen in user's HOME, for example. - - The caller is required to never call this method twice on - the same file. - """ - - self.used_projects[jamfile_module] = [] - bjam.call("load", jamfile_module, file) - self.load_used_projects(jamfile_module) - - def is_jamroot(self, basename): - match = [ pat for pat in self.JAMROOT if re.match(pat, basename)] - if match: - return 1 - else: - return 0 - - def initialize(self, module_name, location=None, basename=None): - """Initialize the module for a project. - - module-name is the name of the project module. - location is the location (directory) of the project to initialize. - If not specified, stanalone project will be initialized - """ - - if "--debug-loading" in self.manager.argv(): - print "Initializing project '%s'" % module_name - - # TODO: need to consider if standalone projects can do anything but defining - # prebuilt targets. If so, we need to give more sensible "location", so that - # source paths are correct. - if not location: - location = "" - - attributes = ProjectAttributes(self.manager, location, module_name) - self.module2attributes[module_name] = attributes - - python_standalone = False - if location: - attributes.set("source-location", [location], exact=1) - elif not module_name in ["test-config", "site-config", "user-config", "project-config"]: - # This is a standalone project with known location. Set source location - # so that it can declare targets. This is intended so that you can put - # a .jam file in your sources and use it via 'using'. Standard modules - # (in 'tools' subdir) may not assume source dir is set. - module = sys.modules[module_name] - attributes.set("source-location", self.loaded_tool_module_path_[module_name], exact=1) - python_standalone = True - - attributes.set("requirements", property_set.empty(), exact=True) - attributes.set("usage-requirements", property_set.empty(), exact=True) - attributes.set("default-build", property_set.empty(), exact=True) - attributes.set("projects-to-build", [], exact=True) - attributes.set("project-root", None, exact=True) - attributes.set("build-dir", None, exact=True) - - self.project_rules_.init_project(module_name, python_standalone) - - jamroot = False - - parent_module = None; - if module_name == "test-config": - # No parent - pass - elif module_name == "site-config": - parent_module = "test-config" - elif module_name == "user-config": - parent_module = "site-config" - elif module_name == "project-config": - parent_module = "user-config" - elif location and not self.is_jamroot(basename): - # We search for parent/project-root only if jamfile was specified - # --- i.e - # if the project is not standalone. - parent_module = self.load_parent(location) - else: - # It's either jamroot, or standalone project. - # If it's jamroot, inherit from user-config. - if location: - # If project-config module exist, inherit from it. - if self.module2attributes.has_key("project-config"): - parent_module = "project-config" - else: - parent_module = "user-config" ; - - jamroot = True ; - - if parent_module: - self.inherit_attributes(module_name, parent_module) - attributes.set("parent-module", parent_module, exact=1) - - if jamroot: - attributes.set("project-root", location, exact=1) - - parent = None - if parent_module: - parent = self.target(parent_module) - - if not self.module2target.has_key(module_name): - target = b2.build.targets.ProjectTarget(self.manager, - module_name, module_name, parent, - self.attribute(module_name,"requirements"), - # FIXME: why we need to pass this? It's not - # passed in jam code. - self.attribute(module_name, "default-build")) - self.module2target[module_name] = target - - self.current_project = self.target(module_name) - - def inherit_attributes(self, project_module, parent_module): - """Make 'project-module' inherit attributes of project - root and parent module.""" - - attributes = self.module2attributes[project_module] - pattributes = self.module2attributes[parent_module] - - # Parent module might be locationless user-config. - # FIXME: - #if [ modules.binding $(parent-module) ] - #{ - # $(attributes).set parent : [ path.parent - # [ path.make [ modules.binding $(parent-module) ] ] ] ; - # } - - attributes.set("project-root", pattributes.get("project-root"), exact=True) - attributes.set("default-build", pattributes.get("default-build"), exact=True) - attributes.set("requirements", pattributes.get("requirements"), exact=True) - attributes.set("usage-requirements", - pattributes.get("usage-requirements"), exact=1) - - parent_build_dir = pattributes.get("build-dir") - - if parent_build_dir: - # Have to compute relative path from parent dir to our dir - # Convert both paths to absolute, since we cannot - # find relative path from ".." to "." - - location = attributes.get("location") - parent_location = pattributes.get("location") - - our_dir = os.path.join(os.getcwd(), location) - parent_dir = os.path.join(os.getcwd(), parent_location) - - build_dir = os.path.join(parent_build_dir, - os.path.relpath(our_dir, parent_dir)) - attributes.set("build-dir", build_dir, exact=True) - - def register_id(self, id, module): - """Associate the given id with the given project module.""" - self.id2module[id] = module - - def current(self): - """Returns the project which is currently being loaded.""" - return self.current_project - - def set_current(self, c): - self.current_project = c - - def push_current(self, project): - """Temporary changes the current project to 'project'. Should - be followed by 'pop-current'.""" - self.saved_current_project.append(self.current_project) - self.current_project = project - - def pop_current(self): - self.current_project = self.saved_current_project[-1] - del self.saved_current_project[-1] - - def attributes(self, project): - """Returns the project-attribute instance for the - specified jamfile module.""" - return self.module2attributes[project] - - def attribute(self, project, attribute): - """Returns the value of the specified attribute in the - specified jamfile module.""" - return self.module2attributes[project].get(attribute) - try: - return self.module2attributes[project].get(attribute) - except: - raise BaseException("No attribute '%s' for project" % (attribute, project)) - - def attributeDefault(self, project, attribute, default): - """Returns the value of the specified attribute in the - specified jamfile module.""" - return self.module2attributes[project].getDefault(attribute, default) - - def target(self, project_module): - """Returns the project target corresponding to the 'project-module'.""" - if not self.module2target.has_key(project_module): - self.module2target[project_module] = \ - b2.build.targets.ProjectTarget(project_module, project_module, - self.attribute(project_module, "requirements")) - - return self.module2target[project_module] - - def use(self, id, location): - # Use/load a project. - saved_project = self.current_project - project_module = self.load(location) - declared_id = self.attributeDefault(project_module, "id", "") - - if not declared_id or declared_id != id: - # The project at 'location' either have no id or - # that id is not equal to the 'id' parameter. - if self.id2module.has_key(id) and self.id2module[id] != project_module: - self.manager.errors()( -"""Attempt to redeclare already existing project id '%s' at location '%s'""" % (id, location)) - self.id2module[id] = project_module - - self.current_module = saved_project - - def add_rule(self, name, callable): - """Makes rule 'name' available to all subsequently loaded Jamfiles. - - Calling that rule wil relay to 'callable'.""" - self.project_rules_.add_rule(name, callable) - - def project_rules(self): - return self.project_rules_ - - def glob_internal(self, project, wildcards, excludes, rule_name): - location = project.get("source-location")[0] - - result = [] - callable = b2.util.path.__dict__[rule_name] - - paths = callable([location], wildcards, excludes) - has_dir = 0 - for w in wildcards: - if os.path.dirname(w): - has_dir = 1 - break - - if has_dir or rule_name != "glob": - result = [] - # The paths we've found are relative to current directory, - # but the names specified in sources list are assumed to - # be relative to source directory of the corresponding - # prject. Either translate them or make absolute. - - for p in paths: - rel = os.path.relpath(p, location) - # If the path is below source location, use relative path. - if not ".." in rel: - result.append(rel) - else: - # Otherwise, use full path just to avoid any ambiguities. - result.append(os.path.abspath(p)) - - else: - # There were not directory in wildcard, so the files are all - # in the source directory of the project. Just drop the - # directory, instead of making paths absolute. - result = [os.path.basename(p) for p in paths] - - return result - - def load_module(self, name, extra_path=None): - """Load a Python module that should be useable from Jamfiles. - - There are generally two types of modules Jamfiles might want to - use: - - Core Boost.Build. Those are imported using plain names, e.g. - 'toolset', so this function checks if we have module named - b2.package.module already. - - Python modules in the same directory as Jamfile. We don't - want to even temporary add Jamfile's directory to sys.path, - since then we might get naming conflicts between standard - Python modules and those. - """ - - # See if we loaded module of this name already - existing = self.loaded_tool_modules_.get(name) - if existing: - return existing - - # See if we have a module b2.whatever.<name>, where <name> - # is what is passed to this function - modules = sys.modules - for class_name in modules: - parts = class_name.split('.') - if name is class_name or parts[0] == "b2" \ - and parts[-1] == name.replace("-", "_"): - module = modules[class_name] - self.loaded_tool_modules_[name] = module - return module - - # Lookup a module in BOOST_BUILD_PATH - path = extra_path - if not path: - path = [] - path.extend(self.manager.boost_build_path()) - location = None - for p in path: - l = os.path.join(p, name + ".py") - if os.path.exists(l): - location = l - break - - if not location: - self.manager.errors()("Cannot find module '%s'" % name) - - mname = name + "__for_jamfile" - file = open(location) - try: - # TODO: this means we'll never make use of .pyc module, - # which might be a problem, or not. - self.loaded_tool_module_path_[mname] = location - module = imp.load_module(mname, file, os.path.basename(location), - (".py", "r", imp.PY_SOURCE)) - self.loaded_tool_modules_[name] = module - return module - finally: - file.close() - - - -# FIXME: -# Defines a Boost.Build extension project. Such extensions usually -# contain library targets and features that can be used by many people. -# Even though extensions are really projects, they can be initialize as -# a module would be with the "using" (project.project-rules.using) -# mechanism. -#rule extension ( id : options * : * ) -#{ -# # The caller is a standalone module for the extension. -# local mod = [ CALLER_MODULE ] ; -# -# # We need to do the rest within the extension module. -# module $(mod) -# { -# import path ; -# -# # Find the root project. -# local root-project = [ project.current ] ; -# root-project = [ $(root-project).project-module ] ; -# while -# [ project.attribute $(root-project) parent-module ] && -# [ project.attribute $(root-project) parent-module ] != user-config -# { -# root-project = [ project.attribute $(root-project) parent-module ] ; -# } -# -# # Create the project data, and bring in the project rules -# # into the module. -# project.initialize $(__name__) : -# [ path.join [ project.attribute $(root-project) location ] ext $(1:L) ] ; -# -# # Create the project itself, i.e. the attributes. -# # All extensions are created in the "/ext" project space. -# project /ext/$(1) : $(2) : $(3) : $(4) : $(5) : $(6) : $(7) : $(8) : $(9) ; -# local attributes = [ project.attributes $(__name__) ] ; -# -# # Inherit from the root project of whomever is defining us. -# project.inherit-attributes $(__name__) : $(root-project) ; -# $(attributes).set parent-module : $(root-project) : exact ; -# } -#} - - -class ProjectAttributes: - """Class keeping all the attributes of a project. - - The standard attributes are 'id', "location", "project-root", "parent" - "requirements", "default-build", "source-location" and "projects-to-build". - """ - - def __init__(self, manager, location, project_module): - self.manager = manager - self.location = location - self.project_module = project_module - self.attributes = {} - self.usage_requirements = None - - def set(self, attribute, specification, exact=False): - """Set the named attribute from the specification given by the user. - The value actually set may be different.""" - - if exact: - self.__dict__[attribute] = specification - - elif attribute == "requirements": - self.requirements = property_set.refine_from_user_input( - self.requirements, specification, - self.project_module, self.location) - - elif attribute == "usage-requirements": - unconditional = [] - for p in specification: - split = property.split_conditional(p) - if split: - unconditional.append(split[1]) - else: - unconditional.append(p) - - non_free = property.remove("free", unconditional) - if non_free: - get_manager().errors()("usage-requirements %s have non-free properties %s" \ - % (specification, non_free)) - - t = property.translate_paths( - property.create_from_strings(specification, allow_condition=True), - self.location) - - existing = self.__dict__.get("usage-requirements") - if existing: - new = property_set.create(existing.all() + t) - else: - new = property_set.create(t) - self.__dict__["usage-requirements"] = new - - - elif attribute == "default-build": - self.__dict__["default-build"] = property_set.create(specification) - - elif attribute == "source-location": - source_location = [] - for path in specification: - source_location.append(os.path.join(self.location, path)) - self.__dict__["source-location"] = source_location - - elif attribute == "build-dir": - self.__dict__["build-dir"] = os.path.join(self.location, specification[0]) - - elif attribute == "id": - id = specification[0] - if id[0] != '/': - id = "/" + id - self.manager.projects().register_id(id, self.project_module) - self.__dict__["id"] = id - - elif not attribute in ["default-build", "location", - "source-location", "parent", - "projects-to-build", "project-root"]: - self.manager.errors()( -"""Invalid project attribute '%s' specified -for project at '%s'""" % (attribute, self.location)) - else: - self.__dict__[attribute] = specification - - def get(self, attribute): - return self.__dict__[attribute] - - def getDefault(self, attribute, default): - return self.__dict__.get(attribute, default) - - def dump(self): - """Prints the project attributes.""" - id = self.get("id") - if not id: - id = "(none)" - else: - id = id[0] - - parent = self.get("parent") - if not parent: - parent = "(none)" - else: - parent = parent[0] - - print "'%s'" % id - print "Parent project:%s", parent - print "Requirements:%s", self.get("requirements") - print "Default build:%s", string.join(self.get("debuild-build")) - print "Source location:%s", string.join(self.get("source-location")) - print "Projects to build:%s", string.join(self.get("projects-to-build").sort()); - -class ProjectRules: - """Class keeping all rules that are made available to Jamfile.""" - - def __init__(self, registry): - self.registry = registry - self.manager_ = registry.manager - self.rules = {} - self.local_names = [x for x in self.__class__.__dict__ - if x not in ["__init__", "init_project", "add_rule", - "error_reporting_wrapper", "add_rule_for_type", "reverse"]] - self.all_names_ = [x for x in self.local_names] - - def _import_rule(self, bjam_module, name, callable): - if hasattr(callable, "bjam_signature"): - bjam.import_rule(bjam_module, name, self.make_wrapper(callable), callable.bjam_signature) - else: - bjam.import_rule(bjam_module, name, self.make_wrapper(callable)) - - - def add_rule_for_type(self, type): - rule_name = type.lower().replace("_", "-") - - def xpto (name, sources = [], requirements = [], default_build = [], usage_requirements = []): - return self.manager_.targets().create_typed_target( - type, self.registry.current(), name[0], sources, - requirements, default_build, usage_requirements) - - self.add_rule(rule_name, xpto) - - def add_rule(self, name, callable): - self.rules[name] = callable - self.all_names_.append(name) - - # Add new rule at global bjam scope. This might not be ideal, - # added because if a jamroot does 'import foo' where foo calls - # add_rule, we need to import new rule to jamroot scope, and - # I'm lazy to do this now. - self._import_rule("", name, callable) - - def all_names(self): - return self.all_names_ - - def call_and_report_errors(self, callable, *args, **kw): - result = None - try: - self.manager_.errors().push_jamfile_context() - result = callable(*args, **kw) - except ExceptionWithUserContext, e: - e.report() - except Exception, e: - try: - self.manager_.errors().handle_stray_exception (e) - except ExceptionWithUserContext, e: - e.report() - finally: - self.manager_.errors().pop_jamfile_context() - - return result - - def make_wrapper(self, callable): - """Given a free-standing function 'callable', return a new - callable that will call 'callable' and report all exceptins, - using 'call_and_report_errors'.""" - def wrapper(*args, **kw): - return self.call_and_report_errors(callable, *args, **kw) - return wrapper - - def init_project(self, project_module, python_standalone=False): - - if python_standalone: - m = sys.modules[project_module] - - for n in self.local_names: - if n != "import_": - setattr(m, n, getattr(self, n)) - - for n in self.rules: - setattr(m, n, self.rules[n]) - - return - - for n in self.local_names: - # Using 'getattr' here gives us a bound method, - # while using self.__dict__[r] would give unbound one. - v = getattr(self, n) - if callable(v): - if n == "import_": - n = "import" - else: - n = string.replace(n, "_", "-") - - self._import_rule(project_module, n, v) - - for n in self.rules: - self._import_rule(project_module, n, self.rules[n]) - - def project(self, *args): - - jamfile_module = self.registry.current().project_module() - attributes = self.registry.attributes(jamfile_module) - - id = None - if args and args[0]: - id = args[0][0] - args = args[1:] - - if id: - attributes.set('id', [id]) - - explicit_build_dir = None - for a in args: - if a: - attributes.set(a[0], a[1:], exact=0) - if a[0] == "build-dir": - explicit_build_dir = a[1] - - # If '--build-dir' is specified, change the build dir for the project. - if self.registry.global_build_dir: - - location = attributes.get("location") - # Project with empty location is 'standalone' project, like - # user-config, or qt. It has no build dir. - # If we try to set build dir for user-config, we'll then - # try to inherit it, with either weird, or wrong consequences. - if location and location == attributes.get("project-root"): - # Re-read the project id, since it might have been changed in - # the project's attributes. - id = attributes.get('id') - - # This is Jamroot. - if id: - if explicit_build_dir and os.path.isabs(explicit_build_dir): - self.registry.manager.errors()( -"""Absolute directory specified via 'build-dir' project attribute -Don't know how to combine that with the --build-dir option.""") - - rid = id - if rid[0] == '/': - rid = rid[1:] - - p = os.path.join(self.registry.global_build_dir, rid) - if explicit_build_dir: - p = os.path.join(p, explicit_build_dir) - attributes.set("build-dir", p, exact=1) - elif explicit_build_dir: - self.registry.manager.errors()( -"""When --build-dir is specified, the 'build-dir' -attribute is allowed only for top-level 'project' invocations""") - - def constant(self, name, value): - """Declare and set a project global constant. - Project global constants are normal variables but should - not be changed. They are applied to every child Jamfile.""" - m = "Jamfile</home/ghost/Work/Boost/boost-svn/tools/build/v2_python/python/tests/bjam/make>" - self.registry.current().add_constant(name[0], value) - - def path_constant(self, name, value): - """Declare and set a project global constant, whose value is a path. The - path is adjusted to be relative to the invocation directory. The given - value path is taken to be either absolute, or relative to this project - root.""" - if len(value) > 1: - self.registry.manager.error()("path constant should have one element") - self.registry.current().add_constant(name[0], value[0], path=1) - - def use_project(self, id, where): - # See comment in 'load' for explanation why we record the - # parameters as opposed to loading the project now. - m = self.registry.current().project_module(); - self.registry.used_projects[m].append((id[0], where[0])) - - def build_project(self, dir): - assert(isinstance(dir, list)) - jamfile_module = self.registry.current().project_module() - attributes = self.registry.attributes(jamfile_module) - now = attributes.get("projects-to-build") - attributes.set("projects-to-build", now + dir, exact=True) - - def explicit(self, target_names): - self.registry.current().mark_targets_as_explicit(target_names) - - def always(self, target_names): - self.registry.current().mark_targets_as_alays(target_names) - - def glob(self, wildcards, excludes=None): - return self.registry.glob_internal(self.registry.current(), - wildcards, excludes, "glob") - - def glob_tree(self, wildcards, excludes=None): - bad = 0 - for p in wildcards: - if os.path.dirname(p): - bad = 1 - - if excludes: - for p in excludes: - if os.path.dirname(p): - bad = 1 - - if bad: - self.registry.manager.errors()( -"The patterns to 'glob-tree' may not include directory") - return self.registry.glob_internal(self.registry.current(), - wildcards, excludes, "glob_tree") - - - def using(self, toolset, *args): - # The module referred by 'using' can be placed in - # the same directory as Jamfile, and the user - # will expect the module to be found even though - # the directory is not in BOOST_BUILD_PATH. - # So temporary change the search path. - current = self.registry.current() - location = current.get('location') - - m = self.registry.load_module(toolset[0], [location]) - if not m.__dict__.has_key("init"): - self.registry.manager.errors()( - "Tool module '%s' does not define the 'init' method" % toolset[0]) - m.init(*args) - - # The above might have clobbered .current-project. Restore the correct - # value. - self.registry.set_current(current) - - def import_(self, name, names_to_import=None, local_names=None): - - name = name[0] - py_name = name - if py_name == "os": - py_name = "os_j" - jamfile_module = self.registry.current().project_module() - attributes = self.registry.attributes(jamfile_module) - location = attributes.get("location") - - saved = self.registry.current() - - m = self.registry.load_module(py_name, [location]) - - for f in m.__dict__: - v = m.__dict__[f] - f = f.replace("_", "-") - if callable(v): - qn = name + "." + f - self._import_rule(jamfile_module, qn, v) - record_jam_to_value_mapping(qualify_jam_action(qn, jamfile_module), v) - - - if names_to_import: - if not local_names: - local_names = names_to_import - - if len(names_to_import) != len(local_names): - self.registry.manager.errors()( -"""The number of names to import and local names do not match.""") - - for n, l in zip(names_to_import, local_names): - self._import_rule(jamfile_module, l, m.__dict__[n]) - - self.registry.set_current(saved) - - def conditional(self, condition, requirements): - """Calculates conditional requirements for multiple requirements - at once. This is a shorthand to be reduce duplication and to - keep an inline declarative syntax. For example: - - lib x : x.cpp : [ conditional <toolset>gcc <variant>debug : - <define>DEBUG_EXCEPTION <define>DEBUG_TRACE ] ; - """ - - c = string.join(condition, ",") - if c.find(":") != -1: - return [c + r for r in requirements] - else: - return [c + ":" + r for r in requirements] - - def option(self, name, value): - name = name[0] - if not name in ["site-config", "user-config", "project-config"]: - get_manager().errors()("The 'option' rule may be used only in site-config or user-config") - - option.set(name, value[0]) |