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. """ from b2.build import toolset as b2_toolset if requirement is None: requirement = [] # The type checking here is my best guess about # what the types should be. assert(isinstance(toolset, str)) # iterable and not a string, allows for future support of sets assert(not isinstance(requirement, basestring) and hasattr(requirement, '__contains__')) 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 a requirement is specified, the signature should be unique # with that requirement if requirement: sig += '-' + '-'.join(requirement) 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) b2_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)]
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)]