Imported Upstream version 1.2.0.d20091224upstream/1.2.0.d20091224

12 files changed, 2399 insertions, 0 deletions

diff --git a/src/engine/SCons/Variables/BoolVariable.py b/src/engine/SCons/Variables/BoolVariable.py
new file mode 100644
index 0000000..1209a4c
--- /dev/null
+++ b/src/engine/SCons/Variables/BoolVariable.py
@@ -0,0 +1,91 @@
+"""engine.SCons.Variables.BoolVariable
+
+This file defines the option type for SCons implementing true/false values.
+
+Usage example:
+
+  opts = Variables()
+  opts.Add(BoolVariable('embedded', 'build for an embedded system', 0))
+  ...
+  if env['embedded'] == 1:
+    ...
+"""
+
+#
+# Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 The SCons Foundation
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be included
+# in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
+# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+
+__revision__ = "src/engine/SCons/Variables/BoolVariable.py 4577 2009/12/27 19:44:43 scons"
+
+__all__ = ['BoolVariable',]
+
+import string
+
+import SCons.Errors
+
+__true_strings  = ('y', 'yes', 'true', 't', '1', 'on' , 'all' )
+__false_strings = ('n', 'no', 'false', 'f', '0', 'off', 'none')
+
+
+def _text2bool(val):
+    """
+    Converts strings to True/False depending on the 'truth' expressed by
+    the string. If the string can't be converted, the original value
+    will be returned.
+
+    See '__true_strings' and '__false_strings' for values considered
+    'true' or 'false respectivly.
+
+    This is usable as 'converter' for SCons' Variables.
+    """
+    lval = string.lower(val)
+    if lval in __true_strings: return True
+    if lval in __false_strings: return False
+    raise ValueError("Invalid value for boolean option: %s" % val)
+
+
+def _validator(key, val, env):
+    """
+    Validates the given value to be either '0' or '1'.
+    
+    This is usable as 'validator' for SCons' Variables.
+    """
+    if not env[key] in (True, False):
+        raise SCons.Errors.UserError(
+            'Invalid value for boolean option %s: %s' % (key, env[key]))
+
+
+def BoolVariable(key, help, default):
+    """
+    The input parameters describe a boolen option, thus they are
+    returned with the correct converter and validator appended. The
+    'help' text will by appended by '(yes|no) to show the valid
+    valued. The result is usable for input to opts.Add().
+    """
+    return (key, '%s (yes|no)' % help, default,
+            _validator, _text2bool)
+
+# Local Variables:
+# tab-width:4
+# indent-tabs-mode:nil
+# End:
+# vim: set expandtab tabstop=4 shiftwidth=4:
diff --git a/src/engine/SCons/Variables/BoolVariableTests.py b/src/engine/SCons/Variables/BoolVariableTests.py
new file mode 100644
index 0000000..c33d9d0
--- /dev/null
+++ b/src/engine/SCons/Variables/BoolVariableTests.py
@@ -0,0 +1,127 @@
+#
+# Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 The SCons Foundation
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be included
+# in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
+# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+
+__revision__ = "src/engine/SCons/Variables/BoolVariableTests.py 4577 2009/12/27 19:44:43 scons"
+
+import sys
+import unittest
+
+import SCons.Errors
+import SCons.Variables
+
+class BoolVariableTestCase(unittest.TestCase):
+    def test_BoolVariable(self):
+        """Test BoolVariable creation"""
+        opts = SCons.Variables.Variables()
+        opts.Add(SCons.Variables.BoolVariable('test', 'test option help', 0))
+
+        o = opts.options[0]
+        assert o.key == 'test', o.key
+        assert o.help == 'test option help (yes|no)', o.help
+        assert o.default == 0, o.default
+        assert o.validator is not None, o.validator
+        assert o.converter is not None, o.converter
+
+    def test_converter(self):
+        """Test the BoolVariable converter"""
+        opts = SCons.Variables.Variables()
+        opts.Add(SCons.Variables.BoolVariable('test', 'test option help', 0))
+
+        o = opts.options[0]
+
+        true_values = [
+                'y',    'Y',
+                'yes',  'YES',
+                't',    'T',
+                'true', 'TRUE',
+                'on',   'ON',
+                'all',  'ALL',
+                '1',
+        ]
+        false_values = [
+                'n',    'N',
+                'no',   'NO',
+                'f',    'F',
+                'false', 'FALSE',
+                'off',  'OFF',
+                'none', 'NONE',
+                '0',
+        ]
+
+        for t in true_values:
+            x = o.converter(t)
+            assert x, "converter returned false for '%s'" % t
+
+        for f in false_values:
+            x = o.converter(f)
+            assert not x, "converter returned true for '%s'" % f
+
+        caught = None
+        try:
+            o.converter('x')
+        except ValueError:
+            caught = 1
+        assert caught, "did not catch expected ValueError"
+
+    def test_validator(self):
+        """Test the BoolVariable validator"""
+        opts = SCons.Variables.Variables()
+        opts.Add(SCons.Variables.BoolVariable('test', 'test option help', 0))
+
+        o = opts.options[0]
+
+        env = {
+            'T' : True,
+            'F' : False,
+            'N' : 'xyzzy',
+        }
+
+        o.validator('T', 0, env)
+
+        o.validator('F', 0, env)
+
+        caught = None
+        try:
+            o.validator('N', 0, env)
+        except SCons.Errors.UserError:
+            caught = 1
+        assert caught, "did not catch expected UserError for N"
+
+        caught = None
+        try:
+            o.validator('NOSUCHKEY', 0, env)
+        except KeyError:
+            caught = 1
+        assert caught, "did not catch expected KeyError for NOSUCHKEY"
+
+
+if __name__ == "__main__":
+    suite = unittest.makeSuite(BoolVariableTestCase, 'test_')
+    if not unittest.TextTestRunner().run(suite).wasSuccessful():
+        sys.exit(1)
+
+# Local Variables:
+# tab-width:4
+# indent-tabs-mode:nil
+# End:
+# vim: set expandtab tabstop=4 shiftwidth=4:
diff --git a/src/engine/SCons/Variables/EnumVariable.py b/src/engine/SCons/Variables/EnumVariable.py
new file mode 100644
index 0000000..90ed48e
--- /dev/null
+++ b/src/engine/SCons/Variables/EnumVariable.py
@@ -0,0 +1,107 @@
+"""engine.SCons.Variables.EnumVariable
+
+This file defines the option type for SCons allowing only specified
+input-values.
+
+Usage example:
+
+  opts = Variables()
+  opts.Add(EnumVariable('debug', 'debug output and symbols', 'no',
+                      allowed_values=('yes', 'no', 'full'),
+                      map={}, ignorecase=2))
+  ...
+  if env['debug'] == 'full':
+    ...
+"""
+
+#
+# Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 The SCons Foundation
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be included
+# in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
+# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+
+__revision__ = "src/engine/SCons/Variables/EnumVariable.py 4577 2009/12/27 19:44:43 scons"
+
+__all__ = ['EnumVariable',]
+
+import string
+
+import SCons.Errors
+
+def _validator(key, val, env, vals):
+    if not val in vals:
+        raise SCons.Errors.UserError(
+            'Invalid value for option %s: %s' % (key, val))
+
+
+def EnumVariable(key, help, default, allowed_values, map={}, ignorecase=0):
+    """
+    The input parameters describe a option with only certain values
+    allowed. They are returned with an appropriate converter and
+    validator appended. The result is usable for input to
+    Variables.Add().
+
+    'key' and 'default' are the values to be passed on to Variables.Add().
+
+    'help' will be appended by the allowed values automatically
+
+    'allowed_values' is a list of strings, which are allowed as values
+    for this option.
+
+    The 'map'-dictionary may be used for converting the input value
+    into canonical values (eg. for aliases).
+
+    'ignorecase' defines the behaviour of the validator:
+
+    If ignorecase == 0, the validator/converter are case-sensitive.
+    If ignorecase == 1, the validator/converter are case-insensitive.
+    If ignorecase == 2, the validator/converter is case-insensitive and
+                        the converted value will always be lower-case.
+
+    The 'validator' tests whether the value is in the list of allowed
+    values. The 'converter' converts input values according to the
+    given 'map'-dictionary (unmapped input values are returned
+    unchanged). 
+    """
+    help = '%s (%s)' % (help, string.join(allowed_values, '|'))
+    # define validator
+    if ignorecase >= 1:
+        validator = lambda key, val, env, vals=allowed_values: \
+                    _validator(key, string.lower(val), env, vals)
+    else:
+        validator = lambda key, val, env, vals=allowed_values: \
+                    _validator(key, val, env, vals)
+    # define converter
+    if ignorecase == 2:
+        converter = lambda val, map=map: \
+                    string.lower(map.get(string.lower(val), val))
+    elif ignorecase == 1:
+        converter = lambda val, map=map: \
+                    map.get(string.lower(val), val)
+    else:
+        converter = lambda val, map=map: \
+                    map.get(val, val)
+    return (key, help, default, validator, converter)
+
+# Local Variables:
+# tab-width:4
+# indent-tabs-mode:nil
+# End:
+# vim: set expandtab tabstop=4 shiftwidth=4:
diff --git a/src/engine/SCons/Variables/EnumVariableTests.py b/src/engine/SCons/Variables/EnumVariableTests.py
new file mode 100644
index 0000000..668487d
--- /dev/null
+++ b/src/engine/SCons/Variables/EnumVariableTests.py
@@ -0,0 +1,204 @@
+#
+# Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 The SCons Foundation
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be included
+# in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
+# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+
+__revision__ = "src/engine/SCons/Variables/EnumVariableTests.py 4577 2009/12/27 19:44:43 scons"
+
+import sys
+import unittest
+
+import SCons.Errors
+import SCons.Variables
+
+class EnumVariableTestCase(unittest.TestCase):
+    def test_EnumVariable(self):
+        """Test EnumVariable creation"""
+        opts = SCons.Variables.Variables()
+        opts.Add(SCons.Variables.EnumVariable('test', 'test option help', 0,
+                                          ['one', 'two', 'three'],
+                                          {}))
+
+        o = opts.options[0]
+        assert o.key == 'test', o.key
+        assert o.help == 'test option help (one|two|three)', o.help
+        assert o.default == 0, o.default
+        assert o.validator is not None, o.validator
+        assert o.converter is not None, o.converter
+
+    def test_converter(self):
+        """Test the EnumVariable converter"""
+        opts = SCons.Variables.Variables()
+        opts.Add(SCons.Variables.EnumVariable('test', 'test option help', 0,
+                                          ['one', 'two', 'three']))
+
+        o = opts.options[0]
+
+        for a in ['one', 'two', 'three', 'no_match']:
+            x = o.converter(a)
+            assert x == a, x
+
+        opts = SCons.Variables.Variables()
+        opts.Add(SCons.Variables.EnumVariable('test', 'test option help', 0,
+                                          ['one', 'two', 'three'],
+                                          {'1' : 'one',
+                                           '2' : 'two',
+                                           '3' : 'three'}))
+
+        o = opts.options[0]
+
+        x = o.converter('one')
+        assert x == 'one', x
+        x = o.converter('1')
+        assert x == 'one', x
+
+        x = o.converter('two')
+        assert x == 'two', x
+        x = o.converter('2')
+        assert x == 'two', x
+
+        x = o.converter('three')
+        assert x == 'three', x
+        x = o.converter('3')
+        assert x == 'three', x
+
+        opts = SCons.Variables.Variables()
+        opts.Add(SCons.Variables.EnumVariable('test0', 'test option help', 0,
+                                          ['one', 'two', 'three'],
+                                          {'a' : 'one',
+                                           'b' : 'two',
+                                           'c' : 'three'},
+                                          ignorecase=0))
+        opts.Add(SCons.Variables.EnumVariable('test1', 'test option help', 0,
+                                          ['one', 'two', 'three'],
+                                          {'a' : 'one',
+                                           'b' : 'two',
+                                           'c' : 'three'},
+                                          ignorecase=1))
+        opts.Add(SCons.Variables.EnumVariable('test2', 'test option help', 0,
+                                          ['one', 'two', 'three'],
+                                          {'a' : 'one',
+                                           'b' : 'two',
+                                           'c' : 'three'},
+                                          ignorecase=2))
+
+        o0 = opts.options[0]
+        o1 = opts.options[1]
+        o2 = opts.options[2]
+
+        table = {
+            'one'   : ['one',   'one',   'one'],
+            'One'   : ['One',   'One',   'one'],
+            'ONE'   : ['ONE',   'ONE',   'one'],
+            'two'   : ['two',   'two',   'two'],
+            'twO'   : ['twO',   'twO',   'two'],
+            'TWO'   : ['TWO',   'TWO',   'two'],
+            'three' : ['three', 'three', 'three'],
+            'thRee' : ['thRee', 'thRee', 'three'],
+            'THREE' : ['THREE', 'THREE', 'three'],
+            'a'     : ['one',   'one',   'one'],
+            'A'     : ['A',     'one',   'one'],
+            'b'     : ['two',   'two',   'two'],
+            'B'     : ['B',     'two',   'two'],
+            'c'     : ['three', 'three', 'three'],
+            'C'     : ['C',     'three', 'three'],
+        }
+
+        for k, l in table.items():
+            x = o0.converter(k)
+            assert x == l[0], "o0 got %s, expected %s" % (x, l[0])
+            x = o1.converter(k)
+            assert x == l[1], "o1 got %s, expected %s" % (x, l[1])
+            x = o2.converter(k)
+            assert x == l[2], "o2 got %s, expected %s" % (x, l[2])
+
+    def test_validator(self):
+        """Test the EnumVariable validator"""
+        opts = SCons.Variables.Variables()
+        opts.Add(SCons.Variables.EnumVariable('test0', 'test option help', 0,
+                                          ['one', 'two', 'three'],
+                                          {'a' : 'one',
+                                           'b' : 'two',
+                                           'c' : 'three'},
+                                          ignorecase=0))
+        opts.Add(SCons.Variables.EnumVariable('test1', 'test option help', 0,
+                                          ['one', 'two', 'three'],
+                                          {'a' : 'one',
+                                           'b' : 'two',
+                                           'c' : 'three'},
+                                          ignorecase=1))
+        opts.Add(SCons.Variables.EnumVariable('test2', 'test option help', 0,
+                                          ['one', 'two', 'three'],
+                                          {'a' : 'one',
+                                           'b' : 'two',
+                                           'c' : 'three'},
+                                          ignorecase=2))
+
+        o0 = opts.options[0]
+        o1 = opts.options[1]
+        o2 = opts.options[2]
+
+        def valid(o, v):
+            o.validator('X', v, {})
+
+        def invalid(o, v):
+            caught = None
+            try:
+                o.validator('X', v, {})
+            except SCons.Errors.UserError:
+                caught = 1
+            assert caught, "did not catch expected UserError for o = %s, v = %s" % (o.key, v)
+
+        table = {
+            'one'   : [  valid,   valid,   valid],
+            'One'   : [invalid,   valid,   valid],
+            'ONE'   : [invalid,   valid,   valid],
+            'two'   : [  valid,   valid,   valid],
+            'twO'   : [invalid,   valid,   valid],
+            'TWO'   : [invalid,   valid,   valid],
+            'three' : [  valid,   valid,   valid],
+            'thRee' : [invalid,   valid,   valid],
+            'THREE' : [invalid,   valid,   valid],
+            'a'     : [invalid, invalid, invalid],
+            'A'     : [invalid, invalid, invalid],
+            'b'     : [invalid, invalid, invalid],
+            'B'     : [invalid, invalid, invalid],
+            'c'     : [invalid, invalid, invalid],
+            'C'     : [invalid, invalid, invalid],
+            'no_v'  : [invalid, invalid, invalid],
+        }
+
+        for v, l in table.items():
+            l[0](o0, v)
+            l[1](o1, v)
+            l[2](o2, v)
+
+
+if __name__ == "__main__":
+    suite = unittest.makeSuite(EnumVariableTestCase, 'test_')
+    if not unittest.TextTestRunner().run(suite).wasSuccessful():
+        sys.exit(1)
+
+# Local Variables:
+# tab-width:4
+# indent-tabs-mode:nil
+# End:
+# vim: set expandtab tabstop=4 shiftwidth=4:
diff --git a/src/engine/SCons/Variables/ListVariable.py b/src/engine/SCons/Variables/ListVariable.py
new file mode 100644
index 0000000..0debd14
--- /dev/null
+++ b/src/engine/SCons/Variables/ListVariable.py
@@ -0,0 +1,139 @@
+"""engine.SCons.Variables.ListVariable
+
+This file defines the option type for SCons implementing 'lists'.
+
+A 'list' option may either be 'all', 'none' or a list of names
+separated by comma. After the option has been processed, the option
+value holds either the named list elements, all list elemens or no
+list elements at all.
+
+Usage example:
+
+  list_of_libs = Split('x11 gl qt ical')
+
+  opts = Variables()
+  opts.Add(ListVariable('shared',
+                      'libraries to build as shared libraries',
+                      'all',
+                      elems = list_of_libs))
+  ...
+  for lib in list_of_libs:
+     if lib in env['shared']:
+         env.SharedObject(...)
+     else:
+         env.Object(...)
+"""
+
+#
+# Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 The SCons Foundation
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be included
+# in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
+# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+
+__revision__ = "src/engine/SCons/Variables/ListVariable.py 4577 2009/12/27 19:44:43 scons"
+
+# Know Bug: This should behave like a Set-Type, but does not really,
+# since elements can occur twice.
+
+__all__ = ['ListVariable',]
+
+import string
+import UserList
+
+import SCons.Util
+
+
+class _ListVariable(UserList.UserList):
+    def __init__(self, initlist=[], allowedElems=[]):
+        UserList.UserList.__init__(self, filter(None, initlist))
+        self.allowedElems = allowedElems[:]
+        self.allowedElems.sort()
+
+    def __cmp__(self, other):
+        raise NotImplementedError
+    def __eq__(self, other):
+        raise NotImplementedError
+    def __ge__(self, other):
+        raise NotImplementedError
+    def __gt__(self, other):
+        raise NotImplementedError
+    def __le__(self, other):
+        raise NotImplementedError
+    def __lt__(self, other):
+        raise NotImplementedError
+    def __str__(self):
+        if len(self) == 0:
+            return 'none'
+        self.data.sort()
+        if self.data == self.allowedElems:
+            return 'all'
+        else:
+            return string.join(self, ',')
+    def prepare_to_store(self):
+        return self.__str__()
+
+def _converter(val, allowedElems, mapdict):
+    """
+    """
+    if val == 'none':
+        val = []
+    elif val == 'all':
+        val = allowedElems
+    else:
+        val = filter(None, string.split(val, ','))
+        val = map(lambda v, m=mapdict: m.get(v, v), val)
+        notAllowed = filter(lambda v, aE=allowedElems: not v in aE, val)
+        if notAllowed:
+            raise ValueError("Invalid value(s) for option: %s" %
+                             string.join(notAllowed, ','))
+    return _ListVariable(val, allowedElems)
+
+
+## def _validator(key, val, env):
+##     """
+##     """
+##     # todo: write validater for pgk list
+##     return 1
+
+
+def ListVariable(key, help, default, names, map={}):
+    """
+    The input parameters describe a 'package list' option, thus they
+    are returned with the correct converter and validater appended. The
+    result is usable for input to opts.Add() .
+
+    A 'package list' option may either be 'all', 'none' or a list of
+    package names (separated by space).
+    """
+    names_str = 'allowed names: %s' % string.join(names, ' ')
+    if SCons.Util.is_List(default):
+        default = string.join(default, ',')
+    help = string.join(
+        (help, '(all|none|comma-separated list of names)', names_str),
+        '\n    ')
+    return (key, help, default,
+            None, #_validator,
+            lambda val, elems=names, m=map: _converter(val, elems, m))
+
+# Local Variables:
+# tab-width:4
+# indent-tabs-mode:nil
+# End:
+# vim: set expandtab tabstop=4 shiftwidth=4:
diff --git a/src/engine/SCons/Variables/ListVariableTests.py b/src/engine/SCons/Variables/ListVariableTests.py
new file mode 100644
index 0000000..353fbe6
--- /dev/null
+++ b/src/engine/SCons/Variables/ListVariableTests.py
@@ -0,0 +1,134 @@
+#
+# Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 The SCons Foundation
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be included
+# in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
+# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+
+__revision__ = "src/engine/SCons/Variables/ListVariableTests.py 4577 2009/12/27 19:44:43 scons"
+
+import copy
+import sys
+import unittest
+
+import SCons.Errors
+import SCons.Variables
+
+class ListVariableTestCase(unittest.TestCase):
+    def test_ListVariable(self):
+        """Test ListVariable creation"""
+        opts = SCons.Variables.Variables()
+        opts.Add(SCons.Variables.ListVariable('test', 'test option help', 'all',
+                                          ['one', 'two', 'three']))
+
+        o = opts.options[0]
+        assert o.key == 'test', o.key
+        assert o.help == 'test option help\n    (all|none|comma-separated list of names)\n    allowed names: one two three', repr(o.help)
+        assert o.default == 'all', o.default
+        assert o.validator is None, o.validator
+        assert not o.converter is None, o.converter
+
+        opts = SCons.Variables.Variables()
+        opts.Add(SCons.Variables.ListVariable('test2', 'test2 help',
+                                          ['one', 'three'],
+                                          ['one', 'two', 'three']))
+
+        o = opts.options[0]
+        assert o.default == 'one,three'
+
+    def test_converter(self):
+        """Test the ListVariable converter"""
+        opts = SCons.Variables.Variables()
+        opts.Add(SCons.Variables.ListVariable('test', 'test option help', 'all',
+                                          ['one', 'two', 'three'],
+                                          {'ONE':'one', 'TWO':'two'}))
+
+        o = opts.options[0]
+
+        x = o.converter('all')
+        assert str(x) == 'all', x
+
+        x = o.converter('none')
+        assert str(x) == 'none', x
+
+        x = o.converter('one')
+        assert str(x) == 'one', x
+        x = o.converter('ONE')
+        assert str(x) == 'one', x
+
+        x = o.converter('two')
+        assert str(x) == 'two', x
+        x = o.converter('TWO')
+        assert str(x) == 'two', x
+
+        x = o.converter('three')
+        assert str(x) == 'three', x
+
+        x = o.converter('one,two')
+        assert str(x) == 'one,two', x
+        x = o.converter('two,one')
+        assert str(x) == 'one,two', x
+
+        x = o.converter('one,three')
+        assert str(x) == 'one,three', x
+        x = o.converter('three,one')
+        assert str(x) == 'one,three', x
+
+        x = o.converter('two,three')
+        assert str(x) == 'three,two', x
+        x = o.converter('three,two')
+        assert str(x) == 'three,two', x
+
+        x = o.converter('one,two,three')
+        assert str(x) == 'all', x
+
+        x = o.converter('three,two,one')
+        assert str(x) == 'all', x
+
+        x = o.converter('three,ONE,TWO')
+        assert str(x) == 'all', x
+
+        caught = None
+        try:
+            x = o.converter('no_match')
+        except ValueError:
+            caught = 1
+        assert caught, "did not catch expected ValueError"
+
+    def test_copy(self):
+        """Test copying a ListVariable like an Environment would"""
+        opts = SCons.Variables.Variables()
+        opts.Add(SCons.Variables.ListVariable('test', 'test option help', 'all',
+                                          ['one', 'two', 'three']))
+
+        o = opts.options[0]
+
+        l = o.converter('all')
+        n = l.__class__(copy.copy(l))
+
+if __name__ == "__main__":
+    suite = unittest.makeSuite(ListVariableTestCase, 'test_')
+    if not unittest.TextTestRunner().run(suite).wasSuccessful():
+        sys.exit(1)
+
+# Local Variables:
+# tab-width:4
+# indent-tabs-mode:nil
+# End:
+# vim: set expandtab tabstop=4 shiftwidth=4:
diff --git a/src/engine/SCons/Variables/PackageVariable.py b/src/engine/SCons/Variables/PackageVariable.py
new file mode 100644
index 0000000..e10ff0c
--- /dev/null
+++ b/src/engine/SCons/Variables/PackageVariable.py
@@ -0,0 +1,109 @@
+"""engine.SCons.Variables.PackageVariable
+
+This file defines the option type for SCons implementing 'package
+activation'.
+
+To be used whenever a 'package' may be enabled/disabled and the
+package path may be specified.
+
+Usage example:
+
+  Examples:
+      x11=no   (disables X11 support)
+      x11=yes  (will search for the package installation dir)
+      x11=/usr/local/X11 (will check this path for existance)
+
+  To replace autoconf's --with-xxx=yyy 
+
+  opts = Variables()
+  opts.Add(PackageVariable('x11',
+                         'use X11 installed here (yes = search some places',
+                         'yes'))
+  ...
+  if env['x11'] == True:
+      dir = ... search X11 in some standard places ...
+      env['x11'] = dir 
+  if env['x11']:
+      ... build with x11 ...
+"""
+
+#
+# Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 The SCons Foundation
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be included
+# in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
+# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+
+__revision__ = "src/engine/SCons/Variables/PackageVariable.py 4577 2009/12/27 19:44:43 scons"
+
+__all__ = ['PackageVariable',]
+
+import string
+
+import SCons.Errors
+
+__enable_strings  = ('1', 'yes', 'true',  'on', 'enable', 'search')
+__disable_strings = ('0', 'no',  'false', 'off', 'disable')
+
+def _converter(val):
+    """
+    """
+    lval = string.lower(val)
+    if lval in __enable_strings: return True
+    if lval in __disable_strings: return False
+    #raise ValueError("Invalid value for boolean option: %s" % val)
+    return val
+
+
+def _validator(key, val, env, searchfunc):
+    # NB: searchfunc is currenty undocumented and unsupported
+    """
+    """
+    # todo: write validator, check for path
+    import os
+    if env[key] is True:
+        if searchfunc:
+            env[key] = searchfunc(key, val)
+    elif env[key] and not os.path.exists(val):
+        raise SCons.Errors.UserError(
+            'Path does not exist for option %s: %s' % (key, val))
+
+
+def PackageVariable(key, help, default, searchfunc=None):
+    # NB: searchfunc is currenty undocumented and unsupported
+    """
+    The input parameters describe a 'package list' option, thus they
+    are returned with the correct converter and validator appended. The
+    result is usable for input to opts.Add() .
+
+    A 'package list' option may either be 'all', 'none' or a list of
+    package names (seperated by space).
+    """
+    help = string.join(
+        (help, '( yes | no | /path/to/%s )' % key),
+        '\n    ')
+    return (key, help, default,
+            lambda k, v, e, f=searchfunc: _validator(k,v,e,f),
+            _converter)
+
+# Local Variables:
+# tab-width:4
+# indent-tabs-mode:nil
+# End:
+# vim: set expandtab tabstop=4 shiftwidth=4:
diff --git a/src/engine/SCons/Variables/PackageVariableTests.py b/src/engine/SCons/Variables/PackageVariableTests.py
new file mode 100644
index 0000000..70ea191
--- /dev/null
+++ b/src/engine/SCons/Variables/PackageVariableTests.py
@@ -0,0 +1,124 @@
+#
+# Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 The SCons Foundation
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be included
+# in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
+# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+
+__revision__ = "src/engine/SCons/Variables/PackageVariableTests.py 4577 2009/12/27 19:44:43 scons"
+
+import sys
+import unittest
+
+import SCons.Errors
+import SCons.Variables
+
+import TestCmd
+
+class PackageVariableTestCase(unittest.TestCase):
+    def test_PackageVariable(self):
+        """Test PackageVariable creation"""
+        opts = SCons.Variables.Variables()
+        opts.Add(SCons.Variables.PackageVariable('test', 'test option help', '/default/path'))
+
+        o = opts.options[0]
+        assert o.key == 'test', o.key
+        assert o.help == 'test option help\n    ( yes | no | /path/to/test )', repr(o.help)
+        assert o.default == '/default/path', o.default
+        assert o.validator is not None, o.validator
+        assert o.converter is not None, o.converter
+
+    def test_converter(self):
+        """Test the PackageVariable converter"""
+        opts = SCons.Variables.Variables()
+        opts.Add(SCons.Variables.PackageVariable('test', 'test option help', '/default/path'))
+
+        o = opts.options[0]
+
+        true_values = [
+                'yes',    'YES',
+                'true',   'TRUE',
+                'on',     'ON',
+                'enable', 'ENABLE',
+                'search', 'SEARCH',
+        ]
+        false_values = [
+                'no',      'NO',
+                'false',   'FALSE',
+                'off',     'OFF',
+                'disable', 'DISABLE',
+        ]
+
+        for t in true_values:
+            x = o.converter(t)
+            assert x, "converter returned false for '%s'" % t
+
+        for f in false_values:
+            x = o.converter(f)
+            assert not x, "converter returned true for '%s'" % f
+
+        x = o.converter('/explicit/path')
+        assert x == '/explicit/path', x
+
+        # Make sure the converter returns True if we give it str(True) and
+        # False when we give it str(False).  This assures consistent operation
+        # through a cycle of Variables.Save(<file>) -> Variables(<file>).
+        x = o.converter(str(True))
+        assert x == True, "converter returned a string when given str(True)"
+
+        x = o.converter(str(False))
+        assert x == False, "converter returned a string when given str(False)"
+
+    def test_validator(self):
+        """Test the PackageVariable validator"""
+        opts = SCons.Variables.Variables()
+        opts.Add(SCons.Variables.PackageVariable('test', 'test option help', '/default/path'))
+
+        test = TestCmd.TestCmd(workdir='')
+        test.write('exists', 'exists\n')
+
+        o = opts.options[0]
+
+        env = {'F':False, 'T':True, 'X':'x'}
+
+        exists = test.workpath('exists')
+        does_not_exist = test.workpath('does_not_exist')
+
+        o.validator('F', '/path', env)
+        o.validator('T', '/path', env)
+        o.validator('X', exists, env)
+
+        caught = None
+        try:
+            o.validator('X', does_not_exist, env)
+        except SCons.Errors.UserError:
+            caught = 1
+        assert caught, "did not catch expected UserError"
+
+
+if __name__ == "__main__":
+    suite = unittest.makeSuite(PackageVariableTestCase, 'test_')
+    if not unittest.TextTestRunner().run(suite).wasSuccessful():
+        sys.exit(1)
+
+# Local Variables:
+# tab-width:4
+# indent-tabs-mode:nil
+# End:
+# vim: set expandtab tabstop=4 shiftwidth=4:
diff --git a/src/engine/SCons/Variables/PathVariable.py b/src/engine/SCons/Variables/PathVariable.py
new file mode 100644
index 0000000..2ebbd8d
--- /dev/null
+++ b/src/engine/SCons/Variables/PathVariable.py
@@ -0,0 +1,147 @@
+"""SCons.Variables.PathVariable
+
+This file defines an option type for SCons implementing path settings.
+
+To be used whenever a a user-specified path override should be allowed.
+
+Arguments to PathVariable are:
+  option-name  = name of this option on the command line (e.g. "prefix")
+  option-help  = help string for option
+  option-dflt  = default value for this option
+  validator    = [optional] validator for option value.  Predefined
+                 validators are:
+
+                     PathAccept -- accepts any path setting; no validation
+                     PathIsDir  -- path must be an existing directory
+                     PathIsDirCreate -- path must be a dir; will create
+                     PathIsFile -- path must be a file
+                     PathExists -- path must exist (any type) [default]
+
+                 The validator is a function that is called and which
+                 should return True or False to indicate if the path
+                 is valid.  The arguments to the validator function
+                 are: (key, val, env).  The key is the name of the
+                 option, the val is the path specified for the option,
+                 and the env is the env to which the Otions have been
+                 added.
+
+Usage example:
+
+  Examples:
+      prefix=/usr/local
+
+  opts = Variables()
+
+  opts = Variables()
+  opts.Add(PathVariable('qtdir',
+                      'where the root of Qt is installed',
+                      qtdir, PathIsDir))
+  opts.Add(PathVariable('qt_includes',
+                      'where the Qt includes are installed',
+                      '$qtdir/includes', PathIsDirCreate))
+  opts.Add(PathVariable('qt_libraries',
+                      'where the Qt library is installed',
+                      '$qtdir/lib'))
+
+"""
+
+#
+# Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 The SCons Foundation
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be included
+# in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
+# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+
+__revision__ = "src/engine/SCons/Variables/PathVariable.py 4577 2009/12/27 19:44:43 scons"
+
+__all__ = ['PathVariable',]
+
+import os
+import os.path
+
+import SCons.Errors
+
+class _PathVariableClass:
+
+    def PathAccept(self, key, val, env):
+        """Accepts any path, no checking done."""
+        pass
+    
+    def PathIsDir(self, key, val, env):
+        """Validator to check if Path is a directory."""
+        if not os.path.isdir(val):
+            if os.path.isfile(val):
+                m = 'Directory path for option %s is a file: %s'
+            else:
+                m = 'Directory path for option %s does not exist: %s'
+            raise SCons.Errors.UserError(m % (key, val))
+
+    def PathIsDirCreate(self, key, val, env):
+        """Validator to check if Path is a directory,
+           creating it if it does not exist."""
+        if os.path.isfile(val):
+            m = 'Path for option %s is a file, not a directory: %s'
+            raise SCons.Errors.UserError(m % (key, val))
+        if not os.path.isdir(val):
+            os.makedirs(val)
+
+    def PathIsFile(self, key, val, env):
+        """validator to check if Path is a file"""
+        if not os.path.isfile(val):
+            if os.path.isdir(val):
+                m = 'File path for option %s is a directory: %s'
+            else:
+                m = 'File path for option %s does not exist: %s'
+            raise SCons.Errors.UserError(m % (key, val))
+
+    def PathExists(self, key, val, env):
+        """validator to check if Path exists"""
+        if not os.path.exists(val):
+            m = 'Path for option %s does not exist: %s'
+            raise SCons.Errors.UserError(m % (key, val))
+
+    def __call__(self, key, help, default, validator=None):
+        # NB: searchfunc is currenty undocumented and unsupported
+        """
+        The input parameters describe a 'path list' option, thus they
+        are returned with the correct converter and validator appended. The
+        result is usable for input to opts.Add() .
+
+        The 'default' option specifies the default path to use if the
+        user does not specify an override with this option.
+
+        validator is a validator, see this file for examples
+        """
+        if validator is None:
+            validator = self.PathExists
+
+        if SCons.Util.is_List(key) or SCons.Util.is_Tuple(key):
+            return (key, '%s ( /path/to/%s )' % (help, key[0]), default,
+                    validator, None)
+        else:
+            return (key, '%s ( /path/to/%s )' % (help, key), default,
+                    validator, None)
+
+PathVariable = _PathVariableClass()
+
+# Local Variables:
+# tab-width:4
+# indent-tabs-mode:nil
+# End:
+# vim: set expandtab tabstop=4 shiftwidth=4:
diff --git a/src/engine/SCons/Variables/PathVariableTests.py b/src/engine/SCons/Variables/PathVariableTests.py
new file mode 100644
index 0000000..e9e35e7
--- /dev/null
+++ b/src/engine/SCons/Variables/PathVariableTests.py
@@ -0,0 +1,237 @@
+#
+# Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 The SCons Foundation
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be included
+# in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
+# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+
+__revision__ = "src/engine/SCons/Variables/PathVariableTests.py 4577 2009/12/27 19:44:43 scons"
+
+import os.path
+import sys
+import unittest
+
+import SCons.Errors
+import SCons.Variables
+
+import TestCmd
+
+class PathVariableTestCase(unittest.TestCase):
+    def test_PathVariable(self):
+        """Test PathVariable creation"""
+        opts = SCons.Variables.Variables()
+        opts.Add(SCons.Variables.PathVariable('test',
+                                          'test option help',
+                                          '/default/path'))
+
+        o = opts.options[0]
+        assert o.key == 'test', o.key
+        assert o.help == 'test option help ( /path/to/test )', repr(o.help)
+        assert o.default == '/default/path', o.default
+        assert o.validator is not None, o.validator
+        assert o.converter is None, o.converter
+
+    def test_PathExists(self):
+        """Test the PathExists validator"""
+        opts = SCons.Variables.Variables()
+        opts.Add(SCons.Variables.PathVariable('test',
+                                          'test option help',
+                                          '/default/path',
+                                          SCons.Variables.PathVariable.PathExists))
+
+        test = TestCmd.TestCmd(workdir='')
+        test.write('exists', 'exists\n')
+
+        o = opts.options[0]
+
+        o.validator('X', test.workpath('exists'), {})
+
+        dne = test.workpath('does_not_exist')
+        try:
+            o.validator('X', dne, {})
+        except SCons.Errors.UserError, e:
+            assert str(e) == 'Path for option X does not exist: %s' % dne, e
+        except:
+            raise "did not catch expected UserError"
+
+    def test_PathIsDir(self):
+        """Test the PathIsDir validator"""
+        opts = SCons.Variables.Variables()
+        opts.Add(SCons.Variables.PathVariable('test',
+                                          'test option help',
+                                          '/default/path',
+                                          SCons.Variables.PathVariable.PathIsDir))
+
+        test = TestCmd.TestCmd(workdir='')
+        test.subdir('dir')
+        test.write('file', "file\n")
+
+        o = opts.options[0]
+
+        o.validator('X', test.workpath('dir'), {})
+
+        f = test.workpath('file')
+        try:
+            o.validator('X', f, {})
+        except SCons.Errors.UserError, e:
+            assert str(e) == 'Directory path for option X is a file: %s' % f, e
+        except:
+            raise "did not catch expected UserError"
+
+        dne = test.workpath('does_not_exist')
+        try:
+            o.validator('X', dne, {})
+        except SCons.Errors.UserError, e:
+            assert str(e) == 'Directory path for option X does not exist: %s' % dne, e
+        except:
+            raise "did not catch expected UserError"
+
+    def test_PathIsDirCreate(self):
+        """Test the PathIsDirCreate validator"""
+        opts = SCons.Variables.Variables()
+        opts.Add(SCons.Variables.PathVariable('test',
+                                          'test option help',
+                                          '/default/path',
+                                          SCons.Variables.PathVariable.PathIsDirCreate))
+
+        test = TestCmd.TestCmd(workdir='')
+        test.write('file', "file\n")
+
+        o = opts.options[0]
+
+        d = test.workpath('dir')
+        o.validator('X', d, {})
+        assert os.path.isdir(d)
+
+        f = test.workpath('file')
+        try:
+            o.validator('X', f, {})
+        except SCons.Errors.UserError, e:
+            assert str(e) == 'Path for option X is a file, not a directory: %s' % f, e
+        except:
+            raise "did not catch expected UserError"
+
+    def test_PathIsFile(self):
+        """Test the PathIsFile validator"""
+        opts = SCons.Variables.Variables()
+        opts.Add(SCons.Variables.PathVariable('test',
+                                          'test option help',
+                                          '/default/path',
+                                          SCons.Variables.PathVariable.PathIsFile))
+
+        test = TestCmd.TestCmd(workdir='')
+        test.subdir('dir')
+        test.write('file', "file\n")
+
+        o = opts.options[0]
+
+        o.validator('X', test.workpath('file'), {})
+
+        d = test.workpath('d')
+        try:
+            o.validator('X', d, {})
+        except SCons.Errors.UserError, e:
+            assert str(e) == 'File path for option X does not exist: %s' % d, e
+        except:
+            raise "did not catch expected UserError"
+
+        dne = test.workpath('does_not_exist')
+        try:
+            o.validator('X', dne, {})
+        except SCons.Errors.UserError, e:
+            assert str(e) == 'File path for option X does not exist: %s' % dne, e
+        except:
+            raise "did not catch expected UserError"
+
+    def test_PathAccept(self):
+        """Test the PathAccept validator"""
+        opts = SCons.Variables.Variables()
+        opts.Add(SCons.Variables.PathVariable('test',
+                                          'test option help',
+                                          '/default/path',
+                                          SCons.Variables.PathVariable.PathAccept))
+
+        test = TestCmd.TestCmd(workdir='')
+        test.subdir('dir')
+        test.write('file', "file\n")
+
+        o = opts.options[0]
+
+        o.validator('X', test.workpath('file'), {})
+
+        d = test.workpath('d')
+        o.validator('X', d, {})
+
+        dne = test.workpath('does_not_exist')
+        o.validator('X', dne, {})
+
+    def test_validator(self):
+        """Test the PathVariable validator argument"""
+        opts = SCons.Variables.Variables()
+        opts.Add(SCons.Variables.PathVariable('test',
+                                          'test option help',
+                                          '/default/path'))
+
+        test = TestCmd.TestCmd(workdir='')
+        test.write('exists', 'exists\n')
+
+        o = opts.options[0]
+
+        o.validator('X', test.workpath('exists'), {})
+
+        dne = test.workpath('does_not_exist')
+        try:
+            o.validator('X', dne, {})
+        except SCons.Errors.UserError, e:
+            expect = 'Path for option X does not exist: %s' % dne
+            assert str(e) == expect, e
+        else:
+            raise "did not catch expected UserError"
+
+        def my_validator(key, val, env):
+            raise Exception, "my_validator() got called for %s, %s!" % (key, val)
+
+        opts = SCons.Variables.Variables()
+        opts.Add(SCons.Variables.PathVariable('test2',
+                                          'more help',
+                                          '/default/path/again',
+                                          my_validator))
+
+        o = opts.options[0]
+
+        try:
+            o.validator('Y', 'value', {})
+        except Exception, e:
+            assert str(e) == 'my_validator() got called for Y, value!', e
+        else:
+            raise "did not catch expected exception from my_validator()"
+
+
+
+
+if __name__ == "__main__":
+    suite = unittest.makeSuite(PathVariableTestCase, 'test_')
+    if not unittest.TextTestRunner().run(suite).wasSuccessful():
+        sys.exit(1)
+
+# Local Variables:
+# tab-width:4
+# indent-tabs-mode:nil
+# End:
+# vim: set expandtab tabstop=4 shiftwidth=4:
diff --git a/src/engine/SCons/Variables/VariablesTests.py b/src/engine/SCons/Variables/VariablesTests.py
new file mode 100644
index 0000000..b89404b
--- /dev/null
+++ b/src/engine/SCons/Variables/VariablesTests.py
@@ -0,0 +1,663 @@
+#
+# Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 The SCons Foundation
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be included
+# in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
+# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+
+__revision__ = "src/engine/SCons/Variables/VariablesTests.py 4577 2009/12/27 19:44:43 scons"
+
+import sys
+import unittest
+import TestSCons
+
+import SCons.Variables
+import SCons.Subst
+import SCons.Warnings
+
+
+class Environment:
+    def __init__(self):
+        self.dict = {}
+    def subst(self, x):
+        return SCons.Subst.scons_subst(x, self, gvars=self.dict)
+    def __setitem__(self, key, value):
+        self.dict[key] = value
+    def __getitem__(self, key):
+        return self.dict[key]
+    def has_key(self, key):
+        return self.dict.has_key(key)
+
+
+def check(key, value, env):
+    assert int(value) == 6 * 9, "key %s = %s" % (key, repr(value))
+    
+# Check saved option file by executing and comparing against
+# the expected dictionary
+def checkSave(file, expected):
+    gdict = {}
+    ldict = {}
+    exec open(file, 'rU').read() in gdict, ldict
+    assert expected == ldict, "%s\n...not equal to...\n%s" % (expected, ldict)
+
+class VariablesTestCase(unittest.TestCase):
+
+    def test_keys(self):
+        """Test the Variables.keys() method"""
+        opts = SCons.Variables.Variables()
+
+        opts.Add('VAR1')
+        opts.Add('VAR2',
+                 'THE answer to THE question',
+                 "42",
+                 check,
+                 lambda x: int(x) + 12)
+        keys = opts.keys()
+        assert keys == ['VAR1', 'VAR2'], keys
+
+    def test_Add(self):
+        """Test adding to a Variables object"""
+        opts = SCons.Variables.Variables()
+
+        opts.Add('VAR')
+        opts.Add('ANSWER',
+                 'THE answer to THE question',
+                 "42",
+                 check,
+                 lambda x: int(x) + 12)
+
+        o = opts.options[0]
+        assert o.key == 'VAR'
+        assert o.help == ''
+        assert o.default is None
+        assert o.validator is None
+        assert o.converter is None
+
+        o = opts.options[1]
+        assert o.key == 'ANSWER'
+        assert o.help == 'THE answer to THE question'
+        assert o.default == "42"
+        o.validator(o.key, o.converter(o.default), {})
+
+        def test_it(var, opts=opts):
+            exc_caught = None
+            try:
+                opts.Add(var)
+            except SCons.Errors.UserError:
+                exc_caught = 1
+            assert exc_caught, "did not catch UserError for '%s'" % var
+        test_it('foo/bar')
+        test_it('foo-bar')
+        test_it('foo.bar')
+
+    def test_AddVariables(self):
+        """Test adding a list of options to a Variables object"""
+        opts = SCons.Variables.Variables()
+
+        opts.AddVariables(('VAR2',),
+                        ('ANSWER2',
+                         'THE answer to THE question',
+                         "42",
+                         check,
+                         lambda x: int(x) + 12))
+
+        o = opts.options[0]
+        assert o.key == 'VAR2', o.key
+        assert o.help == '', o.help
+        assert o.default is None, o.default
+        assert o.validator is None, o.validator
+        assert o.converter is None, o.converter
+
+        o = opts.options[1]
+        assert o.key == 'ANSWER2', o.key
+        assert o.help == 'THE answer to THE question', o.help
+        assert o.default == "42", o.default
+        o.validator(o.key, o.converter(o.default), {})
+
+    def test_Update(self):
+        """Test updating an Environment"""
+
+        # Test that a default value is validated correctly.
+        test = TestSCons.TestSCons()
+        file = test.workpath('custom.py')
+        opts = SCons.Variables.Variables(file)
+        
+        opts.Add('ANSWER',
+                 'THE answer to THE question',
+                 "42",
+                 check,
+                 lambda x: int(x) + 12)
+
+        env = Environment()
+        opts.Update(env)
+        assert env['ANSWER'] == 54
+
+        env = Environment()
+        opts.Update(env, {})
+        assert env['ANSWER'] == 54
+
+        # Test that a bad value from the file is used and
+        # validation fails correctly.
+        test = TestSCons.TestSCons()
+        file = test.workpath('custom.py')
+        test.write('custom.py', 'ANSWER=54')
+        opts = SCons.Variables.Variables(file)
+        
+        opts.Add('ANSWER',
+                 'THE answer to THE question',
+                 "42",
+                 check,
+                 lambda x: int(x) + 12)
+
+        env = Environment()
+        exc_caught = None
+        try:
+            opts.Update(env)
+        except AssertionError:
+            exc_caught = 1
+        assert exc_caught, "did not catch expected assertion"
+
+        env = Environment()
+        exc_caught = None
+        try:
+            opts.Update(env, {})
+        except AssertionError:
+            exc_caught = 1
+        assert exc_caught, "did not catch expected assertion"
+
+        # Test that a good value from the file is used and validated.
+        test = TestSCons.TestSCons()
+        file = test.workpath('custom.py')
+        test.write('custom.py', 'ANSWER=42')
+        opts = SCons.Variables.Variables(file)
+        
+        opts.Add('ANSWER',
+                 'THE answer to THE question',
+                 "10",
+                 check,
+                 lambda x: int(x) + 12)
+
+        env = Environment()
+        opts.Update(env)
+        assert env['ANSWER'] == 54
+
+        env = Environment()
+        opts.Update(env, {})
+        assert env['ANSWER'] == 54
+
+        # Test that a bad value from an args dictionary passed to
+        # Update() is used and validation fails correctly.
+        test = TestSCons.TestSCons()
+        file = test.workpath('custom.py')
+        test.write('custom.py', 'ANSWER=10')
+        opts = SCons.Variables.Variables(file)
+        
+        opts.Add('ANSWER',
+                 'THE answer to THE question',
+                 "12",
+                 check,
+                 lambda x: int(x) + 12)
+
+        env = Environment()
+        exc_caught = None
+        try:
+            opts.Update(env, {'ANSWER':'54'})
+        except AssertionError:
+            exc_caught = 1
+        assert exc_caught, "did not catch expected assertion"
+
+        # Test that a good value from an args dictionary
+        # passed to Update() is used and validated.
+        test = TestSCons.TestSCons()
+        file = test.workpath('custom.py')
+        test.write('custom.py', 'ANSWER=10')
+        opts = SCons.Variables.Variables(file)
+        
+        opts.Add('ANSWER',
+                 'THE answer to THE question',
+                 "12",
+                 check,
+                 lambda x: int(x) + 12)
+
+        env = Environment()
+        opts.Update(env, {'ANSWER':'42'})
+        assert env['ANSWER'] == 54
+
+        # Test against a former bug.  If we supply a converter,
+        # but no default, the value should *not* appear in the
+        # Environment if no value is specified in the options file
+        # or args.
+        test = TestSCons.TestSCons()
+        file = test.workpath('custom.py')
+        opts = SCons.Variables.Variables(file)
+        
+        opts.Add('ANSWER',
+                 help='THE answer to THE question',
+                 converter=str)
+
+        env = Environment()
+        opts.Update(env, {})
+        assert not env.has_key('ANSWER')
+
+        # Test that a default value of None is all right.
+        test = TestSCons.TestSCons()
+        file = test.workpath('custom.py')
+        opts = SCons.Variables.Variables(file)
+
+        opts.Add('ANSWER',
+                 "This is the answer",
+                 None,
+                 check)
+
+        env = Environment()
+        opts.Update(env, {})
+        assert not env.has_key('ANSWER')
+
+    def test_args(self):
+        """Test updating an Environment with arguments overridden"""
+
+        # Test that a bad (command-line) argument is used
+        # and the validation fails correctly.
+        test = TestSCons.TestSCons()
+        file = test.workpath('custom.py')
+        test.write('custom.py', 'ANSWER=42')
+        opts = SCons.Variables.Variables(file, {'ANSWER':54})
+        
+        opts.Add('ANSWER',
+                 'THE answer to THE question',
+                 "42",
+                 check,
+                 lambda x: int(x) + 12)
+
+        env = Environment()
+        exc_caught = None
+        try:
+            opts.Update(env)
+        except AssertionError:
+            exc_caught = 1
+        assert exc_caught, "did not catch expected assertion"
+
+        # Test that a good (command-line) argument is used and validated.
+        test = TestSCons.TestSCons()
+        file = test.workpath('custom.py')
+        test.write('custom.py', 'ANSWER=54')
+        opts = SCons.Variables.Variables(file, {'ANSWER':42})
+        
+        opts.Add('ANSWER',
+                 'THE answer to THE question',
+                 "54",
+                 check,
+                 lambda x: int(x) + 12)
+
+        env = Environment()
+        opts.Update(env)
+        assert env['ANSWER'] == 54
+
+        # Test that a (command-line) argument is overridden by a dictionary
+        # supplied to Update() and the dictionary value is validated correctly.
+        test = TestSCons.TestSCons()
+        file = test.workpath('custom.py')
+        test.write('custom.py', 'ANSWER=54')
+        opts = SCons.Variables.Variables(file, {'ANSWER':54})
+        
+        opts.Add('ANSWER',
+                 'THE answer to THE question',
+                 "54",
+                 check,
+                 lambda x: int(x) + 12)
+
+        env = Environment()
+        opts.Update(env, {'ANSWER':42})
+        assert env['ANSWER'] == 54
+
+    def test_Save(self):
+        """Testing saving Variables"""
+
+        test = TestSCons.TestSCons()
+        cache_file = test.workpath('cached.options')
+        opts = SCons.Variables.Variables()
+
+        def bool_converter(val):
+            if val in [1, 'y']: val = 1
+            if val in [0, 'n']: val = 0
+            return val
+        
+        # test saving out empty file
+        opts.Add('OPT_VAL',
+                 'An option to test',
+                 21,
+                 None,
+                 None)
+        opts.Add('OPT_VAL_2',
+                 default='foo')
+        opts.Add('OPT_VAL_3',
+                 default=1)
+        opts.Add('OPT_BOOL_0',
+                 default='n',
+                 converter=bool_converter)
+        opts.Add('OPT_BOOL_1',
+                 default='y',
+                 converter=bool_converter)
+        opts.Add('OPT_BOOL_2',
+                 default=0,
+                 converter=bool_converter)
+
+        env = Environment()
+        opts.Update(env, {'OPT_VAL_3' : 2})
+        assert env['OPT_VAL'] == 21, env['OPT_VAL']
+        assert env['OPT_VAL_2'] == 'foo', env['OPT_VAL_2']
+        assert env['OPT_VAL_3'] == 2, env['OPT_VAL_3']
+        assert env['OPT_BOOL_0'] == 0, env['OPT_BOOL_0']
+        assert env['OPT_BOOL_1'] == 1, env['OPT_BOOL_1']
+        assert env['OPT_BOOL_2'] == '0', env['OPT_BOOL_2']
+
+        env['OPT_VAL_2'] = 'bar'
+        env['OPT_BOOL_0'] = 0
+        env['OPT_BOOL_1'] = 1
+        env['OPT_BOOL_2'] = 2
+
+        opts.Save(cache_file, env)
+        checkSave(cache_file, { 'OPT_VAL_2' : 'bar',
+                                'OPT_VAL_3' : 2,
+                                'OPT_BOOL_2' : 2})
+
+        # Test against some old bugs
+        class Foo:
+            def __init__(self, x):
+                self.x = x
+            def __str__(self):
+                return self.x
+            
+        test = TestSCons.TestSCons()
+        cache_file = test.workpath('cached.options')
+        opts = SCons.Variables.Variables()
+        
+        opts.Add('THIS_USED_TO_BREAK',
+                 'An option to test',
+                 "Default")
+
+        opts.Add('THIS_ALSO_BROKE',
+                 'An option to test',
+                 "Default2")
+        
+        opts.Add('THIS_SHOULD_WORK',
+                 'An option to test',
+                 Foo('bar'))
+        
+        env = Environment()
+        opts.Update(env, { 'THIS_USED_TO_BREAK' : "Single'Quotes'In'String",
+                           'THIS_ALSO_BROKE' : "\\Escape\nSequences\t",
+                           'THIS_SHOULD_WORK' : Foo('baz') })
+        opts.Save(cache_file, env)
+        checkSave(cache_file, { 'THIS_USED_TO_BREAK' : "Single'Quotes'In'String",
+                                'THIS_ALSO_BROKE' : "\\Escape\nSequences\t",
+                                'THIS_SHOULD_WORK' : 'baz' })
+
+    def test_GenerateHelpText(self):
+        """Test generating the default format help text"""
+        opts = SCons.Variables.Variables()
+
+        opts.Add('ANSWER',
+                 'THE answer to THE question',
+                 "42",
+                 check,
+                 lambda x: int(x) + 12)
+
+        opts.Add('B',
+                 'b - alpha test',
+                 "42",
+                 check,
+                 lambda x: int(x) + 12)
+
+        opts.Add('A',
+                 'a - alpha test',
+                 "42",
+                 check,
+                 lambda x: int(x) + 12)
+
+        env = Environment()
+        opts.Update(env, {})
+
+        expect = """
+ANSWER: THE answer to THE question
+    default: 42
+    actual: 54
+
+B: b - alpha test
+    default: 42
+    actual: 54
+
+A: a - alpha test
+    default: 42
+    actual: 54
+"""
+
+        text = opts.GenerateHelpText(env)
+        assert text == expect, text
+
+        expectAlpha = """
+A: a - alpha test
+    default: 42
+    actual: 54
+
+ANSWER: THE answer to THE question
+    default: 42
+    actual: 54
+
+B: b - alpha test
+    default: 42
+    actual: 54
+"""
+        text = opts.GenerateHelpText(env, sort=cmp)
+        assert text == expectAlpha, text
+
+    def test_FormatVariableHelpText(self):
+        """Test generating custom format help text"""
+        opts = SCons.Variables.Variables()
+
+        def my_format(env, opt, help, default, actual, aliases):
+            return '%s %s %s %s %s\n' % (opt, default, actual, help, aliases)
+
+        opts.FormatVariableHelpText = my_format
+
+        opts.Add('ANSWER',
+                 'THE answer to THE question',
+                 "42",
+                 check,
+                 lambda x: int(x) + 12)
+
+        opts.Add('B',
+                 'b - alpha test',
+                 "42",
+                 check,
+                 lambda x: int(x) + 12)
+
+        opts.Add('A',
+                 'a - alpha test',
+                 "42",
+                 check,
+                 lambda x: int(x) + 12)
+
+        env = Environment()
+        opts.Update(env, {})
+
+        expect = """\
+ANSWER 42 54 THE answer to THE question ['ANSWER']
+B 42 54 b - alpha test ['B']
+A 42 54 a - alpha test ['A']
+"""
+
+        text = opts.GenerateHelpText(env)
+        assert text == expect, text
+
+        expectAlpha = """\
+A 42 54 a - alpha test ['A']
+ANSWER 42 54 THE answer to THE question ['ANSWER']
+B 42 54 b - alpha test ['B']
+"""
+        text = opts.GenerateHelpText(env, sort=cmp)
+        assert text == expectAlpha, text
+        
+    def test_Aliases(self):
+        """Test option aliases"""
+        # test alias as a tuple
+        opts = SCons.Variables.Variables()
+        opts.AddVariables(
+                (('ANSWER', 'ANSWERALIAS'),
+                 'THE answer to THE question',
+                 "42"),
+                )
+        
+        env = Environment()
+        opts.Update(env, {'ANSWER' : 'answer'})
+        
+        assert env.has_key('ANSWER')
+        
+        env = Environment()
+        opts.Update(env, {'ANSWERALIAS' : 'answer'})
+        
+        assert env.has_key('ANSWER') and not env.has_key('ANSWERALIAS')
+        
+        # test alias as a list
+        opts = SCons.Variables.Variables()
+        opts.AddVariables(
+                (['ANSWER', 'ANSWERALIAS'],
+                 'THE answer to THE question',
+                 "42"),
+                )
+        
+        env = Environment()
+        opts.Update(env, {'ANSWER' : 'answer'})
+        
+        assert env.has_key('ANSWER')
+        
+        env = Environment()
+        opts.Update(env, {'ANSWERALIAS' : 'answer'})
+        
+        assert env.has_key('ANSWER') and not env.has_key('ANSWERALIAS')
+
+
+
+class UnknownVariablesTestCase(unittest.TestCase):
+
+    def test_unknown(self):
+        """Test the UnknownVariables() method"""
+        opts = SCons.Variables.Variables()
+        
+        opts.Add('ANSWER',
+                 'THE answer to THE question',
+                 "42")
+
+        args = {
+            'ANSWER'    : 'answer',
+            'UNKNOWN'   : 'unknown',
+        }
+
+        env = Environment()
+        opts.Update(env, args)
+
+        r = opts.UnknownVariables()
+        assert r == {'UNKNOWN' : 'unknown'}, r
+        assert env['ANSWER'] == 'answer', env['ANSWER']
+        
+    def test_AddOptionUpdatesUnknown(self):
+        """Test updating of the 'unknown' dict"""
+        opts = SCons.Variables.Variables()
+        
+        opts.Add('A',
+                 'A test variable',
+                 "1")
+        
+        args = {
+            'A'             : 'a',
+            'ADDEDLATER'    : 'notaddedyet',
+        }
+        
+        env = Environment()
+        opts.Update(env,args)
+        
+        r = opts.UnknownVariables()
+        assert r == {'ADDEDLATER' : 'notaddedyet'}, r
+        assert env['A'] == 'a', env['A']
+        
+        opts.Add('ADDEDLATER',
+                 'An option not present initially',
+                 "1")
+                 
+        args = {
+            'A'             : 'a',
+            'ADDEDLATER'    : 'added',
+        }
+        
+        opts.Update(env, args)
+        
+        r = opts.UnknownVariables()
+        assert len(r) == 0, r
+        assert env['ADDEDLATER'] == 'added', env['ADDEDLATER']
+
+    def test_AddOptionWithAliasUpdatesUnknown(self):
+        """Test updating of the 'unknown' dict (with aliases)"""
+        opts = SCons.Variables.Variables()
+        
+        opts.Add('A',
+                 'A test variable',
+                 "1")
+        
+        args = {
+            'A'                 : 'a',
+            'ADDEDLATERALIAS'   : 'notaddedyet',
+        }
+        
+        env = Environment()
+        opts.Update(env,args)
+        
+        r = opts.UnknownVariables()
+        assert r == {'ADDEDLATERALIAS' : 'notaddedyet'}, r
+        assert env['A'] == 'a', env['A']
+        
+        opts.AddVariables(
+            (('ADDEDLATER', 'ADDEDLATERALIAS'),
+             'An option not present initially',
+             "1"),
+            )
+        
+        args['ADDEDLATERALIAS'] = 'added'
+        
+        opts.Update(env, args)
+        
+        r = opts.UnknownVariables()
+        assert len(r) == 0, r
+        assert env['ADDEDLATER'] == 'added', env['ADDEDLATER']
+
+
+if __name__ == "__main__":
+    suite = unittest.TestSuite()
+    tclasses = [ VariablesTestCase,
+                 UnknownVariablesTestCase ]
+    for tclass in tclasses:
+        names = unittest.getTestCaseNames(tclass, 'test_')
+        suite.addTests(map(tclass, names))
+    if not unittest.TextTestRunner().run(suite).wasSuccessful():
+        sys.exit(1)
+
+# Local Variables:
+# tab-width:4
+# indent-tabs-mode:nil
+# End:
+# vim: set expandtab tabstop=4 shiftwidth=4:
diff --git a/src/engine/SCons/Variables/__init__.py b/src/engine/SCons/Variables/__init__.py
new file mode 100644
index 0000000..7ab711a
--- /dev/null
+++ b/src/engine/SCons/Variables/__init__.py
@@ -0,0 +1,317 @@
+"""engine.SCons.Variables
+
+This file defines the Variables class that is used to add user-friendly
+customizable variables to an SCons build.
+"""
+
+#
+# Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 The SCons Foundation
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be included
+# in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
+# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+
+__revision__ = "src/engine/SCons/Variables/__init__.py 4577 2009/12/27 19:44:43 scons"
+
+import os.path
+import string
+import sys
+
+import SCons.Environment
+import SCons.Errors
+import SCons.Util
+import SCons.Warnings
+
+from BoolVariable import BoolVariable  # okay
+from EnumVariable import EnumVariable  # okay
+from ListVariable import ListVariable  # naja
+from PackageVariable import PackageVariable # naja
+from PathVariable import PathVariable # okay
+
+
+class Variables:
+    instance=None
+
+    """
+    Holds all the options, updates the environment with the variables,
+    and renders the help text.
+    """
+    def __init__(self, files=[], args={}, is_global=1):
+        """
+        files - [optional] List of option configuration files to load
+            (backward compatibility) If a single string is passed it is
+                                     automatically placed in a file list
+        """
+        self.options = []
+        self.args = args
+        if not SCons.Util.is_List(files):
+            if files:
+                files = [ files ]
+            else:
+                files = []
+        self.files = files
+        self.unknown = {}
+
+        # create the singleton instance
+        if is_global:
+            self=Variables.instance
+
+            if not Variables.instance:
+                Variables.instance=self
+
+    def _do_add(self, key, help="", default=None, validator=None, converter=None):
+        class Variable:
+            pass
+
+        option = Variable()
+
+        # if we get a list or a tuple, we take the first element as the
+        # option key and store the remaining in aliases.
+        if SCons.Util.is_List(key) or SCons.Util.is_Tuple(key):
+          option.key     = key[0]
+          option.aliases = key[1:]
+        else:
+          option.key     = key
+          option.aliases = [ key ]
+        option.help = help
+        option.default = default
+        option.validator = validator
+        option.converter = converter
+
+        self.options.append(option)
+        
+        # options might be added after the 'unknown' dict has been set up,
+        # so we remove the key and all its aliases from that dict
+        for alias in list(option.aliases) + [ option.key ]:
+          # TODO(1.5)
+          #if alias in self.unknown:
+          if alias in self.unknown.keys():
+            del self.unknown[alias]
+
+    def keys(self):
+        """
+        Returns the keywords for the options
+        """
+        return map(lambda o: o.key, self.options)
+
+    def Add(self, key, help="", default=None, validator=None, converter=None, **kw):
+        """
+        Add an option.
+
+        key - the name of the variable, or a list or tuple of arguments
+        help - optional help text for the options
+        default - optional default value
+        validator - optional function that is called to validate the option's value
+                    Called with (key, value, environment)
+        converter - optional function that is called to convert the option's value before
+                    putting it in the environment.
+        """
+
+        if SCons.Util.is_List(key) or type(key) == type(()):
+            apply(self._do_add, key)
+            return
+
+        if not SCons.Util.is_String(key) or \
+           not SCons.Environment.is_valid_construction_var(key):
+            raise SCons.Errors.UserError, "Illegal Variables.Add() key `%s'" % str(key)
+
+        self._do_add(key, help, default, validator, converter)
+
+    def AddVariables(self, *optlist):
+        """
+        Add a list of options.
+
+        Each list element is a tuple/list of arguments to be passed on
+        to the underlying method for adding options.
+
+        Example:
+          opt.AddVariables(
+            ('debug', '', 0),
+            ('CC', 'The C compiler'),
+            ('VALIDATE', 'An option for testing validation', 'notset',
+             validator, None),
+            )
+        """
+        for o in optlist:
+            apply(self._do_add, o)
+
+
+    def Update(self, env, args=None):
+        """
+        Update an environment with the option variables.
+
+        env - the environment to update.
+        """
+
+        values = {}
+
+        # first set the defaults:
+        for option in self.options:
+            if not option.default is None:
+                values[option.key] = option.default
+
+        # next set the value specified in the options file
+        for filename in self.files:
+            if os.path.exists(filename):
+                dir = os.path.split(os.path.abspath(filename))[0]
+                if dir:
+                    sys.path.insert(0, dir)
+                try:
+                    values['__name__'] = filename
+                    exec open(filename, 'rU').read() in {}, values
+                finally:
+                    if dir:
+                        del sys.path[0]
+                    del values['__name__']
+
+        # set the values specified on the command line
+        if args is None:
+            args = self.args
+
+        for arg, value in args.items():
+            added = False
+            for option in self.options:
+                if arg in list(option.aliases) + [ option.key ]:
+                    values[option.key] = value
+                    added = True
+            if not added:
+                self.unknown[arg] = value
+
+        # put the variables in the environment:
+        # (don't copy over variables that are not declared as options)
+        for option in self.options:
+            try:
+                env[option.key] = values[option.key]
+            except KeyError:
+                pass
+
+        # Call the convert functions:
+        for option in self.options:
+            if option.converter and values.has_key(option.key):
+                value = env.subst('${%s}'%option.key)
+                try:
+                    try:
+                        env[option.key] = option.converter(value)
+                    except TypeError:
+                        env[option.key] = option.converter(value, env)
+                except ValueError, x:
+                    raise SCons.Errors.UserError, 'Error converting option: %s\n%s'%(option.key, x)
+
+
+        # Finally validate the values:
+        for option in self.options:
+            if option.validator and values.has_key(option.key):
+                option.validator(option.key, env.subst('${%s}'%option.key), env)
+
+    def UnknownVariables(self):
+        """
+        Returns any options in the specified arguments lists that
+        were not known, declared options in this object.
+        """
+        return self.unknown
+
+    def Save(self, filename, env):
+        """
+        Saves all the options in the given file.  This file can
+        then be used to load the options next run.  This can be used
+        to create an option cache file.
+
+        filename - Name of the file to save into
+        env - the environment get the option values from
+        """
+
+        # Create the file and write out the header
+        try:
+            fh = open(filename, 'w')
+
+            try:
+                # Make an assignment in the file for each option
+                # within the environment that was assigned a value
+                # other than the default.
+                for option in self.options:
+                    try:
+                        value = env[option.key]
+                        try:
+                            prepare = value.prepare_to_store
+                        except AttributeError:
+                            try:
+                                eval(repr(value))
+                            except KeyboardInterrupt:
+                                raise
+                            except:
+                                # Convert stuff that has a repr() that
+                                # cannot be evaluated into a string
+                                value = SCons.Util.to_String(value)
+                        else:
+                            value = prepare()
+
+                        defaultVal = env.subst(SCons.Util.to_String(option.default))
+                        if option.converter:
+                            defaultVal = option.converter(defaultVal)
+
+                        if str(env.subst('${%s}' % option.key)) != str(defaultVal):
+                            fh.write('%s = %s\n' % (option.key, repr(value)))
+                    except KeyError:
+                        pass
+            finally:
+                fh.close()
+
+        except IOError, x:
+            raise SCons.Errors.UserError, 'Error writing options to file: %s\n%s' % (filename, x)
+
+    def GenerateHelpText(self, env, sort=None):
+        """
+        Generate the help text for the options.
+
+        env - an environment that is used to get the current values
+              of the options.
+        """
+
+        if sort:
+            options = self.options[:]
+            options.sort(lambda x,y,func=sort: func(x.key,y.key))
+        else:
+            options = self.options
+
+        def format(opt, self=self, env=env):
+            if env.has_key(opt.key):
+                actual = env.subst('${%s}' % opt.key)
+            else:
+                actual = None
+            return self.FormatVariableHelpText(env, opt.key, opt.help, opt.default, actual, opt.aliases)
+        lines = filter(None, map(format, options))
+
+        return string.join(lines, '')
+
+    format  = '\n%s: %s\n    default: %s\n    actual: %s\n'
+    format_ = '\n%s: %s\n    default: %s\n    actual: %s\n    aliases: %s\n'
+
+    def FormatVariableHelpText(self, env, key, help, default, actual, aliases=[]):
+        # Don't display the key name itself as an alias.
+        aliases = filter(lambda a, k=key: a != k, aliases)
+        if len(aliases)==0:
+            return self.format % (key, help, default, actual)
+        else:
+            return self.format_ % (key, help, default, actual, aliases)
+
+# Local Variables:
+# tab-width:4
+# indent-tabs-mode:nil
+# End:
+# vim: set expandtab tabstop=4 shiftwidth=4: