diff options
Diffstat (limited to 'jam-files/boost-build/tools/common.py')
| -rw-r--r-- | jam-files/boost-build/tools/common.py | 840 |
1 files changed, 0 insertions, 840 deletions
diff --git a/jam-files/boost-build/tools/common.py b/jam-files/boost-build/tools/common.py deleted file mode 100644 index 612745b8..00000000 --- a/jam-files/boost-build/tools/common.py +++ /dev/null @@ -1,840 +0,0 @@ -# Status: being ported by Steven Watanabe -# Base revision: 47174 -# -# Copyright (C) Vladimir Prus 2002. Permission to copy, use, modify, sell and -# distribute this software is granted provided this copyright notice appears in -# all copies. This software is provided "as is" without express or implied -# warranty, and with no claim as to its suitability for any purpose. - -""" Provides actions common to all toolsets, such as creating directories and - removing files. -""" - -import re -import bjam -import os -import os.path -import sys - -from b2.build import feature -from b2.util.utility import * -from b2.util import path - -__re__before_first_dash = re.compile ('([^-]*)-') - -def reset (): - """ Clear the module state. This is mainly for testing purposes. - Note that this must be called _after_ resetting the module 'feature'. - """ - global __had_unspecified_value, __had_value, __declared_subfeature - global __init_loc - global __all_signatures, __debug_configuration, __show_configuration - - # Stores toolsets without specified initialization values. - __had_unspecified_value = {} - - # Stores toolsets with specified initialization values. - __had_value = {} - - # Stores toolsets with declared subfeatures. - __declared_subfeature = {} - - # Stores all signatures of the toolsets. - __all_signatures = {} - - # Stores the initialization locations of each toolset - __init_loc = {} - - __debug_configuration = '--debug-configuration' in bjam.variable('ARGV') - __show_configuration = '--show-configuration' in bjam.variable('ARGV') - - global __executable_path_variable - OS = bjam.call("peek", [], "OS")[0] - if OS == "NT": - # On Windows the case and capitalization of PATH is not always predictable, so - # let's find out what variable name was really set. - for n in sys.environ: - if n.lower() == "path": - __executable_path_variable = n - break - else: - __executable_path_variable = "PATH" - - m = {"NT": __executable_path_variable, - "CYGWIN": "PATH", - "MACOSX": "DYLD_LIBRARY_PATH", - "AIX": "LIBPATH"} - global __shared_library_path_variable - __shared_library_path_variable = m.get(OS, "LD_LIBRARY_PATH") - -reset() - -def shared_library_path_variable(): - return __shared_library_path_variable - -# ported from trunk@47174 -class Configurations(object): - """ - This class helps to manage toolset configurations. Each configuration - has a unique ID and one or more parameters. A typical example of a unique ID - is a condition generated by 'common.check-init-parameters' rule. Other kinds - of IDs can be used. Parameters may include any details about the configuration - like 'command', 'path', etc. - - A toolset configuration may be in one of the following states: - - - registered - Configuration has been registered (e.g. by autodetection code) but has - not yet been marked as used, i.e. 'toolset.using' rule has not yet been - called for it. - - used - Once called 'toolset.using' rule marks the configuration as 'used'. - - The main difference between the states above is that while a configuration is - 'registered' its options can be freely changed. This is useful in particular - for autodetection code - all detected configurations may be safely overwritten - by user code. - """ - - def __init__(self): - self.used_ = set() - self.all_ = set() - self.params = {} - - def register(self, id): - """ - Registers a configuration. - - Returns True if the configuration has been added and False if - it already exists. Reports an error if the configuration is 'used'. - """ - if id in self.used_: - #FIXME - errors.error("common: the configuration '$(id)' is in use") - - if id not in self.all_: - self.all_ += [id] - - # Indicate that a new configuration has been added. - return True - else: - return False - - def use(self, id): - """ - Mark a configuration as 'used'. - - Returns True if the state of the configuration has been changed to - 'used' and False if it the state wasn't changed. Reports an error - if the configuration isn't known. - """ - if id not in self.all_: - #FIXME: - errors.error("common: the configuration '$(id)' is not known") - - if id not in self.used_: - self.used_ += [id] - - # indicate that the configuration has been marked as 'used' - return True - else: - return False - - def all(self): - """ Return all registered configurations. """ - return self.all_ - - def used(self): - """ Return all used configurations. """ - return self.used_ - - def get(self, id, param): - """ Returns the value of a configuration parameter. """ - self.params_.getdefault(param, {}).getdefault(id, None) - - def set (self, id, param, value): - """ Sets the value of a configuration parameter. """ - self.params_.setdefault(param, {})[id] = value - -# Ported from trunk@47174 -def check_init_parameters(toolset, requirement, *args): - """ The rule for checking toolset parameters. Trailing parameters should all be - parameter name/value pairs. The rule will check that each parameter either has - a value in each invocation or has no value in each invocation. Also, the rule - will check that the combination of all parameter values is unique in all - invocations. - - Each parameter name corresponds to a subfeature. This rule will declare a - subfeature the first time a non-empty parameter value is passed and will - extend it with all the values. - - The return value from this rule is a condition to be used for flags settings. - """ - # The type checking here is my best guess about - # what the types should be. - assert(isinstance(toolset, str)) - assert(isinstance(requirement, str) or requirement is None) - sig = toolset - condition = replace_grist(toolset, '<toolset>') - subcondition = [] - - for arg in args: - assert(isinstance(arg, tuple)) - assert(len(arg) == 2) - name = arg[0] - value = arg[1] - assert(isinstance(name, str)) - assert(isinstance(value, str) or value is None) - - str_toolset_name = str((toolset, name)) - - # FIXME: is this the correct translation? - ### if $(value)-is-not-empty - if value is not None: - condition = condition + '-' + value - if __had_unspecified_value.has_key(str_toolset_name): - raise BaseException("'%s' initialization: parameter '%s' inconsistent\n" \ - "no value was specified in earlier initialization\n" \ - "an explicit value is specified now" % (toolset, name)) - - # The logic below is for intel compiler. It calls this rule - # with 'intel-linux' and 'intel-win' as toolset, so we need to - # get the base part of toolset name. - # We can't pass 'intel' as toolset, because it that case it will - # be impossible to register versionles intel-linux and - # intel-win of specific version. - t = toolset - m = __re__before_first_dash.match(toolset) - if m: - t = m.group(1) - - if not __had_value.has_key(str_toolset_name): - if not __declared_subfeature.has_key(str((t, name))): - feature.subfeature('toolset', t, name, [], ['propagated']) - __declared_subfeature[str((t, name))] = True - - __had_value[str_toolset_name] = True - - feature.extend_subfeature('toolset', t, name, [value]) - subcondition += ['<toolset-' + t + ':' + name + '>' + value ] - - else: - if __had_value.has_key(str_toolset_name): - raise BaseException ("'%s' initialization: parameter '%s' inconsistent\n" \ - "an explicit value was specified in an earlier initialization\n" \ - "no value is specified now" % (toolset, name)) - - __had_unspecified_value[str_toolset_name] = True - - if value == None: value = '' - - sig = sig + value + '-' - - if __all_signatures.has_key(sig): - message = "duplicate initialization of '%s' with the following parameters: " % toolset - - for arg in args: - name = arg[0] - value = arg[1] - if value == None: value = '<unspecified>' - - message += "'%s' = '%s'\n" % (name, value) - - raise BaseException(message) - - __all_signatures[sig] = True - # FIXME - __init_loc[sig] = "User location unknown" #[ errors.nearest-user-location ] ; - - # If we have a requirement, this version should only be applied under that - # condition. To accomplish this we add a toolset requirement that imposes - # the toolset subcondition, which encodes the version. - if requirement: - r = ['<toolset>' + toolset, requirement] - r = ','.join(r) - toolset.add_requirements([r + ':' + c for c in subcondition]) - - # We add the requirements, if any, to the condition to scope the toolset - # variables and options to this specific version. - condition = [condition] - if requirement: - condition += [requirement] - - if __show_configuration: - print "notice:", condition - return ['/'.join(condition)] - -# Ported from trunk@47077 -def get_invocation_command_nodefault( - toolset, tool, user_provided_command=[], additional_paths=[], path_last=False): - """ - A helper rule to get the command to invoke some tool. If - 'user-provided-command' is not given, tries to find binary named 'tool' in - PATH and in the passed 'additional-path'. Otherwise, verifies that the first - element of 'user-provided-command' is an existing program. - - This rule returns the command to be used when invoking the tool. If we can't - find the tool, a warning is issued. If 'path-last' is specified, PATH is - checked after 'additional-paths' when searching for 'tool'. - """ - assert(isinstance(toolset, str)) - assert(isinstance(tool, str)) - assert(isinstance(user_provided_command, list)) - if additional_paths is not None: - assert(isinstance(additional_paths, list)) - assert(all([isinstance(path, str) for path in additional_paths])) - assert(all(isinstance(path, str) for path in additional_paths)) - assert(isinstance(path_last, bool)) - - if not user_provided_command: - command = find_tool(tool, additional_paths, path_last) - if not command and __debug_configuration: - print "warning: toolset", toolset, "initialization: can't find tool, tool" - #FIXME - #print "warning: initialized from" [ errors.nearest-user-location ] ; - else: - command = check_tool(user_provided_command) - if not command and __debug_configuration: - print "warning: toolset", toolset, "initialization:" - print "warning: can't find user-provided command", user_provided_command - #FIXME - #ECHO "warning: initialized from" [ errors.nearest-user-location ] - - assert(isinstance(command, str)) - - return command - -# ported from trunk@47174 -def get_invocation_command(toolset, tool, user_provided_command = [], - additional_paths = [], path_last = False): - """ Same as get_invocation_command_nodefault, except that if no tool is found, - returns either the user-provided-command, if present, or the 'tool' parameter. - """ - - assert(isinstance(toolset, str)) - assert(isinstance(tool, str)) - assert(isinstance(user_provided_command, list)) - if additional_paths is not None: - assert(isinstance(additional_paths, list)) - assert(all([isinstance(path, str) for path in additional_paths])) - assert(isinstance(path_last, bool)) - - result = get_invocation_command_nodefault(toolset, tool, - user_provided_command, - additional_paths, - path_last) - - if not result: - if user_provided_command: - result = user_provided_command[0] - else: - result = tool - - assert(isinstance(result, str)) - - return result - -# ported from trunk@47281 -def get_absolute_tool_path(command): - """ - Given an invocation command, - return the absolute path to the command. This works even if commnad - has not path element and is present in PATH. - """ - if os.path.dirname(command): - return os.path.dirname(command) - else: - programs = path.programs_path() - m = path.glob(programs, [command, command + '.exe' ]) - if not len(m): - print "Could not find:", command, "in", programs - return os.path.dirname(m[0]) - -# ported from trunk@47174 -def find_tool(name, additional_paths = [], path_last = False): - """ Attempts to find tool (binary) named 'name' in PATH and in - 'additional-paths'. If found in path, returns 'name'. If - found in additional paths, returns full name. If the tool - is found in several directories, returns the first path found. - Otherwise, returns the empty string. If 'path_last' is specified, - path is checked after 'additional_paths'. - """ - assert(isinstance(name, str)) - assert(isinstance(additional_paths, list)) - assert(isinstance(path_last, bool)) - - programs = path.programs_path() - match = path.glob(programs, [name, name + '.exe']) - additional_match = path.glob(additional_paths, [name, name + '.exe']) - - result = [] - if path_last: - result = additional_match - if not result and match: - result = match - - else: - if match: - result = match - - elif additional_match: - result = additional_match - - if result: - return path.native(result[0]) - else: - return '' - -#ported from trunk@47281 -def check_tool_aux(command): - """ Checks if 'command' can be found either in path - or is a full name to an existing file. - """ - assert(isinstance(command, str)) - dirname = os.path.dirname(command) - if dirname: - if os.path.exists(command): - return command - # Both NT and Cygwin will run .exe files by their unqualified names. - elif on_windows() and os.path.exists(command + '.exe'): - return command - # Only NT will run .bat files by their unqualified names. - elif os_name() == 'NT' and os.path.exists(command + '.bat'): - return command - else: - paths = path.programs_path() - if path.glob(paths, [command]): - return command - -# ported from trunk@47281 -def check_tool(command): - """ Checks that a tool can be invoked by 'command'. - If command is not an absolute path, checks if it can be found in 'path'. - If comand is absolute path, check that it exists. Returns 'command' - if ok and empty string otherwise. - """ - assert(isinstance(command, list)) - assert(all(isinstance(c, str) for c in command)) - #FIXME: why do we check the first and last elements???? - if check_tool_aux(command[0]) or check_tool_aux(command[-1]): - return command - -# ported from trunk@47281 -def handle_options(tool, condition, command, options): - """ Handle common options for toolset, specifically sets the following - flag variables: - - CONFIG_COMMAND to 'command' - - OPTIOns for compile to the value of <compileflags> in options - - OPTIONS for compile.c to the value of <cflags> in options - - OPTIONS for compile.c++ to the value of <cxxflags> in options - - OPTIONS for compile.fortran to the value of <fflags> in options - - OPTIONs for link to the value of <linkflags> in options - """ - from b2.build import toolset - - assert(isinstance(tool, str)) - assert(isinstance(condition, list)) - assert(isinstance(command, str)) - assert(isinstance(options, list)) - assert(command) - toolset.flags(tool, 'CONFIG_COMMAND', condition, [command]) - toolset.flags(tool + '.compile', 'OPTIONS', condition, feature.get_values('<compileflags>', options)) - toolset.flags(tool + '.compile.c', 'OPTIONS', condition, feature.get_values('<cflags>', options)) - toolset.flags(tool + '.compile.c++', 'OPTIONS', condition, feature.get_values('<cxxflags>', options)) - toolset.flags(tool + '.compile.fortran', 'OPTIONS', condition, feature.get_values('<fflags>', options)) - toolset.flags(tool + '.link', 'OPTIONS', condition, feature.get_values('<linkflags>', options)) - -# ported from trunk@47281 -def get_program_files_dir(): - """ returns the location of the "program files" directory on a windows - platform - """ - ProgramFiles = bjam.variable("ProgramFiles") - if ProgramFiles: - ProgramFiles = ' '.join(ProgramFiles) - else: - ProgramFiles = "c:\\Program Files" - return ProgramFiles - -# ported from trunk@47281 -def rm_command(): - return __RM - -# ported from trunk@47281 -def copy_command(): - return __CP - -# ported from trunk@47281 -def variable_setting_command(variable, value): - """ - Returns the command needed to set an environment variable on the current - platform. The variable setting persists through all following commands and is - visible in the environment seen by subsequently executed commands. In other - words, on Unix systems, the variable is exported, which is consistent with the - only possible behavior on Windows systems. - """ - assert(isinstance(variable, str)) - assert(isinstance(value, str)) - - if os_name() == 'NT': - return "set " + variable + "=" + value + os.linesep - else: - # (todo) - # The following does not work on CYGWIN and needs to be fixed. On - # CYGWIN the $(nl) variable holds a Windows new-line \r\n sequence that - # messes up the executed export command which then reports that the - # passed variable name is incorrect. This is most likely due to the - # extra \r character getting interpreted as a part of the variable name. - # - # Several ideas pop to mind on how to fix this: - # * One way would be to separate the commands using the ; shell - # command separator. This seems like the quickest possible - # solution but I do not know whether this would break code on any - # platforms I I have no access to. - # * Another would be to not use the terminating $(nl) but that would - # require updating all the using code so it does not simply - # prepend this variable to its own commands. - # * I guess the cleanest solution would be to update Boost Jam to - # allow explicitly specifying \n & \r characters in its scripts - # instead of always relying only on the 'current OS native newline - # sequence'. - # - # Some code found to depend on this behaviour: - # * This Boost Build module. - # * __test__ rule. - # * path-variable-setting-command rule. - # * python.jam toolset. - # * xsltproc.jam toolset. - # * fop.jam toolset. - # (todo) (07.07.2008.) (Jurko) - # - # I think that this works correctly in python -- Steven Watanabe - return variable + "=" + value + os.linesep + "export " + variable + os.linesep - -def path_variable_setting_command(variable, paths): - """ - Returns a command to sets a named shell path variable to the given NATIVE - paths on the current platform. - """ - assert(isinstance(variable, str)) - assert(isinstance(paths, list)) - sep = os.path.pathsep - return variable_setting_command(variable, sep.join(paths)) - -def prepend_path_variable_command(variable, paths): - """ - Returns a command that prepends the given paths to the named path variable on - the current platform. - """ - return path_variable_setting_command(variable, - paths + os.environ.get(variable, "").split(os.pathsep)) - -def file_creation_command(): - """ - Return a command which can create a file. If 'r' is result of invocation, then - 'r foobar' will create foobar with unspecified content. What happens if file - already exists is unspecified. - """ - if os_name() == 'NT': - return "echo. > " - else: - return "touch " - -#FIXME: global variable -__mkdir_set = set() -__re_windows_drive = re.compile(r'^.*:\$') - -def mkdir(engine, target): - # If dir exists, do not update it. Do this even for $(DOT). - bjam.call('NOUPDATE', target) - - global __mkdir_set - - # FIXME: Where is DOT defined? - #if $(<) != $(DOT) && ! $($(<)-mkdir): - if target != '.' and target not in __mkdir_set: - # Cheesy gate to prevent multiple invocations on same dir. - __mkdir_set.add(target) - - # Schedule the mkdir build action. - if os_name() == 'NT': - engine.set_update_action("common.MkDir1-quick-fix-for-windows", target, []) - else: - engine.set_update_action("common.MkDir1-quick-fix-for-unix", target, []) - - # Prepare a Jam 'dirs' target that can be used to make the build only - # construct all the target directories. - engine.add_dependency('dirs', target) - - # Recursively create parent directories. $(<:P) = $(<)'s parent & we - # recurse until root. - - s = os.path.dirname(target) - if os_name() == 'NT': - if(__re_windows_drive.match(s)): - s = '' - - if s: - if s != target: - engine.add_dependency(target, s) - mkdir(engine, s) - else: - bjam.call('NOTFILE', s) - -__re_version = re.compile(r'^([^.]+)[.]([^.]+)[.]?([^.]*)') - -def format_name(format, name, target_type, prop_set): - """ Given a target, as given to a custom tag rule, returns a string formatted - according to the passed format. Format is a list of properties that is - represented in the result. For each element of format the corresponding target - information is obtained and added to the result string. For all, but the - literal, the format value is taken as the as string to prepend to the output - to join the item to the rest of the result. If not given "-" is used as a - joiner. - - The format options can be: - - <base>[joiner] - :: The basename of the target name. - <toolset>[joiner] - :: The abbreviated toolset tag being used to build the target. - <threading>[joiner] - :: Indication of a multi-threaded build. - <runtime>[joiner] - :: Collective tag of the build runtime. - <version:/version-feature | X.Y[.Z]/>[joiner] - :: Short version tag taken from the given "version-feature" - in the build properties. Or if not present, the literal - value as the version number. - <property:/property-name/>[joiner] - :: Direct lookup of the given property-name value in the - build properties. /property-name/ is a regular expression. - e.g. <property:toolset-.*:flavor> will match every toolset. - /otherwise/ - :: The literal value of the format argument. - - For example this format: - - boost_ <base> <toolset> <threading> <runtime> <version:boost-version> - - Might return: - - boost_thread-vc80-mt-gd-1_33.dll, or - boost_regex-vc80-gd-1_33.dll - - The returned name also has the target type specific prefix and suffix which - puts it in a ready form to use as the value from a custom tag rule. - """ - assert(isinstance(format, list)) - assert(isinstance(name, str)) - assert(isinstance(target_type, str) or not type) - # assert(isinstance(prop_set, property_set.PropertySet)) - if type.is_derived(target_type, 'LIB'): - result = "" ; - for f in format: - grist = get_grist(f) - if grist == '<base>': - result += os.path.basename(name) - elif grist == '<toolset>': - result += join_tag(ungrist(f), - toolset_tag(name, target_type, prop_set)) - elif grist == '<threading>': - result += join_tag(ungrist(f), - threading_tag(name, target_type, prop_set)) - elif grist == '<runtime>': - result += join_tag(ungrist(f), - runtime_tag(name, target_type, prop_set)) - elif grist.startswith('<version:'): - key = grist[len('<version:'):-1] - version = prop_set.get('<' + key + '>') - if not version: - version = key - version = __re_version.match(version) - result += join_tag(ungrist(f), version[1] + '_' + version[2]) - elif grist.startswith('<property:'): - key = grist[len('<property:'):-1] - property_re = re.compile('<(' + key + ')>') - p0 = None - for prop in prop_set.raw(): - match = property_re.match(prop) - if match: - p0 = match[1] - break - if p0: - p = prop_set.get('<' + p0 + '>') - if p: - assert(len(p) == 1) - result += join_tag(ungrist(f), p) - else: - result += ungrist(f) - - result = virtual_target.add_prefix_and_suffix( - ''.join(result), target_type, prop_set) - return result - -def join_tag(joiner, tag): - if not joiner: joiner = '-' - return joiner + tag - -__re_toolset_version = re.compile(r"<toolset.*version>(\d+)[.](\d*)") - -def toolset_tag(name, target_type, prop_set): - tag = '' - - properties = prop_set.raw() - tools = prop_set.get('<toolset>') - assert(len(tools) == 0) - tools = tools[0] - if tools.startswith('borland'): tag += 'bcb' - elif tools.startswith('como'): tag += 'como' - elif tools.startswith('cw'): tag += 'cw' - elif tools.startswith('darwin'): tag += 'xgcc' - elif tools.startswith('edg'): tag += edg - elif tools.startswith('gcc'): - flavor = prop_set.get('<toolset-gcc:flavor>') - ''.find - if flavor.find('mingw') != -1: - tag += 'mgw' - else: - tag += 'gcc' - elif tools == 'intel': - if prop_set.get('<toolset-intel:platform>') == ['win']: - tag += 'iw' - else: - tag += 'il' - elif tools.startswith('kcc'): tag += 'kcc' - elif tools.startswith('kylix'): tag += 'bck' - #case metrowerks* : tag += cw ; - #case mingw* : tag += mgw ; - elif tools.startswith('mipspro'): tag += 'mp' - elif tools.startswith('msvc'): tag += 'vc' - elif tools.startswith('sun'): tag += 'sw' - elif tools.startswith('tru64cxx'): tag += 'tru' - elif tools.startswith('vacpp'): tag += 'xlc' - - for prop in properties: - match = __re_toolset_version.match(prop) - if(match): - version = match - break - version_string = None - # For historical reasons, vc6.0 and vc7.0 use different naming. - if tag == 'vc': - if version.group(1) == '6': - # Cancel minor version. - version_string = '6' - elif version.group(1) == '7' and version.group(2) == '0': - version_string = '7' - - # On intel, version is not added, because it does not matter and it's the - # version of vc used as backend that matters. Ideally, we'd encode the - # backend version but that would break compatibility with V1. - elif tag == 'iw': - version_string = '' - - # On borland, version is not added for compatibility with V1. - elif tag == 'bcb': - version_string = '' - - if version_string is None: - version = version.group(1) + version.group(2) - - tag += version - - return tag - - -def threading_tag(name, target_type, prop_set): - tag = '' - properties = prop_set.raw() - if '<threading>multi' in properties: tag = 'mt' - - return tag - - -def runtime_tag(name, target_type, prop_set ): - tag = '' - - properties = prop_set.raw() - if '<runtime-link>static' in properties: tag += 's' - - # This is an ugly thing. In V1, there's a code to automatically detect which - # properties affect a target. So, if <runtime-debugging> does not affect gcc - # toolset, the tag rules won't even see <runtime-debugging>. Similar - # functionality in V2 is not implemented yet, so we just check for toolsets - # which are known to care about runtime debug. - if '<toolset>msvc' in properties \ - or '<stdlib>stlport' in properties \ - or '<toolset-intel:platform>win' in properties: - if '<runtime-debugging>on' in properties: tag += 'g' - - if '<python-debugging>on' in properties: tag += 'y' - if '<variant>debug' in properties: tag += 'd' - if '<stdlib>stlport' in properties: tag += 'p' - if '<stdlib-stlport:iostream>hostios' in properties: tag += 'n' - - return tag - - -## TODO: -##rule __test__ ( ) -##{ -## import assert ; -## -## local nl = " -##" ; -## -## local save-os = [ modules.peek os : .name ] ; -## -## modules.poke os : .name : LINUX ; -## -## assert.result "PATH=foo:bar:baz$(nl)export PATH$(nl)" -## : path-variable-setting-command PATH : foo bar baz ; -## -## assert.result "PATH=foo:bar:$PATH$(nl)export PATH$(nl)" -## : prepend-path-variable-command PATH : foo bar ; -## -## modules.poke os : .name : NT ; -## -## assert.result "set PATH=foo;bar;baz$(nl)" -## : path-variable-setting-command PATH : foo bar baz ; -## -## assert.result "set PATH=foo;bar;%PATH%$(nl)" -## : prepend-path-variable-command PATH : foo bar ; -## -## modules.poke os : .name : $(save-os) ; -##} - -def init(manager): - engine = manager.engine() - - engine.register_action("common.MkDir1-quick-fix-for-unix", 'mkdir -p "$(<)"') - engine.register_action("common.MkDir1-quick-fix-for-windows", 'if not exist "$(<)\\" mkdir "$(<)"') - - import b2.tools.make - import b2.build.alias - - global __RM, __CP, __IGNORE, __LN - # ported from trunk@47281 - if os_name() == 'NT': - __RM = 'del /f /q' - __CP = 'copy' - __IGNORE = '2>nul >nul & setlocal' - __LN = __CP - #if not __LN: - # __LN = CP - else: - __RM = 'rm -f' - __CP = 'cp' - __IGNORE = '' - __LN = 'ln' - - engine.register_action("common.Clean", __RM + ' "$(>)"', - flags=['piecemeal', 'together', 'existing']) - engine.register_action("common.copy", __CP + ' "$(>)" "$(<)"') - engine.register_action("common.RmTemps", __RM + ' "$(>)" ' + __IGNORE, - flags=['quietly', 'updated', 'piecemeal', 'together']) - - engine.register_action("common.hard-link", - __RM + ' "$(<)" 2$(NULL_OUT) $(NULL_OUT)' + os.linesep + - __LN + ' "$(>)" "$(<)" $(NULL_OUT)') |