diff options
| author | Chris Dyer <cdyer@cab.ark.cs.cmu.edu> | 2012-10-02 00:19:43 -0400 |
|---|---|---|
| committer | Chris Dyer <cdyer@cab.ark.cs.cmu.edu> | 2012-10-02 00:19:43 -0400 |
| commit | e26434979adc33bd949566ba7bf02dff64e80a3e (patch) | |
| tree | d1c72495e3af6301bd28e7e66c42de0c7a944d1f /jam-files/boost-build/util | |
| parent | 0870d4a1f5e14cc7daf553b180d599f09f6614a2 (diff) | |
cdec cleanup, remove bayesian stuff, parsing stuff
Diffstat (limited to 'jam-files/boost-build/util')
26 files changed, 0 insertions, 6469 deletions
diff --git a/jam-files/boost-build/util/__init__.py b/jam-files/boost-build/util/__init__.py deleted file mode 100644 index f80fe70e..00000000 --- a/jam-files/boost-build/util/__init__.py +++ /dev/null @@ -1,136 +0,0 @@ - -import bjam -import re -import types - -# Decorator the specifies bjam-side prototype for a Python function -def bjam_signature(s): - - def wrap(f): - f.bjam_signature = s - return f - - return wrap - -def metatarget(f): - - f.bjam_signature = (["name"], ["sources", "*"], ["requirements", "*"], - ["default_build", "*"], ["usage_requirements", "*"]) - return f - -class cached(object): - - def __init__(self, function): - self.function = function - self.cache = {} - - def __call__(self, *args): - try: - return self.cache[args] - except KeyError: - v = self.function(*args) - self.cache[args] = v - return v - - def __get__(self, instance, type): - return types.MethodType(self, instance, type) - -def unquote(s): - if s and s[0] == '"' and s[-1] == '"': - return s[1:-1] - else: - return s - -_extract_jamfile_and_rule = re.compile("(Jamfile<.*>)%(.*)") - -def qualify_jam_action(action_name, context_module): - - if action_name.startswith("###"): - # Callable exported from Python. Don't touch - return action_name - elif _extract_jamfile_and_rule.match(action_name): - # Rule is already in indirect format - return action_name - else: - ix = action_name.find('.') - if ix != -1 and action_name[:ix] == context_module: - return context_module + '%' + action_name[ix+1:] - - return context_module + '%' + action_name - - -def set_jam_action(name, *args): - - m = _extract_jamfile_and_rule.match(name) - if m: - args = ("set-update-action-in-module", m.group(1), m.group(2)) + args - else: - args = ("set-update-action", name) + args - - return bjam.call(*args) - - -def call_jam_function(name, *args): - - m = _extract_jamfile_and_rule.match(name) - if m: - args = ("call-in-module", m.group(1), m.group(2)) + args - return bjam.call(*args) - else: - return bjam.call(*((name,) + args)) - -__value_id = 0 -__python_to_jam = {} -__jam_to_python = {} - -def value_to_jam(value, methods=False): - """Makes a token to refer to a Python value inside Jam language code. - - The token is merely a string that can be passed around in Jam code and - eventually passed back. For example, we might want to pass PropertySet - instance to a tag function and it might eventually call back - to virtual_target.add_suffix_and_prefix, passing the same instance. - - For values that are classes, we'll also make class methods callable - from Jam. - - Note that this is necessary to make a bit more of existing Jamfiles work. - This trick should not be used to much, or else the performance benefits of - Python port will be eaten. - """ - - global __value_id - - r = __python_to_jam.get(value, None) - if r: - return r - - exported_name = '###_' + str(__value_id) - __value_id = __value_id + 1 - __python_to_jam[value] = exported_name - __jam_to_python[exported_name] = value - - if methods and type(value) == types.InstanceType: - for field_name in dir(value): - field = getattr(value, field_name) - if callable(field) and not field_name.startswith("__"): - bjam.import_rule("", exported_name + "." + field_name, field) - - return exported_name - -def record_jam_to_value_mapping(jam_value, python_value): - __jam_to_python[jam_value] = python_value - -def jam_to_value_maybe(jam_value): - - if type(jam_value) == type(""): - return __jam_to_python.get(jam_value, jam_value) - else: - return jam_value - -def stem(filename): - i = filename.find('.') - if i != -1: - return filename[0:i] - else: - return filename diff --git a/jam-files/boost-build/util/assert.jam b/jam-files/boost-build/util/assert.jam deleted file mode 100644 index abedad52..00000000 --- a/jam-files/boost-build/util/assert.jam +++ /dev/null @@ -1,336 +0,0 @@ -# Copyright 2001, 2002, 2003 Dave Abrahams -# Copyright 2006 Rene Rivera -# Copyright 2002, 2003 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) - -import errors ; -import modules ; - - -################################################################################ -# -# Private implementation details. -# -################################################################################ - -# Rule added as a replacement for the regular Jam = operator but which does not -# ignore trailing empty string elements. -# -local rule exact-equal-test ( lhs * : rhs * ) -{ - local lhs_extended = $(lhs) xxx ; - local rhs_extended = $(rhs) xxx ; - if $(lhs_extended) = $(rhs_extended) - { - return true ; - } -} - - -# Two lists are considered set-equal if they contain the same elements, ignoring -# duplicates and ordering. -# -local rule set-equal-test ( set1 * : set2 * ) -{ - if ( $(set1) in $(set2) ) && ( $(set2) in $(set1) ) - { - return true ; - } -} - - -################################################################################ -# -# Public interface. -# -################################################################################ - -# Assert the equality of A and B, ignoring trailing empty string elements. -# -rule equal ( a * : b * ) -{ - if $(a) != $(b) - { - errors.error-skip-frames 3 assertion failure: \"$(a)\" "==" \"$(b)\" - (ignoring trailing empty strings) ; - } -} - - -# Assert that the result of calling RULE-NAME on the given arguments has a false -# logical value (is either an empty list or all empty strings). -# -rule false ( rule-name args * : * ) -{ - local result ; - module [ CALLER_MODULE ] - { - modules.poke assert : result : [ $(1) : $(2) : $(3) : $(4) : $(5) : $(6) - : $(7) : $(8) : $(9) ] ; - } - - if $(result) - { - errors.error-skip-frames 3 assertion failure: Expected false result from - "[" $(rule-name) [ errors.lol->list $(args) : $(2) : $(3) : $(4) : - $(5) : $(6) : $(7) : $(8) : $(9) ] "]" : Got: "[" \"$(result)\" "]" ; - } -} - - -# Assert that ELEMENT is present in LIST. -# -rule "in" ( element : list * ) -{ - if ! $(element) in $(list) - { - errors.error-skip-frames 3 assertion failure: Expected \"$(element)\" in - "[" \"$(list)\" "]" ; - } -} - - -# Assert the inequality of A and B, ignoring trailing empty string elements. -# -rule not-equal ( a * : b * ) -{ - if $(a) = $(b) - { - errors.error-skip-frames 3 assertion failure: \"$(a)\" "!=" \"$(b)\" - (ignoring trailing empty strings) ; - } -} - - -# Assert that ELEMENT is not present in LIST. -# -rule not-in ( element : list * ) -{ - if $(element) in $(list) - { - errors.error-skip-frames 3 assertion failure: Did not expect - \"$(element)\" in "[" \"$(list)\" "]" ; - } -} - - -# Assert the inequality of A and B as sets. -# -rule not-set-equal ( a * : b * ) -{ - if [ set-equal-test $(a) : $(b) ] - { - errors.error-skip-frames 3 assertion failure: Expected "[" \"$(a)\" "]" - and "[" \"$(b)\" "]" to not be equal as sets ; - } -} - - -# Assert that A and B are not exactly equal, not ignoring trailing empty string -# elements. -# -rule not-exact-equal ( a * : b * ) -{ - if [ exact-equal-test $(a) : $(b) ] - { - errors.error-skip-frames 3 assertion failure: \"$(a)\" "!=" \"$(b)\" ; - } -} - - -# Assert that EXPECTED is the result of calling RULE-NAME with the given -# arguments. -# -rule result ( expected * : rule-name args * : * ) -{ - local result ; - module [ CALLER_MODULE ] - { - modules.poke assert : result : [ $(2) : $(3) : $(4) : $(5) : $(6) : $(7) - : $(8) : $(9) ] ; - } - - if ! [ exact-equal-test $(result) : $(expected) ] - { - errors.error-skip-frames 3 assertion failure: "[" $(rule-name) [ - errors.lol->list $(args) : $(3) : $(4) : $(5) : $(6) : $(7) : $(8) : - $(9) ] "]" : Expected: "[" \"$(expected)\" "]" : Got: "[" - \"$(result)\" "]" ; - } -} - - -# Assert that EXPECTED is set-equal (i.e. duplicates and ordering are ignored) -# to the result of calling RULE-NAME with the given arguments. Note that rules -# called this way may accept at most 8 parameters. -# -rule result-set-equal ( expected * : rule-name args * : * ) -{ - local result ; - module [ CALLER_MODULE ] - { - modules.poke assert : result : [ $(2) : $(3) : $(4) : $(5) : $(6) : $(7) - : $(8) : $(9) ] ; - } - - if ! [ set-equal-test $(result) : $(expected) ] - { - errors.error-skip-frames 3 assertion failure: "[" $(rule-name) [ - errors.lol->list $(args) : $(3) : $(4) : $(5) : $(6) : $(7) : $(8) : - $(9) ] "]" : Expected: "[" \"$(expected)\" "]" : Got: "[" - \"$(result)\" "]" ; - } -} - - -# Assert the equality of A and B as sets. -# -rule set-equal ( a * : b * ) -{ - if ! [ set-equal-test $(a) : $(b) ] - { - errors.error-skip-frames 3 assertion failure: Expected "[" \"$(a)\" "]" - and "[" \"$(b)\" "]" to be equal as sets ; - } -} - - -# Assert that the result of calling RULE-NAME on the given arguments has a true -# logical value (is neither an empty list nor all empty strings). -# -rule true ( rule-name args * : * ) -{ - local result ; - module [ CALLER_MODULE ] - { - modules.poke assert : result : [ $(1) : $(2) : $(3) : $(4) : $(5) : $(6) - : $(7) : $(8) : $(9) ] ; - } - - if ! $(result) - { - errors.error-skip-frames 3 assertion failure: Expected true result from - "[" $(rule-name) [ errors.lol->list $(args) : $(2) : $(3) : $(4) : - $(5) : $(6) : $(7) : $(8) : $(9) ] "]" ; - } -} - - -# Assert the exact equality of A and B, not ignoring trailing empty string -# elements. -# -rule exact-equal ( a * : b * ) -{ - if ! [ exact-equal-test $(a) : $(b) ] - { - errors.error-skip-frames 3 assertion failure: \"$(a)\" "==" \"$(b)\" ; - } -} - - -# Assert that the given variable is not an empty list. -# -rule variable-not-empty ( name ) -{ - local value = [ modules.peek [ CALLER_MODULE ] : $(name) ] ; - if ! $(value)-is-not-empty - { - errors.error-skip-frames 3 assertion failure: Expected variable - \"$(name)\" not to be an empty list ; - } -} - - -rule __test__ ( ) -{ - # Helper rule used to avoid test duplication related to different list - # equality test rules. - # - local rule run-equality-test ( equality-assert : ignore-trailing-empty-strings ? ) - { - local not-equality-assert = not-$(equality-assert) ; - - # When the given equality test is expected to ignore trailing empty - # strings some of the test results should be inverted. - local not-equality-assert-i = not-$(equality-assert) ; - if $(ignore-trailing-empty-strings) - { - not-equality-assert-i = $(equality-assert) ; - } - - $(equality-assert) : ; - $(equality-assert) "" "" : "" "" ; - $(not-equality-assert-i) : "" "" ; - $(equality-assert) x : x ; - $(not-equality-assert) : x ; - $(not-equality-assert) "" : x ; - $(not-equality-assert) "" "" : x ; - $(not-equality-assert-i) x : x "" ; - $(equality-assert) x "" : x "" ; - $(not-equality-assert) x : "" x ; - $(equality-assert) "" x : "" x ; - - $(equality-assert) 1 2 3 : 1 2 3 ; - $(not-equality-assert) 1 2 3 : 3 2 1 ; - $(not-equality-assert) 1 2 3 : 1 5 3 ; - $(not-equality-assert) 1 2 3 : 1 "" 3 ; - $(not-equality-assert) 1 2 3 : 1 1 2 3 ; - $(not-equality-assert) 1 2 3 : 1 2 2 3 ; - $(not-equality-assert) 1 2 3 : 5 6 7 ; - - # Extra variables used here just to make sure Boost Jam or Boost Build - # do not handle lists with empty strings differently depending on - # whether they are literals or stored in variables. - - local empty = ; - local empty-strings = "" "" ; - local x-empty-strings = x "" "" ; - local empty-strings-x = "" "" x ; - - $(equality-assert) : $(empty) ; - $(not-equality-assert-i) "" : $(empty) ; - $(not-equality-assert-i) "" "" : $(empty) ; - $(not-equality-assert-i) : $(empty-strings) ; - $(not-equality-assert-i) "" : $(empty-strings) ; - $(equality-assert) "" "" : $(empty-strings) ; - $(equality-assert) $(empty) : $(empty) ; - $(equality-assert) $(empty-strings) : $(empty-strings) ; - $(not-equality-assert-i) $(empty) : $(empty-strings) ; - $(equality-assert) $(x-empty-strings) : $(x-empty-strings) ; - $(equality-assert) $(empty-strings-x) : $(empty-strings-x) ; - $(not-equality-assert) $(empty-strings-x) : $(x-empty-strings) ; - $(not-equality-assert-i) x : $(x-empty-strings) ; - $(not-equality-assert) x : $(empty-strings-x) ; - $(not-equality-assert-i) x : $(x-empty-strings) ; - $(not-equality-assert-i) x "" : $(x-empty-strings) ; - $(equality-assert) x "" "" : $(x-empty-strings) ; - $(not-equality-assert) x : $(empty-strings-x) ; - $(not-equality-assert) "" x : $(empty-strings-x) ; - $(equality-assert) "" "" x : $(empty-strings-x) ; - } - - - # --------------- - # Equality tests. - # --------------- - - run-equality-test equal : ignore-trailing-empty-strings ; - run-equality-test exact-equal ; - - - # ------------------------- - # assert.set-equal() tests. - # ------------------------- - - set-equal : ; - not-set-equal "" "" : ; - set-equal "" "" : "" ; - set-equal "" "" : "" "" ; - set-equal a b c : a b c ; - set-equal a b c : b c a ; - set-equal a b c a : a b c ; - set-equal a b c : a b c a ; - not-set-equal a b c : a b c d ; - not-set-equal a b c d : a b c ; -} diff --git a/jam-files/boost-build/util/container.jam b/jam-files/boost-build/util/container.jam deleted file mode 100644 index dd496393..00000000 --- a/jam-files/boost-build/util/container.jam +++ /dev/null @@ -1,339 +0,0 @@ -# Copyright 2003 Dave Abrahams -# Copyright 2002, 2003 Rene Rivera -# Copyright 2002, 2003, 2004 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) - -# Various container classes. - -# Base for container objects. This lets us construct recursive structures. That -# is containers with containers in them, specifically so we can tell literal -# values from node values. -# -class node -{ - rule __init__ ( - value ? # Optional value to set node to initially. - ) - { - self.value = $(value) ; - } - - # Set the value of this node, passing nothing will clear it. - # - rule set ( value * ) - { - self.value = $(value) ; - } - - # Get the value of this node. - # - rule get ( ) - { - return $(self.value) ; - } -} - - -# A simple vector. Interface mimics the C++ std::vector and std::list, with the -# exception that indices are one (1) based to follow Jam standard. -# -# TODO: Possibly add assertion checks. -# -class vector : node -{ - import numbers ; - import utility ; - import sequence ; - - rule __init__ ( - values * # Initial contents of vector. - ) - { - node.__init__ ; - self.value = $(values) ; - } - - # Get the value of the first element. - # - rule front ( ) - { - return $(self.value[1]) ; - } - - # Get the value of the last element. - # - rule back ( ) - { - return $(self.value[-1]) ; - } - - # Get the value of the element at the given index, one based. Access to - # elements of recursive structures is supported directly. Specifying - # additional index values recursively accesses the elements as containers. - # For example: [ $(v).at 1 : 2 ] would retrieve the second element of our - # first element, assuming the first element is a container. - # - rule at ( - index # The element index, one based. - : * # Additional indices to access recursively. - ) - { - local r = $(self.value[$(index)]) ; - if $(2) - { - r = [ $(r).at $(2) : $(3) : $(4) : $(5) : $(6) : $(7) : $(8) : $(9) ] ; - } - return $(r) ; - } - - # Get the value contained in the given element. This has the same - # functionality and interface as "at" but in addition gets the value of the - # referenced element, assuming it is a "node". - # - rule get-at ( - index # The element index, one based. - : * # Additional indices to access recursively. - ) - { - local r = $(self.value[$(index)]) ; - if $(2) - { - r = [ $(r).at $(2) : $(3) : $(4) : $(5) : $(6) : $(7) : $(8) : $(9) ] ; - } - return [ $(r).get ] ; - } - - # Insert the given value into the front of the vector pushing the rest of - # the elements back. - # - rule push-front ( - value # Value to become first element. - ) - { - self.value = $(value) $(self.value) ; - } - - # Remove the front element from the vector. Does not return the value. No - # effect if vector is empty. - # - rule pop-front ( ) - { - self.value = $(self.value[2-]) ; - } - - # Add the given value at the end of the vector. - # - rule push-back ( - value # Value to become back element. - ) - { - self.value += $(value) ; - } - - # Remove the back element from the vector. Does not return the value. No - # effect if vector is empty. - # - rule pop-back ( ) - { - self.value = $(self.value[1--2]) ; - } - - # Insert the given value at the given index, one based. The values at and to - # the right of the index are pushed back to make room for the new value. - # If the index is passed the end of the vector the element is added to the - # end. - # - rule insert ( - index # The index to insert at, one based. - : value # The value to insert. - ) - { - local left = $(self.value[1-$(index)]) ; - local right = $(self.value[$(index)-]) ; - if $(right)-is-not-empty - { - left = $(left[1--2]) ; - } - self.value = $(left) $(value) $(right) ; - } - - # Remove one or more elements from the vector. The range is inclusive, and - # not specifying an end is equivalent to the [start, start] range. - # - rule erase ( - start # Index of first element to remove. - end ? # Optional, index of last element to remove. - ) - { - end ?= $(start) ; - local left = $(self.value[1-$(start)]) ; - left = $(left[1--2]) ; - local right = $(self.value[$(end)-]) ; - right = $(right[2-]) ; - self.value = $(left) $(right) ; - } - - # Remove all elements from the vector. - # - rule clear ( ) - { - self.value = ; - } - - # The number of elements in the vector. - # - rule size ( ) - { - return [ sequence.length $(self.value) ] ; - } - - # Returns "true" if there are NO elements in the vector, empty otherwise. - # - rule empty ( ) - { - if ! $(self.value)-is-not-empty - { - return true ; - } - } - - # Returns the textual representation of content. - # - rule str ( ) - { - return "[" [ sequence.transform utility.str : $(self.value) ] "]" ; - } - - # Sorts the vector inplace, calling 'utility.less' for comparisons. - # - rule sort ( ) - { - self.value = [ sequence.insertion-sort $(self.value) : utility.less ] ; - } - - # Returns true if content is equal to the content of other vector. Uses - # 'utility.equal' for comparison. - # - rule equal ( another ) - { - local mismatch ; - local size = [ size ] ; - if $(size) = [ $(another).size ] - { - for local i in [ numbers.range 1 $(size) ] - { - if ! [ utility.equal [ at $(i) ] [ $(another).at $(i) ] ] - { - mismatch = true ; - } - } - } - else - { - mismatch = true ; - } - - if ! $(mismatch) - { - return true ; - } - } -} - - -rule __test__ ( ) -{ - import assert ; - import "class" : new ; - - local v1 = [ new vector ] ; - assert.true $(v1).equal $(v1) ; - assert.true $(v1).empty ; - assert.result 0 : $(v1).size ; - assert.result "[" "]" : $(v1).str ; - $(v1).push-back b ; - $(v1).push-front a ; - assert.result "[" a b "]" : $(v1).str ; - assert.result a : $(v1).front ; - assert.result b : $(v1).back ; - $(v1).insert 2 : d ; - $(v1).insert 2 : c ; - $(v1).insert 4 : f ; - $(v1).insert 4 : e ; - $(v1).pop-back ; - assert.result 5 : $(v1).size ; - assert.result d : $(v1).at 3 ; - $(v1).pop-front ; - assert.result c : $(v1).front ; - assert.false $(v1).empty ; - $(v1).erase 3 4 ; - assert.result 2 : $(v1).size ; - - local v2 = [ new vector q w e r t y ] ; - assert.result 6 : $(v2).size ; - $(v1).push-back $(v2) ; - assert.result 3 : $(v1).size ; - local v2-alias = [ $(v1).back ] ; - assert.result e : $(v2-alias).at 3 ; - $(v1).clear ; - assert.true $(v1).empty ; - assert.false $(v2-alias).empty ; - $(v2).pop-back ; - assert.result t : $(v2-alias).back ; - - local v3 = [ new vector ] ; - $(v3).push-back [ new vector 1 2 3 4 5 ] ; - $(v3).push-back [ new vector a b c ] ; - assert.result "[" "[" 1 2 3 4 5 "]" "[" a b c "]" "]" : $(v3).str ; - $(v3).push-back [ new vector [ new vector x y z ] [ new vector 7 8 9 ] ] ; - assert.result 1 : $(v3).at 1 : 1 ; - assert.result b : $(v3).at 2 : 2 ; - assert.result a b c : $(v3).get-at 2 ; - assert.result 7 8 9 : $(v3).get-at 3 : 2 ; - - local v4 = [ new vector 4 3 6 ] ; - $(v4).sort ; - assert.result 3 4 6 : $(v4).get ; - assert.false $(v4).equal $(v3) ; - - local v5 = [ new vector 3 4 6 ] ; - assert.true $(v4).equal $(v5) ; - # Check that vectors of different sizes are considered non-equal. - $(v5).pop-back ; - assert.false $(v4).equal $(v5) ; - - local v6 = [ new vector [ new vector 1 2 3 ] ] ; - assert.true $(v6).equal [ new vector [ new vector 1 2 3 ] ] ; - - local v7 = [ new vector 111 222 333 ] ; - assert.true $(v7).equal $(v7) ; - $(v7).insert 4 : 444 ; - assert.result 111 222 333 444 : $(v7).get ; - $(v7).insert 999 : xxx ; - assert.result 111 222 333 444 xxx : $(v7).get ; - - local v8 = [ new vector "" "" "" ] ; - assert.true $(v8).equal $(v8) ; - assert.false $(v8).empty ; - assert.result 3 : $(v8).size ; - assert.result "" : $(v8).at 1 ; - assert.result "" : $(v8).at 2 ; - assert.result "" : $(v8).at 3 ; - assert.result : $(v8).at 4 ; - $(v8).insert 2 : 222 ; - assert.result 4 : $(v8).size ; - assert.result "" 222 "" "" : $(v8).get ; - $(v8).insert 999 : "" ; - assert.result 5 : $(v8).size ; - assert.result "" 222 "" "" "" : $(v8).get ; - $(v8).insert 999 : xxx ; - assert.result 6 : $(v8).size ; - assert.result "" 222 "" "" "" xxx : $(v8).get ; - - # Regression test for a bug causing vector.equal to compare only the first - # and the last element in the given vectors. - local v9 = [ new vector 111 xxx 222 ] ; - local v10 = [ new vector 111 yyy 222 ] ; - assert.false $(v9).equal $(v10) ; -} diff --git a/jam-files/boost-build/util/doc.jam b/jam-files/boost-build/util/doc.jam deleted file mode 100644 index a7515588..00000000 --- a/jam-files/boost-build/util/doc.jam +++ /dev/null @@ -1,997 +0,0 @@ -# Copyright 2002, 2005 Dave Abrahams -# Copyright 2002, 2003, 2006 Rene Rivera -# Copyright 2003 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) - -# Documentation system, handles --help requests. -# It defines rules that attach documentation to modules, rules, and variables. -# Collects and generates documentation for the various parts of the build -# system. The documentation is collected from comments integrated into the code. - -import modules ; -import print ; -import set ; -import container ; -import "class" ; -import sequence ; -import path ; - - -# The type of output to generate. -# "console" is formated text echoed to the console (the default); -# "text" is formated text appended to the output file; -# "html" is HTML output to the file. -# -help-output = console ; - - -# The file to output documentation to when generating "text" or "html" help. -# This is without extension as the extension is determined by the type of -# output. -# -help-output-file = help ; - -# Whether to include local rules in help output. -# -.option.show-locals ?= ; - -# When showing documentation for a module, whether to also generate -# automatically the detailed docs for each item in the module. -# -.option.detailed ?= ; - -# Generate debug output as the help is generated and modules are parsed. -# -.option.debug ?= ; - -# Enable or disable a documentation option. -# -local rule set-option ( - option # The option name. - : value ? # Enabled (non-empty), or disabled (empty) -) -{ - .option.$(option) = $(value) ; -} - - -# Set the type of output. -# -local rule set-output ( type ) -{ - help-output = $(type) ; -} - - -# Set the output to a file. -# -local rule set-output-file ( file ) -{ - help-output-file = $(file) ; -} - - -# Extracts the brief comment from a complete comment. The brief comment is the -# first sentence. -# -local rule brief-comment ( - docs * # The comment documentation. -) -{ - local d = $(docs:J=" ") ; - local p = [ MATCH ".*([.])$" : $(d) ] ; - if ! $(p) { d = $(d)"." ; } - d = $(d)" " ; - local m = [ MATCH "^([^.]+[.])(.*)" : $(d) ] ; - local brief = $(m[1]) ; - while $(m[2]) && [ MATCH "^([^ ])" : $(m[2]) ] - { - m = [ MATCH "^([^.]+[.])(.*)" : $(m[2]) ] ; - brief += $(m[1]) ; - } - return $(brief:J="") ; -} - - -# Specifies the documentation for the current module. -# -local rule set-module-doc ( - module-name ? # The name of the module to document. - : docs * # The documentation for the module. -) -{ - module-name ?= * ; - - $(module-name).brief = [ brief-comment $(docs) ] ; - $(module-name).docs = $(docs) ; - - if ! $(module-name) in $(documented-modules) - { - documented-modules += $(module-name) ; - } -} - - -# Specifies the documentation for the current module. -# -local rule set-module-copyright ( - module-name ? # The name of the module to document. - : copyright * # The copyright for the module. -) -{ - module-name ?= * ; - - $(module-name).copy-brief = [ brief-comment $(copyright) ] ; - $(module-name).copy-docs = $(docs) ; - - if ! $(module-name) in $(documented-modules) - { - documented-modules += $(module-name) ; - } -} - - -# Specifies the documentation for a rule in the current module. If called in the -# global module, this documents a global rule. -# -local rule set-rule-doc ( - name # The name of the rule. - module-name ? # The name of the module to document. - is-local ? # Whether the rule is local to the module. - : docs * # The documentation for the rule. -) -{ - module-name ?= * ; - - $(module-name).$(name).brief = [ brief-comment $(docs) ] ; - $(module-name).$(name).docs = $(docs) ; - $(module-name).$(name).is-local = $(is-local) ; - - if ! $(name) in $($(module-name).rules) - { - $(module-name).rules += $(name) ; - } -} - - -# Specify a class, will turn a rule into a class. -# -local rule set-class-doc ( - name # The name of the class. - module-name ? # The name of the module to document. - : super-name ? # The super class name. -) -{ - module-name ?= * ; - - $(module-name).$(name).is-class = true ; - $(module-name).$(name).super-name = $(super-name) ; - $(module-name).$(name).class-rules = - [ MATCH "^($(name)[.].*)" : $($(module-name).rules) ] ; - $(module-name).$($(module-name).$(name).class-rules).is-class-rule = true ; - - $(module-name).classes += $(name) ; - $(module-name).class-rules += $($(module-name).$(name).class-rules) ; - $(module-name).rules = - [ set.difference $($(module-name).rules) : - $(name) $($(module-name).$(name).class-rules) ] ; -} - - -# Set the argument call signature of a rule. -# -local rule set-rule-arguments-signature ( - name # The name of the rule. - module-name ? # The name of the module to document. - : signature * # The arguments signature. -) -{ - module-name ?= * ; - - $(module-name).$(name).signature = $(signature) ; -} - - -# Specifies the documentation for an argument of a rule. -# -local rule set-argument-doc ( - name # The name of the argument. - qualifier # Argument syntax qualifier, "*", "+", etc. - rule-name # The name of the rule. - module-name ? # THe optional name of the module. - : docs * # The documentation. -) -{ - module-name ?= * ; - - $(module-name).$(rule-name).args.$(name).qualifier = $(qualifier) ; - $(module-name).$(rule-name).args.$(name).docs = $(docs) ; - - if ! $(name) in $($(module-name).$(rule-name).args) - { - $(module-name).$(rule-name).args += $(name) ; - } -} - - -# Specifies the documentation for a variable in the current module. If called in -# the global module, the global variable is documented. -# -local rule set-variable-doc ( - name # The name of the variable. - default # The default value. - initial # The initial value. - module-name ? # The name of the module to document. - : docs * # The documentation for the variable. -) -{ - module-name ?= * ; - - $(module-name).$(name).brief = [ brief-comment $(docs) ] ; - $(module-name).$(name).default = $(default) ; - $(module-name).$(name).initial = $(initial) ; - $(module-name).$(name).docs = $(docs) ; - - if ! $(name) in $($(module-name).variables) - { - $(module-name).variables += $(name) ; - } -} - - -# Generates a general description of the documentation and help system. -# -local rule print-help-top ( ) -{ - print.section "General command line usage" ; - - print.text " bjam [options] [properties] [targets] - - Options, properties and targets can be specified in any order. - " ; - - print.section "Important Options" ; - - print.list-start ; - print.list-item "--clean Remove targets instead of building" ; - print.list-item "-a Rebuild everything" ; - print.list-item "-n Don't execute the commands, only print them" ; - print.list-item "-d+2 Show commands as they are executed" ; - print.list-item "-d0 Supress all informational messages" ; - print.list-item "-q Stop at first error" ; - print.list-item "--debug-configuration Diagnose configuration" ; - print.list-item "--debug-building Report which targets are built with what properties" ; - print.list-item "--debug-generator Diagnose generator search/execution" ; - print.list-end ; - - print.section "Further Help" - The following options can be used to obtain additional documentation. - ; - - print.list-start ; - print.list-item "--help-options Print more obscure command line options." ; - print.list-item "--help-internal Boost.Build implementation details." ; - print.list-item "--help-doc-options Implementation details doc formatting." ; - print.list-end ; -} - - -# Generate Jam/Boost.Jam command usage information. -# -local rule print-help-usage ( ) -{ - print.section "Boost.Jam Usage" - "bjam [ options... ] targets..." - ; - print.list-start ; - print.list-item -a; - Build all targets, even if they are current. ; - print.list-item -fx; - Read '"x"' as the Jamfile for building instead of searching for the - Boost.Build system. ; - print.list-item -jx; - Run up to '"x"' commands concurrently. ; - print.list-item -n; - Do not execute build commands. Instead print out the commands as they - would be executed if building. ; - print.list-item -ox; - Output the used build commands to file '"x"'. ; - print.list-item -q; - Quit as soon as a build failure is encountered. Without this option - Boost.Jam will continue building as many targets as it can. - print.list-item -sx=y; - Sets a Jam variable '"x"' to the value '"y"', overriding any value that - variable would have from the environment. ; - print.list-item -tx; - Rebuild the target '"x"', even if it is up-to-date. ; - print.list-item -v; - Display the version of bjam. ; - print.list-item --x; - Any option not explicitly handled by Boost.Jam remains available to - build scripts using the '"ARGV"' variable. ; - print.list-item -dn; - Enables output of diagnostic messages. The debug level '"n"' and all - below it are enabled by this option. ; - print.list-item -d+n; - Enables output of diagnostic messages. Only the output for debug level - '"n"' is enabled. ; - print.list-end ; - print.section "Debug Levels" - Each debug level shows a different set of information. Usually with - higher levels producing more verbose information. The following levels - are supported: ; - print.list-start ; - print.list-item 0; - Turn off all diagnostic output. Only errors are reported. ; - print.list-item 1; - Show the actions taken for building targets, as they are executed. ; - print.list-item 2; - Show "quiet" actions and display all action text, as they are executed. ; - print.list-item 3; - Show dependency analysis, and target/source timestamps/paths. ; - print.list-item 4; - Show arguments of shell invocations. ; - print.list-item 5; - Show rule invocations and variable expansions. ; - print.list-item 6; - Show directory/header file/archive scans, and attempts at binding to targets. ; - print.list-item 7; - Show variable settings. ; - print.list-item 8; - Show variable fetches, variable expansions, and evaluation of '"if"' expressions. ; - print.list-item 9; - Show variable manipulation, scanner tokens, and memory usage. ; - print.list-item 10; - Show execution times for rules. ; - print.list-item 11; - Show parsing progress of Jamfiles. ; - print.list-item 12; - Show graph for target dependencies. ; - print.list-item 13; - Show changes in target status (fate). ; - print.list-end ; -} - - -# Generates description of options controlling the help system. This -# automatically reads the options as all variables in the doc module of the form -# ".option.*". -# -local rule print-help-options ( - module-name # The doc module. -) -{ - print.section "Help Options" - These are all the options available for enabling or disabling to control - the help system in various ways. Options can be enabled or disabled with - '"--help-enable-<option>"', and "'--help-disable-<option>'" - respectively. - ; - local options-to-list = [ MATCH ^[.]option[.](.*) : $($(module-name).variables) ] ; - if $(options-to-list) - { - print.list-start ; - for local option in [ sequence.insertion-sort $(options-to-list) ] - { - local def = disabled ; - if $($(module-name)..option.$(option).default) != "(empty)" - { - def = enabled ; - } - print.list-item $(option): $($(module-name)..option.$(option).docs) - Default is $(def). ; - } - print.list-end ; - } -} - - -# Generate brief documentation for all the known items in the section for a -# module. Possible sections are: "rules", and "variables". -# -local rule print-help-module-section ( - module # The module name. - section # rules or variables. - : section-head # The title of the section. - section-description * # The detailed description of the section. -) -{ - if $($(module).$(section)) - { - print.section $(section-head) $(section-description) ; - print.list-start ; - for local item in [ sequence.insertion-sort $($(module).$(section)) ] - { - local show = ; - if ! $($(module).$(item).is-local) - { - show = yes ; - } - if $(.option.show-locals) - { - show = yes ; - } - if $(show) - { - print.list-item $(item): $($(module).$(item).brief) ; - } - } - print.list-end ; - } -} - - -# Generate documentation for all possible modules. We attempt to list all known -# modules together with a brief description of each. -# -local rule print-help-all ( - ignored # Usually the module name, but is ignored here. -) -{ - print.section "Modules" - "These are all the known modules. Use --help <module> to get more" - "detailed information." - ; - if $(documented-modules) - { - print.list-start ; - for local module-name in [ sequence.insertion-sort $(documented-modules) ] - { - # The brief docs for each module. - print.list-item $(module-name): $($(module-name).brief) ; - } - print.list-end ; - } - # The documentation for each module when details are requested. - if $(documented-modules) && $(.option.detailed) - { - for local module-name in [ sequence.insertion-sort $(documented-modules) ] - { - # The brief docs for each module. - print-help-module $(module-name) ; - } - } -} - - -# Generate documentation for a module. Basic information about the module is -# generated. -# -local rule print-help-module ( - module-name # The module to generate docs for. -) -{ - # Print the docs. - print.section "Module '$(module-name)'" $($(module-name).docs) ; - - # Print out the documented classes. - print-help-module-section $(module-name) classes : "Module '$(module-name)' classes" - Use --help $(module-name).<class-name> to get more information. ; - - # Print out the documented rules. - print-help-module-section $(module-name) rules : "Module '$(module-name)' rules" - Use --help $(module-name).<rule-name> to get more information. ; - - # Print out the documented variables. - print-help-module-section $(module-name) variables : "Module '$(module-name)' variables" - Use --help $(module-name).<variable-name> to get more information. ; - - # Print out all the same information but indetailed form. - if $(.option.detailed) - { - print-help-classes $(module-name) ; - print-help-rules $(module-name) ; - print-help-variables $(module-name) ; - } -} - - -# Generate documentation for a set of rules in a module. -# -local rule print-help-rules ( - module-name # Module of the rules. - : name * # Optional list of rules to describe. -) -{ - name ?= $($(module-name).rules) ; - if [ set.intersection $(name) : $($(module-name).rules) $($(module-name).class-rules) ] - { - # Print out the given rules. - for local rule-name in [ sequence.insertion-sort $(name) ] - { - if $(.option.show-locals) || ! $($(module-name).$(rule-name).is-local) - { - local signature = $($(module-name).$(rule-name).signature:J=" ") ; - signature ?= "" ; - print.section "Rule '$(module-name).$(rule-name) ( $(signature) )'" - $($(module-name).$(rule-name).docs) ; - if $($(module-name).$(rule-name).args) - { - print.list-start ; - for local arg-name in $($(module-name).$(rule-name).args) - { - print.list-item $(arg-name): $($(module-name).$(rule-name).args.$(arg-name).docs) ; - } - print.list-end ; - } - } - } - } -} - - -# Generate documentation for a set of classes in a module. -# -local rule print-help-classes ( - module-name # Module of the classes. - : name * # Optional list of classes to describe. -) -{ - name ?= $($(module-name).classes) ; - if [ set.intersection $(name) : $($(module-name).classes) ] - { - # Print out the given classes. - for local class-name in [ sequence.insertion-sort $(name) ] - { - if $(.option.show-locals) || ! $($(module-name).$(class-name).is-local) - { - local signature = $($(module-name).$(class-name).signature:J=" ") ; - signature ?= "" ; - print.section "Class '$(module-name).$(class-name) ( $(signature) )'" - $($(module-name).$(class-name).docs) - "Inherits from '"$($(module-name).$(class-name).super-name)"'." ; - if $($(module-name).$(class-name).args) - { - print.list-start ; - for local arg-name in $($(module-name).$(class-name).args) - { - print.list-item $(arg-name): $($(module-name).$(class-name).args.$(arg-name).docs) ; - } - print.list-end ; - } - } - - # Print out the documented rules of the class. - print-help-module-section $(module-name) $(class-name).class-rules : "Class '$(module-name).$(class-name)' rules" - Use --help $(module-name).<rule-name> to get more information. ; - - # Print out all the rules if details are requested. - if $(.option.detailed) - { - print-help-rules $(module-name) : $($(module-name).$(class-name).class-rules) ; - } - } - } -} - - -# Generate documentation for a set of variables in a module. -# -local rule print-help-variables ( - module-name ? # Module of the variables. - : name * # Optional list of variables to describe. -) -{ - name ?= $($(module-name).variables) ; - if [ set.intersection $(name) : $($(module-name).variables) ] - { - # Print out the given variables. - for local variable-name in [ sequence.insertion-sort $(name) ] - { - print.section "Variable '$(module-name).$(variable-name)'" $($(module-name).$(variable-name).docs) ; - if $($(module-name).$(variable-name).default) || - $($(module-name).$(variable-name).initial) - { - print.list-start ; - if $($(module-name).$(variable-name).default) - { - print.list-item "default value:" '$($(module-name).$(variable-name).default:J=" ")' ; - } - if $($(module-name).$(variable-name).initial) - { - print.list-item "initial value:" '$($(module-name).$(variable-name).initial:J=" ")' ; - } - print.list-end ; - } - } - } -} - - -# Generate documentation for a project. -# -local rule print-help-project ( - unused ? - : jamfile * # The project Jamfile. -) -{ - if $(jamfile<$(jamfile)>.docs) - { - # Print the docs. - print.section "Project-specific help" - Project has jamfile at $(jamfile) ; - - print.lines $(jamfile<$(jamfile)>.docs) "" ; - } -} - - -# Generate documentation for a config file. -# -local rule print-help-config ( - unused ? - : type # The type of configuration file user or site. - config-file # The configuration Jamfile. -) -{ - if $(jamfile<$(config-file)>.docs) - { - # Print the docs. - print.section "Configuration help" - Configuration file at $(config-file) ; - - print.lines $(jamfile<$(config-file)>.docs) "" ; - } -} - - -ws = " " ; - -# Extract the text from a block of comments. -# -local rule extract-comment ( - var # The name of the variable to extract from. -) -{ - local comment = ; - local line = $($(var)[1]) ; - local l = [ MATCH "^[$(ws)]*(#)(.*)$" : $(line) ] ; - while $(l[1]) && $($(var)) - { - if $(l[2]) { comment += [ MATCH "^[$(ws)]?(.*)$" : $(l[2]) ] ; } - else { comment += "" ; } - $(var) = $($(var)[2-]) ; - line = $($(var)[1]) ; - l = [ MATCH "^[$(ws)]*(#)(.*)$" : $(line) ] ; - } - return $(comment) ; -} - - -# Extract s single line of Jam syntax, ignoring any comments. -# -local rule extract-syntax ( - var # The name of the variable to extract from. -) -{ - local syntax = ; - local line = $($(var)[1]) ; - while ! $(syntax) && ! [ MATCH "^[$(ws)]*(#)" : $(line) ] && $($(var)) - { - local m = [ MATCH "^[$(ws)]*(.*)$" : $(line) ] ; - if $(m) && ! $(m) = "" - { - syntax = $(m) ; - } - $(var) = $($(var)[2-]) ; - line = $($(var)[1]) ; - } - return $(syntax) ; -} - - -# Extract the next token, this is either a single Jam construct or a comment as -# a single token. -# -local rule extract-token ( - var # The name of the variable to extract from. -) -{ - local parts = ; - while ! $(parts) - { - parts = [ MATCH "^[$(ws)]*([^$(ws)]+)[$(ws)]*(.*)" : $($(var)[1]) ] ; - if ! $(parts) - { - $(var) = $($(var)[2-]) ; - } - } - local token = ; - if [ MATCH "^(#)" : $(parts[1]) ] - { - token = $(parts:J=" ") ; - $(var) = $($(var)[2-]) ; - } - else - { - token = $(parts[1]) ; - $(var) = $(parts[2-]:J=" ") $($(var)[2-]) ; - } - return $(token) ; -} - - -# Scan for a rule declaration as the next item in the variable. -# -local rule scan-rule ( - syntax ? # The first part of the text which contains the rule declaration. - : var # The name of the variable to extract from. -) -{ - local rule-parts = - [ MATCH "^[$(ws)]*(rule|local[$(ws)]*rule)[$(ws)]+([^$(ws)]+)[$(ws)]*(.*)" : $(syntax:J=" ") ] ; - if $(rule-parts[1]) - { - # Mark as doc for rule. - local rule-name = $(rule-parts[2]) ; - if $(scope-name) - { - rule-name = $(scope-name).$(rule-name) ; - } - local is-local = [ MATCH "^(local).*" : $(rule-parts[1]) ] ; - if $(comment-block) - { - set-rule-doc $(rule-name) $(module-name) $(is-local) : $(comment-block) ; - } - # Parse args of rule. - $(var) = $(rule-parts[3-]) $($(var)) ; - set-rule-arguments-signature $(rule-name) $(module-name) : [ scan-rule-arguments $(var) ] ; - # Scan within this rules scope. - local scope-level = [ extract-token $(var) ] ; - local scope-name = $(rule-name) ; - while $(scope-level) - { - local comment-block = [ extract-comment $(var) ] ; - local syntax-block = [ extract-syntax $(var) ] ; - if [ scan-rule $(syntax-block) : $(var) ] - { - } - else if [ MATCH "^(\\{)" : $(syntax-block) ] - { - scope-level += "{" ; - } - else if [ MATCH "^[^\\}]*([\\}])[$(ws)]*$" : $(syntax-block) ] - { - scope-level = $(scope-level[2-]) ; - } - } - - return true ; - } -} - - -# Scan the arguments of a rule. -# -local rule scan-rule-arguments ( - var # The name of the variable to extract from. -) -{ - local arg-syntax = ; - local token = [ extract-token $(var) ] ; - while $(token) != "(" && $(token) != "{" - { - token = [ extract-token $(var) ] ; - } - if $(token) != "{" - { - token = [ extract-token $(var) ] ; - } - local arg-signature = ; - while $(token) != ")" && $(token) != "{" - { - local arg-name = ; - local arg-qualifier = " " ; - local arg-doc = ; - if $(token) = ":" - { - arg-signature += $(token) ; - token = [ extract-token $(var) ] ; - } - arg-name = $(token) ; - arg-signature += $(token) ; - token = [ extract-token $(var) ] ; - if [ MATCH "^([\\*\\+\\?])" : $(token) ] - { - arg-qualifier = $(token) ; - arg-signature += $(token) ; - token = [ extract-token $(var) ] ; - } - if $(token) = ":" - { - arg-signature += $(token) ; - token = [ extract-token $(var) ] ; - } - if [ MATCH "^(#)" : $(token) ] - { - $(var) = $(token) $($(var)) ; - arg-doc = [ extract-comment $(var) ] ; - token = [ extract-token $(var) ] ; - } - set-argument-doc $(arg-name) $(arg-qualifier) $(rule-name) $(module-name) : $(arg-doc) ; - } - while $(token) != "{" - { - token = [ extract-token $(var) ] ; - } - $(var) = "{" $($(var)) ; - arg-signature ?= "" ; - return $(arg-signature) ; -} - - -# Scan for a variable declaration. -# -local rule scan-variable ( - syntax ? # The first part of the text which contains the variable declaration. - : var # The name of the variable to extract from. -) -{ - # [1] = name, [2] = value(s) - local var-parts = - [ MATCH "^[$(ws)]*([^$(ws)]+)[$(ws)]+([\\?\\=]*)[$(ws)]+([^\\;]*)\\;" : $(syntax) ] ; - if $(var-parts) - { - local value = [ MATCH "^(.*)[ ]$" : $(var-parts[3-]:J=" ") ] ; - local default-value = "" ; - local initial-valie = "" ; - if $(var-parts[2]) = "?=" - { - default-value = $(value) ; - default-value ?= "(empty)" ; - } - else - { - initial-value = $(value) ; - initial-value ?= "(empty)" ; - } - if $(comment-block) - { - set-variable-doc $(var-parts[1]) $(default-value) $(initial-value) $(module-name) : $(comment-block) ; - } - return true ; - } -} - - -# Scan a class declaration. -# -local rule scan-class ( - syntax ? # The syntax text for the class declaration. -) -{ - # [1] = class?, [2] = name, [3] = superclass - local class-parts = - [ MATCH "^[$(ws)]*([^$(ws)]+)[$(ws)]+([^$(ws)]+)[$(ws)]+:*[$(ws)]*([^$(ws);]*)" : $(syntax) ] ; - if $(class-parts[1]) = "class" || $(class-parts[1]) = "class.class" - { - set-class-doc $(class-parts[2]) $(module-name) : $(class-parts[3]) ; - } -} - - -# Scan a module file for documentation comments. This also invokes any actions -# assigned to the module. The actions are the rules that do the actual output of -# the documentation. This rule is invoked as the header scan rule for the module -# file. -# -rule scan-module ( - target # The module file. - : text * # The text in the file, one item per line. - : action * # Rule to call to output docs for the module. -) -{ - if $(.option.debug) { ECHO "HELP:" scanning module target '$(target)' ; } - local module-name = $(target:B) ; - local module-documented = ; - local comment-block = ; - local syntax-block = ; - # This is a hack because we can not get the line of a file if it happens to - # not have a new-line termination. - text += "}" ; - while $(text) - { - comment-block = [ extract-comment text ] ; - syntax-block = [ extract-syntax text ] ; - if $(.option.debug) - { - ECHO "HELP:" comment block; '$(comment-block)' ; - ECHO "HELP:" syntax block; '$(syntax-block)' ; - } - if [ scan-rule $(syntax-block) : text ] { } - else if [ scan-variable $(syntax-block) : text ] { } - else if [ scan-class $(syntax-block) ] { } - else if [ MATCH .*([cC]opyright).* : $(comment-block:J=" ") ] - { - # mark as the copy for the module. - set-module-copyright $(module-name) : $(comment-block) ; - } - else if $(action[1]) in "print-help-project" "print-help-config" - && ! $(jamfile<$(target)>.docs) - { - # special module docs for the project jamfile. - jamfile<$(target)>.docs = $(comment-block) ; - } - else if ! $(module-documented) - { - # document the module. - set-module-doc $(module-name) : $(comment-block) ; - module-documented = true ; - } - } - if $(action) - { - $(action[1]) $(module-name) : $(action[2-]) ; - } -} - - -# Import scan-module to global scope, so that it is available during header -# scanning phase. -# -IMPORT $(__name__) : scan-module : : doc.scan-module ; - - -# Read in a file using the SHELL builtin and return the individual lines as -# would be done for header scanning. -# -local rule read-file ( - file # The file to read in. -) -{ - file = [ path.native [ path.root [ path.make $(file) ] [ path.pwd ] ] ] ; - if ! $(.file<$(file)>.lines) - { - local content ; - switch [ modules.peek : OS ] - { - case NT : - content = [ SHELL "TYPE \"$(file)\"" ] ; - - case * : - content = [ SHELL "cat \"$(file)\"" ] ; - } - local lines ; - local nl = " -" ; - local << = "([^$(nl)]*)[$(nl)](.*)" ; - local line+ = [ MATCH "$(<<)" : "$(content)" ] ; - while $(line+) - { - lines += $(line+[1]) ; - line+ = [ MATCH "$(<<)" : "$(line+[2])" ] ; - } - .file<$(file)>.lines = $(lines) ; - } - return $(.file<$(file)>.lines) ; -} - - -# Add a scan action to perform to generate the help documentation. The action -# rule is passed the name of the module as the first argument. The second -# argument(s) are optional and passed directly as specified here. -# -local rule do-scan ( - modules + # The modules to scan and perform the action on. - : action * # The action rule, plus the secondary arguments to pass to the action rule. -) -{ - if $(help-output) = text - { - print.output $(help-output-file).txt plain ; - ALWAYS $(help-output-file).txt ; - DEPENDS all : $(help-output-file).txt ; - } - if $(help-output) = html - { - print.output $(help-output-file).html html ; - ALWAYS $(help-output-file).html ; - DEPENDS all : $(help-output-file).html ; - } - for local module-file in $(modules[1--2]) - { - scan-module $(module-file) : [ read-file $(module-file) ] ; - } - scan-module $(modules[-1]) : [ read-file $(modules[-1]) ] : $(action) ; -} diff --git a/jam-files/boost-build/util/indirect.jam b/jam-files/boost-build/util/indirect.jam deleted file mode 100644 index ec63f192..00000000 --- a/jam-files/boost-build/util/indirect.jam +++ /dev/null @@ -1,115 +0,0 @@ -# Copyright 2003 Dave Abrahams -# Copyright 2003 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) - -import modules ; -import numbers ; - - -# The pattern that indirect rules must match: module%rule -.pattern = ^([^%]*)%([^%]+)$ ; - - -# -# Type checking rules. -# -local rule indirect-rule ( x ) -{ - if ! [ MATCH $(.pattern) : $(x) ] - { - return "expected a string of the form module%rule, but got \""$(x)"\" for argument" ; - } -} - - -# Make an indirect rule which calls the given rule. If context is supplied it is -# expected to be the module in which to invoke the rule by the 'call' rule -# below. Otherwise, the rule will be invoked in the module of this rule's -# caller. -# -rule make ( rulename bound-args * : context ? ) -{ - context ?= [ CALLER_MODULE ] ; - context ?= "" ; - return $(context)%$(rulename) $(bound-args) ; -} - - -# Make an indirect rule which calls the given rule. 'rulename' may be a -# qualified rule; if so it is returned unchanged. Otherwise, if frames is not -# supplied, the result will be invoked (by 'call', below) in the module of the -# caller. Otherwise, frames > 1 specifies additional call frames to back up in -# order to find the module context. -# -rule make-qualified ( rulename bound-args * : frames ? ) -{ - if [ MATCH $(.pattern) : $(rulename) ] - { - return $(rulename) $(bound-args) ; - } - else - { - frames ?= 1 ; - # If the rule name includes a Jamfile module, grab it. - local module-context = [ MATCH ^(Jamfile<[^>]*>)\\..* : $(rulename) ] ; - - if ! $(module-context) - { - # Take the first dot-separated element as module name. This disallows - # module names with dots, but allows rule names with dots. - module-context = [ MATCH ^([^.]*)\\..* : $(rulename) ] ; - } - module-context ?= [ CALLER_MODULE $(frames) ] ; - return [ make $(rulename) $(bound-args) : $(module-context) ] ; - } -} - - -# Returns the module name in which the given indirect rule will be invoked. -# -rule get-module ( [indirect-rule] x ) -{ - local m = [ MATCH $(.pattern) : $(x) ] ; - if ! $(m[1]) - { - m = ; - } - return $(m[1]) ; -} - - -# Returns the rulename that will be called when x is invoked. -# -rule get-rule ( [indirect-rule] x ) -{ - local m = [ MATCH $(.pattern) : $(x) ] ; - return $(m[2]) ; -} - - -# Invoke the given indirect-rule. -# -rule call ( [indirect-rule] r args * : * ) -{ - return [ modules.call-in [ get-module $(r) ] : [ get-rule $(r) ] $(args) - : $(2) : $(3) : $(4) : $(5) : $(6) : $(7) : $(8) : $(9) ] ; -} - - -rule __test__ -{ - import assert ; - - rule foo-barr! ( x ) - { - assert.equal $(x) : x ; - } - - assert.equal [ get-rule [ make foo-barr! ] ] : foo-barr! ; - assert.equal [ get-module [ make foo-barr! ] ] : [ CALLER_MODULE ] ; - - call [ make foo-barr! ] x ; - call [ make foo-barr! x ] ; - call [ make foo-barr! : [ CALLER_MODULE ] ] x ; -} diff --git a/jam-files/boost-build/util/indirect.py b/jam-files/boost-build/util/indirect.py deleted file mode 100644 index 78fa8994..00000000 --- a/jam-files/boost-build/util/indirect.py +++ /dev/null @@ -1,15 +0,0 @@ -# Status: minimally ported. This module is not supposed to be used much -# with Boost.Build/Python. -# -# Copyright 2003 Dave Abrahams -# Copyright 2003 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) - -from b2.util import call_jam_function, bjam_signature - -def call(*args): - a1 = args[0] - name = a1[0] - a1tail = a1[1:] - call_jam_function(name, *((a1tail,) + args[1:])) diff --git a/jam-files/boost-build/util/logger.py b/jam-files/boost-build/util/logger.py deleted file mode 100644 index de652129..00000000 --- a/jam-files/boost-build/util/logger.py +++ /dev/null @@ -1,46 +0,0 @@ -# Copyright Pedro Ferreira 2005. Distributed under the Boost -# Software License, Version 1.0. (See accompanying -# file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) - -import sys - -class NullLogger: - def __init__ (self): - self.indent_ = '' - - def log (self, source_name, *args): - if self.on () and self.interesting (source_name): - self.do_log (self.indent_) - for i in args: - self.do_log (i) - self.do_log ('\n') - - def increase_indent (self): - if self.on (): - self.indent_ += ' ' - - def decrease_indent (self): - if self.on () and len (self.indent_) > 4: - self.indent_ = self.indent_ [-4:] - - def do_log (self, *args): - pass - - def interesting (self, source_name): - return False - - def on (self): - return True - -class TextLogger (NullLogger): - def __init__ (self): - NullLogger.__init__ (self) - - def do_log (self, arg): - sys.stdout.write (str (arg)) - - def interesting (self, source_name): - return True - - def on (self): - return True diff --git a/jam-files/boost-build/util/numbers.jam b/jam-files/boost-build/util/numbers.jam deleted file mode 100644 index 665347d3..00000000 --- a/jam-files/boost-build/util/numbers.jam +++ /dev/null @@ -1,218 +0,0 @@ -# Copyright 2001, 2002 Dave Abrahams -# Copyright 2002, 2003 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) - -import errors ; - - -rule trim-leading-zeroes ( value ) -{ - return [ CALC $(value) + 0 ] ; -} - - -rule check ( numbers * ) -{ - for local n in $(numbers) - { - switch $(n) - { - case *[^0-9]* : - errors.error $(n) "in" $(numbers) : is not a number ; - } - } -} - - -rule increment ( number ) -{ - return [ CALC $(number) + 1 ] ; -} - - -rule decrement ( number ) -{ - return [ CALC $(number) - 1 ] ; -} - - -rule range ( start finish ? : step ? ) -{ - if ! $(finish) - { - finish = $(start) ; - start = 1 ; - } - step ?= 1 ; - - check $(start) $(finish) $(step) ; - - if $(finish) != 0 - { - local result ; - while [ less $(start) $(finish) ] || $(start) = $(finish) - { - result += $(start) ; - start = [ CALC $(start) + $(step) ] ; - } - return $(result) ; - } -} - - -rule less ( n1 n2 ) -{ - switch [ CALC $(n2) - $(n1) ] - { - case [1-9]* : return true ; - } -} - - -rule log10 ( number ) -{ - switch $(number) - { - case *[^0-9]* : errors.error $(number) is not a number ; - case 0 : errors.error can't take log of zero ; - case [1-9] : return 0 ; - case [1-9]? : return 1 ; - case [1-9]?? : return 2 ; - case [1-9]??? : return 3 ; - case [1-9]???? : return 4 ; - case [1-9]????? : return 5 ; - case [1-9]?????? : return 6 ; - case [1-9]??????? : return 7 ; - case [1-9]???????? : return 8 ; - case [1-9]????????? : return 9 ; - case * : - { - import sequence ; - import string ; - local chars = [ string.chars $(number) ] ; - while $(chars[1]) = 0 - { - chars = $(chars[2-]) ; - } - if ! $(chars) - { - errors.error can't take log of zero ; - } - else - { - return [ decrement [ sequence.length $(chars) ] ] ; - } - } - } -} - - -rule __test__ ( ) -{ - import assert ; - - assert.result 1 : increment 0 ; - assert.result 2 : increment 1 ; - assert.result 1 : decrement 2 ; - assert.result 0 : decrement 1 ; - assert.result 50 : increment 49 ; - assert.result 49 : decrement 50 ; - assert.result 99 : increment 98 ; - assert.result 99 : decrement 100 ; - assert.result 100 : increment 99 ; - assert.result 999 : decrement 1000 ; - assert.result 1000 : increment 999 ; - - assert.result 1 2 3 : range 3 ; - assert.result 1 2 3 4 5 6 7 8 9 10 11 12 : range 12 ; - assert.result 3 4 5 6 7 8 9 10 11 : range 3 11 ; - assert.result : range 0 ; - assert.result 1 4 7 10 : range 10 : 3 ; - assert.result 2 4 6 8 10 : range 2 10 : 2 ; - assert.result 25 50 75 100 : range 25 100 : 25 ; - - assert.result 0 : trim-leading-zeroes 0 ; - assert.result 1234 : trim-leading-zeroes 1234 ; - assert.result 123456 : trim-leading-zeroes 0000123456 ; - assert.result 1000123456 : trim-leading-zeroes 1000123456 ; - assert.result 10000 : trim-leading-zeroes 10000 ; - assert.result 10000 : trim-leading-zeroes 00010000 ; - - assert.true less 1 2 ; - assert.true less 1 12 ; - assert.true less 1 21 ; - assert.true less 005 217 ; - assert.false less 0 0 ; - assert.false less 03 3 ; - assert.false less 3 03 ; - assert.true less 005 217 ; - assert.true less 0005 217 ; - assert.true less 5 00217 ; - - # TEMPORARY disabled, because nested "try"/"catch" do not work and I do no - # have the time to fix that right now. - if $(0) - { - try ; - { - decrement 0 ; - } - catch can't decrement zero! ; - - try ; - { - check foo ; - } - catch : not a number ; - - try ; - { - increment foo ; - } - catch : not a number ; - - try ; - { - log10 0 ; - } - catch can't take log of zero ; - - try ; - { - log10 000 ; - } - catch can't take log of zero ; - - } - - assert.result 0 : log10 1 ; - assert.result 0 : log10 9 ; - assert.result 1 : log10 10 ; - assert.result 1 : log10 99 ; - assert.result 2 : log10 100 ; - assert.result 2 : log10 101 ; - assert.result 2 : log10 125 ; - assert.result 2 : log10 999 ; - assert.result 3 : log10 1000 ; - assert.result 10 : log10 12345678901 ; - - for local x in [ range 75 110 : 5 ] - { - for local y in [ range $(x) 111 : 3 ] - { - if $(x) != $(y) - { - assert.true less $(x) $(y) ; - } - } - } - - for local x in [ range 90 110 : 2 ] - { - for local y in [ range 80 $(x) : 4 ] - { - assert.false less $(x) $(y) ; - } - } -} diff --git a/jam-files/boost-build/util/option.jam b/jam-files/boost-build/util/option.jam deleted file mode 100644 index f6dc3752..00000000 --- a/jam-files/boost-build/util/option.jam +++ /dev/null @@ -1,109 +0,0 @@ -# Copyright (c) 2005 Vladimir Prus. -# -# Use, modification and distribution is subject to the Boost Software -# License Version 1.0. (See accompanying file LICENSE_1_0.txt or -# http://www.boost.org/LICENSE_1_0.txt) - -import modules ; - -# Set a value for a named option, to be used when not overridden on the command -# line. -rule set ( name : value ? ) -{ - .option.$(name) = $(value) ; -} - -rule get ( name : default-value ? : implied-value ? ) -{ - local m = [ MATCH --$(name)=(.*) : [ modules.peek : ARGV ] ] ; - if $(m) - { - return $(m[1]) ; - } - else - { - m = [ MATCH (--$(name)) : [ modules.peek : ARGV ] ] ; - if $(m) && $(implied-value) - { - return $(implied-value) ; - } - else if $(.option.$(name)) - { - return $(.option.$(name)) ; - } - else - { - return $(default-value) ; - } - } -} - - -# Check command-line args as soon as possible. For each option try to load -# module named after option. Is that succeeds, invoke 'process' rule in the -# module. The rule may return "true" to indicate that the regular build process -# should not be attempted. -# -# Options take the general form of: --<name>[=<value>] [<value>] -# -rule process ( ) -{ - local ARGV = [ modules.peek : ARGV ] ; - local BOOST_BUILD_PATH = [ modules.peek : BOOST_BUILD_PATH ] ; - - local dont-build ; - local args = $(ARGV) ; - while $(args) - { - local arg = [ MATCH ^--(.*) : $(args[1]) ] ; - while $(args[2-]) && ! $(arg) - { - args = $(args[2-]) ; - arg = [ MATCH ^--(.*) : $(args[1]) ] ; - } - args = $(args[2-]) ; - - if $(arg) - { - local split = [ MATCH ^(([^-=]+)[^=]*)(=?)(.*)$ : $(arg) ] ; - local full-name = $(split[1]) ; - local prefix = $(split[2]) ; - local values ; - - if $(split[3]) - { - values = $(split[4]) ; - } - if $(args) && ! [ MATCH ^(--).* : $(args[1]) ] - { - values += $(args[1]) ; - args = $(args[2-]) ; - } - - # Jook in options subdirectories of BOOST_BUILD_PATH for modules - # matching the full option name and then its prefix. - local plugin-dir = options ; - local option-files = [ GLOB $(plugin-dir:D=$(BOOST_BUILD_PATH)) : - $(full-name).jam $(prefix).jam ] ; - - if $(option-files) - { - # Load the file into a module named for the option. - local f = $(option-files[1]) ; - local module-name = --$(f:D=:S=) ; - modules.load $(module-name) : $(f:D=) : $(f:D) ; - - # If there is a process rule, call it with the full option name - # and its value (if any). If there was no "=" in the option, the - # value will be empty. - if process in [ RULENAMES $(module-name) ] - { - dont-build += [ modules.call-in $(module-name) : process - --$(full-name) : $(values) ] ; - } - } - } - } - - return $(dont-build) ; -} diff --git a/jam-files/boost-build/util/option.py b/jam-files/boost-build/util/option.py deleted file mode 100644 index 47d6abdf..00000000 --- a/jam-files/boost-build/util/option.py +++ /dev/null @@ -1,35 +0,0 @@ -# Copyright (c) 2005-2010 Vladimir Prus. -# -# Use, modification and distribution is subject to the Boost Software -# License Version 1.0. (See accompanying file LICENSE_1_0.txt or -# http://www.boost.org/LICENSE_1_0.txt) - -import sys -import re -import b2.util.regex - -options = {} - -# Set a value for a named option, to be used when not overridden on the command -# line. -def set(name, value=None): - - global options - - options[name] = value - -def get(name, default_value=None, implied_value=None): - - global options - - matches = b2.util.regex.transform(sys.argv, "--" + re.escape(name) + "=(.*)") - if matches: - return matches[-1] - else: - m = b2.util.regex.transform(sys.argv, "--(" + re.escape(name) + ")") - if m and implied_value: - return implied_value - elif options.has_key(name) and options[name] != None: - return options[name] - else: - return default_value diff --git a/jam-files/boost-build/util/order.jam b/jam-files/boost-build/util/order.jam deleted file mode 100644 index a74fc8c8..00000000 --- a/jam-files/boost-build/util/order.jam +++ /dev/null @@ -1,169 +0,0 @@ -# Copyright (C) 2003 Vladimir Prus -# Use, modification, and distribution is subject to the Boost Software -# License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy -# at http://www.boost.org/LICENSE_1_0.txt) - -# This module defines a class which allows to order arbitrary object with -# regard to arbitrary binary relation. -# -# The primary use case is the gcc toolset, which is sensitive to library order: -# if library 'a' uses symbols from library 'b', then 'a' must be present before -# 'b' on the linker's command line. -# -# This requirement can be lifted for gcc with GNU ld, but for gcc with Solaris -# LD (and for Solaris toolset as well), the order always matters. -# -# So, we need to store order requirements and then order libraries according to -# them. It is not possible to use the dependency graph as order requirements. -# What we need is a "use symbols" relationship while dependency graph provides -# the "needs to be updated" relationship. -# -# For example:: -# lib a : a.cpp b; -# lib b ; -# -# For static linking, library 'a' need not depend on 'b'. However, it should -# still come before 'b' on the command line. - -class order -{ - rule __init__ ( ) - { - } - - # Adds the constraint that 'first' should preceede 'second'. - rule add-pair ( first second ) - { - .constraits += $(first)--$(second) ; - } - NATIVE_RULE class@order : add-pair ; - - # Given a list of objects, reorder them so that the constraints specified by - # 'add-pair' are satisfied. - # - # The algorithm was adopted from an awk script by Nikita Youshchenko - # (yoush at cs dot msu dot su) - rule order ( objects * ) - { - # The algorithm used is the same is standard transitive closure, except - # that we're not keeping in-degree for all vertices, but rather removing - # edges. - local result ; - if $(objects) - { - local constraints = [ eliminate-unused-constraits $(objects) ] ; - - # Find some library that nobody depends upon and add it to the - # 'result' array. - local obj ; - while $(objects) - { - local new_objects ; - while $(objects) - { - obj = $(objects[1]) ; - if [ has-no-dependents $(obj) : $(constraints) ] - { - # Emulate break ; - new_objects += $(objects[2-]) ; - objects = ; - } - else - { - new_objects += $(obj) ; - obj = ; - objects = $(objects[2-]) ; - } - } - - if ! $(obj) - { - errors.error "Circular order dependencies" ; - } - # No problem with placing first. - result += $(obj) ; - # Remove all contraints where 'obj' comes first, since they are - # already satisfied. - constraints = [ remove-satisfied $(constraints) : $(obj) ] ; - - # Add the remaining objects for further processing on the next - # iteration - objects = $(new_objects) ; - } - - } - return $(result) ; - } - NATIVE_RULE class@order : order ; - - # Eliminate constraints which mention objects not in 'objects'. In - # graph-theory terms, this is finding a subgraph induced by ordered - # vertices. - rule eliminate-unused-constraits ( objects * ) - { - local result ; - for local c in $(.constraints) - { - local m = [ MATCH (.*)--(.*) : $(c) ] ; - if $(m[1]) in $(objects) && $(m[2]) in $(objects) - { - result += $(c) ; - } - } - return $(result) ; - } - - # Returns true if there's no constraint in 'constaraints' where 'obj' comes - # second. - rule has-no-dependents ( obj : constraints * ) - { - local failed ; - while $(constraints) && ! $(failed) - { - local c = $(constraints[1]) ; - local m = [ MATCH (.*)--(.*) : $(c) ] ; - if $(m[2]) = $(obj) - { - failed = true ; - } - constraints = $(constraints[2-]) ; - } - if ! $(failed) - { - return true ; - } - } - - rule remove-satisfied ( constraints * : obj ) - { - local result ; - for local c in $(constraints) - { - local m = [ MATCH (.*)--(.*) : $(c) ] ; - if $(m[1]) != $(obj) - { - result += $(c) ; - } - } - return $(result) ; - } -} - - -rule __test__ ( ) -{ - import "class" : new ; - import assert ; - - c1 = [ new order ] ; - $(c1).add-pair l1 l2 ; - - assert.result l1 l2 : $(c1).order l1 l2 ; - assert.result l1 l2 : $(c1).order l2 l1 ; - - $(c1).add-pair l2 l3 ; - assert.result l1 l2 : $(c1).order l2 l1 ; - $(c1).add-pair x l2 ; - assert.result l1 l2 : $(c1).order l2 l1 ; - assert.result l1 l2 l3 : $(c1).order l2 l3 l1 ; -} diff --git a/jam-files/boost-build/util/order.py b/jam-files/boost-build/util/order.py deleted file mode 100644 index 4e67b3f1..00000000 --- a/jam-files/boost-build/util/order.py +++ /dev/null @@ -1,121 +0,0 @@ -# Copyright (C) 2003 Vladimir Prus -# Use, modification, and distribution is subject to the Boost Software -# License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy -# at http://www.boost.org/LICENSE_1_0.txt) - -class Order: - """Allows ordering arbitrary objects with regard to arbitrary binary relation. - - The primary use case is the gcc toolset, which is sensitive to - library order: if library 'a' uses symbols from library 'b', - then 'a' must be present before 'b' on the linker's command line. - - This requirement can be lifted for gcc with GNU ld, but for gcc with - Solaris LD (and for Solaris toolset as well), the order always matters. - - So, we need to store order requirements and then order libraries - according to them. It it not possible to use dependency graph as - order requirements. What we need is "use symbols" relationship - while dependency graph provides "needs to be updated" relationship. - - For example:: - lib a : a.cpp b; - lib b ; - - For static linking, the 'a' library need not depend on 'b'. However, it - still should come before 'b' on the command line. - """ - - def __init__ (self): - self.constraints_ = [] - - def add_pair (self, first, second): - """ Adds the constraint that 'first' should precede 'second'. - """ - self.constraints_.append ((first, second)) - - def order (self, objects): - """ Given a list of objects, reorder them so that the constains specified - by 'add_pair' are satisfied. - - The algorithm was adopted from an awk script by Nikita Youshchenko - (yoush at cs dot msu dot su) - """ - # The algorithm used is the same is standard transitive closure, - # except that we're not keeping in-degree for all vertices, but - # rather removing edges. - result = [] - - if not objects: - return result - - constraints = self.__eliminate_unused_constraits (objects) - - # Find some library that nobody depends upon and add it to - # the 'result' array. - obj = None - while objects: - new_objects = [] - while objects: - obj = objects [0] - - if self.__has_no_dependents (obj, constraints): - # Emulate break ; - new_objects.extend (objects [1:]) - objects = [] - - else: - new_objects.append (obj) - obj = None - objects = objects [1:] - - if not obj: - raise BaseException ("Circular order dependencies") - - # No problem with placing first. - result.append (obj) - - # Remove all containts where 'obj' comes first, - # since they are already satisfied. - constraints = self.__remove_satisfied (constraints, obj) - - # Add the remaining objects for further processing - # on the next iteration - objects = new_objects - - return result - - def __eliminate_unused_constraits (self, objects): - """ Eliminate constraints which mention objects not in 'objects'. - In graph-theory terms, this is finding subgraph induced by - ordered vertices. - """ - result = [] - for c in self.constraints_: - if c [0] in objects and c [1] in objects: - result.append (c) - - return result - - def __has_no_dependents (self, obj, constraints): - """ Returns true if there's no constraint in 'constraints' where - 'obj' comes second. - """ - failed = False - while constraints and not failed: - c = constraints [0] - - if c [1] == obj: - failed = True - - constraints = constraints [1:] - - return not failed - - def __remove_satisfied (self, constraints, obj): - result = [] - for c in constraints: - if c [0] != obj: - result.append (c) - - return result diff --git a/jam-files/boost-build/util/os.jam b/jam-files/boost-build/util/os.jam deleted file mode 100644 index daef27f7..00000000 --- a/jam-files/boost-build/util/os.jam +++ /dev/null @@ -1,171 +0,0 @@ -# Copyright 2001, 2002, 2003, 2005 Dave Abrahams -# Copyright 2006 Rene Rivera -# Copyright 2003, 2005 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) - -import modules ; -import string ; - - -# Return the value(s) of the given environment variable(s) at the time bjam was -# invoked. -rule environ ( variable-names + ) -{ - return [ modules.peek .ENVIRON : $(variable-names) ] ; -} - -.name = [ modules.peek : OS ] ; -.platform = [ modules.peek : OSPLAT ] ; -.version = [ modules.peek : OSVER ] ; - - -local rule constant ( c : os ? ) -{ - os ?= $(.name) ; - # First look for a platform-specific name, then the general value. - local variables = .$(c)-$(os) .$(c) ; - local result = $($(variables)) ; - return $(result[1]) ; -} - -rule get-constant ( os ? ) -{ - # Find the name of the constant being accessed, which is equal to the name - # used to invoke us. - local bt = [ BACKTRACE 1 ] ; - local rulename = [ MATCH ([^.]*)$ : $(bt[4]) ] ; - return [ constant $(rulename) : $(os) ] ; -} - - -# export all the common constants -.constants = name platform version shared-library-path-variable path-separator executable-path-variable executable-suffix ; -for local constant in $(.constants) -{ - IMPORT $(__name__) : get-constant : $(__name__) : $(constant) ; -} -EXPORT $(__name__) : $(.constants) ; - -.executable-path-variable-NT = PATH ; -# On Windows the case and capitalization of PATH is not always predictable, so -# let's find out what variable name was really set. -if $(.name) = NT -{ - for local n in [ VARNAMES .ENVIRON ] - { - if $(n:L) = path - { - .executable-path-variable-NT = $(n) ; - } - } -} - -# Specific constants for various platforms. There's no need to define any -# constant whose value would be the same as the default, below. -.shared-library-path-variable-NT = $(.executable-path-variable-NT) ; -.path-separator-NT = ";" ; -.expand-variable-prefix-NT = % ; -.expand-variable-suffix-NT = % ; -.executable-suffix-NT = .exe ; - -.shared-library-path-variable-CYGWIN = PATH ; - -.shared-library-path-variable-MACOSX = DYLD_LIBRARY_PATH ; - -.shared-library-path-variable-AIX = LIBPATH ; - -# Default constants -.shared-library-path-variable = LD_LIBRARY_PATH ; -.path-separator = ":" ; -.expand-variable-prefix = $ ; -.expand-variable-suffix = "" ; -.executable-path-variable = PATH ; -.executable-suffix = "" ; - - -# Return a list of the directories in the PATH. Yes, that information is (sort -# of) available in the global module, but jam code can change those values, and -# it isn't always clear what case/capitalization to use when looking. This rule -# is a more reliable way to get there. -rule executable-path ( ) -{ - return [ string.words [ environ [ constant executable-path-variable ] ] - : [ constant path-separator ] ] ; -} - - -# Initialize the list of home directories for the current user depending on the -# OS. -if $(.name) = NT -{ - local home = [ environ HOMEDRIVE HOMEPATH ] ; - .home-directories = $(home[1])$(home[2]) [ environ HOME ] [ environ USERPROFILE ] ; -} -else -{ - .home-directories = [ environ HOME ] ; -} - - -# Can't use 'constant' mechanism because it only returns 1-element values. -rule home-directories ( ) -{ - return $(.home-directories) ; -} - - -# Return the string needed to represent the expansion of the named shell -# variable. -rule expand-variable ( variable ) -{ - local prefix = [ constant expand-variable-prefix ] ; - local suffix = [ constant expand-variable-suffix ] ; - return $(prefix)$(variable)$(suffix) ; -} - - -# Returns true if running on windows, whether in cygwin or not. -rule on-windows ( ) -{ - local result ; - if [ modules.peek : NT ] - { - result = true ; - } - else if [ modules.peek : UNIX ] - { - switch [ modules.peek : JAMUNAME ] - { - case CYGWIN* : - { - result = true ; - } - } - } - return $(result) ; -} - - -if ! [ on-windows ] -{ - .on-unix = 1 ; -} - - -rule on-unix -{ - return $(.on-unix) ; -} - - -rule __test__ -{ - import assert ; - if ! ( --quiet in [ modules.peek : ARGV ] ) - { - ECHO os: name= [ name ] ; - ECHO os: version= [ version ] ; - } - assert.true name ; -} diff --git a/jam-files/boost-build/util/os_j.py b/jam-files/boost-build/util/os_j.py deleted file mode 100644 index f44cca62..00000000 --- a/jam-files/boost-build/util/os_j.py +++ /dev/null @@ -1,19 +0,0 @@ -# Status: stub, just enough to make tests work. -# -# Named os_j to avoid conflicts with standard 'os'. See -# project.py:import for special-casing. -# -# Copyright 2001, 2002, 2003, 2005 Dave Abrahams -# Copyright 2006 Rene Rivera -# Copyright 2003, 2005 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) - -import bjam - -__OS = bjam.call("peek", [], "OS")[0] - -# Return Jam's name of OS to prevent existing code from burning -# when faced with Python naming -def name(): - return __OS diff --git a/jam-files/boost-build/util/path.jam b/jam-files/boost-build/util/path.jam deleted file mode 100644 index ea26b816..00000000 --- a/jam-files/boost-build/util/path.jam +++ /dev/null @@ -1,934 +0,0 @@ -# Copyright Vladimir Prus 2002-2006. -# Copyright Dave Abrahams 2003-2004. -# Copyright Rene Rivera 2003-2006. -# -# Distributed under the Boost Software License, Version 1.0. -# (See accompanying file LICENSE_1_0.txt or copy at -# http://www.boost.org/LICENSE_1_0.txt) - -# Performs various path manipulations. Paths are always in a 'normalized' -# representation. In it, a path may be either: -# -# - '.', or -# -# - ['/'] [ ( '..' '/' )* (token '/')* token ] -# -# In plain english, path can be rooted, '..' elements are allowed only at the -# beginning, and it never ends in slash, except for path consisting of slash -# only. - -import errors ; -import modules ; -import regex ; -import sequence ; -import set ; -import version ; - - -os = [ modules.peek : OS ] ; -if [ modules.peek : UNIX ] -{ - local uname = [ modules.peek : JAMUNAME ] ; - switch $(uname) - { - case CYGWIN* : os = CYGWIN ; - case * : os = UNIX ; - } -} - - -# Converts the native path into normalized form. -# -rule make ( native ) -{ - return [ make-$(os) $(native) ] ; -} - - -# Builds native representation of the path. -# -rule native ( path ) -{ - return [ native-$(os) $(path) ] ; -} - - -# Tests if a path is rooted. -# -rule is-rooted ( path ) -{ - return [ MATCH "^(/)" : $(path) ] ; -} - - -# Tests if a path has a parent. -# -rule has-parent ( path ) -{ - if $(path) != / - { - return 1 ; - } - else - { - return ; - } -} - - -# Returns the path without any directory components. -# -rule basename ( path ) -{ - return [ MATCH "([^/]+)$" : $(path) ] ; -} - - -# Returns parent directory of the path. If no parent exists, error is issued. -# -rule parent ( path ) -{ - if [ has-parent $(path) ] - { - if $(path) = . - { - return .. ; - } - else - { - # Strip everything at the end of path up to and including the last - # slash. - local result = [ regex.match "((.*)/)?([^/]+)" : $(path) : 2 3 ] ; - - # Did we strip what we shouldn't? - if $(result[2]) = ".." - { - return $(path)/.. ; - } - else - { - if ! $(result[1]) - { - if [ is-rooted $(path) ] - { - result = / ; - } - else - { - result = . ; - } - } - return $(result[1]) ; - } - } - } - else - { - errors.error "Path '$(path)' has no parent" ; - } -} - - -# Returns path2 such that "[ join path path2 ] = .". The path may not contain -# ".." element or be rooted. -# -rule reverse ( path ) -{ - if $(path) = . - { - return $(path) ; - } - else - { - local tokens = [ regex.split $(path) "/" ] ; - local tokens2 ; - for local i in $(tokens) - { - tokens2 += .. ; - } - return [ sequence.join $(tokens2) : "/" ] ; - } -} - - -# Concatenates the passed path elements. Generates an error if any element other -# than the first one is rooted. Skips any empty or undefined path elements. -# -rule join ( elements + ) -{ - if ! $(elements[2-]) - { - return $(elements[1]) ; - } - else - { - for local e in $(elements[2-]) - { - if [ is-rooted $(e) ] - { - errors.error only the first element may be rooted ; - } - } - if [ version.check-jam-version 3 1 17 ] - { - return [ NORMALIZE_PATH "$(elements)" ] ; - } - else - { - # Boost Jam prior to version 3.1.17 had problems with its - # NORMALIZE_PATH rule in case you passed it a leading backslash - # instead of a slash, in some cases when you sent it an empty - # initial path element and possibly some others. At least some of - # those cases were being hit and relied upon when calling this rule - # from the path.make-NT rule. - if ! $(elements[1]) && $(elements[2]) - { - return [ NORMALIZE_PATH "/" "$(elements[2-])" ] ; - } - else - { - return [ NORMALIZE_PATH "$(elements)" ] ; - } - } - } -} - - -# If 'path' is relative, it is rooted at 'root'. Otherwise, it is unchanged. -# -rule root ( path root ) -{ - if [ is-rooted $(path) ] - { - return $(path) ; - } - else - { - return [ join $(root) $(path) ] ; - } -} - - -# Returns the current working directory. -# -rule pwd ( ) -{ - if ! $(.pwd) - { - .pwd = [ make [ PWD ] ] ; - } - return $(.pwd) ; -} - - -# Returns the list of files matching the given pattern in the specified -# directory. Both directories and patterns are supplied as portable paths. Each -# pattern should be non-absolute path, and can't contain "." or ".." elements. -# Each slash separated element of pattern can contain the following special -# characters: -# - '?', which match any character -# - '*', which matches arbitrary number of characters. -# A file $(d)/e1/e2/e3 (where 'd' is in $(dirs)) matches pattern p1/p2/p3 if and -# only if e1 matches p1, e2 matches p2 and so on. -# -# For example: -# [ glob . : *.cpp ] -# [ glob . : */build/Jamfile ] -# -rule glob ( dirs * : patterns + : exclude-patterns * ) -{ - local result ; - local real-patterns ; - local real-exclude-patterns ; - for local d in $(dirs) - { - for local p in $(patterns) - { - local pattern = [ path.root $(p) $(d) ] ; - real-patterns += [ path.native $(pattern) ] ; - } - - for local p in $(exclude-patterns) - { - local pattern = [ path.root $(p) $(d) ] ; - real-exclude-patterns += [ path.native $(pattern) ] ; - } - } - - local inc = [ GLOB-RECURSIVELY $(real-patterns) ] ; - inc = [ sequence.transform NORMALIZE_PATH : $(inc) ] ; - local exc = [ GLOB-RECURSIVELY $(real-exclude-patterns) ] ; - exc = [ sequence.transform NORMALIZE_PATH : $(exc) ] ; - - return [ sequence.transform path.make : [ set.difference $(inc) : $(exc) ] ] - ; -} - - -# Recursive version of GLOB. Builds the glob of files while also searching in -# the subdirectories of the given roots. An optional set of exclusion patterns -# will filter out the matching entries from the result. The exclusions also -# apply to the subdirectory scanning, such that directories that match the -# exclusion patterns will not be searched. -# -rule glob-tree ( roots * : patterns + : exclude-patterns * ) -{ - return [ sequence.transform path.make : [ .glob-tree [ sequence.transform - path.native : $(roots) ] : $(patterns) : $(exclude-patterns) ] ] ; -} - - -local rule .glob-tree ( roots * : patterns * : exclude-patterns * ) -{ - local excluded ; - if $(exclude-patterns) - { - excluded = [ GLOB $(roots) : $(exclude-patterns) ] ; - } - local result = [ set.difference [ GLOB $(roots) : $(patterns) ] : - $(excluded) ] ; - local subdirs ; - for local d in [ set.difference [ GLOB $(roots) : * ] : $(excluded) ] - { - if ! ( $(d:D=) in . .. ) && ! [ CHECK_IF_FILE $(d) ] - { - subdirs += $(d) ; - } - } - if $(subdirs) - { - result += [ .glob-tree $(subdirs) : $(patterns) : $(exclude-patterns) ] - ; - } - return $(result) ; -} - - -# Returns true is the specified file exists. -# -rule exists ( file ) -{ - return [ path.glob $(file:D) : $(file:D=) ] ; -} -NATIVE_RULE path : exists ; - - -# Find out the absolute name of path and returns the list of all the parents, -# starting with the immediate one. Parents are returned as relative names. If -# 'upper_limit' is specified, directories above it will be pruned. -# -rule all-parents ( path : upper_limit ? : cwd ? ) -{ - cwd ?= [ pwd ] ; - local path_ele = [ regex.split [ root $(path) $(cwd) ] "/" ] ; - - if ! $(upper_limit) - { - upper_limit = / ; - } - local upper_ele = [ regex.split [ root $(upper_limit) $(cwd) ] "/" ] ; - - # Leave only elements in 'path_ele' below 'upper_ele'. - while $(path_ele) && ( $(upper_ele[1]) = $(path_ele[1]) ) - { - upper_ele = $(upper_ele[2-]) ; - path_ele = $(path_ele[2-]) ; - } - - # Have all upper elements been removed ? - if $(upper_ele) - { - errors.error "$(upper_limit) is not prefix of $(path)" ; - } - - # Create the relative paths to parents, number of elements in 'path_ele'. - local result ; - for local i in $(path_ele) - { - path = [ parent $(path) ] ; - result += $(path) ; - } - return $(result) ; -} - - -# Search for 'pattern' in parent directories of 'dir', up till and including -# 'upper_limit', if it is specified, or till the filesystem root otherwise. -# -rule glob-in-parents ( dir : patterns + : upper-limit ? ) -{ - local result ; - local parent-dirs = [ all-parents $(dir) : $(upper-limit) ] ; - - while $(parent-dirs) && ! $(result) - { - result = [ glob $(parent-dirs[1]) : $(patterns) ] ; - parent-dirs = $(parent-dirs[2-]) ; - } - return $(result) ; -} - - -# Assuming 'child' is a subdirectory of 'parent', return the relative path from -# 'parent' to 'child'. -# -rule relative ( child parent : no-error ? ) -{ - local not-a-child ; - if $(parent) = "." - { - return $(child) ; - } - else - { - local split1 = [ regex.split $(parent) / ] ; - local split2 = [ regex.split $(child) / ] ; - - while $(split1) - { - if $(split1[1]) = $(split2[1]) - { - split1 = $(split1[2-]) ; - split2 = $(split2[2-]) ; - } - else - { - not-a-child = true ; - split1 = ; - } - } - if $(split2) - { - if $(not-a-child) - { - if $(no-error) - { - return not-a-child ; - } - else - { - errors.error $(child) is not a subdir of $(parent) ; - } - } - else - { - return [ join $(split2) ] ; - } - } - else - { - return "." ; - } - } -} - - -# Returns the minimal path to path2 that is relative path1. -# -rule relative-to ( path1 path2 ) -{ - local root_1 = [ regex.split [ reverse $(path1) ] / ] ; - local split1 = [ regex.split $(path1) / ] ; - local split2 = [ regex.split $(path2) / ] ; - - while $(split1) && $(root_1) - { - if $(split1[1]) = $(split2[1]) - { - root_1 = $(root_1[2-]) ; - split1 = $(split1[2-]) ; - split2 = $(split2[2-]) ; - } - else - { - split1 = ; - } - } - return [ join . $(root_1) $(split2) ] ; -} - - -# Returns the list of paths which are used by the operating system for looking -# up programs. -# -rule programs-path ( ) -{ - local result ; - local raw = [ modules.peek : PATH Path path ] ; - for local p in $(raw) - { - if $(p) - { - result += [ path.make $(p) ] ; - } - } - return $(result) ; -} - -rule makedirs ( path ) -{ - local result = true ; - local native = [ native $(path) ] ; - if ! [ exists $(native) ] - { - if [ makedirs [ parent $(path) ] ] - { - if ! [ MAKEDIR $(native) ] - { - errors.error "Could not create directory '$(path)'" ; - result = ; - } - } - } - return $(result) ; -} - -# Converts native Windows paths into our internal canonic path representation. -# Supports 'invalid' paths containing multiple successive path separator -# characters. -# -# TODO: Check and if needed add support for Windows 'X:file' path format where -# the file is located in the current folder on drive X. -# -rule make-NT ( native ) -{ - local result ; - - if [ version.check-jam-version 3 1 17 ] - { - result = [ NORMALIZE_PATH $(native) ] ; - } - else - { - # This old implementation is really fragile due to a not so clear way - # NORMALIZE_PATH rule worked in Boost.Jam versions prior to 3.1.17. E.g. - # path.join would mostly ignore empty path elements but would root the - # joined path in case the initial two path elements were empty or some - # similar accidental wierdness. - result = [ path.join [ regex.split $(native) "[/\\]" ] ] ; - } - - # We need to add an extra '/' in front in case this is a rooted Windows path - # starting with a drive letter and not a path separator character since the - # builtin NORMALIZE_PATH rule has no knowledge of this leading drive letter - # and treats it as a regular folder name. - if [ regex.match "(^.:)" : $(native) ] - { - result = /$(result) ; - } - - return $(result) ; -} - - -rule native-NT ( path ) -{ - local result ; - if [ is-rooted $(path) ] && ! [ regex.match "^/(.:)" : $(path) ] - { - result = $(path) ; - } - else - { - result = [ MATCH "^/?(.*)" : $(path) ] ; - } - result = [ sequence.join [ regex.split $(result) "/" ] : "\\" ] ; - return $(result) ; -} - - -rule make-UNIX ( native ) -{ - # VP: I have no idea now 'native' can be empty here! But it can! - if ! $(native) - { - errors.error "Empty path passed to 'make-UNIX'" ; - } - else - { - return [ NORMALIZE_PATH $(native:T) ] ; - } -} - - -rule native-UNIX ( path ) -{ - return $(path) ; -} - - -rule make-CYGWIN ( path ) -{ - return [ make-NT $(path) ] ; -} - - -rule native-CYGWIN ( path ) -{ - local result = $(path) ; - if [ regex.match "(^/.:)" : $(path) ] # Windows absolute path. - { - result = [ MATCH "^/?(.*)" : $(path) ] ; # Remove leading '/'. - } - return [ native-UNIX $(result) ] ; -} - - -# split-path-VMS: splits input native path into device dir file (each part is -# optional). -# -# example: -# -# dev:[dir]file.c => dev: [dir] file.c -# -rule split-path-VMS ( native ) -{ - local matches = [ MATCH ([a-zA-Z0-9_-]+:)?(\\[[^\]]*\\])?(.*)?$ : $(native) ] ; - local device = $(matches[1]) ; - local dir = $(matches[2]) ; - local file = $(matches[3]) ; - - return $(device) $(dir) $(file) ; -} - - -# Converts a native VMS path into a portable path spec. -# -# Does not handle current-device absolute paths such as "[dir]File.c" as it is -# not clear how to represent them in the portable path notation. -# -# Adds a trailing dot (".") to the file part if no extension is present (helps -# when converting it back into native path). -# -rule make-VMS ( native ) -{ - if [ MATCH ^(\\[[a-zA-Z0-9]) : $(native) ] - { - errors.error "Can't handle default-device absolute paths: " $(native) ; - } - - local parts = [ split-path-VMS $(native) ] ; - local device = $(parts[1]) ; - local dir = $(parts[2]) ; - local file = $(parts[3]) ; - local elems ; - - if $(device) - { - # - # rooted - # - elems = /$(device) ; - } - - if $(dir) = "[]" - { - # - # Special case: current directory - # - elems = $(elems) "." ; - } - else if $(dir) - { - dir = [ regex.replace $(dir) "\\[|\\]" "" ] ; - local dir_parts = [ regex.split $(dir) \\. ] ; - - if $(dir_parts[1]) = "" - { - # - # Relative path - # - dir_parts = $(dir_parts[2--1]) ; - } - - # - # replace "parent-directory" parts (- => ..) - # - dir_parts = [ regex.replace-list $(dir_parts) : - : .. ] ; - - elems = $(elems) $(dir_parts) ; - } - - if $(file) - { - if ! [ MATCH (\\.) : $(file) ] - { - # - # Always add "." to end of non-extension file. - # - file = $(file). ; - } - elems = $(elems) $(file) ; - } - - local portable = [ path.join $(elems) ] ; - - return $(portable) ; -} - - -# Converts a portable path spec into a native VMS path. -# -# Relies on having at least one dot (".") included in the file name to be able -# to differentiate it from the directory part. -# -rule native-VMS ( path ) -{ - local device = "" ; - local dir = $(path) ; - local file = "" ; - local native ; - local split ; - - # - # Has device ? - # - if [ is-rooted $(dir) ] - { - split = [ MATCH ^/([^:]+:)/?(.*) : $(dir) ] ; - device = $(split[1]) ; - dir = $(split[2]) ; - } - - # - # Has file ? - # - # This is no exact science, just guess work: - # - # If the last part of the current path spec - # includes some chars, followed by a dot, - # optionally followed by more chars - - # then it is a file (keep your fingers crossed). - # - split = [ regex.split $(dir) / ] ; - local maybe_file = $(split[-1]) ; - - if [ MATCH ^([^.]+\\..*) : $(maybe_file) ] - { - file = $(maybe_file) ; - dir = [ sequence.join $(split[1--2]) : / ] ; - } - - # - # Has dir spec ? - # - if $(dir) = "." - { - dir = "[]" ; - } - else if $(dir) - { - dir = [ regex.replace $(dir) \\.\\. - ] ; - dir = [ regex.replace $(dir) / . ] ; - - if $(device) = "" - { - # - # Relative directory - # - dir = "."$(dir) ; - } - dir = "["$(dir)"]" ; - } - - native = [ sequence.join $(device) $(dir) $(file) ] ; - - return $(native) ; -} - - -rule __test__ ( ) -{ - import assert ; - import errors : try catch ; - - assert.true is-rooted "/" ; - assert.true is-rooted "/foo" ; - assert.true is-rooted "/foo/bar" ; - assert.result : is-rooted "." ; - assert.result : is-rooted "foo" ; - assert.result : is-rooted "foo/bar" ; - - assert.true has-parent "foo" ; - assert.true has-parent "foo/bar" ; - assert.true has-parent "." ; - assert.result : has-parent "/" ; - - assert.result "." : basename "." ; - assert.result ".." : basename ".." ; - assert.result "foo" : basename "foo" ; - assert.result "foo" : basename "bar/foo" ; - assert.result "foo" : basename "gaz/bar/foo" ; - assert.result "foo" : basename "/gaz/bar/foo" ; - - assert.result "." : parent "foo" ; - assert.result "/" : parent "/foo" ; - assert.result "foo/bar" : parent "foo/bar/giz" ; - assert.result ".." : parent "." ; - assert.result ".." : parent "../foo" ; - assert.result "../../foo" : parent "../../foo/bar" ; - - assert.result "." : reverse "." ; - assert.result ".." : reverse "foo" ; - assert.result "../../.." : reverse "foo/bar/giz" ; - - assert.result "foo" : join "foo" ; - assert.result "/foo" : join "/" "foo" ; - assert.result "foo/bar" : join "foo" "bar" ; - assert.result "foo/bar" : join "foo/giz" "../bar" ; - assert.result "foo/giz" : join "foo/bar/baz" "../../giz" ; - assert.result ".." : join "." ".." ; - assert.result ".." : join "foo" "../.." ; - assert.result "../.." : join "../foo" "../.." ; - assert.result "/foo" : join "/bar" "../foo" ; - assert.result "foo/giz" : join "foo/giz" "." ; - assert.result "." : join lib2 ".." ; - assert.result "/" : join "/a" ".." ; - - assert.result /a/b : join /a/b/c .. ; - - assert.result "foo/bar/giz" : join "foo" "bar" "giz" ; - assert.result "giz" : join "foo" ".." "giz" ; - assert.result "foo/giz" : join "foo" "." "giz" ; - - try ; - { - join "a" "/b" ; - } - catch only first element may be rooted ; - - local CWD = "/home/ghost/build" ; - assert.result : all-parents . : . : $(CWD) ; - assert.result . .. ../.. ../../.. : all-parents "Jamfile" : "" : $(CWD) ; - assert.result foo . .. ../.. ../../.. : all-parents "foo/Jamfile" : "" : $(CWD) ; - assert.result ../Work .. ../.. ../../.. : all-parents "../Work/Jamfile" : "" : $(CWD) ; - - local CWD = "/home/ghost" ; - assert.result . .. : all-parents "Jamfile" : "/home" : $(CWD) ; - assert.result . : all-parents "Jamfile" : "/home/ghost" : $(CWD) ; - - assert.result "c/d" : relative "a/b/c/d" "a/b" ; - assert.result "foo" : relative "foo" "." ; - - local save-os = [ modules.peek path : os ] ; - modules.poke path : os : NT ; - - assert.result "foo/bar/giz" : make "foo/bar/giz" ; - assert.result "foo/bar/giz" : make "foo\\bar\\giz" ; - assert.result "foo" : make "foo/" ; - assert.result "foo" : make "foo\\" ; - assert.result "foo" : make "foo/." ; - assert.result "foo" : make "foo/bar/.." ; - assert.result "foo" : make "foo/bar/../" ; - assert.result "foo" : make "foo/bar/..\\" ; - assert.result "foo/bar" : make "foo/././././bar" ; - assert.result "/foo" : make "\\foo" ; - assert.result "/D:/My Documents" : make "D:\\My Documents" ; - assert.result "/c:/boost/tools/build/new/project.jam" : make "c:\\boost\\tools\\build\\test\\..\\new\\project.jam" ; - - # Test processing 'invalid' paths containing multiple successive path - # separators. - assert.result "foo" : make "foo//" ; - assert.result "foo" : make "foo///" ; - assert.result "foo" : make "foo\\\\" ; - assert.result "foo" : make "foo\\\\\\" ; - assert.result "/foo" : make "//foo" ; - assert.result "/foo" : make "///foo" ; - assert.result "/foo" : make "\\\\foo" ; - assert.result "/foo" : make "\\\\\\foo" ; - assert.result "/foo" : make "\\/\\/foo" ; - assert.result "foo/bar" : make "foo//\\//\\\\bar//\\//\\\\\\//\\//\\\\" ; - assert.result "foo" : make "foo/bar//.." ; - assert.result "foo/bar" : make "foo/bar/giz//.." ; - assert.result "foo/giz" : make "foo//\\//\\\\bar///\\\\//\\\\////\\/..///giz\\//\\\\\\//\\//\\\\" ; - assert.result "../../../foo" : make "..///.//..///.//..////foo///" ; - - # Test processing 'invalid' rooted paths with too many '..' path elements - # that would place them before the root. - assert.result : make "/.." ; - assert.result : make "/../" ; - assert.result : make "/../." ; - assert.result : make "/.././" ; - assert.result : make "/foo/../bar/giz/.././././../../." ; - assert.result : make "/foo/../bar/giz/.././././../.././" ; - assert.result : make "//foo/../bar/giz/.././././../../." ; - assert.result : make "//foo/../bar/giz/.././././../.././" ; - assert.result : make "\\\\foo/../bar/giz/.././././../../." ; - assert.result : make "\\\\foo/../bar/giz/.././././../.././" ; - assert.result : make "/..///.//..///.//..////foo///" ; - - assert.result "foo\\bar\\giz" : native "foo/bar/giz" ; - assert.result "foo" : native "foo" ; - assert.result "\\foo" : native "/foo" ; - assert.result "D:\\My Documents\\Work" : native "/D:/My Documents/Work" ; - - modules.poke path : os : UNIX ; - - assert.result "foo/bar/giz" : make "foo/bar/giz" ; - assert.result "/sub1" : make "/sub1/." ; - assert.result "/sub1" : make "/sub1/sub2/.." ; - assert.result "sub1" : make "sub1/." ; - assert.result "sub1" : make "sub1/sub2/.." ; - assert.result "/foo/bar" : native "/foo/bar" ; - - modules.poke path : os : VMS ; - - # - # Don't really need to poke os before these - # - assert.result "disk:" "[dir]" "file" : split-path-VMS "disk:[dir]file" ; - assert.result "disk:" "[dir]" "" : split-path-VMS "disk:[dir]" ; - assert.result "disk:" "" "" : split-path-VMS "disk:" ; - assert.result "disk:" "" "file" : split-path-VMS "disk:file" ; - assert.result "" "[dir]" "file" : split-path-VMS "[dir]file" ; - assert.result "" "[dir]" "" : split-path-VMS "[dir]" ; - assert.result "" "" "file" : split-path-VMS "file" ; - assert.result "" "" "" : split-path-VMS "" ; - - # - # Special case: current directory - # - assert.result "" "[]" "" : split-path-VMS "[]" ; - assert.result "disk:" "[]" "" : split-path-VMS "disk:[]" ; - assert.result "" "[]" "file" : split-path-VMS "[]file" ; - assert.result "disk:" "[]" "file" : split-path-VMS "disk:[]file" ; - - # - # Make portable paths - # - assert.result "/disk:" : make "disk:" ; - assert.result "foo/bar/giz" : make "[.foo.bar.giz]" ; - assert.result "foo" : make "[.foo]" ; - assert.result "foo" : make "[.foo.bar.-]" ; - assert.result ".." : make "[.-]" ; - assert.result ".." : make "[-]" ; - assert.result "." : make "[]" ; - assert.result "giz.h" : make "giz.h" ; - assert.result "foo/bar/giz.h" : make "[.foo.bar]giz.h" ; - assert.result "/disk:/my_docs" : make "disk:[my_docs]" ; - assert.result "/disk:/boost/tools/build/new/project.jam" : make "disk:[boost.tools.build.test.-.new]project.jam" ; - - # - # Special case (adds '.' to end of file w/o extension to - # disambiguate from directory in portable path spec). - # - assert.result "Jamfile." : make "Jamfile" ; - assert.result "dir/Jamfile." : make "[.dir]Jamfile" ; - assert.result "/disk:/dir/Jamfile." : make "disk:[dir]Jamfile" ; - - # - # Make native paths - # - assert.result "disk:" : native "/disk:" ; - assert.result "[.foo.bar.giz]" : native "foo/bar/giz" ; - assert.result "[.foo]" : native "foo" ; - assert.result "[.-]" : native ".." ; - assert.result "[.foo.-]" : native "foo/.." ; - assert.result "[]" : native "." ; - assert.result "disk:[my_docs.work]" : native "/disk:/my_docs/work" ; - assert.result "giz.h" : native "giz.h" ; - assert.result "disk:Jamfile." : native "/disk:Jamfile." ; - assert.result "disk:[my_docs.work]Jamfile." : native "/disk:/my_docs/work/Jamfile." ; - - modules.poke path : os : $(save-os) ; -} diff --git a/jam-files/boost-build/util/path.py b/jam-files/boost-build/util/path.py deleted file mode 100644 index 222b96bf..00000000 --- a/jam-files/boost-build/util/path.py +++ /dev/null @@ -1,904 +0,0 @@ -# Status: this module is ported on demand by however needs something -# from it. Functionality that is not needed by Python port will -# be dropped. - -# 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. - -# Performs various path manipulations. Path are always in a 'normilized' -# representation. In it, a path may be either: -# -# - '.', or -# -# - ['/'] [ ( '..' '/' )* (token '/')* token ] -# -# In plain english, path can be rooted, '..' elements are allowed only -# at the beginning, and it never ends in slash, except for path consisting -# of slash only. - -import os.path -from utility import to_seq -from glob import glob as builtin_glob - -from b2.util import bjam_signature - -@bjam_signature((["path", "root"],)) -def root (path, root): - """ If 'path' is relative, it is rooted at 'root'. Otherwise, it's unchanged. - """ - if os.path.isabs (path): - return path - else: - return os.path.join (root, path) - -@bjam_signature((["native"],)) -def make (native): - """ Converts the native path into normalized form. - """ - # TODO: make os selection here. - return make_UNIX (native) - -def make_UNIX (native): - - # VP: I have no idea now 'native' can be empty here! But it can! - assert (native) - - return os.path.normpath (native) - -@bjam_signature((["path"],)) -def native (path): - """ Builds a native representation of the path. - """ - # TODO: make os selection here. - return native_UNIX (path) - -def native_UNIX (path): - return path - - -def pwd (): - """ Returns the current working directory. - # TODO: is it a good idea to use the current dir? Some use-cases - may not allow us to depend on the current dir. - """ - return make (os.getcwd ()) - -def is_rooted (path): - """ Tests if a path is rooted. - """ - return path and path [0] == '/' - - -################################################################### -# Still to port. -# Original lines are prefixed with "# " -# -# # 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. -# -# # Performs various path manipulations. Path are always in a 'normilized' -# # representation. In it, a path may be either: -# # -# # - '.', or -# # -# # - ['/'] [ ( '..' '/' )* (token '/')* token ] -# # -# # In plain english, path can be rooted, '..' elements are allowed only -# # at the beginning, and it never ends in slash, except for path consisting -# # of slash only. -# -# import modules ; -# import sequence ; -# import regex ; -# import errors : error ; -# -# -# os = [ modules.peek : OS ] ; -# if [ modules.peek : UNIX ] -# { -# local uname = [ modules.peek : JAMUNAME ] ; -# switch $(uname) -# { -# case CYGWIN* : -# os = CYGWIN ; -# -# case * : -# os = UNIX ; -# } -# } -# -# # -# # Tests if a path is rooted. -# # -# rule is-rooted ( path ) -# { -# return [ MATCH "^(/)" : $(path) ] ; -# } -# -# # -# # Tests if a path has a parent. -# # -# rule has-parent ( path ) -# { -# if $(path) != / { -# return 1 ; -# } else { -# return ; -# } -# } -# -# # -# # Returns the path without any directory components. -# # -# rule basename ( path ) -# { -# return [ MATCH "([^/]+)$" : $(path) ] ; -# } -# -# # -# # Returns parent directory of the path. If no parent exists, error is issued. -# # -# rule parent ( path ) -# { -# if [ has-parent $(path) ] { -# -# if $(path) = . { -# return .. ; -# } else { -# -# # Strip everything at the end of path up to and including -# # the last slash -# local result = [ regex.match "((.*)/)?([^/]+)" : $(path) : 2 3 ] ; -# -# # Did we strip what we shouldn't? -# if $(result[2]) = ".." { -# return $(path)/.. ; -# } else { -# if ! $(result[1]) { -# if [ is-rooted $(path) ] { -# result = / ; -# } else { -# result = . ; -# } -# } -# return $(result[1]) ; -# } -# } -# } else { -# error "Path '$(path)' has no parent" ; -# } -# } -# -# # -# # Returns path2 such that "[ join path path2 ] = .". -# # The path may not contain ".." element or be rooted. -# # -# rule reverse ( path ) -# { -# if $(path) = . -# { -# return $(path) ; -# } -# else -# { -# local tokens = [ regex.split $(path) "/" ] ; -# local tokens2 ; -# for local i in $(tokens) { -# tokens2 += .. ; -# } -# return [ sequence.join $(tokens2) : "/" ] ; -# } -# } -# -# # -# # Auxillary rule: does all the semantic of 'join', except for error cheching. -# # The error checking is separated because this rule is recursive, and I don't -# # like the idea of checking the same input over and over. -# # -# local rule join-imp ( elements + ) -# { -# return [ NORMALIZE_PATH $(elements:J="/") ] ; -# } -# -# # -# # Contanenates the passed path elements. Generates an error if -# # any element other than the first one is rooted. -# # -# rule join ( elements + ) -# { -# if ! $(elements[2]) -# { -# return $(elements[1]) ; -# } -# else -# { -# for local e in $(elements[2-]) -# { -# if [ is-rooted $(e) ] -# { -# error only first element may be rooted ; -# } -# } -# return [ join-imp $(elements) ] ; -# } -# } - - -def glob (dirs, patterns): - """ Returns the list of files matching the given pattern in the - specified directory. Both directories and patterns are - supplied as portable paths. Each pattern should be non-absolute - path, and can't contain "." or ".." elements. Each slash separated - element of pattern can contain the following special characters: - - '?', which match any character - - '*', which matches arbitrary number of characters. - A file $(d)/e1/e2/e3 (where 'd' is in $(dirs)) matches pattern p1/p2/p3 - if and only if e1 matches p1, e2 matches p2 and so on. - - For example: - [ glob . : *.cpp ] - [ glob . : */build/Jamfile ] - """ -# { -# local result ; -# if $(patterns:D) -# { -# # When a pattern has a directory element, we first glob for -# # directory, and then glob for file name is the found directories. -# for local p in $(patterns) -# { -# # First glob for directory part. -# local globbed-dirs = [ glob $(dirs) : $(p:D) ] ; -# result += [ glob $(globbed-dirs) : $(p:D="") ] ; -# } -# } -# else -# { -# # When a pattern has not directory, we glob directly. -# # Take care of special ".." value. The "GLOB" rule simply ignores -# # the ".." element (and ".") element in directory listings. This is -# # needed so that -# # -# # [ glob libs/*/Jamfile ] -# # -# # don't return -# # -# # libs/../Jamfile (which is the same as ./Jamfile) -# # -# # On the other hand, when ".." is explicitly present in the pattern -# # we need to return it. -# # -# for local dir in $(dirs) -# { -# for local p in $(patterns) -# { -# if $(p) != ".." -# { -# result += [ sequence.transform make -# : [ GLOB [ native $(dir) ] : $(p) ] ] ; -# } -# else -# { -# result += [ path.join $(dir) .. ] ; -# } -# } -# } -# } -# return $(result) ; -# } -# - -# TODO: (PF) I replaced the code above by this. I think it should work but needs to be tested. - result = [] - dirs = to_seq (dirs) - patterns = to_seq (patterns) - - splitdirs = [] - for dir in dirs: - splitdirs += dir.split (os.pathsep) - - for dir in splitdirs: - for pattern in patterns: - p = os.path.join (dir, pattern) - import glob - result.extend (glob.glob (p)) - return result - -# -# Find out the absolute name of path and returns the list of all the parents, -# starting with the immediate one. Parents are returned as relative names. -# If 'upper_limit' is specified, directories above it will be pruned. -# -def all_parents(path, upper_limit=None, cwd=None): - - if not cwd: - cwd = os.getcwd() - - path_abs = os.path.join(cwd, path) - - if upper_limit: - upper_limit = os.path.join(cwd, upper_limit) - - result = [] - while path_abs and path_abs != upper_limit: - (head, tail) = os.path.split(path) - path = os.path.join(path, "..") - result.append(path) - path_abs = head - - if upper_limit and path_abs != upper_limit: - raise BaseException("'%s' is not a prefix of '%s'" % (upper_limit, path)) - - return result - -# Search for 'pattern' in parent directories of 'dir', up till and including -# 'upper_limit', if it is specified, or till the filesystem root otherwise. -# -def glob_in_parents(dir, patterns, upper_limit=None): - - result = [] - parent_dirs = all_parents(dir, upper_limit) - - for p in parent_dirs: - result = glob(p, patterns) - if result: break - - return result - -# -# # -# # Assuming 'child' is a subdirectory of 'parent', return the relative -# # path from 'parent' to 'child' -# # -# rule relative ( child parent ) -# { -# if $(parent) = "." -# { -# return $(child) ; -# } -# else -# { -# local split1 = [ regex.split $(parent) / ] ; -# local split2 = [ regex.split $(child) / ] ; -# -# while $(split1) -# { -# if $(split1[1]) = $(split2[1]) -# { -# split1 = $(split1[2-]) ; -# split2 = $(split2[2-]) ; -# } -# else -# { -# errors.error $(child) is not a subdir of $(parent) ; -# } -# } -# return [ join $(split2) ] ; -# } -# } -# -# # Returns the minimal path to path2 that is relative path1. -# # -# rule relative-to ( path1 path2 ) -# { -# local root_1 = [ regex.split [ reverse $(path1) ] / ] ; -# local split1 = [ regex.split $(path1) / ] ; -# local split2 = [ regex.split $(path2) / ] ; -# -# while $(split1) && $(root_1) -# { -# if $(split1[1]) = $(split2[1]) -# { -# root_1 = $(root_1[2-]) ; -# split1 = $(split1[2-]) ; -# split2 = $(split2[2-]) ; -# } -# else -# { -# split1 = ; -# } -# } -# return [ join . $(root_1) $(split2) ] ; -# } - -# Returns the list of paths which are used by the operating system -# for looking up programs -def programs_path (): - raw = [] - names = ['PATH', 'Path', 'path'] - - for name in names: - raw.append(os.environ.get (name, '')) - - result = [] - for elem in raw: - if elem: - for p in elem.split(os.path.pathsep): - result.append(make(p)) - - return result - -# rule make-NT ( native ) -# { -# local tokens = [ regex.split $(native) "[/\\]" ] ; -# local result ; -# -# # Handle paths ending with slashes -# if $(tokens[-1]) = "" -# { -# tokens = $(tokens[1--2]) ; # discard the empty element -# } -# -# result = [ path.join $(tokens) ] ; -# -# if [ regex.match "(^.:)" : $(native) ] -# { -# result = /$(result) ; -# } -# -# if $(native) = "" -# { -# result = "." ; -# } -# -# return $(result) ; -# } -# -# rule native-NT ( path ) -# { -# local result = [ MATCH "^/?(.*)" : $(path) ] ; -# result = [ sequence.join [ regex.split $(result) "/" ] : "\\" ] ; -# return $(result) ; -# } -# -# rule make-CYGWIN ( path ) -# { -# return [ make-NT $(path) ] ; -# } -# -# rule native-CYGWIN ( path ) -# { -# local result = $(path) ; -# if [ regex.match "(^/.:)" : $(path) ] # win absolute -# { -# result = [ MATCH "^/?(.*)" : $(path) ] ; # remove leading '/' -# } -# return [ native-UNIX $(result) ] ; -# } -# -# # -# # split-VMS: splits input native path into -# # device dir file (each part is optional), -# # example: -# # -# # dev:[dir]file.c => dev: [dir] file.c -# # -# rule split-path-VMS ( native ) -# { -# local matches = [ MATCH ([a-zA-Z0-9_-]+:)?(\\[[^\]]*\\])?(.*)?$ : $(native) ] ; -# local device = $(matches[1]) ; -# local dir = $(matches[2]) ; -# local file = $(matches[3]) ; -# -# return $(device) $(dir) $(file) ; -# } -# -# # -# # Converts a native VMS path into a portable path spec. -# # -# # Does not handle current-device absolute paths such -# # as "[dir]File.c" as it is not clear how to represent -# # them in the portable path notation. -# # -# # Adds a trailing dot (".") to the file part if no extension -# # is present (helps when converting it back into native path). -# # -# rule make-VMS ( native ) -# { -# if [ MATCH ^(\\[[a-zA-Z0-9]) : $(native) ] -# { -# errors.error "Can't handle default-device absolute paths: " $(native) ; -# } -# -# local parts = [ split-path-VMS $(native) ] ; -# local device = $(parts[1]) ; -# local dir = $(parts[2]) ; -# local file = $(parts[3]) ; -# local elems ; -# -# if $(device) -# { -# # -# # rooted -# # -# elems = /$(device) ; -# } -# -# if $(dir) = "[]" -# { -# # -# # Special case: current directory -# # -# elems = $(elems) "." ; -# } -# else if $(dir) -# { -# dir = [ regex.replace $(dir) "\\[|\\]" "" ] ; -# local dir_parts = [ regex.split $(dir) \\. ] ; -# -# if $(dir_parts[1]) = "" -# { -# # -# # Relative path -# # -# dir_parts = $(dir_parts[2--1]) ; -# } -# -# # -# # replace "parent-directory" parts (- => ..) -# # -# dir_parts = [ regex.replace-list $(dir_parts) : - : .. ] ; -# -# elems = $(elems) $(dir_parts) ; -# } -# -# if $(file) -# { -# if ! [ MATCH (\\.) : $(file) ] -# { -# # -# # Always add "." to end of non-extension file -# # -# file = $(file). ; -# } -# elems = $(elems) $(file) ; -# } -# -# local portable = [ path.join $(elems) ] ; -# -# return $(portable) ; -# } -# -# # -# # Converts a portable path spec into a native VMS path. -# # -# # Relies on having at least one dot (".") included in the file -# # name to be able to differentiate it ftom the directory part. -# # -# rule native-VMS ( path ) -# { -# local device = "" ; -# local dir = $(path) ; -# local file = "" ; -# local native ; -# local split ; -# -# # -# # Has device ? -# # -# if [ is-rooted $(dir) ] -# { -# split = [ MATCH ^/([^:]+:)/?(.*) : $(dir) ] ; -# device = $(split[1]) ; -# dir = $(split[2]) ; -# } -# -# # -# # Has file ? -# # -# # This is no exact science, just guess work: -# # -# # If the last part of the current path spec -# # includes some chars, followed by a dot, -# # optionally followed by more chars - -# # then it is a file (keep your fingers crossed). -# # -# split = [ regex.split $(dir) / ] ; -# local maybe_file = $(split[-1]) ; -# -# if [ MATCH ^([^.]+\\..*) : $(maybe_file) ] -# { -# file = $(maybe_file) ; -# dir = [ sequence.join $(split[1--2]) : / ] ; -# } -# -# # -# # Has dir spec ? -# # -# if $(dir) = "." -# { -# dir = "[]" ; -# } -# else if $(dir) -# { -# dir = [ regex.replace $(dir) \\.\\. - ] ; -# dir = [ regex.replace $(dir) / . ] ; -# -# if $(device) = "" -# { -# # -# # Relative directory -# # -# dir = "."$(dir) ; -# } -# dir = "["$(dir)"]" ; -# } -# -# native = [ sequence.join $(device) $(dir) $(file) ] ; -# -# return $(native) ; -# } -# -# -# rule __test__ ( ) { -# -# import assert ; -# import errors : try catch ; -# -# assert.true is-rooted "/" ; -# assert.true is-rooted "/foo" ; -# assert.true is-rooted "/foo/bar" ; -# assert.result : is-rooted "." ; -# assert.result : is-rooted "foo" ; -# assert.result : is-rooted "foo/bar" ; -# -# assert.true has-parent "foo" ; -# assert.true has-parent "foo/bar" ; -# assert.true has-parent "." ; -# assert.result : has-parent "/" ; -# -# assert.result "." : basename "." ; -# assert.result ".." : basename ".." ; -# assert.result "foo" : basename "foo" ; -# assert.result "foo" : basename "bar/foo" ; -# assert.result "foo" : basename "gaz/bar/foo" ; -# assert.result "foo" : basename "/gaz/bar/foo" ; -# -# assert.result "." : parent "foo" ; -# assert.result "/" : parent "/foo" ; -# assert.result "foo/bar" : parent "foo/bar/giz" ; -# assert.result ".." : parent "." ; -# assert.result ".." : parent "../foo" ; -# assert.result "../../foo" : parent "../../foo/bar" ; -# -# -# assert.result "." : reverse "." ; -# assert.result ".." : reverse "foo" ; -# assert.result "../../.." : reverse "foo/bar/giz" ; -# -# assert.result "foo" : join "foo" ; -# assert.result "/foo" : join "/" "foo" ; -# assert.result "foo/bar" : join "foo" "bar" ; -# assert.result "foo/bar" : join "foo/giz" "../bar" ; -# assert.result "foo/giz" : join "foo/bar/baz" "../../giz" ; -# assert.result ".." : join "." ".." ; -# assert.result ".." : join "foo" "../.." ; -# assert.result "../.." : join "../foo" "../.." ; -# assert.result "/foo" : join "/bar" "../foo" ; -# assert.result "foo/giz" : join "foo/giz" "." ; -# assert.result "." : join lib2 ".." ; -# assert.result "/" : join "/a" ".." ; -# -# assert.result /a/b : join /a/b/c .. ; -# -# assert.result "foo/bar/giz" : join "foo" "bar" "giz" ; -# assert.result "giz" : join "foo" ".." "giz" ; -# assert.result "foo/giz" : join "foo" "." "giz" ; -# -# try ; -# { -# join "a" "/b" ; -# } -# catch only first element may be rooted ; -# -# local CWD = "/home/ghost/build" ; -# assert.result : all-parents . : . : $(CWD) ; -# assert.result . .. ../.. ../../.. : all-parents "Jamfile" : "" : $(CWD) ; -# assert.result foo . .. ../.. ../../.. : all-parents "foo/Jamfile" : "" : $(CWD) ; -# assert.result ../Work .. ../.. ../../.. : all-parents "../Work/Jamfile" : "" : $(CWD) ; -# -# local CWD = "/home/ghost" ; -# assert.result . .. : all-parents "Jamfile" : "/home" : $(CWD) ; -# assert.result . : all-parents "Jamfile" : "/home/ghost" : $(CWD) ; -# -# assert.result "c/d" : relative "a/b/c/d" "a/b" ; -# assert.result "foo" : relative "foo" "." ; -# -# local save-os = [ modules.peek path : os ] ; -# modules.poke path : os : NT ; -# -# assert.result "foo/bar/giz" : make "foo/bar/giz" ; -# assert.result "foo/bar/giz" : make "foo\\bar\\giz" ; -# assert.result "foo" : make "foo/." ; -# assert.result "foo" : make "foo/bar/.." ; -# assert.result "/D:/My Documents" : make "D:\\My Documents" ; -# assert.result "/c:/boost/tools/build/new/project.jam" : make "c:\\boost\\tools\\build\\test\\..\\new\\project.jam" ; -# -# assert.result "foo\\bar\\giz" : native "foo/bar/giz" ; -# assert.result "foo" : native "foo" ; -# assert.result "D:\\My Documents\\Work" : native "/D:/My Documents/Work" ; -# -# modules.poke path : os : UNIX ; -# -# assert.result "foo/bar/giz" : make "foo/bar/giz" ; -# assert.result "/sub1" : make "/sub1/." ; -# assert.result "/sub1" : make "/sub1/sub2/.." ; -# assert.result "sub1" : make "sub1/." ; -# assert.result "sub1" : make "sub1/sub2/.." ; -# assert.result "/foo/bar" : native "/foo/bar" ; -# -# modules.poke path : os : VMS ; -# -# # -# # Don't really need to poke os before these -# # -# assert.result "disk:" "[dir]" "file" : split-path-VMS "disk:[dir]file" ; -# assert.result "disk:" "[dir]" "" : split-path-VMS "disk:[dir]" ; -# assert.result "disk:" "" "" : split-path-VMS "disk:" ; -# assert.result "disk:" "" "file" : split-path-VMS "disk:file" ; -# assert.result "" "[dir]" "file" : split-path-VMS "[dir]file" ; -# assert.result "" "[dir]" "" : split-path-VMS "[dir]" ; -# assert.result "" "" "file" : split-path-VMS "file" ; -# assert.result "" "" "" : split-path-VMS "" ; -# -# # -# # Special case: current directory -# # -# assert.result "" "[]" "" : split-path-VMS "[]" ; -# assert.result "disk:" "[]" "" : split-path-VMS "disk:[]" ; -# assert.result "" "[]" "file" : split-path-VMS "[]file" ; -# assert.result "disk:" "[]" "file" : split-path-VMS "disk:[]file" ; -# -# # -# # Make portable paths -# # -# assert.result "/disk:" : make "disk:" ; -# assert.result "foo/bar/giz" : make "[.foo.bar.giz]" ; -# assert.result "foo" : make "[.foo]" ; -# assert.result "foo" : make "[.foo.bar.-]" ; -# assert.result ".." : make "[.-]" ; -# assert.result ".." : make "[-]" ; -# assert.result "." : make "[]" ; -# assert.result "giz.h" : make "giz.h" ; -# assert.result "foo/bar/giz.h" : make "[.foo.bar]giz.h" ; -# assert.result "/disk:/my_docs" : make "disk:[my_docs]" ; -# assert.result "/disk:/boost/tools/build/new/project.jam" : make "disk:[boost.tools.build.test.-.new]project.jam" ; -# -# # -# # Special case (adds '.' to end of file w/o extension to -# # disambiguate from directory in portable path spec). -# # -# assert.result "Jamfile." : make "Jamfile" ; -# assert.result "dir/Jamfile." : make "[.dir]Jamfile" ; -# assert.result "/disk:/dir/Jamfile." : make "disk:[dir]Jamfile" ; -# -# # -# # Make native paths -# # -# assert.result "disk:" : native "/disk:" ; -# assert.result "[.foo.bar.giz]" : native "foo/bar/giz" ; -# assert.result "[.foo]" : native "foo" ; -# assert.result "[.-]" : native ".." ; -# assert.result "[.foo.-]" : native "foo/.." ; -# assert.result "[]" : native "." ; -# assert.result "disk:[my_docs.work]" : native "/disk:/my_docs/work" ; -# assert.result "giz.h" : native "giz.h" ; -# assert.result "disk:Jamfile." : native "/disk:Jamfile." ; -# assert.result "disk:[my_docs.work]Jamfile." : native "/disk:/my_docs/work/Jamfile." ; -# -# modules.poke path : os : $(save-os) ; -# -# } - -# - - -#def glob(dir, patterns): -# result = [] -# for pattern in patterns: -# result.extend(builtin_glob(os.path.join(dir, pattern))) -# return result - -def glob(dirs, patterns, exclude_patterns=None): - """Returns the list of files matching the given pattern in the - specified directory. Both directories and patterns are - supplied as portable paths. Each pattern should be non-absolute - path, and can't contain '.' or '..' elements. Each slash separated - element of pattern can contain the following special characters: - - '?', which match any character - - '*', which matches arbitrary number of characters. - A file $(d)/e1/e2/e3 (where 'd' is in $(dirs)) matches pattern p1/p2/p3 - if and only if e1 matches p1, e2 matches p2 and so on. - For example: - [ glob . : *.cpp ] - [ glob . : */build/Jamfile ] - """ - - assert(isinstance(patterns, list)) - assert(isinstance(dirs, list)) - - if not exclude_patterns: - exclude_patterns = [] - else: - assert(isinstance(exclude_patterns, list)) - - real_patterns = [os.path.join(d, p) for p in patterns for d in dirs] - real_exclude_patterns = [os.path.join(d, p) for p in exclude_patterns - for d in dirs] - - inc = [os.path.normpath(name) for p in real_patterns - for name in builtin_glob(p)] - exc = [os.path.normpath(name) for p in real_exclude_patterns - for name in builtin_glob(p)] - return [x for x in inc if x not in exc] - -def glob_tree(roots, patterns, exclude_patterns=None): - """Recursive version of GLOB. Builds the glob of files while - also searching in the subdirectories of the given roots. An - optional set of exclusion patterns will filter out the - matching entries from the result. The exclusions also apply - to the subdirectory scanning, such that directories that - match the exclusion patterns will not be searched.""" - - if not exclude_patterns: - exclude_patterns = [] - - result = glob(roots, patterns, exclude_patterns) - subdirs = [s for s in glob(roots, ["*"]) if s != "." and s != ".." and os.path.isdir(s)] - if subdirs: - result.extend(glob_tree(subdirs, patterns, exclude_patterns)) - - return result - -def glob_in_parents(dir, patterns, upper_limit=None): - """Recursive version of GLOB which glob sall parent directories - of dir until the first match is found. Returns an empty result if no match - is found""" - - assert(isinstance(dir, str)) - assert(isinstance(patterns, list)) - - result = [] - - absolute_dir = os.path.join(os.getcwd(), dir) - absolute_dir = os.path.normpath(absolute_dir) - while absolute_dir: - new_dir = os.path.split(absolute_dir)[0] - if new_dir == absolute_dir: - break - result = glob([new_dir], patterns) - if result: - break - absolute_dir = new_dir - - return result - - -# The relpath functionality is written by -# Cimarron Taylor -def split(p, rest=[]): - (h,t) = os.path.split(p) - if len(h) < 1: return [t]+rest - if len(t) < 1: return [h]+rest - return split(h,[t]+rest) - -def commonpath(l1, l2, common=[]): - if len(l1) < 1: return (common, l1, l2) - if len(l2) < 1: return (common, l1, l2) - if l1[0] != l2[0]: return (common, l1, l2) - return commonpath(l1[1:], l2[1:], common+[l1[0]]) - -def relpath(p1, p2): - (common,l1,l2) = commonpath(split(p1), split(p2)) - p = [] - if len(l1) > 0: - p = [ '../' * len(l1) ] - p = p + l2 - if p: - return os.path.join( *p ) - else: - return "." diff --git a/jam-files/boost-build/util/print.jam b/jam-files/boost-build/util/print.jam deleted file mode 100644 index 708d21ab..00000000 --- a/jam-files/boost-build/util/print.jam +++ /dev/null @@ -1,488 +0,0 @@ -# Copyright 2003 Douglas Gregor -# Copyright 2002, 2003, 2005 Rene Rivera -# Copyright 2002, 2003, 2004, 2005 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) - -# Utilities for generating format independent output. Using these -# will help in generation of documentation in at minimum plain/console -# and html. - -import modules ; -import numbers ; -import string ; -import regex ; -import "class" ; -import scanner ; -import path ; - -# The current output target. Defaults to console. -output-target = console ; - -# The current output type. Defaults to plain. Other possible values are "html". -output-type = plain ; - -# Whitespace. -.whitespace = [ string.whitespace ] ; - - -# Set the target and type of output to generate. This sets both the destination -# output and the type of docs to generate to that output. The target can be -# either a file or "console" for echoing to the console. If the type of output -# is not specified it defaults to plain text. -# -rule output ( - target # The target file or device; file or "console". - type ? # The type of output; "plain" or "html". -) -{ - type ?= plain ; - if $(output-target) != $(target) - { - output-target = $(target) ; - output-type = $(type) ; - if $(output-type) = html - { - text - "<!DOCTYPE html PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\">" - "<html>" - "<head>" - "</head>" - "<body link=\"#0000ff\" vlink=\"#800080\">" - : true - : prefix ; - text - "</body>" - "</html>" - : - : suffix ; - } - } -} - - -# Generate a section with a description. The type of output can be controlled by -# the value of the 'output-type' variable. -# -rule section ( - name # The name of the section. - description * # A number of description lines. -) -{ - if $(output-type) = plain - { - lines [ split-at-words $(name): ] ; - lines ; - } - else if $(output-type) = html - { - name = [ escape-html $(name) ] ; - text <h3>$(name)</h3> <p> ; - } - local pre = ; - while $(description) - { - local paragraph = ; - while $(description) && [ string.is-whitespace $(description[1]) ] { description = $(description[2-]) ; } - if $(pre) - { - while $(description) && ( - $(pre) = " $(description[1])" || - ( $(pre) < [ string.chars [ MATCH "^([$(.whitespace)]*)" : " $(description[1])" ] ] ) - ) - { paragraph += $(description[1]) ; description = $(description[2-]) ; } - while [ string.is-whitespace $(paragraph[-1]) ] { paragraph = $(paragraph[1--2]) ; } - pre = ; - if $(output-type) = plain - { - lines $(paragraph) "" : " " " " ; - } - else if $(output-type) = html - { - text <blockquote> ; - lines $(paragraph) ; - text </blockquote> ; - } - } - else - { - while $(description) && ! [ string.is-whitespace $(description[1]) ] - { paragraph += $(description[1]) ; description = $(description[2-]) ; } - if $(paragraph[1]) = :: && ! $(paragraph[2]) - { - pre = " " ; - } - if $(paragraph[1]) = :: - { - if $(output-type) = plain - { - lines $(paragraph[2-]) "" : " " " " ; - lines ; - } - else if $(output-type) = html - { - text <blockquote> ; - lines $(paragraph[2-]) ; - text </blockquote> ; - } - } - else - { - local p = [ MATCH "(.*)(::)$" : $(paragraph[-1]) ] ; - local pws = [ MATCH "([ ]*)$" : $(p[1]) ] ; - p = [ MATCH "(.*)($(pws))($(p[2]))$" : $(paragraph[-1]) ] ; - if $(p[3]) = :: - { - pre = [ string.chars [ MATCH "^([$(.whitespace)]*)" : " $(p[1])" ] ] ; - if ! $(p[2]) || $(p[2]) = "" { paragraph = $(paragraph[1--2]) $(p[1]): ; } - else { paragraph = $(paragraph[1--2]) $(p[1]) ; } - if $(output-type) = plain - { - lines [ split-at-words " " $(paragraph) ] : " " " " ; - lines ; - } - else if $(output-type) = html - { - text </p> <p> [ escape-html $(paragraph) ] ; - } - } - else - { - if $(output-type) = plain - { - lines [ split-at-words " " $(paragraph) ] : " " " " ; - lines ; - } - else if $(output-type) = html - { - text </p> <p> [ escape-html $(paragraph) ] ; - } - } - } - } - } - if $(output-type) = html - { - text </p> ; - } -} - - -# Generate the start of a list of items. The type of output can be controlled by -# the value of the 'output-type' variable. -# -rule list-start ( ) -{ - if $(output-type) = plain - { - } - else if $(output-type) = html - { - text <ul> ; - } -} - - -# Generate an item in a list. The type of output can be controlled by the value -# of the 'output-type' variable. -# -rule list-item ( - item + # The item to list. -) -{ - if $(output-type) = plain - { - lines [ split-at-words "*" $(item) ] : " " " " ; - } - else if $(output-type) = html - { - text <li> [ escape-html $(item) ] </li> ; - } -} - - -# Generate the end of a list of items. The type of output can be controlled by -# the value of the 'output-type' variable. -# -rule list-end ( ) -{ - if $(output-type) = plain - { - lines ; - } - else if $(output-type) = html - { - text </ul> ; - } -} - - -# Split the given text into separate lines, word-wrapping to a margin. The -# default margin is 78 characters. -# -rule split-at-words ( - text + # The text to split. - : margin ? # An optional margin, default is 78. -) -{ - local lines = ; - text = [ string.words $(text:J=" ") ] ; - text = $(text:J=" ") ; - margin ?= 78 ; - local char-match-1 = ".?" ; - local char-match = "" ; - while $(margin) != 0 - { - char-match = $(char-match)$(char-match-1) ; - margin = [ numbers.decrement $(margin) ] ; - } - while $(text) - { - local s = "" ; - local t = "" ; - # divide s into the first X characters and the rest - s = [ MATCH "^($(char-match))(.*)" : $(text) ] ; - - if $(s[2]) - { - # split the first half at a space - t = [ MATCH "^(.*)[\\ ]([^\\ ]*)$" : $(s[1]) ] ; - } - else - { - t = $(s) ; - } - - if ! $(t[2]) - { - t += "" ; - } - - text = $(t[2])$(s[2]) ; - lines += $(t[1]) ; - } - return $(lines) ; -} - - -# Generate a set of fixed lines. Each single item passed in is output on a -# separate line. For console this just echos each line, but for html this will -# split them with <br>. -# -rule lines ( - text * # The lines of text. - : indent ? # Optional indentation prepended to each line after the first one. - outdent ? # Optional indentation to prepend to the first line. -) -{ - text ?= "" ; - indent ?= "" ; - outdent ?= "" ; - if $(output-type) = plain - { - text $(outdent)$(text[1]) $(indent)$(text[2-]) ; - } - else if $(output-type) = html - { - local indent-chars = [ string.chars $(indent) ] ; - indent = "" ; - for local c in $(indent-chars) - { - if $(c) = " " { c = " " ; } - else if $(c) = " " { c = " " ; } - indent = $(indent)$(c) ; - } - local html-text = [ escape-html $(text) : " " ] ; - text $(html-text[1])<br> $(indent)$(html-text[2-])<br> ; - } -} - - -# Output text directly to the current target. When doing output to a file, one -# can indicate if the text should be output to "prefix" it, as the "body" -# (default), or "suffix" of the file. This is independant of the actual -# execution order of the text rule. This rule invokes a singular action, one -# action only once, which does the build of the file. Therefore actions on the -# target outside of this rule will happen entirely before and/or after all -# output using this rule. -# -rule text ( - strings * # The strings of text to output. - : overwrite ? # true to overwrite the output (if it is a file) - : prefix-body-suffix ? # Indication to output prefix, body, or suffix (for a file). -) -{ - prefix-body-suffix ?= body ; - if $(output-target) = console - { - if ! $(strings) - { - ECHO ; - } - else - { - for local s in $(strings) - { - ECHO $(s) ; - } - } - } - if ! $($(output-target).did-action) - { - $(output-target).did-action = yes ; - $(output-target).text-prefix = ; - $(output-target).text-body = ; - $(output-target).text-suffix = ; - - nl on $(output-target) = " -" ; - text-redirect on $(output-target) = ">>" ; - if $(overwrite) - { - text-redirect on $(output-target) = ">" ; - } - text-content on $(output-target) = ; - - text-action $(output-target) ; - - if $(overwrite) && $(output-target) != console - { - check-for-update $(output-target) ; - } - } - $(output-target).text-$(prefix-body-suffix) += $(strings) ; - text-content on $(output-target) = - $($(output-target).text-prefix) - $($(output-target).text-body) - $($(output-target).text-suffix) ; -} - - -# Outputs the text to the current targets, after word-wrapping it. -# -rule wrapped-text ( text + ) -{ - local lines = [ split-at-words $(text) ] ; - text $(lines) ; -} - - -# Escapes text into html/xml printable equivalents. Does not know about tags and -# therefore tags fed into this will also be escaped. Currently escapes space, -# "<", ">", and "&". -# -rule escape-html ( - text + # The text to escape. - : space ? # What to replace spaces with, defaults to " ". -) -{ - local html-text = ; - while $(text) - { - local html = $(text[1]) ; - text = $(text[2-]) ; - html = [ regex.replace $(html) "&" "&" ] ; - html = [ regex.replace $(html) "<" "<" ] ; - html = [ regex.replace $(html) ">" ">" ] ; - if $(space) - { - html = [ regex.replace $(html) " " "$(space)" ] ; - } - html-text += $(html) ; - } - return $(html-text) ; -} - - -# Outputs the text strings collected by the text rule to the output file. -# -actions quietly text-action -{ - @($(STDOUT):E=$(text-content:J=$(nl))) $(text-redirect) "$(<)" -} - - -rule get-scanner ( ) -{ - if ! $(.scanner) - { - .scanner = [ class.new print-scanner ] ; - } - return $(.scanner) ; -} - - -# The following code to update print targets when their contents -# change is a horrible hack. It basically creates a target which -# binds to this file (print.jam) and installs a scanner on it -# which reads the target and compares its contents to the new -# contents that we're writing. -# -rule check-for-update ( target ) -{ - local scanner = [ get-scanner ] ; - local file = [ path.native [ modules.binding $(__name__) ] ] ; - local g = [ MATCH <(.*)> : $(target:G) ] ; - local dependency-target = $(__file__:G=$(g:E=)-$(target:G=)-$(scanner)) ; - DEPENDS $(target) : $(dependency-target) ; - SEARCH on $(dependency-target) = $(file:D) ; - ISFILE $(dependency-target) ; - NOUPDATE $(dependency-target) ; - base on $(dependency-target) = $(target) ; - scanner.install $(scanner) : $(dependency-target) none ; - return $(dependency-target) ; -} - - -class print-scanner : scanner -{ - import path ; - import os ; - - rule pattern ( ) - { - return "(One match...)" ; - } - - rule process ( target : matches * : binding ) - { - local base = [ on $(target) return $(base) ] ; - local nl = [ on $(base) return $(nl) ] ; - local text-content = [ on $(base) return $(text-content) ] ; - local dir = [ on $(base) return $(LOCATE) ] ; - if $(dir) - { - dir = [ path.make $(dir) ] ; - } - local file = [ path.native [ path.join $(dir) $(base:G=) ] ] ; - local actual-content ; - if [ os.name ] = NT - { - actual-content = [ SHELL "type \"$(file)\" 2>nul" ] ; - } - else - { - actual-content = [ SHELL "cat \"$(file)\" 2>/dev/null" ] ; - } - if $(text-content:J=$(nl)) != $(actual-content) - { - ALWAYS $(base) ; - } - } -} - - -rule __test__ ( ) -{ - import assert ; - - assert.result one two three : split-at-words one two three : 5 ; - assert.result "one two" three : split-at-words one two three : 8 ; - assert.result "one two" three : split-at-words one two three : 9 ; - assert.result "one two three" : split-at-words one two three ; - - # VP, 2004-12-03 The following test fails for some reason, so commenting it - # out. - #assert.result "one two three" "&<>" : - # escape-html "one two three" "&<>" ; -} diff --git a/jam-files/boost-build/util/regex.jam b/jam-files/boost-build/util/regex.jam deleted file mode 100644 index 234c36f6..00000000 --- a/jam-files/boost-build/util/regex.jam +++ /dev/null @@ -1,193 +0,0 @@ -# Copyright 2001, 2002 Dave Abrahams -# Copyright 2003 Douglas Gregor -# Copyright 2003 Rene Rivera -# Copyright 2002, 2003, 2004, 2005 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) - -# -# Returns a list of the following substrings: -# 1) from beginning till the first occurrence of 'separator' or till the end, -# 2) between each occurrence of 'separator' and the next occurrence, -# 3) from the last occurrence of 'separator' till the end. -# If no separator is present, the result will contain only one element. -# - -rule split ( string separator ) -{ - local result ; - local s = $(string) ; - - # Break pieaces off 's' until it has no separators left. - local match = 1 ; - while $(match) - { - match = [ MATCH ^(.*)($(separator))(.*) : $(s) ] ; - if $(match) - { - match += "" ; # in case 3rd item was empty - works around MATCH bug - result = $(match[3]) $(result) ; - s = $(match[1]) ; - } - } - # Combine the remaining part at the beginning, which does not have - # separators, with the pieces broken off. Note that the rule's signature - # does not allow the initial s to be empty. - return $(s) $(result) ; -} - - -# Returns the concatenated results of Applying regex.split to every element of -# the list using the separator pattern. -# -rule split-list ( list * : separator ) -{ - local result ; - for s in $(list) - { - result += [ split $(s) $(separator) ] ; - } - return $(result) ; -} - - -# Match string against pattern, and return the elements indicated by indices. -# -rule match ( pattern : string : indices * ) -{ - indices ?= 1 2 3 4 5 6 7 8 9 ; - local x = [ MATCH $(pattern) : $(string) ] ; - return $(x[$(indices)]) ; -} - - -# Matches all elements of 'list' agains the 'pattern' and returns a list of -# elements indicated by indices of all successful matches. If 'indices' is -# omitted returns a list of first paranthethised groups of all successful -# matches. -# -rule transform ( list * : pattern : indices * ) -{ - indices ?= 1 ; - local result ; - for local e in $(list) - { - local m = [ MATCH $(pattern) : $(e) ] ; - if $(m) - { - result += $(m[$(indices)]) ; - } - } - return $(result) ; -} - -NATIVE_RULE regex : transform ; - - -# Escapes all of the characters in symbols using the escape symbol escape-symbol -# for the given string, and returns the escaped string. -# -rule escape ( string : symbols : escape-symbol ) -{ - local result = "" ; - local m = 1 ; - while $(m) - { - m = [ MATCH ^([^$(symbols)]*)([$(symbols)])(.*) : $(string) ] ; - if $(m) - { - m += "" ; # Supposedly a bug fix; borrowed from regex.split - result = "$(result)$(m[1])$(escape-symbol)$(m[2])" ; - string = $(m[3]) ; - } - } - string ?= "" ; - result = "$(result)$(string)" ; - return $(result) ; -} - - -# Replaces occurrences of a match string in a given string and returns the new -# string. The match string can be a regex expression. -# -rule replace ( - string # The string to modify. - match # The characters to replace. - replacement # The string to replace with. - ) -{ - local result = "" ; - local parts = 1 ; - while $(parts) - { - parts = [ MATCH ^(.*)($(match))(.*) : $(string) ] ; - if $(parts) - { - parts += "" ; - result = "$(replacement)$(parts[3])$(result)" ; - string = $(parts[1]) ; - } - } - string ?= "" ; - result = "$(string)$(result)" ; - return $(result) ; -} - - -# Replaces occurrences of a match string in a given list of strings and returns -# a list of new strings. The match string can be a regex expression. -# -# list - the list of strings to modify. -# match - the search expression. -# replacement - the string to replace with. -# -rule replace-list ( list * : match : replacement ) -{ - local result ; - for local e in $(list) - { - result += [ replace $(e) $(match) $(replacement) ] ; - } - return $(result) ; -} - - -rule __test__ ( ) -{ - import assert ; - - assert.result a b c : split "a/b/c" / ; - assert.result "" a b c : split "/a/b/c" / ; - assert.result "" "" a b c : split "//a/b/c" / ; - assert.result "" a "" b c : split "/a//b/c" / ; - assert.result "" a "" b c "" : split "/a//b/c/" / ; - assert.result "" a "" b c "" "" : split "/a//b/c//" / ; - - assert.result a c b d - : match (.)(.)(.)(.) : abcd : 1 3 2 4 ; - - assert.result a b c d - : match (.)(.)(.)(.) : abcd ; - - assert.result ababab cddc - : match ((ab)*)([cd]+) : abababcddc : 1 3 ; - - assert.result a.h c.h - : transform <a.h> \"b.h\" <c.h> : <(.*)> ; - - assert.result a.h b.h c.h - : transform <a.h> \"b.h\" <c.h> : <([^>]*)>|\"([^\"]*)\" : 1 2 ; - - assert.result "^<?xml version=\"1.0\"^>" - : escape "<?xml version=\"1.0\">" : "&|()<>^" : "^" ; - - assert.result "<?xml version=\\\"1.0\\\">" - : escape "<?xml version=\"1.0\">" : "\\\"" : "\\" ; - - assert.result "string string " : replace "string string " " " " " ; - assert.result " string string" : replace " string string" " " " " ; - assert.result "string string" : replace "string string" " " " " ; - assert.result "-" : replace "&" "&" "-" ; - - assert.result "-" "a-b" : replace-list "&" "a&b" : "&" : "-" ; -} diff --git a/jam-files/boost-build/util/regex.py b/jam-files/boost-build/util/regex.py deleted file mode 100644 index 29e26ecf..00000000 --- a/jam-files/boost-build/util/regex.py +++ /dev/null @@ -1,25 +0,0 @@ -# (C) Copyright David Abrahams 2001. 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. - -import re - -def transform (list, pattern, indices = [1]): - """ Matches all elements of 'list' agains the 'pattern' - and returns a list of the elements indicated by indices of - all successfull matches. If 'indices' is omitted returns - a list of first paranthethised groups of all successfull - matches. - """ - result = [] - - for e in list: - m = re.match (pattern, e) - - if m: - for i in indices: - result.append (m.group (i)) - - return result - diff --git a/jam-files/boost-build/util/sequence.jam b/jam-files/boost-build/util/sequence.jam deleted file mode 100644 index 73919a65..00000000 --- a/jam-files/boost-build/util/sequence.jam +++ /dev/null @@ -1,335 +0,0 @@ -# Copyright 2001, 2002, 2003 Dave Abrahams -# Copyright 2006 Rene Rivera -# Copyright 2002, 2003 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) - -import assert ; -import numbers ; -import modules ; - - -# Note that algorithms in this module execute largely in the caller's module -# namespace, so that local rules can be used as function objects. Also note that -# most predicates can be multi-element lists. In that case, all but the first -# element are prepended to the first argument which is passed to the rule named -# by the first element. - - -# Return the elements e of $(sequence) for which [ $(predicate) e ] has a -# non-null value. -# -rule filter ( predicate + : sequence * ) -{ - local caller = [ CALLER_MODULE ] ; - local result ; - - for local e in $(sequence) - { - if [ modules.call-in $(caller) : $(predicate) $(e) ] - { - result += $(e) ; - } - } - return $(result) ; -} - - -# Return a new sequence consisting of [ $(function) $(e) ] for each element e of -# $(sequence). -# -rule transform ( function + : sequence * ) -{ - local caller = [ CALLER_MODULE ] ; - local result ; - - for local e in $(sequence) - { - result += [ modules.call-in $(caller) : $(function) $(e) ] ; - } - return $(result) ; -} - - -rule reverse ( s * ) -{ - local r ; - for local x in $(s) - { - r = $(x) $(r) ; - } - return $(r) ; -} - - -rule less ( a b ) -{ - if $(a) < $(b) - { - return true ; - } -} - - -# Insertion-sort s using the BinaryPredicate ordered. -# -rule insertion-sort ( s * : ordered * ) -{ - if ! $(ordered) - { - return [ SORT $(s) ] ; - } - else - { - local caller = [ CALLER_MODULE ] ; - ordered ?= sequence.less ; - local result = $(s[1]) ; - if $(ordered) = sequence.less - { - local head tail ; - for local x in $(s[2-]) - { - head = ; - tail = $(result) ; - while $(tail) && ( $(tail[1]) < $(x) ) - { - head += $(tail[1]) ; - tail = $(tail[2-]) ; - } - result = $(head) $(x) $(tail) ; - } - } - else - { - for local x in $(s[2-]) - { - local head tail ; - tail = $(result) ; - while $(tail) && [ modules.call-in $(caller) : $(ordered) $(tail[1]) $(x) ] - { - head += $(tail[1]) ; - tail = $(tail[2-]) ; - } - result = $(head) $(x) $(tail) ; - } - } - - return $(result) ; - } -} - - -# Merge two ordered sequences using the BinaryPredicate ordered. -# -rule merge ( s1 * : s2 * : ordered * ) -{ - ordered ?= sequence.less ; - local result__ ; - local caller = [ CALLER_MODULE ] ; - - while $(s1) && $(s2) - { - if [ modules.call-in $(caller) : $(ordered) $(s1[1]) $(s2[1]) ] - { - result__ += $(s1[1]) ; - s1 = $(s1[2-]) ; - } - else if [ modules.call-in $(caller) : $(ordered) $(s2[1]) $(s1[1]) ] - { - result__ += $(s2[1]) ; - s2 = $(s2[2-]) ; - } - else - { - s2 = $(s2[2-]) ; - } - - } - result__ += $(s1) ; - result__ += $(s2) ; - - return $(result__) ; -} - - -# Join the elements of s into one long string. If joint is supplied, it is used -# as a separator. -# -rule join ( s * : joint ? ) -{ - joint ?= "" ; - return $(s:J=$(joint)) ; -} - - -# Find the length of any sequence. -# -rule length ( s * ) -{ - local result = 0 ; - for local i in $(s) - { - result = [ CALC $(result) + 1 ] ; - } - return $(result) ; -} - - -rule unique ( list * : stable ? ) -{ - local result ; - local prev ; - if $(stable) - { - for local f in $(list) - { - if ! $(f) in $(result) - { - result += $(f) ; - } - } - } - else - { - for local i in [ SORT $(list) ] - { - if $(i) != $(prev) - { - result += $(i) ; - } - prev = $(i) ; - } - } - return $(result) ; -} - - -# Returns the maximum number in 'elements'. Uses 'ordered' for comparisons or -# 'numbers.less' if none is provided. -# -rule max-element ( elements + : ordered ? ) -{ - ordered ?= numbers.less ; - - local max = $(elements[1]) ; - for local e in $(elements[2-]) - { - if [ $(ordered) $(max) $(e) ] - { - max = $(e) ; - } - } - return $(max) ; -} - - -# Returns all of 'elements' for which corresponding element in parallel list -# 'rank' is equal to the maximum value in 'rank'. -# -rule select-highest-ranked ( elements * : ranks * ) -{ - if $(elements) - { - local max-rank = [ max-element $(ranks) ] ; - local result ; - while $(elements) - { - if $(ranks[1]) = $(max-rank) - { - result += $(elements[1]) ; - } - elements = $(elements[2-]) ; - ranks = $(ranks[2-]) ; - } - return $(result) ; - } -} -NATIVE_RULE sequence : select-highest-ranked ; - - -rule __test__ ( ) -{ - # Use a unique module so we can test the use of local rules. - module sequence.__test__ - { - import assert ; - import sequence ; - - local rule is-even ( n ) - { - if $(n) in 0 2 4 6 8 - { - return true ; - } - } - - assert.result 4 6 4 2 8 : sequence.filter is-even : 1 4 6 3 4 7 2 3 8 ; - - # Test that argument binding works. - local rule is-equal-test ( x y ) - { - if $(x) = $(y) - { - return true ; - } - } - - assert.result 3 3 3 : sequence.filter is-equal-test 3 : 1 2 3 4 3 5 3 5 7 ; - - local rule append-x ( n ) - { - return $(n)x ; - } - - assert.result 1x 2x 3x : sequence.transform append-x : 1 2 3 ; - - local rule repeat2 ( x ) - { - return $(x) $(x) ; - } - - assert.result 1 1 2 2 3 3 : sequence.transform repeat2 : 1 2 3 ; - - local rule test-greater ( a b ) - { - if $(a) > $(b) - { - return true ; - } - } - assert.result 1 2 3 4 5 6 7 8 9 : sequence.insertion-sort 9 6 5 3 8 7 1 2 4 ; - assert.result 9 8 7 6 5 4 3 2 1 : sequence.insertion-sort 9 6 5 3 8 7 1 2 4 : test-greater ; - assert.result 1 2 3 4 5 6 : sequence.merge 1 3 5 : 2 4 6 ; - assert.result 6 5 4 3 2 1 : sequence.merge 5 3 1 : 6 4 2 : test-greater ; - assert.result 1 2 3 : sequence.merge 1 2 3 : ; - assert.result 1 : sequence.merge 1 : 1 ; - - assert.result foo-bar-baz : sequence.join foo bar baz : - ; - assert.result substandard : sequence.join sub stan dard ; - assert.result 3.0.1 : sequence.join 3.0.1 : - ; - - assert.result 0 : sequence.length ; - assert.result 3 : sequence.length a b c ; - assert.result 17 : sequence.length 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 ; - - assert.result 1 : sequence.length a ; - assert.result 10 : sequence.length a b c d e f g h i j ; - assert.result 11 : sequence.length a b c d e f g h i j k ; - assert.result 12 : sequence.length a b c d e f g h i j k l ; - - local p2 = x ; - for local i in 1 2 3 4 5 6 7 8 - { - p2 = $(p2) $(p2) ; - } - assert.result 256 : sequence.length $(p2) ; - - assert.result 1 2 3 4 5 : sequence.unique 1 2 3 2 4 3 3 5 5 5 ; - - assert.result 5 : sequence.max-element 1 3 5 0 4 ; - - assert.result e-3 h-3 : sequence.select-highest-ranked e-1 e-3 h-3 m-2 : 1 3 3 2 ; - - assert.result 7 6 5 4 3 2 1 : sequence.reverse 1 2 3 4 5 6 7 ; - } -} diff --git a/jam-files/boost-build/util/sequence.py b/jam-files/boost-build/util/sequence.py deleted file mode 100644 index 1d32efd2..00000000 --- a/jam-files/boost-build/util/sequence.py +++ /dev/null @@ -1,50 +0,0 @@ -# (C) Copyright David Abrahams 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. - -import operator - -def unique (values, stable=False): - if stable: - s = set() - r = [] - for v in values: - if not v in s: - r.append(v) - s.add(v) - return r - else: - return list(set(values)) - -def max_element (elements, ordered = None): - """ Returns the maximum number in 'elements'. Uses 'ordered' for comparisons, - or '<' is none is provided. - """ - if not ordered: ordered = operator.lt - - max = elements [0] - for e in elements [1:]: - if ordered (max, e): - max = e - - return max - -def select_highest_ranked (elements, ranks): - """ Returns all of 'elements' for which corresponding element in parallel - list 'rank' is equal to the maximum value in 'rank'. - """ - if not elements: - return [] - - max_rank = max_element (ranks) - - result = [] - while elements: - if ranks [0] == max_rank: - result.append (elements [0]) - - elements = elements [1:] - ranks = ranks [1:] - - return result diff --git a/jam-files/boost-build/util/set.jam b/jam-files/boost-build/util/set.jam deleted file mode 100644 index fc179134..00000000 --- a/jam-files/boost-build/util/set.jam +++ /dev/null @@ -1,93 +0,0 @@ -# Copyright 2001, 2002 Dave Abrahams -# Copyright 2003 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) - -class set -{ - rule __init__ ( ) - { - } - - rule add ( elements * ) - { - for local e in $(elements) - { - if ! $($(e)) - { - $(e) = 1 ; - self.result += $(e) ; - } - } - } - - rule contains ( element ) - { - return $($(element)) ; - } - - rule list ( ) - { - return $(self.result) ; - } -} - - - -# Returns the elements of set1 that are not in set2. -# -rule difference ( set1 * : set2 * ) -{ - local result = ; - for local element in $(set1) - { - if ! ( $(element) in $(set2) ) - { - result += $(element) ; - } - } - return $(result) ; -} - -NATIVE_RULE set : difference ; - - -# Removes all the items appearing in both set1 & set2. -# -rule intersection ( set1 * : set2 * ) -{ - local result ; - for local v in $(set1) - { - if $(v) in $(set2) - { - result += $(v) ; - } - } - return $(result) ; -} - - -# Returns whether set1 & set2 contain the same elements. Note that this ignores -# any element ordering differences as well as any element duplication. -# -rule equal ( set1 * : set2 * ) -{ - if $(set1) in $(set2) && ( $(set2) in $(set1) ) - { - return true ; - } -} - - -rule __test__ ( ) -{ - import assert ; - - assert.result 0 1 4 6 8 9 : difference 0 1 2 3 4 5 6 7 8 9 : 2 3 5 7 ; - assert.result 2 5 7 : intersection 0 1 2 4 5 6 7 8 9 : 2 3 5 7 ; - - assert.true equal : ; - assert.true equal 1 1 2 3 : 3 2 2 1 ; - assert.false equal 2 3 : 3 2 2 1 ; -} diff --git a/jam-files/boost-build/util/set.py b/jam-files/boost-build/util/set.py deleted file mode 100644 index dc7cf328..00000000 --- a/jam-files/boost-build/util/set.py +++ /dev/null @@ -1,42 +0,0 @@ -# (C) Copyright David Abrahams 2001. 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. - -from utility import to_seq - -def difference (b, a): - """ Returns the elements of B that are not in A. - """ - result = [] - for element in b: - if not element in a: - result.append (element) - - return result - -def intersection (set1, set2): - """ Removes from set1 any items which don't appear in set2 and returns the result. - """ - result = [] - for v in set1: - if v in set2: - result.append (v) - return result - -def contains (small, large): - """ Returns true iff all elements of 'small' exist in 'large'. - """ - small = to_seq (small) - large = to_seq (large) - - for s in small: - if not s in large: - return False - return True - -def equal (a, b): - """ Returns True iff 'a' contains the same elements as 'b', irrespective of their order. - # TODO: Python 2.4 has a proper set class. - """ - return contains (a, b) and contains (b, a) diff --git a/jam-files/boost-build/util/string.jam b/jam-files/boost-build/util/string.jam deleted file mode 100644 index a39ed119..00000000 --- a/jam-files/boost-build/util/string.jam +++ /dev/null @@ -1,189 +0,0 @@ -# Copyright 2002 Dave Abrahams -# Copyright 2002, 2003 Rene Rivera -# 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) - -import regex ; - - -# Characters considered whitespace, as a list. -.whitespace-chars = " " " " " -" ; - -# Characters considered whitespace, as a single string. -.whitespace = $(.whitespace-chars:J="") ; - - -# Returns the canonical set of whitespace characters, as a list. -# -rule whitespace-chars ( ) -{ - return $(.whitespace-chars) ; -} - - -# Returns the canonical set of whitespace characters, as a single string. -# -rule whitespace ( ) -{ - return $(.whitespace) ; -} - - -# Splits the given string into a list of strings composed of each character of -# the string in sequence. -# -rule chars ( - string # The string to split. - ) -{ - local result ; - while $(string) - { - local s = [ MATCH (.?)(.?)(.?)(.?)(.?)(.?)(.?)(.?)(.*) : $(string) ] ; - string = $(s[9]) ; - result += $(s[1-8]) ; - } - - # Trim off empty strings. - while $(result[1]) && ! $(result[-1]) - { - result = $(result[1--2]) ; - } - - return $(result) ; -} - - -# Apply a set of standard transformations to string to produce an abbreviation -# no more than 5 characters long. -# -rule abbreviate ( string ) -{ - local r = $(.abbreviated-$(string)) ; - if $(r) - { - return $(r) ; - } - # Anything less than 4 characters gets no abbreviation. - else if ! [ MATCH (....) : $(string) ] - { - .abbreviated-$(string) = $(string) ; - return $(string) ; - } - else - { - # Separate the initial letter in case it's a vowel. - local s1 = [ MATCH ^(.)(.*) : $(string) ] ; - - # Drop trailing "ing". - local s2 = [ MATCH ^(.*)ing$ : $(s1[2]) ] ; - s2 ?= $(s1[2]) ; - - # Reduce all doubled characters to one. - local last = "" ; - for local c in [ chars $(s2) ] - { - if $(c) != $(last) - { - r += $(c) ; - last = $(c) ; - } - } - s2 = $(r:J="") ; - - # Chop all vowels out of the remainder. - s2 = [ regex.replace $(s2) [AEIOUaeiou] "" ] ; - - # Shorten remaining consonants to 4 characters. - s2 = [ MATCH ^(.?.?.?.?) : $(s2) ] ; - - # Glue the initial character back on to the front. - s2 = $(s1[1])$(s2) ; - - .abbreviated-$(string) = $(s2) ; - return $(s2) ; - } -} - - -# Concatenates the given strings, inserting the given separator between each -# string. -# -rule join ( - strings * # The strings to join. - : separator ? # The optional separator. - ) -{ - separator ?= "" ; - return $(strings:J=$(separator)) ; -} - - -# Split a string into whitespace separated words. -# -rule words ( - string # The string to split. - : whitespace * # Optional, characters to consider as whitespace. - ) -{ - whitespace = $(whitespace:J="") ; - whitespace ?= $(.whitespace) ; - local w = ; - while $(string) - { - string = [ MATCH "^[$(whitespace)]*([^$(whitespace)]*)(.*)" : $(string) ] ; - if $(string[1]) && $(string[1]) != "" - { - w += $(string[1]) ; - } - string = $(string[2]) ; - } - return $(w) ; -} - - -# Check that the given string is composed entirely of whitespace. -# -rule is-whitespace ( - string ? # The string to test. - ) -{ - if ! $(string) { return true ; } - else if $(string) = "" { return true ; } - else if [ MATCH "^([$(.whitespace)]+)$" : $(string) ] { return true ; } - else { return ; } -} - -rule __test__ ( ) -{ - import assert ; - assert.result a b c : chars abc ; - - assert.result rntm : abbreviate runtime ; - assert.result ovrld : abbreviate overload ; - assert.result dbg : abbreviate debugging ; - assert.result async : abbreviate asynchronous ; - assert.result pop : abbreviate pop ; - assert.result aaa : abbreviate aaa ; - assert.result qck : abbreviate quack ; - assert.result sttc : abbreviate static ; - - # Check boundary cases. - assert.result a : chars a ; - assert.result : chars "" ; - assert.result a b c d e f g h : chars abcdefgh ; - assert.result a b c d e f g h i : chars abcdefghi ; - assert.result a b c d e f g h i j : chars abcdefghij ; - assert.result a b c d e f g h i j k : chars abcdefghijk ; - - assert.result a//b/c/d : join a "" b c d : / ; - assert.result abcd : join a "" b c d ; - - assert.result a b c : words "a b c" ; - - assert.true is-whitespace " " ; - assert.false is-whitespace " a b c " ; - assert.true is-whitespace "" ; - assert.true is-whitespace ; -} diff --git a/jam-files/boost-build/util/utility.jam b/jam-files/boost-build/util/utility.jam deleted file mode 100644 index c46747f5..00000000 --- a/jam-files/boost-build/util/utility.jam +++ /dev/null @@ -1,235 +0,0 @@ -# Copyright 2001, 2002 Dave Abrahams -# Copyright 2002, 2003, 2004, 2005 Vladimir Prus -# Copyright 2008 Jurko Gospodnetic -# 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) - -import "class" : is-instance ; -import errors ; - - -# For all elements of 'list' which do not already have 'suffix', add 'suffix'. -# -rule apply-default-suffix ( suffix : list * ) -{ - local result ; - for local i in $(list) - { - if $(i:S) = $(suffix) - { - result += $(i) ; - } - else - { - result += $(i)$(suffix) ; - } - } - return $(result) ; -} - - -# If 'name' contains a dot, returns the part before the last dot. If 'name' -# contains no dot, returns it unmodified. -# -rule basename ( name ) -{ - if $(name:S) - { - name = $(name:B) ; - } - return $(name) ; -} - - -# Return the file of the caller of the rule that called caller-file. -# -rule caller-file ( ) -{ - local bt = [ BACKTRACE ] ; - return $(bt[9]) ; -} - - -# Tests if 'a' is equal to 'b'. If 'a' is a class instance, calls its 'equal' -# method. Uses ordinary jam's comparison otherwise. -# -rule equal ( a b ) -{ - if [ is-instance $(a) ] - { - return [ $(a).equal $(b) ] ; - } - else - { - if $(a) = $(b) - { - return true ; - } - } -} - - -# Tests if 'a' is less than 'b'. If 'a' is a class instance, calls its 'less' -# method. Uses ordinary jam's comparison otherwise. -# -rule less ( a b ) -{ - if [ is-instance $(a) ] - { - return [ $(a).less $(b) ] ; - } - else - { - if $(a) < $(b) - { - return true ; - } - } -} - - -# Returns the textual representation of argument. If it is a class instance, -# class its 'str' method. Otherwise, returns the argument. -# -rule str ( value ) -{ - if [ is-instance $(value) ] - { - return [ $(value).str ] ; - } - else - { - return $(value) ; - } -} - - -# Accepts a list of gristed values and returns them ungristed. Reports an error -# in case any of the passed parameters is not gristed, i.e. surrounded in angle -# brackets < and >. -# -rule ungrist ( names * ) -{ - local result ; - for local name in $(names) - { - local stripped = [ MATCH ^<(.*)>$ : $(name) ] ; - if ! $(stripped) - { - errors.error "in ungrist $(names) : $(name) is not of the form <.*>" ; - } - result += $(stripped) ; - } - return $(result) ; -} - - -# If the passed value is quoted, unquotes it. Otherwise returns the value -# unchanged. -# -rule unquote ( value ? ) -{ - local match-result = [ MATCH ^(\")(.*)(\")$ : $(value) ] ; - if $(match-result) - { - return $(match-result[2]) ; - } - else - { - return $(value) ; - } -} - - -rule __test__ ( ) -{ - import assert ; - import "class" : new ; - import errors : try catch ; - - assert.result 123 : str 123 ; - - class test-class__ - { - rule __init__ ( ) { } - rule str ( ) { return "str-test-class" ; } - rule less ( a ) { return "yes, of course!" ; } - rule equal ( a ) { return "not sure" ; } - } - - assert.result "str-test-class" : str [ new test-class__ ] ; - assert.true less 1 2 ; - assert.false less 2 1 ; - assert.result "yes, of course!" : less [ new test-class__ ] 1 ; - assert.true equal 1 1 ; - assert.false equal 1 2 ; - assert.result "not sure" : equal [ new test-class__ ] 1 ; - - assert.result foo.lib foo.lib : apply-default-suffix .lib : foo.lib foo.lib - ; - - assert.result foo : basename foo ; - assert.result foo : basename foo.so ; - assert.result foo.so : basename foo.so.1 ; - - assert.result : unquote ; - assert.result "" : unquote "" ; - assert.result foo : unquote foo ; - assert.result \"foo : unquote \"foo ; - assert.result foo\" : unquote foo\" ; - assert.result foo : unquote \"foo\" ; - assert.result \"foo\" : unquote \"\"foo\"\" ; - - assert.result : ungrist ; - assert.result foo : ungrist <foo> ; - assert.result <foo> : ungrist <<foo>> ; - assert.result foo bar : ungrist <foo> <bar> ; - - try ; - { - ungrist "" ; - } - catch "in ungrist : is not of the form <.*>" ; - - try ; - { - ungrist <> ; - } - catch "in ungrist <> : <> is not of the form <.*>" ; - - try ; - { - ungrist foo ; - } - catch "in ungrist foo : foo is not of the form <.*>" ; - - try ; - { - ungrist <foo ; - } - catch "in ungrist <foo : <foo is not of the form <.*>" ; - - try ; - { - ungrist foo> ; - } - catch "in ungrist foo> : foo> is not of the form <.*>" ; - - try ; - { - ungrist foo bar ; - } - catch "in ungrist foo : foo is not of the form <.*>" ; - - try ; - { - ungrist foo <bar> ; - } - catch "in ungrist foo : foo is not of the form <.*>" ; - - try ; - { - ungrist <foo> bar ; - } - catch "in ungrist bar : bar is not of the form <.*>" ; -} diff --git a/jam-files/boost-build/util/utility.py b/jam-files/boost-build/util/utility.py deleted file mode 100644 index afea765b..00000000 --- a/jam-files/boost-build/util/utility.py +++ /dev/null @@ -1,155 +0,0 @@ -# (C) Copyright David Abrahams 2001. 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. - -""" Utility functions to add/remove/get grists. - Grists are string enclosed in angle brackets (<>) that are used as prefixes. See Jam for more information. -""" - -import re -import os -import bjam -from b2.exceptions import * - -__re_grist_and_value = re.compile (r'(<[^>]*>)(.*)') -__re_grist_content = re.compile ('^<(.*)>$') -__re_backslash = re.compile (r'\\') - -def to_seq (value): - """ If value is a sequence, returns it. - If it is a string, returns a sequence with value as its sole element. - """ - if not value: - return [] - - if isinstance (value, str): - return [value] - - else: - return value - -def replace_references_by_objects (manager, refs): - objs = [] - for r in refs: - objs.append (manager.get_object (r)) - return objs - -def add_grist (features): - """ Transform a string by bracketing it with "<>". If already bracketed, does nothing. - features: one string or a sequence of strings - return: the gristed string, if features is a string, or a sequence of gristed strings, if features is a sequence - """ - - def grist_one (feature): - if feature [0] != '<' and feature [len (feature) - 1] != '>': - return '<' + feature + '>' - else: - return feature - - if isinstance (features, str): - return grist_one (features) - else: - return [ grist_one (feature) for feature in features ] - -def replace_grist (features, new_grist): - """ Replaces the grist of a string by a new one. - Returns the string with the new grist. - """ - def replace_grist_one (name, new_grist): - split = __re_grist_and_value.match (name) - if not split: - return new_grist + name - else: - return new_grist + split.group (2) - - if isinstance (features, str): - return replace_grist_one (features, new_grist) - else: - return [ replace_grist_one (feature, new_grist) for feature in features ] - -def get_value (property): - """ Gets the value of a property, that is, the part following the grist, if any. - """ - return replace_grist (property, '') - -def get_grist (value): - """ Returns the grist of a string. - If value is a sequence, does it for every value and returns the result as a sequence. - """ - def get_grist_one (name): - split = __re_grist_and_value.match (name) - if not split: - return '' - else: - return split.group (1) - - if isinstance (value, str): - return get_grist_one (value) - else: - return [ get_grist_one (v) for v in value ] - -def ungrist (value): - """ Returns the value without grist. - If value is a sequence, does it for every value and returns the result as a sequence. - """ - def ungrist_one (value): - stripped = __re_grist_content.match (value) - if not stripped: - raise BaseException ("in ungrist: '%s' is not of the form <.*>" % value) - - return stripped.group (1) - - if isinstance (value, str): - return ungrist_one (value) - else: - return [ ungrist_one (v) for v in value ] - -def replace_suffix (name, new_suffix): - """ Replaces the suffix of name by new_suffix. - If no suffix exists, the new one is added. - """ - split = os.path.splitext (name) - return split [0] + new_suffix - -def forward_slashes (s): - """ Converts all backslashes to forward slashes. - """ - return __re_backslash.sub ('/', s) - - -def split_action_id (id): - """ Splits an id in the toolset and specific rule parts. E.g. - 'gcc.compile.c++' returns ('gcc', 'compile.c++') - """ - split = id.split ('.', 1) - toolset = split [0] - name = '' - if len (split) > 1: - name = split [1] - return (toolset, name) - -def os_name (): - result = bjam.variable("OS") - assert(len(result) == 1) - return result[0] - -def platform (): - return bjam.variable("OSPLAT") - -def os_version (): - return bjam.variable("OSVER") - -def on_windows (): - """ Returns true if running on windows, whether in cygwin or not. - """ - if bjam.variable("NT"): - return True - - elif bjam.variable("UNIX"): - - uname = bjam.variable("JAMUNAME") - if uname and uname[0].startswith("CYGWIN"): - return True - - return False |