Imported Upstream version 2.0.0upstream/2.0.0

14 files changed, 324 insertions, 3173 deletions

diff --git a/engine/SCons/compat/__init__.py b/engine/SCons/compat/__init__.py
index 165dddf..cba69ef 100644
--- a/engine/SCons/compat/__init__.py
+++ b/engine/SCons/compat/__init__.py
@@ -31,12 +31,12 @@ we still support.
 
 Other code will not generally reference things in this package through
 the SCons.compat namespace.  The modules included here add things to
-the __builtin__ namespace or the global module list so that the rest
+the builtins namespace or the global module list so that the rest
 of our code can use the objects and names imported here regardless of
 Python version.
 
-Simply enough, things that go in the __builtin__ name space come from
-our builtins module.
+Simply enough, things that go in the builtins name space come from
+our _scons_builtins module.
 
 The rest of the things here will be in individual compatibility modules
 that are either: 1) suitably modified copies of the future modules that
@@ -60,20 +60,35 @@ function defined below loads the module as the "real" name (without the
 rest of our code will find our pre-loaded compatibility module.
 """
 
-__revision__ = "src/engine/SCons/compat/__init__.py 4720 2010/03/24 03:14:11 jars"
+__revision__ = "src/engine/SCons/compat/__init__.py 5023 2010/06/14 22:05:46 scons"
+
+import os
+import sys
+import imp   # Use the "imp" module to protect imports from fixers.
 
 def import_as(module, name):
     """
     Imports the specified module (from our local directory) as the
-    specified name.
+    specified name, returning the loaded module object.
     """
-    import imp
-    import os.path
     dir = os.path.split(__file__)[0]
-    file, filename, suffix_mode_type = imp.find_module(module, [dir])
-    imp.load_module(name, file, filename, suffix_mode_type)
+    return imp.load_module(name, *imp.find_module(module, [dir]))
+
+def rename_module(new, old):
+    """
+    Attempts to import the old module and load it under the new name.
+    Used for purely cosmetic name changes in Python 3.x.
+    """
+    try:
+        sys.modules[new] = imp.load_module(old, *imp.find_module(old))
+        return True
+    except ImportError:
+        return False
+
+
+rename_module('builtins', '__builtin__')
+import _scons_builtins
 
-import builtins
 
 try:
     import hashlib
@@ -92,75 +107,48 @@ try:
     set
 except NameError:
     # Pre-2.4 Python has no native set type
-    try:
-        # Python 2.2 and 2.3 can use the copy of the 2.[45] sets module
-        # that we grabbed.
-        import_as('_scons_sets', 'sets')
-    except (ImportError, SyntaxError):
-        # Python 1.5 (ImportError, no __future_ module) and 2.1
-        # (SyntaxError, no generators in __future__) will blow up
-        # trying to import the 2.[45] sets module, so back off to a
-        # custom sets module that can be discarded easily when we
-        # stop supporting those versions.
-        import_as('_scons_sets15', 'sets')
-    import __builtin__
-    import sets
-    __builtin__.set = sets.Set
-
-import fnmatch
-try:
-    fnmatch.filter
-except AttributeError:
-    # Pre-2.2 Python has no fnmatch.filter() function.
-    def filter(names, pat):
-        """Return the subset of the list NAMES that match PAT"""
-        import os,posixpath
-        result=[]
-        pat = os.path.normcase(pat)
-        if not fnmatch._cache.has_key(pat):
-            import re
-            res = fnmatch.translate(pat)
-            fnmatch._cache[pat] = re.compile(res)
-        match = fnmatch._cache[pat].match
-        if os.path is posixpath:
-            # normcase on posix is NOP. Optimize it away from the loop.
-            for name in names:
-                if match(name):
-                    result.append(name)
-        else:
-            for name in names:
-                if match(os.path.normcase(name)):
-                    result.append(name)
-        return result
-    fnmatch.filter = filter
-    del filter
+    import_as('_scons_sets', 'sets')
+    import builtins, sets
+    builtins.set = sets.Set
 
-try:
-    import itertools
-except ImportError:
-    # Pre-2.3 Python has no itertools module.
-    import_as('_scons_itertools', 'itertools')
 
-# If we need the compatibility version of textwrap, it  must be imported
-# before optparse, which uses it.
 try:
-    import textwrap
+    import collections
 except ImportError:
-    # Pre-2.3 Python has no textwrap module.
-    import_as('_scons_textwrap', 'textwrap')
+    # Pre-2.4 Python has no collections module.
+    import_as('_scons_collections', 'collections')
+else:
+    try:
+        collections.UserDict
+    except AttributeError:
+        exec('from UserDict import UserDict as _UserDict')
+        collections.UserDict = _UserDict
+        del _UserDict
+    try:
+        collections.UserList
+    except AttributeError:
+        exec('from UserList import UserList as _UserList')
+        collections.UserList = _UserList
+        del _UserList
+    try:
+        collections.UserString
+    except AttributeError:
+        exec('from UserString import UserString as _UserString')
+        collections.UserString = _UserString
+        del _UserString
+
 
 try:
-    import optparse
+    import io
 except ImportError:
-    # Pre-2.3 Python has no optparse module.
-    import_as('_scons_optparse', 'optparse')
+    # Pre-2.6 Python has no io module.
+    import_as('_scons_io', 'io')
+
 
-import os
 try:
     os.devnull
 except AttributeError:
     # Pre-2.4 Python has no os.devnull attribute
-    import sys
     _names = sys.builtin_module_names
     if 'posix' in _names:
         os.devnull = '/dev/null'
@@ -176,64 +164,25 @@ except AttributeError:
     os.path.lexists = lexists
 
 
-try:
-    import platform
-except ImportError:
-    # Pre-2.3 Python has no platform module.
-    import_as('_scons_platform', 'platform')
+# When we're using the '-3' option during regression tests, importing
+# cPickle gives a warning no matter how it's done, so always use the
+# real profile module, whether it's fast or not.
+if os.environ.get('SCONS_HORRIBLE_REGRESSION_TEST_HACK') is None:
+    # Not a regression test with '-3', so try to use faster version.
+    # In 3.x, 'pickle' automatically loads the fast version if available.
+    rename_module('pickle', 'cPickle')
 
 
-import shlex
-try:
-    shlex.split
-except AttributeError:
-    # Pre-2.3 Python has no shlex.split() function.
-    #
-    # The full white-space splitting semantics of shlex.split() are
-    # complicated to reproduce by hand, so just use a compatibility
-    # version of the shlex module cribbed from Python 2.5 with some
-    # minor modifications for older Python versions.
-    del shlex
-    import_as('_scons_shlex', 'shlex')
+# In 3.x, 'profile' automatically loads the fast version if available.
+rename_module('profile', 'cProfile')
 
 
-import shutil
-try:
-    shutil.move
-except AttributeError:
-    # Pre-2.3 Python has no shutil.move() function.
-    #
-    # Cribbed from Python 2.5.
-    import os
-
-    def move(src, dst):
-        """Recursively move a file or directory to another location.
-
-        If the destination is on our current filesystem, then simply use
-        rename.  Otherwise, copy src to the dst and then remove src.
-        A lot more could be done here...  A look at a mv.c shows a lot of
-        the issues this implementation glosses over.
-
-        """
-        try:
-            os.rename(src, dst)
-        except OSError:
-            if os.path.isdir(src):
-                if shutil.destinsrc(src, dst):
-                    raise Error, "Cannot move a directory '%s' into itself '%s'." % (src, dst)
-                shutil.copytree(src, dst, symlinks=True)
-                shutil.rmtree(src)
-            else:
-                shutil.copy2(src,dst)
-                os.unlink(src)
-    shutil.move = move
-    del move
-
-    def destinsrc(src, dst):
-        src = os.path.abspath(src)
-        return os.path.abspath(dst)[:len(src)] == src
-    shutil.destinsrc = destinsrc
-    del destinsrc
+# Before Python 3.0, the 'queue' module was named 'Queue'.
+rename_module('queue', 'Queue')
+
+
+# Before Python 3.0, the 'winreg' module was named '_winreg'
+rename_module('winreg', '_winreg')
 
 
 try:
@@ -242,57 +191,43 @@ except ImportError:
     # Pre-2.4 Python has no subprocess module.
     import_as('_scons_subprocess', 'subprocess')
 
-import sys
 try:
-    sys.version_info
+    sys.intern
 except AttributeError:
-    # Pre-1.6 Python has no sys.version_info
-    import string
-    version_string = string.split(sys.version)[0]
-    version_ints = map(int, string.split(version_string, '.'))
-    sys.version_info = tuple(version_ints + ['final', 0])
-
-try:
-    import UserString
-except ImportError:
-    # Pre-1.6 Python has no UserString module.
-    import_as('_scons_UserString', 'UserString')
-
-import tempfile
+    # Pre-2.6 Python has no sys.intern() function.
+    import builtins
+    try:
+        sys.intern = builtins.intern
+    except AttributeError:
+        # Pre-2.x Python has no builtin intern() function.
+        def intern(x):
+           return x
+        sys.intern = intern
+        del intern
 try:
-    tempfile.mkstemp
+    sys.maxsize
 except AttributeError:
-    # Pre-2.3 Python has no tempfile.mkstemp function, so try to simulate it.
-    # adapted from the mkstemp implementation in python 3.
-    import os
-    import errno
-    def mkstemp(*args, **kw):
-        text = False
-        # TODO (1.5)
-        #if 'text' in kw :
-        if 'text' in kw.keys() :
-            text = kw['text']
-            del kw['text']
-        elif len( args ) == 4 :
-            text = args[3]
-            args = args[:3]
-        flags = os.O_RDWR | os.O_CREAT | os.O_EXCL
-        if not text and hasattr( os, 'O_BINARY' ) :
-            flags = flags | os.O_BINARY
-        while True:
-            try :
-                name = apply(tempfile.mktemp, args, kw)
-                fd = os.open( name, flags, 0600 )
-                return (fd, os.path.abspath(name))
-            except OSError, e:
-                if e.errno == errno.EEXIST:
-                    continue
-                raise
-
-    tempfile.mkstemp = mkstemp
-    del mkstemp
-
-
+    # Pre-2.6 Python has no sys.maxsize attribute
+    # Wrapping sys in () is silly, but protects it from 2to3 renames fixer
+    sys.maxsize = (sys).maxint
+
+
+if os.environ.get('SCONS_HORRIBLE_REGRESSION_TEST_HACK') is not None:
+    # We can't apply the 'callable' fixer until the floor is 2.6, but the
+    # '-3' option to Python 2.6 and 2.7 generates almost ten thousand
+    # warnings.  This hack allows us to run regression tests with the '-3'
+    # option by replacing the callable() built-in function with a hack
+    # that performs the same function but doesn't generate the warning.
+    # Note that this hack is ONLY intended to be used for regression
+    # testing, and should NEVER be used for real runs.
+    from types import ClassType
+    def callable(obj):
+        if hasattr(obj, '__call__'): return True
+        if isinstance(obj, (ClassType, type)): return True
+        return False
+    import builtins
+    builtins.callable = callable
+    del callable
 
 
 # Local Variables:
diff --git a/engine/SCons/compat/_scons_UserString.py b/engine/SCons/compat/_scons_UserString.py
deleted file mode 100644
index f8c462e..0000000
--- a/engine/SCons/compat/_scons_UserString.py
+++ /dev/null
@@ -1,98 +0,0 @@
-#
-# Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 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/compat/_scons_UserString.py 4720 2010/03/24 03:14:11 jars"
-
-__doc__ = """
-A user-defined wrapper around string objects
-
-This class is "borrowed" from the Python 2.2 UserString and modified
-slightly for use with SCons.  It is *NOT* guaranteed to be fully compliant
-with the standard UserString class from all later versions of Python.
-In particular, it does not necessarily contain all of the methods found
-in later versions.
-"""
-
-import types
-
-StringType = types.StringType
-
-if hasattr(types, 'UnicodeType'):
-    UnicodeType = types.UnicodeType
-    def is_String(obj):
-        return type(obj) in (StringType, UnicodeType)
-else:
-    def is_String(obj):
-        return type(obj) is StringType
-
-class UserString:
-    def __init__(self, seq):
-        if is_String(seq):
-            self.data = seq
-        elif isinstance(seq, UserString):
-            self.data = seq.data[:]
-        else:
-            self.data = str(seq)
-    def __str__(self): return str(self.data)
-    def __repr__(self): return repr(self.data)
-    def __int__(self): return int(self.data)
-    def __long__(self): return long(self.data)
-    def __float__(self): return float(self.data)
-    def __complex__(self): return complex(self.data)
-    def __hash__(self): return hash(self.data)
-
-    def __cmp__(self, string):
-        if isinstance(string, UserString):
-            return cmp(self.data, string.data)
-        else:
-            return cmp(self.data, string)
-    def __contains__(self, char):
-        return char in self.data
-
-    def __len__(self): return len(self.data)
-    def __getitem__(self, index): return self.__class__(self.data[index])
-    def __getslice__(self, start, end):
-        start = max(start, 0); end = max(end, 0)
-        return self.__class__(self.data[start:end])
-
-    def __add__(self, other):
-        if isinstance(other, UserString):
-            return self.__class__(self.data + other.data)
-        elif is_String(other):
-            return self.__class__(self.data + other)
-        else:
-            return self.__class__(self.data + str(other))
-    def __radd__(self, other):
-        if is_String(other):
-            return self.__class__(other + self.data)
-        else:
-            return self.__class__(str(other) + self.data)
-    def __mul__(self, n):
-        return self.__class__(self.data*n)
-    __rmul__ = __mul__
-
-# Local Variables:
-# tab-width:4
-# indent-tabs-mode:nil
-# End:
-# vim: set expandtab tabstop=4 shiftwidth=4:
diff --git a/engine/SCons/compat/builtins.py b/engine/SCons/compat/_scons_builtins.py
index e687885..234d380 100644
--- a/engine/SCons/compat/builtins.py
+++ b/engine/SCons/compat/_scons_builtins.py
@@ -27,21 +27,18 @@
 # Copyright (c) 2001-2004 Twisted Matrix Laboratories
 
 __doc__ = """
-Compatibility idioms for __builtin__ names
+Compatibility idioms for builtins names
 
-This module adds names to the __builtin__ module for things that we want
+This module adds names to the builtins module for things that we want
 to use in SCons but which don't show up until later Python versions than
 the earliest ones we support.
 
-This module checks for the following __builtin__ names:
+This module checks for the following builtins names:
 
         all()
         any()
-        bool()
-        dict()
-        True
-        False
-        zip()
+        sorted()
+        memoryview()
 
 Implementations of functions are *NOT* guaranteed to be fully compliant
 with these functions in later versions of Python.  We are only concerned
@@ -55,9 +52,9 @@ the FUNCTIONS or DATA output, that means those names are already built in
 to this version of Python and we don't need to add them from this module.
 """
 
-__revision__ = "src/engine/SCons/compat/builtins.py 4720 2010/03/24 03:14:11 jars"
+__revision__ = "src/engine/SCons/compat/_scons_builtins.py 5023 2010/06/14 22:05:46 scons"
 
-import __builtin__
+import builtins
 
 try:
     all
@@ -71,7 +68,7 @@ except NameError:
             if not element:
                 return False
         return True
-    __builtin__.all = all
+    builtins.all = all
     all = all
 
 try:
@@ -86,83 +83,49 @@ except NameError:
             if element:
                 return True
         return False
-    __builtin__.any = any
+    builtins.any = any
     any = any
 
 try:
-    bool
+    memoryview
 except NameError:
-    # Pre-2.2 Python has no bool() function.
-    def bool(value):
-        """Demote a value to 0 or 1, depending on its truth value.
+    # Pre-2.7 doesn't have the memoryview() built-in.
+    class memoryview(object):
+        def __init__(self, obj):
+            # wrapping buffer in () keeps the fixer from changing it
+            self.obj = (buffer)(obj)
+        def __getitem__(self, indx):
+            if isinstance(indx, slice):
+                return self.obj[indx.start:indx.stop]
+            else:
+                return self.obj[indx]
+    builtins.memoryview = memoryview
 
-        This is not to be confused with types.BooleanType, which is
-        way too hard to duplicate in early Python versions to be
-        worth the trouble.
-        """
-        return not not value
-    __builtin__.bool = bool
-    bool = bool
-
-try:
-    dict
-except NameError:
-    # Pre-2.2 Python has no dict() keyword.
-    def dict(seq=[], **kwargs):
-        """
-        New dictionary initialization.
-        """
-        d = {}
-        for k, v in seq:
-            d[k] = v
-        d.update(kwargs)
-        return d
-    __builtin__.dict = dict
-
-try:
-    False
-except NameError:
-    # Pre-2.2 Python has no False keyword.
-    __builtin__.False = not 1
-    # Assign to False in this module namespace so it shows up in pydoc output.
-    False = False
-
-try:
-    True
-except NameError:
-    # Pre-2.2 Python has no True keyword.
-    __builtin__.True = not 0
-    # Assign to True in this module namespace so it shows up in pydoc output.
-    True = True
-
-try:
-    file
-except NameError:
-    # Pre-2.2 Python has no file() function.
-    __builtin__.file = open
-
-#
 try:
-    zip
+    sorted
 except NameError:
-    # Pre-2.2 Python has no zip() function.
-    def zip(*lists):
-        """
-        Emulates the behavior we need from the built-in zip() function
-        added in Python 2.2.
-
-        Returns a list of tuples, where each tuple contains the i-th
-        element rom each of the argument sequences.  The returned
-        list is truncated in length to the length of the shortest
-        argument sequence.
-        """
-        result = []
-        for i in xrange(min(map(len, lists))):
-            result.append(tuple(map(lambda l, i=i: l[i], lists)))
+    # Pre-2.4 Python has no sorted() function.
+    #
+    # The pre-2.4 Python list.sort() method does not support
+    # list.sort(key=) nor list.sort(reverse=) keyword arguments, so
+    # we must implement the functionality of those keyword arguments
+    # by hand instead of passing them to list.sort().
+    def sorted(iterable, cmp=None, key=None, reverse=False):
+        if key is not None:
+            result = [(key(x), x) for x in iterable]
+        else:
+            result = iterable[:]
+        if cmp is None:
+            # Pre-2.3 Python does not support list.sort(None).
+            result.sort()
+        else:
+            result.sort(cmp)
+        if key is not None:
+            result = [t1 for t0,t1 in result]
+        if reverse:
+            result.reverse()
         return result
-    __builtin__.zip = zip
-
-
+    builtins.sorted = sorted
 
 #if sys.version_info[:3] in ((2, 2, 0), (2, 2, 1)):
 #    def lstrip(s, c=string.whitespace):
diff --git a/engine/SCons/compat/_scons_collections.py b/engine/SCons/compat/_scons_collections.py
new file mode 100644
index 0000000..b44319c
--- /dev/null
+++ b/engine/SCons/compat/_scons_collections.py
@@ -0,0 +1,45 @@
+#
+# Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 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.
+#
+
+__doc__ = """
+collections compatibility module for older (pre-2.4) Python versions
+
+This does not not NOT (repeat, *NOT*) provide complete collections
+functionality.  It only wraps the portions of collections functionality
+used by SCons, in an interface that looks enough like collections for
+our purposes.
+"""
+
+__revision__ = "src/engine/SCons/compat/_scons_collections.py 5023 2010/06/14 22:05:46 scons"
+
+# Use exec to hide old names from fixers.
+exec("""if True:
+            from UserDict import UserDict
+            from UserList import UserList
+            from UserString import UserString""")
+
+# Local Variables:
+# tab-width:4
+# indent-tabs-mode:nil
+# End:
+# vim: set expandtab tabstop=4 shiftwidth=4:
diff --git a/engine/SCons/compat/_scons_dbm.py b/engine/SCons/compat/_scons_dbm.py
new file mode 100644
index 0000000..6228aee
--- /dev/null
+++ b/engine/SCons/compat/_scons_dbm.py
@@ -0,0 +1,45 @@
+#
+# Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 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.
+#
+
+__doc__ = """
+dbm compatibility module for Python versions that don't have dbm.
+
+This does not not NOT (repeat, *NOT*) provide complete dbm functionality.
+It's just a stub on which to hang just enough pieces of dbm functionality
+that the whichdb.whichdb() implementstation in the various 2.X versions of
+Python won't blow up even if dbm wasn't compiled in.
+"""
+
+__revision__ = "src/engine/SCons/compat/_scons_dbm.py 5023 2010/06/14 22:05:46 scons"
+
+class error(Exception):
+    pass
+
+def open(*args, **kw):
+    raise error()
+
+# Local Variables:
+# tab-width:4
+# indent-tabs-mode:nil
+# End:
+# vim: set expandtab tabstop=4 shiftwidth=4:
diff --git a/engine/SCons/compat/_scons_hashlib.py b/engine/SCons/compat/_scons_hashlib.py
index b325e33..1c93787 100644
--- a/engine/SCons/compat/_scons_hashlib.py
+++ b/engine/SCons/compat/_scons_hashlib.py
@@ -31,18 +31,18 @@ purposes, anyway).  In fact, this module will raise an ImportError if
 the underlying md5 module isn't available.
 """
 
-__revision__ = "src/engine/SCons/compat/_scons_hashlib.py 4720 2010/03/24 03:14:11 jars"
+__revision__ = "src/engine/SCons/compat/_scons_hashlib.py 5023 2010/06/14 22:05:46 scons"
 
 import md5
-import string
+from string import hexdigits
 
-class md5obj:
+class md5obj(object):
 
     md5_module = md5
 
     def __init__(self, name, string=''):
         if not name in ('MD5', 'md5'):
-            raise ValueError, "unsupported hash type"
+            raise ValueError("unsupported hash type")
         self.name = 'md5'
         self.m = self.md5_module.md5()
 
@@ -61,23 +61,8 @@ class md5obj:
     def update(self, arg):
         return self.m.update(arg)
 
-    if hasattr(md5.md5(), 'hexdigest'):
-
-        def hexdigest(self):
-            return self.m.hexdigest()
-
-    else:
-
-        # Objects created by the underlying md5 module have no native
-        # hexdigest() method (*cough* 1.5.2 *cough*), so provide an
-        # equivalent lifted from elsewhere.
-        def hexdigest(self):
-            h = string.hexdigits
-            r = ''
-            for c in self.digest():
-                i = ord(c)
-                r = r + h[(i >> 4) & 0xF] + h[i & 0xF]
-            return r
+    def hexdigest(self):
+        return self.m.hexdigest()
 
 new = md5obj
 
diff --git a/engine/SCons/compat/_scons_io.py b/engine/SCons/compat/_scons_io.py
new file mode 100644
index 0000000..3dc6ffd
--- /dev/null
+++ b/engine/SCons/compat/_scons_io.py
@@ -0,0 +1,45 @@
+#
+# Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 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.
+#
+
+__doc__ = """
+io compatibility module for older (pre-2.6) Python versions
+
+This does not not NOT (repeat, *NOT*) provide complete io
+functionality.  It only wraps the portions of io functionality used
+by SCons, in an interface that looks enough like io for our purposes.
+"""
+
+__revision__ = "src/engine/SCons/compat/_scons_io.py 5023 2010/06/14 22:05:46 scons"
+
+# Use the "imp" module to protect the imports below from fixers.
+import imp
+
+_cStringIO = imp.load_module('cStringIO', *imp.find_module('cStringIO'))
+StringIO = _cStringIO.StringIO
+del _cStringIO
+
+# Local Variables:
+# tab-width:4
+# indent-tabs-mode:nil
+# End:
+# vim: set expandtab tabstop=4 shiftwidth=4:
diff --git a/engine/SCons/compat/_scons_itertools.py b/engine/SCons/compat/_scons_itertools.py
deleted file mode 100644
index 44add7c..0000000
--- a/engine/SCons/compat/_scons_itertools.py
+++ /dev/null
@@ -1,124 +0,0 @@
-#
-# Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 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/compat/_scons_itertools.py 4720 2010/03/24 03:14:11 jars"
-
-__doc__ = """
-Implementations of itertools functions for Python versions that don't
-have iterators.
-
-These implement the functions by creating the entire list, not returning
-it element-by-element as the real itertools functions do.  This means
-that early Python versions won't get the performance benefit of using
-the itertools, but we can still use them so the later Python versions
-do get the advantages of using iterators.
-
-Because we return the entire list, we intentionally do not implement the
-itertools functions that "return" infinitely-long lists: the count(),
-cycle() and repeat() functions.  Other functions below have remained
-unimplemented simply because they aren't being used (yet) and it wasn't
-obvious how to do it.  Or, conversely, we only implemented those functions
-that *were* easy to implement (mostly because the Python documentation
-contained examples of equivalent code).
-
-Note that these do not have independent unit tests, so it's possible
-that there are bugs.
-"""
-
-def chain(*iterables):
-    result = []
-    for x in iterables:
-        result.extend(list(x))
-    return result
-
-def count(n=0):
-    # returns infinite length, should not be supported
-    raise NotImplementedError
-
-def cycle(iterable):
-    # returns infinite length, should not be supported
-    raise NotImplementedError
-
-def dropwhile(predicate, iterable):
-    result = []
-    for x in iterable:
-        if not predicate(x):
-            result.append(x)
-            break
-    result.extend(iterable)
-    return result
-
-def groupby(iterable, *args):
-    raise NotImplementedError
-
-def ifilter(predicate, iterable):
-    result = []
-    if predicate is None:
-        predicate = bool
-    for x in iterable:
-        if predicate(x):
-            result.append(x)
-    return result
-
-def ifilterfalse(predicate, iterable):
-    result = []
-    if predicate is None:
-        predicate = bool
-    for x in iterable:
-        if not predicate(x):
-            result.append(x)
-    return result
-
-def imap(function, *iterables):
-    return apply(map, (function,) + tuple(iterables))
-
-def islice(*args, **kw):
-    raise NotImplementedError
-
-def izip(*iterables):
-    return apply(zip, iterables)
-
-def repeat(*args, **kw):
-    # returns infinite length, should not be supported
-    raise NotImplementedError
-
-def starmap(*args, **kw):
-    raise NotImplementedError
-
-def takewhile(predicate, iterable):
-    result = []
-    for x in iterable:
-        if predicate(x):
-            result.append(x)
-        else:
-            break
-    return result
-
-def tee(*args, **kw):
-    raise NotImplementedError
-
-# Local Variables:
-# tab-width:4
-# indent-tabs-mode:nil
-# End:
-# vim: set expandtab tabstop=4 shiftwidth=4:
diff --git a/engine/SCons/compat/_scons_optparse.py b/engine/SCons/compat/_scons_optparse.py
deleted file mode 100644
index 219adba..0000000
--- a/engine/SCons/compat/_scons_optparse.py
+++ /dev/null
@@ -1,1725 +0,0 @@
-"""optparse - a powerful, extensible, and easy-to-use option parser.
-
-By Greg Ward <gward@python.net>
-
-Originally distributed as Optik; see http://optik.sourceforge.net/ .
-
-If you have problems with this module, please do not file bugs,
-patches, or feature requests with Python; instead, use Optik's
-SourceForge project page:
-  http://sourceforge.net/projects/optik
-
-For support, use the optik-users@lists.sourceforge.net mailing list
-(http://lists.sourceforge.net/lists/listinfo/optik-users).
-"""
-
-# Python developers: please do not make changes to this file, since
-# it is automatically generated from the Optik source code.
-
-__version__ = "1.5.3"
-
-__all__ = ['Option',
-           'SUPPRESS_HELP',
-           'SUPPRESS_USAGE',
-           'Values',
-           'OptionContainer',
-           'OptionGroup',
-           'OptionParser',
-           'HelpFormatter',
-           'IndentedHelpFormatter',
-           'TitledHelpFormatter',
-           'OptParseError',
-           'OptionError',
-           'OptionConflictError',
-           'OptionValueError',
-           'BadOptionError']
-
-__copyright__ = """
-Copyright (c) 2001-2006 Gregory P. Ward.  All rights reserved.
-Copyright (c) 2002-2006 Python Software Foundation.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-
-  * Redistributions of source code must retain the above copyright
-    notice, this list of conditions and the following disclaimer.
-
-  * Redistributions in binary form must reproduce the above copyright
-    notice, this list of conditions and the following disclaimer in the
-    documentation and/or other materials provided with the distribution.
-
-  * Neither the name of the author nor the names of its
-    contributors may be used to endorse or promote products derived from
-    this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
-IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
-TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
-PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR
-CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-"""
-
-import string
-import sys, os
-import types
-import textwrap
-
-def _repr(self):
-    return "<%s at 0x%x: %s>" % (self.__class__.__name__, id(self), self)
-
-
-try:
-    sys.getdefaultencoding
-except AttributeError:
-    def fake_getdefaultencoding():
-        return None
-    sys.getdefaultencoding = fake_getdefaultencoding
-
-try:
-    ''.encode
-except AttributeError:
-    def encode_wrapper(s, encoding, replacement):
-        return s
-else:
-    def encode_wrapper(s, encoding, replacement):
-        return s.encode(encoding, replacement)
-
-
-# This file was generated from:
-#   Id: option_parser.py 527 2006-07-23 15:21:30Z greg
-#   Id: option.py 522 2006-06-11 16:22:03Z gward
-#   Id: help.py 527 2006-07-23 15:21:30Z greg
-#   Id: errors.py 509 2006-04-20 00:58:24Z gward
-
-try:
-    from gettext import gettext
-except ImportError:
-    def gettext(message):
-        return message
-_ = gettext
-
-
-class OptParseError (Exception):
-    def __init__(self, msg):
-        self.msg = msg
-
-    def __str__(self):
-        return self.msg
-
-
-class OptionError (OptParseError):
-    """
-    Raised if an Option instance is created with invalid or
-    inconsistent arguments.
-    """
-
-    def __init__(self, msg, option):
-        self.msg = msg
-        self.option_id = str(option)
-
-    def __str__(self):
-        if self.option_id:
-            return "option %s: %s" % (self.option_id, self.msg)
-        else:
-            return self.msg
-
-class OptionConflictError (OptionError):
-    """
-    Raised if conflicting options are added to an OptionParser.
-    """
-
-class OptionValueError (OptParseError):
-    """
-    Raised if an invalid option value is encountered on the command
-    line.
-    """
-
-class BadOptionError (OptParseError):
-    """
-    Raised if an invalid option is seen on the command line.
-    """
-    def __init__(self, opt_str):
-        self.opt_str = opt_str
-
-    def __str__(self):
-        return _("no such option: %s") % self.opt_str
-
-class AmbiguousOptionError (BadOptionError):
-    """
-    Raised if an ambiguous option is seen on the command line.
-    """
-    def __init__(self, opt_str, possibilities):
-        BadOptionError.__init__(self, opt_str)
-        self.possibilities = possibilities
-
-    def __str__(self):
-        return (_("ambiguous option: %s (%s?)")
-                % (self.opt_str, string.join(self.possibilities, ", ")))
-
-
-class HelpFormatter:
-
-    """
-    Abstract base class for formatting option help.  OptionParser
-    instances should use one of the HelpFormatter subclasses for
-    formatting help; by default IndentedHelpFormatter is used.
-
-    Instance attributes:
-      parser : OptionParser
-        the controlling OptionParser instance
-      indent_increment : int
-        the number of columns to indent per nesting level
-      max_help_position : int
-        the maximum starting column for option help text
-      help_position : int
-        the calculated starting column for option help text;
-        initially the same as the maximum
-      width : int
-        total number of columns for output (pass None to constructor for
-        this value to be taken from the $COLUMNS environment variable)
-      level : int
-        current indentation level
-      current_indent : int
-        current indentation level (in columns)
-      help_width : int
-        number of columns available for option help text (calculated)
-      default_tag : str
-        text to replace with each option's default value, "%default"
-        by default.  Set to false value to disable default value expansion.
-      option_strings : { Option : str }
-        maps Option instances to the snippet of help text explaining
-        the syntax of that option, e.g. "-h, --help" or
-        "-fFILE, --file=FILE"
-      _short_opt_fmt : str
-        format string controlling how short options with values are
-        printed in help text.  Must be either "%s%s" ("-fFILE") or
-        "%s %s" ("-f FILE"), because those are the two syntaxes that
-        Optik supports.
-      _long_opt_fmt : str
-        similar but for long options; must be either "%s %s" ("--file FILE")
-        or "%s=%s" ("--file=FILE").
-    """
-
-    NO_DEFAULT_VALUE = "none"
-
-    def __init__(self,
-                 indent_increment,
-                 max_help_position,
-                 width,
-                 short_first):
-        self.parser = None
-        self.indent_increment = indent_increment
-        self.help_position = self.max_help_position = max_help_position
-        if width is None:
-            try:
-                width = int(os.environ['COLUMNS'])
-            except (KeyError, ValueError):
-                width = 80
-            width = width - 2
-        self.width = width
-        self.current_indent = 0
-        self.level = 0
-        self.help_width = None          # computed later
-        self.short_first = short_first
-        self.default_tag = "%default"
-        self.option_strings = {}
-        self._short_opt_fmt = "%s %s"
-        self._long_opt_fmt = "%s=%s"
-
-    def set_parser(self, parser):
-        self.parser = parser
-
-    def set_short_opt_delimiter(self, delim):
-        if delim not in ("", " "):
-            raise ValueError(
-                "invalid metavar delimiter for short options: %r" % delim)
-        self._short_opt_fmt = "%s" + delim + "%s"
-
-    def set_long_opt_delimiter(self, delim):
-        if delim not in ("=", " "):
-            raise ValueError(
-                "invalid metavar delimiter for long options: %r" % delim)
-        self._long_opt_fmt = "%s" + delim + "%s"
-
-    def indent(self):
-        self.current_indent = self.current_indent + self.indent_increment
-        self.level = self.level + 1
-
-    def dedent(self):
-        self.current_indent = self.current_indent - self.indent_increment
-        assert self.current_indent >= 0, "Indent decreased below 0."
-        self.level = self.level - 1
-
-    def format_usage(self, usage):
-        raise NotImplementedError, "subclasses must implement"
-
-    def format_heading(self, heading):
-        raise NotImplementedError, "subclasses must implement"
-
-    def _format_text(self, text):
-        """
-        Format a paragraph of free-form text for inclusion in the
-        help output at the current indentation level.
-        """
-        text_width = self.width - self.current_indent
-        indent = " "*self.current_indent
-        return textwrap.fill(text,
-                             text_width,
-                             initial_indent=indent,
-                             subsequent_indent=indent)
-
-    def format_description(self, description):
-        if description:
-            return self._format_text(description) + "\n"
-        else:
-            return ""
-
-    def format_epilog(self, epilog):
-        if epilog:
-            return "\n" + self._format_text(epilog) + "\n"
-        else:
-            return ""
-
-
-    def expand_default(self, option):
-        if self.parser is None or not self.default_tag:
-            return option.help
-
-        default_value = self.parser.defaults.get(option.dest)
-        if default_value is NO_DEFAULT or default_value is None:
-            default_value = self.NO_DEFAULT_VALUE
-
-        return string.replace(option.help, self.default_tag, str(default_value))
-
-    def format_option(self, option):
-        # The help for each option consists of two parts:
-        #   * the opt strings and metavars
-        #     eg. ("-x", or "-fFILENAME, --file=FILENAME")
-        #   * the user-supplied help string
-        #     eg. ("turn on expert mode", "read data from FILENAME")
-        #
-        # If possible, we write both of these on the same line:
-        #   -x      turn on expert mode
-        #
-        # But if the opt string list is too long, we put the help
-        # string on a second line, indented to the same column it would
-        # start in if it fit on the first line.
-        #   -fFILENAME, --file=FILENAME
-        #           read data from FILENAME
-        result = []
-        opts = self.option_strings[option]
-        opt_width = self.help_position - self.current_indent - 2
-        if len(opts) > opt_width:
-            opts = "%*s%s\n" % (self.current_indent, "", opts)
-            indent_first = self.help_position
-        else:                       # start help on same line as opts
-            opts = "%*s%-*s  " % (self.current_indent, "", opt_width, opts)
-            indent_first = 0
-        result.append(opts)
-        if option.help:
-            help_text = self.expand_default(option)
-            help_lines = textwrap.wrap(help_text, self.help_width)
-            result.append("%*s%s\n" % (indent_first, "", help_lines[0]))
-            for line in help_lines[1:]:
-                result.append("%*s%s\n" % (self.help_position, "", line))
-        elif opts[-1] != "\n":
-            result.append("\n")
-        return string.join(result, "")
-
-    def store_option_strings(self, parser):
-        self.indent()
-        max_len = 0
-        for opt in parser.option_list:
-            strings = self.format_option_strings(opt)
-            self.option_strings[opt] = strings
-            max_len = max(max_len, len(strings) + self.current_indent)
-        self.indent()
-        for group in parser.option_groups:
-            for opt in group.option_list:
-                strings = self.format_option_strings(opt)
-                self.option_strings[opt] = strings
-                max_len = max(max_len, len(strings) + self.current_indent)
-        self.dedent()
-        self.dedent()
-        self.help_position = min(max_len + 2, self.max_help_position)
-        self.help_width = self.width - self.help_position
-
-    def format_option_strings(self, option):
-        """Return a comma-separated list of option strings & metavariables."""
-        if option.takes_value():
-            metavar = option.metavar or string.upper(option.dest)
-            short_opts = []
-            for sopt in option._short_opts:
-                short_opts.append(self._short_opt_fmt % (sopt, metavar))
-            long_opts = []
-            for lopt in option._long_opts:
-                long_opts.append(self._long_opt_fmt % (lopt, metavar))
-        else:
-            short_opts = option._short_opts
-            long_opts = option._long_opts
-
-        if self.short_first:
-            opts = short_opts + long_opts
-        else:
-            opts = long_opts + short_opts
-
-        return string.join(opts, ", ")
-
-class IndentedHelpFormatter (HelpFormatter):
-    """Format help with indented section bodies.
-    """
-
-    def __init__(self,
-                 indent_increment=2,
-                 max_help_position=24,
-                 width=None,
-                 short_first=1):
-        HelpFormatter.__init__(
-            self, indent_increment, max_help_position, width, short_first)
-
-    def format_usage(self, usage):
-        return _("Usage: %s\n") % usage
-
-    def format_heading(self, heading):
-        return "%*s%s:\n" % (self.current_indent, "", heading)
-
-
-class TitledHelpFormatter (HelpFormatter):
-    """Format help with underlined section headers.
-    """
-
-    def __init__(self,
-                 indent_increment=0,
-                 max_help_position=24,
-                 width=None,
-                 short_first=0):
-        HelpFormatter.__init__ (
-            self, indent_increment, max_help_position, width, short_first)
-
-    def format_usage(self, usage):
-        return "%s  %s\n" % (self.format_heading(_("Usage")), usage)
-
-    def format_heading(self, heading):
-        return "%s\n%s\n" % (heading, "=-"[self.level] * len(heading))
-
-
-def _parse_num(val, type):
-    if string.lower(val[:2]) == "0x":         # hexadecimal
-        radix = 16
-    elif string.lower(val[:2]) == "0b":       # binary
-        radix = 2
-        val = val[2:] or "0"            # have to remove "0b" prefix
-    elif val[:1] == "0":                # octal
-        radix = 8
-    else:                               # decimal
-        radix = 10
-
-    return type(val, radix)
-
-def _parse_int(val):
-    return _parse_num(val, int)
-
-def _parse_long(val):
-    return _parse_num(val, long)
-
-try:
-    int('0', 10)
-except TypeError:
-    # Python 1.5.2 doesn't allow a radix value to be passed to int().
-    _parse_int = int
-
-try:
-    long('0', 10)
-except TypeError:
-    # Python 1.5.2 doesn't allow a radix value to be passed to long().
-    _parse_long = long
-
-_builtin_cvt = { "int" : (_parse_int, _("integer")),
-                 "long" : (_parse_long, _("long integer")),
-                 "float" : (float, _("floating-point")),
-                 "complex" : (complex, _("complex")) }
-
-def check_builtin(option, opt, value):
-    (cvt, what) = _builtin_cvt[option.type]
-    try:
-        return cvt(value)
-    except ValueError:
-        raise OptionValueError(
-            _("option %s: invalid %s value: %r") % (opt, what, value))
-
-def check_choice(option, opt, value):
-    if value in option.choices:
-        return value
-    else:
-        choices = string.join(map(repr, option.choices), ", ")
-        raise OptionValueError(
-            _("option %s: invalid choice: %r (choose from %s)")
-            % (opt, value, choices))
-
-# Not supplying a default is different from a default of None,
-# so we need an explicit "not supplied" value.
-NO_DEFAULT = ("NO", "DEFAULT")
-
-
-class Option:
-    """
-    Instance attributes:
-      _short_opts : [string]
-      _long_opts : [string]
-
-      action : string
-      type : string
-      dest : string
-      default : any
-      nargs : int
-      const : any
-      choices : [string]
-      callback : function
-      callback_args : (any*)
-      callback_kwargs : { string : any }
-      help : string
-      metavar : string
-    """
-
-    # The list of instance attributes that may be set through
-    # keyword args to the constructor.
-    ATTRS = ['action',
-             'type',
-             'dest',
-             'default',
-             'nargs',
-             'const',
-             'choices',
-             'callback',
-             'callback_args',
-             'callback_kwargs',
-             'help',
-             'metavar']
-
-    # The set of actions allowed by option parsers.  Explicitly listed
-    # here so the constructor can validate its arguments.
-    ACTIONS = ("store",
-               "store_const",
-               "store_true",
-               "store_false",
-               "append",
-               "append_const",
-               "count",
-               "callback",
-               "help",
-               "version")
-
-    # The set of actions that involve storing a value somewhere;
-    # also listed just for constructor argument validation.  (If
-    # the action is one of these, there must be a destination.)
-    STORE_ACTIONS = ("store",
-                     "store_const",
-                     "store_true",
-                     "store_false",
-                     "append",
-                     "append_const",
-                     "count")
-
-    # The set of actions for which it makes sense to supply a value
-    # type, ie. which may consume an argument from the command line.
-    TYPED_ACTIONS = ("store",
-                     "append",
-                     "callback")
-
-    # The set of actions which *require* a value type, ie. that
-    # always consume an argument from the command line.
-    ALWAYS_TYPED_ACTIONS = ("store",
-                            "append")
-
-    # The set of actions which take a 'const' attribute.
-    CONST_ACTIONS = ("store_const",
-                     "append_const")
-
-    # The set of known types for option parsers.  Again, listed here for
-    # constructor argument validation.
-    TYPES = ("string", "int", "long", "float", "complex", "choice")
-
-    # Dictionary of argument checking functions, which convert and
-    # validate option arguments according to the option type.
-    #
-    # Signature of checking functions is:
-    #   check(option : Option, opt : string, value : string) -> any
-    # where
-    #   option is the Option instance calling the checker
-    #   opt is the actual option seen on the command-line
-    #     (eg. "-a", "--file")
-    #   value is the option argument seen on the command-line
-    #
-    # The return value should be in the appropriate Python type
-    # for option.type -- eg. an integer if option.type == "int".
-    #
-    # If no checker is defined for a type, arguments will be
-    # unchecked and remain strings.
-    TYPE_CHECKER = { "int"    : check_builtin,
-                     "long"   : check_builtin,
-                     "float"  : check_builtin,
-                     "complex": check_builtin,
-                     "choice" : check_choice,
-                   }
-
-
-    # CHECK_METHODS is a list of unbound method objects; they are called
-    # by the constructor, in order, after all attributes are
-    # initialized.  The list is created and filled in later, after all
-    # the methods are actually defined.  (I just put it here because I
-    # like to define and document all class attributes in the same
-    # place.)  Subclasses that add another _check_*() method should
-    # define their own CHECK_METHODS list that adds their check method
-    # to those from this class.
-    CHECK_METHODS = None
-
-
-    # -- Constructor/initialization methods ----------------------------
-
-    def __init__(self, *opts, **attrs):
-        # Set _short_opts, _long_opts attrs from 'opts' tuple.
-        # Have to be set now, in case no option strings are supplied.
-        self._short_opts = []
-        self._long_opts = []
-        opts = self._check_opt_strings(opts)
-        self._set_opt_strings(opts)
-
-        # Set all other attrs (action, type, etc.) from 'attrs' dict
-        self._set_attrs(attrs)
-
-        # Check all the attributes we just set.  There are lots of
-        # complicated interdependencies, but luckily they can be farmed
-        # out to the _check_*() methods listed in CHECK_METHODS -- which
-        # could be handy for subclasses!  The one thing these all share
-        # is that they raise OptionError if they discover a problem.
-        for checker in self.CHECK_METHODS:
-            checker(self)
-
-    def _check_opt_strings(self, opts):
-        # Filter out None because early versions of Optik had exactly
-        # one short option and one long option, either of which
-        # could be None.
-        opts = filter(None, opts)
-        if not opts:
-            raise TypeError("at least one option string must be supplied")
-        return opts
-
-    def _set_opt_strings(self, opts):
-        for opt in opts:
-            if len(opt) < 2:
-                raise OptionError(
-                    "invalid option string %r: "
-                    "must be at least two characters long" % opt, self)
-            elif len(opt) == 2:
-                if not (opt[0] == "-" and opt[1] != "-"):
-                    raise OptionError(
-                        "invalid short option string %r: "
-                        "must be of the form -x, (x any non-dash char)" % opt,
-                        self)
-                self._short_opts.append(opt)
-            else:
-                if not (opt[0:2] == "--" and opt[2] != "-"):
-                    raise OptionError(
-                        "invalid long option string %r: "
-                        "must start with --, followed by non-dash" % opt,
-                        self)
-                self._long_opts.append(opt)
-
-    def _set_attrs(self, attrs):
-        for attr in self.ATTRS:
-            if attrs.has_key(attr):
-                setattr(self, attr, attrs[attr])
-                del attrs[attr]
-            else:
-                if attr == 'default':
-                    setattr(self, attr, NO_DEFAULT)
-                else:
-                    setattr(self, attr, None)
-        if attrs:
-            attrs = attrs.keys()
-            attrs.sort()
-            raise OptionError(
-                "invalid keyword arguments: %s" % string.join(attrs, ", "),
-                self)
-
-
-    # -- Constructor validation methods --------------------------------
-
-    def _check_action(self):
-        if self.action is None:
-            self.action = "store"
-        elif self.action not in self.ACTIONS:
-            raise OptionError("invalid action: %r" % self.action, self)
-
-    def _check_type(self):
-        if self.type is None:
-            if self.action in self.ALWAYS_TYPED_ACTIONS:
-                if self.choices is not None:
-                    # The "choices" attribute implies "choice" type.
-                    self.type = "choice"
-                else:
-                    # No type given?  "string" is the most sensible default.
-                    self.type = "string"
-        else:
-            # Allow type objects or builtin type conversion functions
-            # (int, str, etc.) as an alternative to their names.  (The
-            # complicated check of __builtin__ is only necessary for
-            # Python 2.1 and earlier, and is short-circuited by the
-            # first check on modern Pythons.)
-            import __builtin__
-            if ( type(self.type) is types.TypeType or
-                 (hasattr(self.type, "__name__") and
-                  getattr(__builtin__, self.type.__name__, None) is self.type) ):
-                self.type = self.type.__name__
-
-            if self.type == "str":
-                self.type = "string"
-
-            if self.type not in self.TYPES:
-                raise OptionError("invalid option type: %r" % self.type, self)
-            if self.action not in self.TYPED_ACTIONS:
-                raise OptionError(
-                    "must not supply a type for action %r" % self.action, self)
-
-    def _check_choice(self):
-        if self.type == "choice":
-            if self.choices is None:
-                raise OptionError(
-                    "must supply a list of choices for type 'choice'", self)
-            elif type(self.choices) not in (types.TupleType, types.ListType):
-                raise OptionError(
-                    "choices must be a list of strings ('%s' supplied)"
-                    % string.split(str(type(self.choices)), "'")[1], self)
-        elif self.choices is not None:
-            raise OptionError(
-                "must not supply choices for type %r" % self.type, self)
-
-    def _check_dest(self):
-        # No destination given, and we need one for this action.  The
-        # self.type check is for callbacks that take a value.
-        takes_value = (self.action in self.STORE_ACTIONS or
-                       self.type is not None)
-        if self.dest is None and takes_value:
-
-            # Glean a destination from the first long option string,
-            # or from the first short option string if no long options.
-            if self._long_opts:
-                # eg. "--foo-bar" -> "foo_bar"
-                self.dest = string.replace(self._long_opts[0][2:], '-', '_')
-            else:
-                self.dest = self._short_opts[0][1]
-
-    def _check_const(self):
-        if self.action not in self.CONST_ACTIONS and self.const is not None:
-            raise OptionError(
-                "'const' must not be supplied for action %r" % self.action,
-                self)
-
-    def _check_nargs(self):
-        if self.action in self.TYPED_ACTIONS:
-            if self.nargs is None:
-                self.nargs = 1
-        elif self.nargs is not None:
-            raise OptionError(
-                "'nargs' must not be supplied for action %r" % self.action,
-                self)
-
-    def _check_callback(self):
-        if self.action == "callback":
-            if not callable(self.callback):
-                raise OptionError(
-                    "callback not callable: %r" % self.callback, self)
-            if (self.callback_args is not None and
-                type(self.callback_args) is not types.TupleType):
-                raise OptionError(
-                    "callback_args, if supplied, must be a tuple: not %r"
-                    % self.callback_args, self)
-            if (self.callback_kwargs is not None and
-                type(self.callback_kwargs) is not types.DictType):
-                raise OptionError(
-                    "callback_kwargs, if supplied, must be a dict: not %r"
-                    % self.callback_kwargs, self)
-        else:
-            if self.callback is not None:
-                raise OptionError(
-                    "callback supplied (%r) for non-callback option"
-                    % self.callback, self)
-            if self.callback_args is not None:
-                raise OptionError(
-                    "callback_args supplied for non-callback option", self)
-            if self.callback_kwargs is not None:
-                raise OptionError(
-                    "callback_kwargs supplied for non-callback option", self)
-
-
-    CHECK_METHODS = [_check_action,
-                     _check_type,
-                     _check_choice,
-                     _check_dest,
-                     _check_const,
-                     _check_nargs,
-                     _check_callback]
-
-
-    # -- Miscellaneous methods -----------------------------------------
-
-    def __str__(self):
-        return string.join(self._short_opts + self._long_opts, "/")
-
-    __repr__ = _repr
-
-    def takes_value(self):
-        return self.type is not None
-
-    def get_opt_string(self):
-        if self._long_opts:
-            return self._long_opts[0]
-        else:
-            return self._short_opts[0]
-
-
-    # -- Processing methods --------------------------------------------
-
-    def check_value(self, opt, value):
-        checker = self.TYPE_CHECKER.get(self.type)
-        if checker is None:
-            return value
-        else:
-            return checker(self, opt, value)
-
-    def convert_value(self, opt, value):
-        if value is not None:
-            if self.nargs == 1:
-                return self.check_value(opt, value)
-            else:
-                return tuple(map(lambda v, o=opt, s=self: s.check_value(o, v), value))
-
-    def process(self, opt, value, values, parser):
-
-        # First, convert the value(s) to the right type.  Howl if any
-        # value(s) are bogus.
-        value = self.convert_value(opt, value)
-
-        # And then take whatever action is expected of us.
-        # This is a separate method to make life easier for
-        # subclasses to add new actions.
-        return self.take_action(
-            self.action, self.dest, opt, value, values, parser)
-
-    def take_action(self, action, dest, opt, value, values, parser):
-        if action == "store":
-            setattr(values, dest, value)
-        elif action == "store_const":
-            setattr(values, dest, self.const)
-        elif action == "store_true":
-            setattr(values, dest, True)
-        elif action == "store_false":
-            setattr(values, dest, False)
-        elif action == "append":
-            values.ensure_value(dest, []).append(value)
-        elif action == "append_const":
-            values.ensure_value(dest, []).append(self.const)
-        elif action == "count":
-            setattr(values, dest, values.ensure_value(dest, 0) + 1)
-        elif action == "callback":
-            args = self.callback_args or ()
-            kwargs = self.callback_kwargs or {}
-            apply(self.callback, (self, opt, value, parser,) + args, kwargs)
-        elif action == "help":
-            parser.print_help()
-            parser.exit()
-        elif action == "version":
-            parser.print_version()
-            parser.exit()
-        else:
-            raise RuntimeError, "unknown action %r" % self.action
-
-        return 1
-
-# class Option
-
-
-SUPPRESS_HELP = "SUPPRESS"+"HELP"
-SUPPRESS_USAGE = "SUPPRESS"+"USAGE"
-
-# For compatibility with Python 2.2
-try:
-    True, False
-except NameError:
-    (True, False) = (1, 0)
-
-try:
-    types.UnicodeType
-except AttributeError:
-    def isbasestring(x):
-        return isinstance(x, types.StringType)
-else:
-    def isbasestring(x):
-        return isinstance(x, types.StringType) or isinstance(x, types.UnicodeType)
-
-class Values:
-
-    def __init__(self, defaults=None):
-        if defaults:
-            for (attr, val) in defaults.items():
-                setattr(self, attr, val)
-
-    def __str__(self):
-        return str(self.__dict__)
-
-    __repr__ = _repr
-
-    def __cmp__(self, other):
-        if isinstance(other, Values):
-            return cmp(self.__dict__, other.__dict__)
-        elif isinstance(other, types.DictType):
-            return cmp(self.__dict__, other)
-        else:
-            return -1
-
-    def _update_careful(self, dict):
-        """
-        Update the option values from an arbitrary dictionary, but only
-        use keys from dict that already have a corresponding attribute
-        in self.  Any keys in dict without a corresponding attribute
-        are silently ignored.
-        """
-        for attr in dir(self):
-            if dict.has_key(attr):
-                dval = dict[attr]
-                if dval is not None:
-                    setattr(self, attr, dval)
-
-    def _update_loose(self, dict):
-        """
-        Update the option values from an arbitrary dictionary,
-        using all keys from the dictionary regardless of whether
-        they have a corresponding attribute in self or not.
-        """
-        self.__dict__.update(dict)
-
-    def _update(self, dict, mode):
-        if mode == "careful":
-            self._update_careful(dict)
-        elif mode == "loose":
-            self._update_loose(dict)
-        else:
-            raise ValueError, "invalid update mode: %r" % mode
-
-    def read_module(self, modname, mode="careful"):
-        __import__(modname)
-        mod = sys.modules[modname]
-        self._update(vars(mod), mode)
-
-    def read_file(self, filename, mode="careful"):
-        vars = {}
-        exec open(filename, 'rU').read() in vars
-        self._update(vars, mode)
-
-    def ensure_value(self, attr, value):
-        if not hasattr(self, attr) or getattr(self, attr) is None:
-            setattr(self, attr, value)
-        return getattr(self, attr)
-
-
-class OptionContainer:
-
-    """
-    Abstract base class.
-
-    Class attributes:
-      standard_option_list : [Option]
-        list of standard options that will be accepted by all instances
-        of this parser class (intended to be overridden by subclasses).
-
-    Instance attributes:
-      option_list : [Option]
-        the list of Option objects contained by this OptionContainer
-      _short_opt : { string : Option }
-        dictionary mapping short option strings, eg. "-f" or "-X",
-        to the Option instances that implement them.  If an Option
-        has multiple short option strings, it will appears in this
-        dictionary multiple times. [1]
-      _long_opt : { string : Option }
-        dictionary mapping long option strings, eg. "--file" or
-        "--exclude", to the Option instances that implement them.
-        Again, a given Option can occur multiple times in this
-        dictionary. [1]
-      defaults : { string : any }
-        dictionary mapping option destination names to default
-        values for each destination [1]
-
-    [1] These mappings are common to (shared by) all components of the
-        controlling OptionParser, where they are initially created.
-
-    """
-
-    def __init__(self, option_class, conflict_handler, description):
-        # Initialize the option list and related data structures.
-        # This method must be provided by subclasses, and it must
-        # initialize at least the following instance attributes:
-        # option_list, _short_opt, _long_opt, defaults.
-        self._create_option_list()
-
-        self.option_class = option_class
-        self.set_conflict_handler(conflict_handler)
-        self.set_description(description)
-
-    def _create_option_mappings(self):
-        # For use by OptionParser constructor -- create the master
-        # option mappings used by this OptionParser and all
-        # OptionGroups that it owns.
-        self._short_opt = {}            # single letter -> Option instance
-        self._long_opt = {}             # long option -> Option instance
-        self.defaults = {}              # maps option dest -> default value
-
-
-    def _share_option_mappings(self, parser):
-        # For use by OptionGroup constructor -- use shared option
-        # mappings from the OptionParser that owns this OptionGroup.
-        self._short_opt = parser._short_opt
-        self._long_opt = parser._long_opt
-        self.defaults = parser.defaults
-
-    def set_conflict_handler(self, handler):
-        if handler not in ("error", "resolve"):
-            raise ValueError, "invalid conflict_resolution value %r" % handler
-        self.conflict_handler = handler
-
-    def set_description(self, description):
-        self.description = description
-
-    def get_description(self):
-        return self.description
-
-
-    def destroy(self):
-        """see OptionParser.destroy()."""
-        del self._short_opt
-        del self._long_opt
-        del self.defaults
-
-
-    # -- Option-adding methods -----------------------------------------
-
-    def _check_conflict(self, option):
-        conflict_opts = []
-        for opt in option._short_opts:
-            if self._short_opt.has_key(opt):
-                conflict_opts.append((opt, self._short_opt[opt]))
-        for opt in option._long_opts:
-            if self._long_opt.has_key(opt):
-                conflict_opts.append((opt, self._long_opt[opt]))
-
-        if conflict_opts:
-            handler = self.conflict_handler
-            if handler == "error":
-                raise OptionConflictError(
-                    "conflicting option string(s): %s"
-                    % string.join(map(lambda co: co[0], conflict_opts), ", "),
-                    option)
-            elif handler == "resolve":
-                for (opt, c_option) in conflict_opts:
-                    if opt[:2] == "--":
-                        c_option._long_opts.remove(opt)
-                        del self._long_opt[opt]
-                    else:
-                        c_option._short_opts.remove(opt)
-                        del self._short_opt[opt]
-                    if not (c_option._short_opts or c_option._long_opts):
-                        c_option.container.option_list.remove(c_option)
-
-    def add_option(self, *args, **kwargs):
-        """add_option(Option)
-           add_option(opt_str, ..., kwarg=val, ...)
-        """
-        if type(args[0]) is types.StringType:
-            option = apply(self.option_class, args, kwargs)
-        elif len(args) == 1 and not kwargs:
-            option = args[0]
-            if not isinstance(option, Option):
-                raise TypeError, "not an Option instance: %r" % option
-        else:
-            raise TypeError, "invalid arguments"
-
-        self._check_conflict(option)
-
-        self.option_list.append(option)
-        option.container = self
-        for opt in option._short_opts:
-            self._short_opt[opt] = option
-        for opt in option._long_opts:
-            self._long_opt[opt] = option
-
-        if option.dest is not None:     # option has a dest, we need a default
-            if option.default is not NO_DEFAULT:
-                self.defaults[option.dest] = option.default
-            elif not self.defaults.has_key(option.dest):
-                self.defaults[option.dest] = None
-
-        return option
-
-    def add_options(self, option_list):
-        for option in option_list:
-            self.add_option(option)
-
-    # -- Option query/removal methods ----------------------------------
-
-    def get_option(self, opt_str):
-        return (self._short_opt.get(opt_str) or
-                self._long_opt.get(opt_str))
-
-    def has_option(self, opt_str):
-        return (self._short_opt.has_key(opt_str) or
-                self._long_opt.has_key(opt_str))
-
-    def remove_option(self, opt_str):
-        option = self._short_opt.get(opt_str)
-        if option is None:
-            option = self._long_opt.get(opt_str)
-        if option is None:
-            raise ValueError("no such option %r" % opt_str)
-
-        for opt in option._short_opts:
-            del self._short_opt[opt]
-        for opt in option._long_opts:
-            del self._long_opt[opt]
-        option.container.option_list.remove(option)
-
-
-    # -- Help-formatting methods ---------------------------------------
-
-    def format_option_help(self, formatter):
-        if not self.option_list:
-            return ""
-        result = []
-        for option in self.option_list:
-            if not option.help is SUPPRESS_HELP:
-                result.append(formatter.format_option(option))
-        return string.join(result, "")
-
-    def format_description(self, formatter):
-        return formatter.format_description(self.get_description())
-
-    def format_help(self, formatter):
-        result = []
-        if self.description:
-            result.append(self.format_description(formatter))
-        if self.option_list:
-            result.append(self.format_option_help(formatter))
-        return string.join(result, "\n")
-
-
-class OptionGroup (OptionContainer):
-
-    def __init__(self, parser, title, description=None):
-        self.parser = parser
-        OptionContainer.__init__(
-            self, parser.option_class, parser.conflict_handler, description)
-        self.title = title
-
-    def _create_option_list(self):
-        self.option_list = []
-        self._share_option_mappings(self.parser)
-
-    def set_title(self, title):
-        self.title = title
-
-    def destroy(self):
-        """see OptionParser.destroy()."""
-        OptionContainer.destroy(self)
-        del self.option_list
-
-    # -- Help-formatting methods ---------------------------------------
-
-    def format_help(self, formatter):
-        result = formatter.format_heading(self.title)
-        formatter.indent()
-        result = result + OptionContainer.format_help(self, formatter)
-        formatter.dedent()
-        return result
-
-
-class OptionParser (OptionContainer):
-
-    """
-    Class attributes:
-      standard_option_list : [Option]
-        list of standard options that will be accepted by all instances
-        of this parser class (intended to be overridden by subclasses).
-
-    Instance attributes:
-      usage : string
-        a usage string for your program.  Before it is displayed
-        to the user, "%prog" will be expanded to the name of
-        your program (self.prog or os.path.basename(sys.argv[0])).
-      prog : string
-        the name of the current program (to override
-        os.path.basename(sys.argv[0])).
-      epilog : string
-        paragraph of help text to print after option help
-
-      option_groups : [OptionGroup]
-        list of option groups in this parser (option groups are
-        irrelevant for parsing the command-line, but very useful
-        for generating help)
-
-      allow_interspersed_args : bool = true
-        if true, positional arguments may be interspersed with options.
-        Assuming -a and -b each take a single argument, the command-line
-          -ablah foo bar -bboo baz
-        will be interpreted the same as
-          -ablah -bboo -- foo bar baz
-        If this flag were false, that command line would be interpreted as
-          -ablah -- foo bar -bboo baz
-        -- ie. we stop processing options as soon as we see the first
-        non-option argument.  (This is the tradition followed by
-        Python's getopt module, Perl's Getopt::Std, and other argument-
-        parsing libraries, but it is generally annoying to users.)
-
-      process_default_values : bool = true
-        if true, option default values are processed similarly to option
-        values from the command line: that is, they are passed to the
-        type-checking function for the option's type (as long as the
-        default value is a string).  (This really only matters if you
-        have defined custom types; see SF bug #955889.)  Set it to false
-        to restore the behaviour of Optik 1.4.1 and earlier.
-
-      rargs : [string]
-        the argument list currently being parsed.  Only set when
-        parse_args() is active, and continually trimmed down as
-        we consume arguments.  Mainly there for the benefit of
-        callback options.
-      largs : [string]
-        the list of leftover arguments that we have skipped while
-        parsing options.  If allow_interspersed_args is false, this
-        list is always empty.
-      values : Values
-        the set of option values currently being accumulated.  Only
-        set when parse_args() is active.  Also mainly for callbacks.
-
-    Because of the 'rargs', 'largs', and 'values' attributes,
-    OptionParser is not thread-safe.  If, for some perverse reason, you
-    need to parse command-line arguments simultaneously in different
-    threads, use different OptionParser instances.
-
-    """
-
-    standard_option_list = []
-
-    def __init__(self,
-                 usage=None,
-                 option_list=None,
-                 option_class=Option,
-                 version=None,
-                 conflict_handler="error",
-                 description=None,
-                 formatter=None,
-                 add_help_option=True,
-                 prog=None,
-                 epilog=None):
-        OptionContainer.__init__(
-            self, option_class, conflict_handler, description)
-        self.set_usage(usage)
-        self.prog = prog
-        self.version = version
-        self.allow_interspersed_args = True
-        self.process_default_values = True
-        if formatter is None:
-            formatter = IndentedHelpFormatter()
-        self.formatter = formatter
-        self.formatter.set_parser(self)
-        self.epilog = epilog
-
-        # Populate the option list; initial sources are the
-        # standard_option_list class attribute, the 'option_list'
-        # argument, and (if applicable) the _add_version_option() and
-        # _add_help_option() methods.
-        self._populate_option_list(option_list,
-                                   add_help=add_help_option)
-
-        self._init_parsing_state()
-
-
-    def destroy(self):
-        """
-        Declare that you are done with this OptionParser.  This cleans up
-        reference cycles so the OptionParser (and all objects referenced by
-        it) can be garbage-collected promptly.  After calling destroy(), the
-        OptionParser is unusable.
-        """
-        OptionContainer.destroy(self)
-        for group in self.option_groups:
-            group.destroy()
-        del self.option_list
-        del self.option_groups
-        del self.formatter
-
-
-    # -- Private methods -----------------------------------------------
-    # (used by our or OptionContainer's constructor)
-
-    def _create_option_list(self):
-        self.option_list = []
-        self.option_groups = []
-        self._create_option_mappings()
-
-    def _add_help_option(self):
-        self.add_option("-h", "--help",
-                        action="help",
-                        help=_("show this help message and exit"))
-
-    def _add_version_option(self):
-        self.add_option("--version",
-                        action="version",
-                        help=_("show program's version number and exit"))
-
-    def _populate_option_list(self, option_list, add_help=True):
-        if self.standard_option_list:
-            self.add_options(self.standard_option_list)
-        if option_list:
-            self.add_options(option_list)
-        if self.version:
-            self._add_version_option()
-        if add_help:
-            self._add_help_option()
-
-    def _init_parsing_state(self):
-        # These are set in parse_args() for the convenience of callbacks.
-        self.rargs = None
-        self.largs = None
-        self.values = None
-
-
-    # -- Simple modifier methods ---------------------------------------
-
-    def set_usage(self, usage):
-        if usage is None:
-            self.usage = _("%prog [options]")
-        elif usage is SUPPRESS_USAGE:
-            self.usage = None
-        # For backwards compatibility with Optik 1.3 and earlier.
-        elif string.lower(usage)[:7] == "usage: ":
-            self.usage = usage[7:]
-        else:
-            self.usage = usage
-
-    def enable_interspersed_args(self):
-        self.allow_interspersed_args = True
-
-    def disable_interspersed_args(self):
-        self.allow_interspersed_args = False
-
-    def set_process_default_values(self, process):
-        self.process_default_values = process
-
-    def set_default(self, dest, value):
-        self.defaults[dest] = value
-
-    def set_defaults(self, **kwargs):
-        self.defaults.update(kwargs)
-
-    def _get_all_options(self):
-        options = self.option_list[:]
-        for group in self.option_groups:
-            options.extend(group.option_list)
-        return options
-
-    def get_default_values(self):
-        if not self.process_default_values:
-            # Old, pre-Optik 1.5 behaviour.
-            return Values(self.defaults)
-
-        defaults = self.defaults.copy()
-        for option in self._get_all_options():
-            default = defaults.get(option.dest)
-            if isbasestring(default):
-                opt_str = option.get_opt_string()
-                defaults[option.dest] = option.check_value(opt_str, default)
-
-        return Values(defaults)
-
-
-    # -- OptionGroup methods -------------------------------------------
-
-    def add_option_group(self, *args, **kwargs):
-        # XXX lots of overlap with OptionContainer.add_option()
-        if type(args[0]) is types.StringType:
-            group = apply(OptionGroup, (self,) + args, kwargs)
-        elif len(args) == 1 and not kwargs:
-            group = args[0]
-            if not isinstance(group, OptionGroup):
-                raise TypeError, "not an OptionGroup instance: %r" % group
-            if group.parser is not self:
-                raise ValueError, "invalid OptionGroup (wrong parser)"
-        else:
-            raise TypeError, "invalid arguments"
-
-        self.option_groups.append(group)
-        return group
-
-    def get_option_group(self, opt_str):
-        option = (self._short_opt.get(opt_str) or
-                  self._long_opt.get(opt_str))
-        if option and option.container is not self:
-            return option.container
-        return None
-
-
-    # -- Option-parsing methods ----------------------------------------
-
-    def _get_args(self, args):
-        if args is None:
-            return sys.argv[1:]
-        else:
-            return args[:]              # don't modify caller's list
-
-    def parse_args(self, args=None, values=None):
-        """
-        parse_args(args : [string] = sys.argv[1:],
-                   values : Values = None)
-        -> (values : Values, args : [string])
-
-        Parse the command-line options found in 'args' (default:
-        sys.argv[1:]).  Any errors result in a call to 'error()', which
-        by default prints the usage message to stderr and calls
-        sys.exit() with an error message.  On success returns a pair
-        (values, args) where 'values' is an Values instance (with all
-        your option values) and 'args' is the list of arguments left
-        over after parsing options.
-        """
-        rargs = self._get_args(args)
-        if values is None:
-            values = self.get_default_values()
-
-        # Store the halves of the argument list as attributes for the
-        # convenience of callbacks:
-        #   rargs
-        #     the rest of the command-line (the "r" stands for
-        #     "remaining" or "right-hand")
-        #   largs
-        #     the leftover arguments -- ie. what's left after removing
-        #     options and their arguments (the "l" stands for "leftover"
-        #     or "left-hand")
-        self.rargs = rargs
-        self.largs = largs = []
-        self.values = values
-
-        try:
-            stop = self._process_args(largs, rargs, values)
-        except (BadOptionError, OptionValueError), err:
-            self.error(str(err))
-
-        args = largs + rargs
-        return self.check_values(values, args)
-
-    def check_values(self, values, args):
-        """
-        check_values(values : Values, args : [string])
-        -> (values : Values, args : [string])
-
-        Check that the supplied option values and leftover arguments are
-        valid.  Returns the option values and leftover arguments
-        (possibly adjusted, possibly completely new -- whatever you
-        like).  Default implementation just returns the passed-in
-        values; subclasses may override as desired.
-        """
-        return (values, args)
-
-    def _process_args(self, largs, rargs, values):
-        """_process_args(largs : [string],
-                         rargs : [string],
-                         values : Values)
-
-        Process command-line arguments and populate 'values', consuming
-        options and arguments from 'rargs'.  If 'allow_interspersed_args' is
-        false, stop at the first non-option argument.  If true, accumulate any
-        interspersed non-option arguments in 'largs'.
-        """
-        while rargs:
-            arg = rargs[0]
-            # We handle bare "--" explicitly, and bare "-" is handled by the
-            # standard arg handler since the short arg case ensures that the
-            # len of the opt string is greater than 1.
-            if arg == "--":
-                del rargs[0]
-                return
-            elif arg[0:2] == "--":
-                # process a single long option (possibly with value(s))
-                self._process_long_opt(rargs, values)
-            elif arg[:1] == "-" and len(arg) > 1:
-                # process a cluster of short options (possibly with
-                # value(s) for the last one only)
-                self._process_short_opts(rargs, values)
-            elif self.allow_interspersed_args:
-                largs.append(arg)
-                del rargs[0]
-            else:
-                return                  # stop now, leave this arg in rargs
-
-        # Say this is the original argument list:
-        # [arg0, arg1, ..., arg(i-1), arg(i), arg(i+1), ..., arg(N-1)]
-        #                            ^
-        # (we are about to process arg(i)).
-        #
-        # Then rargs is [arg(i), ..., arg(N-1)] and largs is a *subset* of
-        # [arg0, ..., arg(i-1)] (any options and their arguments will have
-        # been removed from largs).
-        #
-        # The while loop will usually consume 1 or more arguments per pass.
-        # If it consumes 1 (eg. arg is an option that takes no arguments),
-        # then after _process_arg() is done the situation is:
-        #
-        #   largs = subset of [arg0, ..., arg(i)]
-        #   rargs = [arg(i+1), ..., arg(N-1)]
-        #
-        # If allow_interspersed_args is false, largs will always be
-        # *empty* -- still a subset of [arg0, ..., arg(i-1)], but
-        # not a very interesting subset!
-
-    def _match_long_opt(self, opt):
-        """_match_long_opt(opt : string) -> string
-
-        Determine which long option string 'opt' matches, ie. which one
-        it is an unambiguous abbrevation for.  Raises BadOptionError if
-        'opt' doesn't unambiguously match any long option string.
-        """
-        return _match_abbrev(opt, self._long_opt)
-
-    def _process_long_opt(self, rargs, values):
-        arg = rargs.pop(0)
-
-        # Value explicitly attached to arg?  Pretend it's the next
-        # argument.
-        if "=" in arg:
-            (opt, next_arg) = string.split(arg, "=", 1)
-            rargs.insert(0, next_arg)
-            had_explicit_value = True
-        else:
-            opt = arg
-            had_explicit_value = False
-
-        opt = self._match_long_opt(opt)
-        option = self._long_opt[opt]
-        if option.takes_value():
-            nargs = option.nargs
-            if len(rargs) < nargs:
-                if nargs == 1:
-                    self.error(_("%s option requires an argument") % opt)
-                else:
-                    self.error(_("%s option requires %d arguments")
-                               % (opt, nargs))
-            elif nargs == 1:
-                value = rargs.pop(0)
-            else:
-                value = tuple(rargs[0:nargs])
-                del rargs[0:nargs]
-
-        elif had_explicit_value:
-            self.error(_("%s option does not take a value") % opt)
-
-        else:
-            value = None
-
-        option.process(opt, value, values, self)
-
-    def _process_short_opts(self, rargs, values):
-        arg = rargs.pop(0)
-        stop = False
-        i = 1
-        for ch in arg[1:]:
-            opt = "-" + ch
-            option = self._short_opt.get(opt)
-            i = i + 1                      # we have consumed a character
-
-            if not option:
-                raise BadOptionError(opt)
-            if option.takes_value():
-                # Any characters left in arg?  Pretend they're the
-                # next arg, and stop consuming characters of arg.
-                if i < len(arg):
-                    rargs.insert(0, arg[i:])
-                    stop = True
-
-                nargs = option.nargs
-                if len(rargs) < nargs:
-                    if nargs == 1:
-                        self.error(_("%s option requires an argument") % opt)
-                    else:
-                        self.error(_("%s option requires %d arguments")
-                                   % (opt, nargs))
-                elif nargs == 1:
-                    value = rargs.pop(0)
-                else:
-                    value = tuple(rargs[0:nargs])
-                    del rargs[0:nargs]
-
-            else:                       # option doesn't take a value
-                value = None
-
-            option.process(opt, value, values, self)
-
-            if stop:
-                break
-
-
-    # -- Feedback methods ----------------------------------------------
-
-    def get_prog_name(self):
-        if self.prog is None:
-            return os.path.basename(sys.argv[0])
-        else:
-            return self.prog
-
-    def expand_prog_name(self, s):
-        return string.replace(s, "%prog", self.get_prog_name())
-
-    def get_description(self):
-        return self.expand_prog_name(self.description)
-
-    def exit(self, status=0, msg=None):
-        if msg:
-            sys.stderr.write(msg)
-        sys.exit(status)
-
-    def error(self, msg):
-        """error(msg : string)
-
-        Print a usage message incorporating 'msg' to stderr and exit.
-        If you override this in a subclass, it should not return -- it
-        should either exit or raise an exception.
-        """
-        self.print_usage(sys.stderr)
-        self.exit(2, "%s: error: %s\n" % (self.get_prog_name(), msg))
-
-    def get_usage(self):
-        if self.usage:
-            return self.formatter.format_usage(
-                self.expand_prog_name(self.usage))
-        else:
-            return ""
-
-    def print_usage(self, file=None):
-        """print_usage(file : file = stdout)
-
-        Print the usage message for the current program (self.usage) to
-        'file' (default stdout).  Any occurence of the string "%prog" in
-        self.usage is replaced with the name of the current program
-        (basename of sys.argv[0]).  Does nothing if self.usage is empty
-        or not defined.
-        """
-        if self.usage:
-            file.write(self.get_usage() + '\n')
-
-    def get_version(self):
-        if self.version:
-            return self.expand_prog_name(self.version)
-        else:
-            return ""
-
-    def print_version(self, file=None):
-        """print_version(file : file = stdout)
-
-        Print the version message for this program (self.version) to
-        'file' (default stdout).  As with print_usage(), any occurence
-        of "%prog" in self.version is replaced by the current program's
-        name.  Does nothing if self.version is empty or undefined.
-        """
-        if self.version:
-            file.write(self.get_version() + '\n')
-
-    def format_option_help(self, formatter=None):
-        if formatter is None:
-            formatter = self.formatter
-        formatter.store_option_strings(self)
-        result = []
-        result.append(formatter.format_heading(_("Options")))
-        formatter.indent()
-        if self.option_list:
-            result.append(OptionContainer.format_option_help(self, formatter))
-            result.append("\n")
-        for group in self.option_groups:
-            result.append(group.format_help(formatter))
-            result.append("\n")
-        formatter.dedent()
-        # Drop the last "\n", or the header if no options or option groups:
-        return string.join(result[:-1], "")
-
-    def format_epilog(self, formatter):
-        return formatter.format_epilog(self.epilog)
-
-    def format_help(self, formatter=None):
-        if formatter is None:
-            formatter = self.formatter
-        result = []
-        if self.usage:
-            result.append(self.get_usage() + "\n")
-        if self.description:
-            result.append(self.format_description(formatter) + "\n")
-        result.append(self.format_option_help(formatter))
-        result.append(self.format_epilog(formatter))
-        return string.join(result, "")
-
-    # used by test suite
-    def _get_encoding(self, file):
-        encoding = getattr(file, "encoding", None)
-        if not encoding:
-            encoding = sys.getdefaultencoding()
-        return encoding
-
-    def print_help(self, file=None):
-        """print_help(file : file = stdout)
-
-        Print an extended help message, listing all options and any
-        help text provided with them, to 'file' (default stdout).
-        """
-        if file is None:
-            file = sys.stdout
-        encoding = self._get_encoding(file)
-        file.write(encode_wrapper(self.format_help(), encoding, "replace"))
-
-# class OptionParser
-
-
-def _match_abbrev(s, wordmap):
-    """_match_abbrev(s : string, wordmap : {string : Option}) -> string
-
-    Return the string key in 'wordmap' for which 's' is an unambiguous
-    abbreviation.  If 's' is found to be ambiguous or doesn't match any of
-    'words', raise BadOptionError.
-    """
-    # Is there an exact match?
-    if wordmap.has_key(s):
-        return s
-    else:
-        # Isolate all words with s as a prefix.
-        possibilities = filter(lambda w, s=s: w[:len(s)] == s, wordmap.keys())
-        # No exact match, so there had better be just one possibility.
-        if len(possibilities) == 1:
-            return possibilities[0]
-        elif not possibilities:
-            raise BadOptionError(s)
-        else:
-            # More than one possible completion: ambiguous prefix.
-            possibilities.sort()
-            raise AmbiguousOptionError(s, possibilities)
-
-
-# Some day, there might be many Option classes.  As of Optik 1.3, the
-# preferred way to instantiate Options is indirectly, via make_option(),
-# which will become a factory function when there are many Option
-# classes.
-make_option = Option
-
-# Local Variables:
-# tab-width:4
-# indent-tabs-mode:nil
-# End:
-# vim: set expandtab tabstop=4 shiftwidth=4:
diff --git a/engine/SCons/compat/_scons_sets.py b/engine/SCons/compat/_scons_sets.py
index 12dbead..0fde994 100644
--- a/engine/SCons/compat/_scons_sets.py
+++ b/engine/SCons/compat/_scons_sets.py
@@ -54,29 +54,8 @@ what's tested is actually `z in y'.
 # - Raymond Hettinger added a number of speedups and other
 #   improvements.
 
-from __future__ import generators
-try:
-    from itertools import ifilter, ifilterfalse
-except ImportError:
-    # Code to make the module run under Py2.2
-    def ifilter(predicate, iterable):
-        if predicate is None:
-            def predicate(x):
-                return x
-        for x in iterable:
-            if predicate(x):
-                yield x
-    def ifilterfalse(predicate, iterable):
-        if predicate is None:
-            def predicate(x):
-                return x
-        for x in iterable:
-            if not predicate(x):
-                yield x
-    try:
-        True, False
-    except NameError:
-        True, False = (0==0, 0!=0)
+# protect this import from the fixers...
+exec('from itertools import ifilterfalse as filterfalse')
 
 __all__ = ['BaseSet', 'Set', 'ImmutableSet']
 
@@ -91,7 +70,7 @@ class BaseSet(object):
         """This is an abstract class."""
         # Don't call this from a concrete subclass!
         if self.__class__ is BaseSet:
-            raise TypeError, ("BaseSet is an abstract class.  "
+            raise TypeError("BaseSet is an abstract class.  "
                               "Use Set or ImmutableSet.")
 
     # Standard protocols: __len__, __repr__, __str__, __iter__
@@ -110,9 +89,9 @@ class BaseSet(object):
     # __str__ is the same as __repr__
     __str__ = __repr__
 
-    def _repr(self, sorted=False):
-        elements = self._data.keys()
-        if sorted:
+    def _repr(self, sort_them=False):
+        elements = list(self._data.keys())
+        if sort_them:
             elements.sort()
         return '%s(%r)' % (self.__class__.__name__, elements)
 
@@ -121,7 +100,8 @@ class BaseSet(object):
 
         This is the keys iterator for the underlying dict.
         """
-        return self._data.iterkeys()
+        # Wrapping name in () prevents fixer from "fixing" this
+        return (self._data.iterkeys)()
 
     # Three-way comparison is not supported.  However, because __eq__ is
     # tried before __cmp__, if Set x == Set y, x.__eq__(y) returns True and
@@ -129,7 +109,7 @@ class BaseSet(object):
     # case).
 
     def __cmp__(self, other):
-        raise TypeError, "can't compare sets using cmp()"
+        raise TypeError("can't compare sets using cmp()")
 
     # Equality comparisons using the underlying dicts.  Mixed-type comparisons
     # are allowed here, where Set == z for non-Set z always returns False,
@@ -231,7 +211,7 @@ class BaseSet(object):
             little, big = self, other
         else:
             little, big = other, self
-        common = ifilter(big._data.has_key, little)
+        common = iter(filter(big._data.has_key, little))
         return self.__class__(common)
 
     def __xor__(self, other):
@@ -256,9 +236,9 @@ class BaseSet(object):
             otherdata = other._data
         except AttributeError:
             otherdata = Set(other)._data
-        for elt in ifilterfalse(otherdata.has_key, selfdata):
+        for elt in filterfalse(otherdata.has_key, selfdata):
             data[elt] = value
-        for elt in ifilterfalse(selfdata.has_key, otherdata):
+        for elt in filterfalse(selfdata.has_key, otherdata):
             data[elt] = value
         return result
 
@@ -283,7 +263,7 @@ class BaseSet(object):
         except AttributeError:
             otherdata = Set(other)._data
         value = True
-        for elt in ifilterfalse(otherdata.has_key, self):
+        for elt in filterfalse(otherdata.has_key, self):
             data[elt] = value
         return result
 
@@ -309,7 +289,7 @@ class BaseSet(object):
         self._binary_sanity_check(other)
         if len(self) > len(other):  # Fast check for obvious cases
             return False
-        for elt in ifilterfalse(other._data.has_key, self):
+        for elt in filterfalse(other._data.has_key, self):
             return False
         return True
 
@@ -318,7 +298,7 @@ class BaseSet(object):
         self._binary_sanity_check(other)
         if len(self) < len(other):  # Fast check for obvious cases
             return False
-        for elt in ifilterfalse(self._data.has_key, other):
+        for elt in filterfalse(self._data.has_key, other):
             return False
         return True
 
@@ -340,7 +320,7 @@ class BaseSet(object):
         # Check that the other argument to a binary operation is also
         # a set, raising a TypeError otherwise.
         if not isinstance(other, BaseSet):
-            raise TypeError, "Binary operation only permitted between sets"
+            raise TypeError("Binary operation only permitted between sets")
 
     def _compute_hash(self):
         # Calculate hash code for a set by xor'ing the hash codes of
@@ -438,7 +418,7 @@ class Set(BaseSet):
     def __hash__(self):
         """A Set cannot be hashed."""
         # We inherit object.__hash__, so we must deny this explicitly
-        raise TypeError, "Can't hash a Set, only an ImmutableSet."
+        raise TypeError("Can't hash a Set, only an ImmutableSet.")
 
     # In-place union, intersection, differences.
     # Subtle:  The xyz_update() functions deliberately return None,
@@ -501,7 +481,7 @@ class Set(BaseSet):
             other = Set(other)
         if self is other:
             self.clear()
-        for elt in ifilter(data.has_key, other):
+        for elt in filter(data.has_key, other):
             del data[elt]
 
     # Python dict-like mass mutations: update, clear
diff --git a/engine/SCons/compat/_scons_sets15.py b/engine/SCons/compat/_scons_sets15.py
deleted file mode 100644
index bafa009..0000000
--- a/engine/SCons/compat/_scons_sets15.py
+++ /dev/null
@@ -1,176 +0,0 @@
-#
-# A Set class that works all the way back to Python 1.5.  From:
-#
-#       Python Cookbook:  Yet another Set class for Python
-#       http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/106469
-#       Goncalo Rodriques
-#
-#       This is a pure Pythonic implementation of a set class.  The syntax
-#       and methods implemented are, for the most part, borrowed from
-#       PEP 218 by Greg Wilson.
-#
-# Note that this class violates the formal definition of a set() by adding
-# a __getitem__() method so we can iterate over a set's elements under
-# Python 1.5 and 2.1, which don't support __iter__() and iterator types.
-#
-
-import string
-
-class Set:
-    """The set class. It can contain mutable objects."""
-
-    def __init__(self, seq = None):
-        """The constructor. It can take any object giving an iterator as an optional
-        argument to populate the new set."""
-        self.elems = []
-        if seq:
-            for elem in seq:
-                if elem not in self.elems:
-                    hash(elem)
-                    self.elems.append(elem)
-
-    def __str__(self):
-        return "set([%s])" % string.join(map(str, self.elems), ", ")
-
-
-    def copy(self):
-        """Shallow copy of a set object."""
-        return Set(self.elems)
-
-    def __contains__(self, elem):
-        return elem in self.elems
-
-    def __len__(self):
-        return len(self.elems)
-
-    def __getitem__(self, index):
-        # Added so that Python 1.5 can iterate over the elements.
-        # The cookbook recipe's author didn't like this because there
-        # really isn't any order in a set object, but this is necessary
-        # to make the class work well enough for our purposes.
-        return self.elems[index]
-
-    def items(self):
-        """Returns a list of the elements in the set."""
-        return self.elems
-
-    def add(self, elem):
-        """Add one element to the set."""
-        if elem not in self.elems:
-            hash(elem)
-            self.elems.append(elem)
-
-    def remove(self, elem):
-        """Remove an element from the set. Return an error if elem is not in the set."""
-        try:
-            self.elems.remove(elem)
-        except ValueError:
-            raise LookupError, "Object %s is not a member of the set." % str(elem)
-
-    def discard(self, elem):
-        """Remove an element from the set. Do nothing if elem is not in the set."""
-        try:
-            self.elems.remove(elem)
-        except ValueError:
-            pass
-
-    def sort(self, func=cmp):
-        self.elems.sort(func)
-
-    #Define an iterator for a set.
-    def __iter__(self):
-        return iter(self.elems)
-
-    #The basic binary operations with sets.
-    def __or__(self, other):
-        """Union of two sets."""
-        ret = self.copy()
-        for elem in other.elems:
-            if elem not in ret:
-                ret.elems.append(elem)
-        return ret
-
-    def __sub__(self, other):
-        """Difference of two sets."""
-        ret = self.copy()
-        for elem in other.elems:
-            ret.discard(elem)
-        return ret
-
-    def __and__(self, other):
-        """Intersection of two sets."""
-        ret = Set()
-        for elem in self.elems:
-            if elem in other.elems:
-                ret.elems.append(elem)
-        return ret
-
-    def __add__(self, other):
-        """Symmetric difference of two sets."""
-        ret = Set()
-        temp = other.copy()
-        for elem in self.elems:
-            if elem in temp.elems:
-                temp.elems.remove(elem)
-            else:
-                ret.elems.append(elem)
-        #Add remaining elements.
-        for elem in temp.elems:
-                ret.elems.append(elem)
-        return ret
-
-    def __mul__(self, other):
-        """Cartesian product of two sets."""
-        ret = Set()
-        for elemself in self.elems:
-            x = map(lambda other, s=elemself: (s, other), other.elems)
-            ret.elems.extend(x)
-        return ret
-
-    #Some of the binary comparisons.
-    def __lt__(self, other):
-        """Returns 1 if the lhs set is contained but not equal to the rhs set."""
-        if len(self.elems) < len(other.elems):
-            temp = other.copy()
-            for elem in self.elems:
-                if elem in temp.elems:
-                    temp.remove(elem)
-                else:
-                    return 0
-            return len(temp.elems) == 0
-        else:
-            return 0
-
-    def __le__(self, other):
-        """Returns 1 if the lhs set is contained in the rhs set."""
-        if len(self.elems) <= len(other.elems):
-            ret = 1
-            for elem in self.elems:
-                if elem not in other.elems:
-                    ret = 0
-                    break
-            return ret
-        else:
-            return 0
-
-    def __eq__(self, other):
-        """Returns 1 if the sets are equal."""
-        if len(self.elems) != len(other.elems):
-            return 0
-        else:
-            return len(self - other) == 0
-
-    def __cmp__(self, other):
-        """Returns 1 if the sets are equal."""
-        if self.__lt__(other):
-            return -1
-        elif other.__lt__(self):
-            return 1
-        else:
-            return 0
-
-# Local Variables:
-# tab-width:4
-# indent-tabs-mode:nil
-# End:
-# vim: set expandtab tabstop=4 shiftwidth=4:
diff --git a/engine/SCons/compat/_scons_shlex.py b/engine/SCons/compat/_scons_shlex.py
deleted file mode 100644
index 9e30a01..0000000
--- a/engine/SCons/compat/_scons_shlex.py
+++ /dev/null
@@ -1,325 +0,0 @@
-# -*- coding: iso-8859-1 -*-
-"""A lexical analyzer class for simple shell-like syntaxes."""
-
-# Module and documentation by Eric S. Raymond, 21 Dec 1998
-# Input stacking and error message cleanup added by ESR, March 2000
-# push_source() and pop_source() made explicit by ESR, January 2001.
-# Posix compliance, split(), string arguments, and
-# iterator interface by Gustavo Niemeyer, April 2003.
-
-import os.path
-import sys
-#from collections import deque
-
-class deque:
-    def __init__(self):
-        self.data = []
-    def __len__(self):
-        return len(self.data)
-    def appendleft(self, item):
-        self.data.insert(0, item)
-    def popleft(self):
-        return self.data.pop(0)
-
-try:
-    basestring
-except NameError:
-    import types
-    def is_basestring(s):
-        return type(s) is types.StringType
-else:
-    def is_basestring(s):
-        return isinstance(s, basestring)
-
-try:
-    from cStringIO import StringIO
-except ImportError:
-    from StringIO import StringIO
-
-__all__ = ["shlex", "split"]
-
-class shlex:
-    "A lexical analyzer class for simple shell-like syntaxes."
-    def __init__(self, instream=None, infile=None, posix=False):
-        if is_basestring(instream):
-            instream = StringIO(instream)
-        if instream is not None:
-            self.instream = instream
-            self.infile = infile
-        else:
-            self.instream = sys.stdin
-            self.infile = None
-        self.posix = posix
-        if posix:
-            self.eof = None
-        else:
-            self.eof = ''
-        self.commenters = '#'
-        self.wordchars = ('abcdfeghijklmnopqrstuvwxyz'
-                          'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_')
-        if self.posix:
-            self.wordchars = self.wordchars + ('ßàáâãäåæçèéêëìíîïðñòóôõöøùúûüýþÿ'
-                               'ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖØÙÚÛÜÝÞ')
-        self.whitespace = ' \t\r\n'
-        self.whitespace_split = False
-        self.quotes = '\'"'
-        self.escape = '\\'
-        self.escapedquotes = '"'
-        self.state = ' '
-        self.pushback = deque()
-        self.lineno = 1
-        self.debug = 0
-        self.token = ''
-        self.filestack = deque()
-        self.source = None
-        if self.debug:
-            print 'shlex: reading from %s, line %d' \
-                  % (self.instream, self.lineno)
-
-    def push_token(self, tok):
-        "Push a token onto the stack popped by the get_token method"
-        if self.debug >= 1:
-            print "shlex: pushing token " + repr(tok)
-        self.pushback.appendleft(tok)
-
-    def push_source(self, newstream, newfile=None):
-        "Push an input source onto the lexer's input source stack."
-        if is_basestring(newstream):
-            newstream = StringIO(newstream)
-        self.filestack.appendleft((self.infile, self.instream, self.lineno))
-        self.infile = newfile
-        self.instream = newstream
-        self.lineno = 1
-        if self.debug:
-            if newfile is not None:
-                print 'shlex: pushing to file %s' % (self.infile,)
-            else:
-                print 'shlex: pushing to stream %s' % (self.instream,)
-
-    def pop_source(self):
-        "Pop the input source stack."
-        self.instream.close()
-        (self.infile, self.instream, self.lineno) = self.filestack.popleft()
-        if self.debug:
-            print 'shlex: popping to %s, line %d' \
-                  % (self.instream, self.lineno)
-        self.state = ' '
-
-    def get_token(self):
-        "Get a token from the input stream (or from stack if it's nonempty)"
-        if self.pushback:
-            tok = self.pushback.popleft()
-            if self.debug >= 1:
-                print "shlex: popping token " + repr(tok)
-            return tok
-        # No pushback.  Get a token.
-        raw = self.read_token()
-        # Handle inclusions
-        if self.source is not None:
-            while raw == self.source:
-                spec = self.sourcehook(self.read_token())
-                if spec:
-                    (newfile, newstream) = spec
-                    self.push_source(newstream, newfile)
-                raw = self.get_token()
-        # Maybe we got EOF instead?
-        while raw == self.eof:
-            if not self.filestack:
-                return self.eof
-            else:
-                self.pop_source()
-                raw = self.get_token()
-        # Neither inclusion nor EOF
-        if self.debug >= 1:
-            if raw != self.eof:
-                print "shlex: token=" + repr(raw)
-            else:
-                print "shlex: token=EOF"
-        return raw
-
-    def read_token(self):
-        quoted = False
-        escapedstate = ' '
-        while True:
-            nextchar = self.instream.read(1)
-            if nextchar == '\n':
-                self.lineno = self.lineno + 1
-            if self.debug >= 3:
-                print "shlex: in state", repr(self.state), \
-                      "I see character:", repr(nextchar)
-            if self.state is None:
-                self.token = ''        # past end of file
-                break
-            elif self.state == ' ':
-                if not nextchar:
-                    self.state = None  # end of file
-                    break
-                elif nextchar in self.whitespace:
-                    if self.debug >= 2:
-                        print "shlex: I see whitespace in whitespace state"
-                    if self.token or (self.posix and quoted):
-                        break   # emit current token
-                    else:
-                        continue
-                elif nextchar in self.commenters:
-                    self.instream.readline()
-                    self.lineno = self.lineno + 1
-                elif self.posix and nextchar in self.escape:
-                    escapedstate = 'a'
-                    self.state = nextchar
-                elif nextchar in self.wordchars:
-                    self.token = nextchar
-                    self.state = 'a'
-                elif nextchar in self.quotes:
-                    if not self.posix:
-                        self.token = nextchar
-                    self.state = nextchar
-                elif self.whitespace_split:
-                    self.token = nextchar
-                    self.state = 'a'
-                else:
-                    self.token = nextchar
-                    if self.token or (self.posix and quoted):
-                        break   # emit current token
-                    else:
-                        continue
-            elif self.state in self.quotes:
-                quoted = True
-                if not nextchar:      # end of file
-                    if self.debug >= 2:
-                        print "shlex: I see EOF in quotes state"
-                    # XXX what error should be raised here?
-                    raise ValueError, "No closing quotation"
-                if nextchar == self.state:
-                    if not self.posix:
-                        self.token = self.token + nextchar
-                        self.state = ' '
-                        break
-                    else:
-                        self.state = 'a'
-                elif self.posix and nextchar in self.escape and \
-                     self.state in self.escapedquotes:
-                    escapedstate = self.state
-                    self.state = nextchar
-                else:
-                    self.token = self.token + nextchar
-            elif self.state in self.escape:
-                if not nextchar:      # end of file
-                    if self.debug >= 2:
-                        print "shlex: I see EOF in escape state"
-                    # XXX what error should be raised here?
-                    raise ValueError, "No escaped character"
-                # In posix shells, only the quote itself or the escape
-                # character may be escaped within quotes.
-                if escapedstate in self.quotes and \
-                   nextchar != self.state and nextchar != escapedstate:
-                    self.token = self.token + self.state
-                self.token = self.token + nextchar
-                self.state = escapedstate
-            elif self.state == 'a':
-                if not nextchar:
-                    self.state = None   # end of file
-                    break
-                elif nextchar in self.whitespace:
-                    if self.debug >= 2:
-                        print "shlex: I see whitespace in word state"
-                    self.state = ' '
-                    if self.token or (self.posix and quoted):
-                        break   # emit current token
-                    else:
-                        continue
-                elif nextchar in self.commenters:
-                    self.instream.readline()
-                    self.lineno = self.lineno + 1
-                    if self.posix:
-                        self.state = ' '
-                        if self.token or (self.posix and quoted):
-                            break   # emit current token
-                        else:
-                            continue
-                elif self.posix and nextchar in self.quotes:
-                    self.state = nextchar
-                elif self.posix and nextchar in self.escape:
-                    escapedstate = 'a'
-                    self.state = nextchar
-                elif nextchar in self.wordchars or nextchar in self.quotes \
-                    or self.whitespace_split:
-                    self.token = self.token + nextchar
-                else:
-                    self.pushback.appendleft(nextchar)
-                    if self.debug >= 2:
-                        print "shlex: I see punctuation in word state"
-                    self.state = ' '
-                    if self.token:
-                        break   # emit current token
-                    else:
-                        continue
-        result = self.token
-        self.token = ''
-        if self.posix and not quoted and result == '':
-            result = None
-        if self.debug > 1:
-            if result:
-                print "shlex: raw token=" + repr(result)
-            else:
-                print "shlex: raw token=EOF"
-        return result
-
-    def sourcehook(self, newfile):
-        "Hook called on a filename to be sourced."
-        if newfile[0] == '"':
-            newfile = newfile[1:-1]
-        # This implements cpp-like semantics for relative-path inclusion.
-        if is_basestring(self.infile) and not os.path.isabs(newfile):
-            newfile = os.path.join(os.path.dirname(self.infile), newfile)
-        return (newfile, open(newfile, "r"))
-
-    def error_leader(self, infile=None, lineno=None):
-        "Emit a C-compiler-like, Emacs-friendly error-message leader."
-        if infile is None:
-            infile = self.infile
-        if lineno is None:
-            lineno = self.lineno
-        return "\"%s\", line %d: " % (infile, lineno)
-
-    def __iter__(self):
-        return self
-
-    def next(self):
-        token = self.get_token()
-        if token == self.eof:
-            raise StopIteration
-        return token
-
-def split(s, comments=False):
-    lex = shlex(s, posix=True)
-    lex.whitespace_split = True
-    if not comments:
-        lex.commenters = ''
-    #return list(lex)
-    result = []
-    while True:
-        token = lex.get_token()
-        if token == lex.eof:
-            break
-        result.append(token)
-    return result
-
-if __name__ == '__main__':
-    if len(sys.argv) == 1:
-        lexer = shlex()
-    else:
-        file = sys.argv[1]
-        lexer = shlex(open(file), file)
-    while 1:
-        tt = lexer.get_token()
-        if tt:
-            print "Token: " + repr(tt)
-        else:
-            break
-
-# Local Variables:
-# tab-width:4
-# indent-tabs-mode:nil
-# End:
-# vim: set expandtab tabstop=4 shiftwidth=4:
diff --git a/engine/SCons/compat/_scons_subprocess.py b/engine/SCons/compat/_scons_subprocess.py
index ccd403a..eebe53d 100644
--- a/engine/SCons/compat/_scons_subprocess.py
+++ b/engine/SCons/compat/_scons_subprocess.py
@@ -356,7 +356,6 @@ import sys
 mswindows = (sys.platform == "win32")
 
 import os
-import string
 import types
 import traceback
 
@@ -384,13 +383,13 @@ if mswindows:
     try:
         # Try to get _subprocess
         from _subprocess import *
-        class STARTUPINFO:
+        class STARTUPINFO(object):
             dwFlags = 0
             hStdInput = None
             hStdOutput = None
             hStdError = None
             wShowWindow = 0
-        class pywintypes:
+        class pywintypes(object):
             error = IOError
     except ImportError:
         # If not there, then drop back to requiring pywin32
@@ -434,18 +433,11 @@ except KeyboardInterrupt:
 except:
     MAXFD = 256
 
-# True/False does not exist on 2.2.0
-try:
-    False
-except NameError:
-    False = 0
-    True = 1
-
 try:
     isinstance(1, int)
 except TypeError:
     def is_int(obj):
-        return type(obj) == type(1)
+        return isinstance(obj, type(1))
     def is_int_or_long(obj):
         return type(obj) in (type(1), type(1L))
 else:
@@ -458,20 +450,17 @@ try:
     types.StringTypes
 except AttributeError:
     try:
-        types.StringTypes = (types.StringType, types.UnicodeType)
-    except AttributeError:
-        types.StringTypes = (types.StringType,)
-    def is_string(obj):
-        return type(obj) in types.StringTypes
-else:
-    def is_string(obj):
-        return isinstance(obj, types.StringTypes)
+        types.StringTypes = (str, unicode)
+    except NameError:
+        types.StringTypes = (str,)
+def is_string(obj):
+    return isinstance(obj, types.StringTypes)
 
 _active = []
 
 def _cleanup():
     for inst in _active[:]:
-        if inst.poll(_deadstate=sys.maxint) >= 0:
+        if inst.poll(_deadstate=sys.maxsize) >= 0:
             try:
                 _active.remove(inst)
             except ValueError:
@@ -504,7 +493,7 @@ def check_call(*popenargs, **kwargs):
 
     check_call(["ls", "-l"])
     """
-    retcode = apply(call, popenargs, kwargs)
+    retcode = call(*popenargs, **kwargs)
     cmd = kwargs.get("args")
     if cmd is None:
         cmd = popenargs[0]
@@ -578,14 +567,7 @@ def list2cmdline(seq):
             result.extend(bs_buf)
             result.append('"')
 
-    return string.join(result, '')
-
-
-try:
-    object
-except NameError:
-    class object:
-        pass
+    return ''.join(result)
 
 class Popen(object):
     def __init__(self, args, bufsize=0, executable=None,
@@ -674,7 +656,7 @@ class Popen(object):
             # We didn't get to successfully create a child process.
             return
         # In case the child hasn't been waited on, check if it's done.
-        self.poll(_deadstate=sys.maxint)
+        self.poll(_deadstate=sys.maxsize)
         if self.returncode is None and _active is not None:
             # Child is still running, keep us alive until we can wait on it.
             _active.append(self)
@@ -853,7 +835,7 @@ class Popen(object):
                 # a subclass of OSError.  FIXME: We should really
                 # translate errno using _sys_errlist (or simliar), but
                 # how can this be done from Python?
-                raise apply(WindowsError, e.args)
+                raise WindowsError(*e.args)
 
             # Retain the process handle, but close the thread handle
             self._child_created = True
@@ -1003,7 +985,7 @@ class Popen(object):
 
 
         def _close_fds(self, but):
-            for i in xrange(3, MAXFD):
+            for i in range(3, MAXFD):
                 if i == but:
                     continue
                 try:
@@ -1100,7 +1082,7 @@ class Popen(object):
                     exc_lines = traceback.format_exception(exc_type,
                                                            exc_value,
                                                            tb)
-                    exc_value.child_traceback = string.join(exc_lines, '')
+                    exc_value.child_traceback = ''.join(exc_lines)
                     os.write(errpipe_write, pickle.dumps(exc_value))
 
                 # This exitcode won't be reported to applications, so it
@@ -1187,7 +1169,8 @@ class Popen(object):
                     # When select has indicated that the file is writable,
                     # we can write up to PIPE_BUF bytes without risk
                     # blocking.  POSIX defines PIPE_BUF >= 512
-                    bytes_written = os.write(self.stdin.fileno(), buffer(input, input_offset, 512))
+                    m = memoryview(input)[input_offset:input_offset+512]
+                    bytes_written = os.write(self.stdin.fileno(), m)
                     input_offset = input_offset + bytes_written
                     if input_offset >= len(input):
                         self.stdin.close()
@@ -1209,9 +1192,9 @@ class Popen(object):
 
             # All data exchanged.  Translate lists into strings.
             if stdout is not None:
-                stdout = string.join(stdout, '')
+                stdout = ''.join(stdout)
             if stderr is not None:
-                stderr = string.join(stderr, '')
+                stderr = ''.join(stderr)
 
             # Translate newlines, if requested.  We cannot let the file
             # object do the translation: It is based on stdio, which is
diff --git a/engine/SCons/compat/_scons_textwrap.py b/engine/SCons/compat/_scons_textwrap.py
deleted file mode 100644
index 81781af..0000000
--- a/engine/SCons/compat/_scons_textwrap.py
+++ /dev/null
@@ -1,382 +0,0 @@
-"""Text wrapping and filling.
-"""
-
-# Copyright (C) 1999-2001 Gregory P. Ward.
-# Copyright (C) 2002, 2003 Python Software Foundation.
-# Written by Greg Ward <gward@python.net>
-
-__revision__ = "$Id: textwrap.py,v 1.32.8.2 2004/05/13 01:48:15 gward Exp $"
-
-import string, re
-
-try:
-   unicode
-except NameError:
-   class unicode:
-       pass
-
-# Do the right thing with boolean values for all known Python versions
-# (so this module can be copied to projects that don't depend on Python
-# 2.3, e.g. Optik and Docutils).
-try:
-    True, False
-except NameError:
-    (True, False) = (1, 0)
-
-__all__ = ['TextWrapper', 'wrap', 'fill']
-
-# Hardcode the recognized whitespace characters to the US-ASCII
-# whitespace characters.  The main reason for doing this is that in
-# ISO-8859-1, 0xa0 is non-breaking whitespace, so in certain locales
-# that character winds up in string.whitespace.  Respecting
-# string.whitespace in those cases would 1) make textwrap treat 0xa0 the
-# same as any other whitespace char, which is clearly wrong (it's a
-# *non-breaking* space), 2) possibly cause problems with Unicode,
-# since 0xa0 is not in range(128).
-_whitespace = '\t\n\x0b\x0c\r '
-
-class TextWrapper:
-    """
-    Object for wrapping/filling text.  The public interface consists of
-    the wrap() and fill() methods; the other methods are just there for
-    subclasses to override in order to tweak the default behaviour.
-    If you want to completely replace the main wrapping algorithm,
-    you'll probably have to override _wrap_chunks().
-
-    Several instance attributes control various aspects of wrapping:
-      width (default: 70)
-        the maximum width of wrapped lines (unless break_long_words
-        is false)
-      initial_indent (default: "")
-        string that will be prepended to the first line of wrapped
-        output.  Counts towards the line's width.
-      subsequent_indent (default: "")
-        string that will be prepended to all lines save the first
-        of wrapped output; also counts towards each line's width.
-      expand_tabs (default: true)
-        Expand tabs in input text to spaces before further processing.
-        Each tab will become 1 .. 8 spaces, depending on its position in
-        its line.  If false, each tab is treated as a single character.
-      replace_whitespace (default: true)
-        Replace all whitespace characters in the input text by spaces
-        after tab expansion.  Note that if expand_tabs is false and
-        replace_whitespace is true, every tab will be converted to a
-        single space!
-      fix_sentence_endings (default: false)
-        Ensure that sentence-ending punctuation is always followed
-        by two spaces.  Off by default because the algorithm is
-        (unavoidably) imperfect.
-      break_long_words (default: true)
-        Break words longer than 'width'.  If false, those words will not
-        be broken, and some lines might be longer than 'width'.
-    """
-
-    whitespace_trans = string.maketrans(_whitespace, ' ' * len(_whitespace))
-
-    unicode_whitespace_trans = {}
-    try:
-        uspace = eval("ord(u' ')")
-    except SyntaxError:
-        # Python1.5 doesn't understand u'' syntax, in which case we
-        # won't actually use the unicode translation below, so it
-        # doesn't matter what value we put in the table.
-        uspace = ord(' ')
-    for x in map(ord, _whitespace):
-        unicode_whitespace_trans[x] = uspace
-
-    # This funky little regex is just the trick for splitting
-    # text up into word-wrappable chunks.  E.g.
-    #   "Hello there -- you goof-ball, use the -b option!"
-    # splits into
-    #   Hello/ /there/ /--/ /you/ /goof-/ball,/ /use/ /the/ /-b/ /option!
-    # (after stripping out empty strings).
-    try:
-        wordsep_re = re.compile(r'(\s+|'                  # any whitespace
-                                r'[^\s\w]*\w{2,}-(?=\w{2,})|' # hyphenated words
-                                r'(?<=[\w\!\"\'\&\.\,\?])-{2,}(?=\w))')   # em-dash
-    except re.error:
-        # Pre-2.0 Python versions don't have the (?<= negative look-behind
-        # assertion.  It mostly doesn't matter for the simple input
-        # SCons is going to give it, so just leave it out.
-        wordsep_re = re.compile(r'(\s+|'                    # any whitespace
-                                r'-*\w{2,}-(?=\w{2,}))')    # hyphenated words
-
-    # XXX will there be a locale-or-charset-aware version of
-    # string.lowercase in 2.3?
-    sentence_end_re = re.compile(r'[%s]'              # lowercase letter
-                                 r'[\.\!\?]'          # sentence-ending punct.
-                                 r'[\"\']?'           # optional end-of-quote
-                                 % string.lowercase)
-
-
-    def __init__(self,
-                 width=70,
-                 initial_indent="",
-                 subsequent_indent="",
-                 expand_tabs=True,
-                 replace_whitespace=True,
-                 fix_sentence_endings=False,
-                 break_long_words=True):
-        self.width = width
-        self.initial_indent = initial_indent
-        self.subsequent_indent = subsequent_indent
-        self.expand_tabs = expand_tabs
-        self.replace_whitespace = replace_whitespace
-        self.fix_sentence_endings = fix_sentence_endings
-        self.break_long_words = break_long_words
-
-
-    # -- Private methods -----------------------------------------------
-    # (possibly useful for subclasses to override)
-
-    def _munge_whitespace(self, text):
-        """_munge_whitespace(text : string) -> string
-
-        Munge whitespace in text: expand tabs and convert all other
-        whitespace characters to spaces.  Eg. " foo\tbar\n\nbaz"
-        becomes " foo    bar  baz".
-        """
-        if self.expand_tabs:
-            text = string.expandtabs(text)
-        if self.replace_whitespace:
-            if type(text) == type(''):
-                text = string.translate(text, self.whitespace_trans)
-            elif isinstance(text, unicode):
-                text = string.translate(text, self.unicode_whitespace_trans)
-        return text
-
-
-    def _split(self, text):
-        """_split(text : string) -> [string]
-
-        Split the text to wrap into indivisible chunks.  Chunks are
-        not quite the same as words; see wrap_chunks() for full
-        details.  As an example, the text
-          Look, goof-ball -- use the -b option!
-        breaks into the following chunks:
-          'Look,', ' ', 'goof-', 'ball', ' ', '--', ' ',
-          'use', ' ', 'the', ' ', '-b', ' ', 'option!'
-        """
-        chunks = self.wordsep_re.split(text)
-        chunks = filter(None, chunks)
-        return chunks
-
-    def _fix_sentence_endings(self, chunks):
-        """_fix_sentence_endings(chunks : [string])
-
-        Correct for sentence endings buried in 'chunks'.  Eg. when the
-        original text contains "... foo.\nBar ...", munge_whitespace()
-        and split() will convert that to [..., "foo.", " ", "Bar", ...]
-        which has one too few spaces; this method simply changes the one
-        space to two.
-        """
-        i = 0
-        pat = self.sentence_end_re
-        while i < len(chunks)-1:
-            if chunks[i+1] == " " and pat.search(chunks[i]):
-                chunks[i+1] = "  "
-                i = i + 2
-            else:
-                i = i + 1
-
-    def _handle_long_word(self, chunks, cur_line, cur_len, width):
-        """_handle_long_word(chunks : [string],
-                             cur_line : [string],
-                             cur_len : int, width : int)
-
-        Handle a chunk of text (most likely a word, not whitespace) that
-        is too long to fit in any line.
-        """
-        space_left = max(width - cur_len, 1)
-
-        # If we're allowed to break long words, then do so: put as much
-        # of the next chunk onto the current line as will fit.
-        if self.break_long_words:
-            cur_line.append(chunks[0][0:space_left])
-            chunks[0] = chunks[0][space_left:]
-
-        # Otherwise, we have to preserve the long word intact.  Only add
-        # it to the current line if there's nothing already there --
-        # that minimizes how much we violate the width constraint.
-        elif not cur_line:
-            cur_line.append(chunks.pop(0))
-
-        # If we're not allowed to break long words, and there's already
-        # text on the current line, do nothing.  Next time through the
-        # main loop of _wrap_chunks(), we'll wind up here again, but
-        # cur_len will be zero, so the next line will be entirely
-        # devoted to the long word that we can't handle right now.
-
-    def _wrap_chunks(self, chunks):
-        """_wrap_chunks(chunks : [string]) -> [string]
-
-        Wrap a sequence of text chunks and return a list of lines of
-        length 'self.width' or less.  (If 'break_long_words' is false,
-        some lines may be longer than this.)  Chunks correspond roughly
-        to words and the whitespace between them: each chunk is
-        indivisible (modulo 'break_long_words'), but a line break can
-        come between any two chunks.  Chunks should not have internal
-        whitespace; ie. a chunk is either all whitespace or a "word".
-        Whitespace chunks will be removed from the beginning and end of
-        lines, but apart from that whitespace is preserved.
-        """
-        lines = []
-        if self.width <= 0:
-            raise ValueError("invalid width %r (must be > 0)" % self.width)
-
-        while chunks:
-
-            # Start the list of chunks that will make up the current line.
-            # cur_len is just the length of all the chunks in cur_line.
-            cur_line = []
-            cur_len = 0
-
-            # Figure out which static string will prefix this line.
-            if lines:
-                indent = self.subsequent_indent
-            else:
-                indent = self.initial_indent
-
-            # Maximum width for this line.
-            width = self.width - len(indent)
-
-            # First chunk on line is whitespace -- drop it, unless this
-            # is the very beginning of the text (ie. no lines started yet).
-            if string.strip(chunks[0]) == '' and lines:
-                del chunks[0]
-
-            while chunks:
-                l = len(chunks[0])
-
-                # Can at least squeeze this chunk onto the current line.
-                if cur_len + l <= width:
-                    cur_line.append(chunks.pop(0))
-                    cur_len = cur_len + l
-
-                # Nope, this line is full.
-                else:
-                    break
-
-            # The current line is full, and the next chunk is too big to
-            # fit on *any* line (not just this one).
-            if chunks and len(chunks[0]) > width:
-                self._handle_long_word(chunks, cur_line, cur_len, width)
-
-            # If the last chunk on this line is all whitespace, drop it.
-            if cur_line and string.strip(cur_line[-1]) == '':
-                del cur_line[-1]
-
-            # Convert current line back to a string and store it in list
-            # of all lines (return value).
-            if cur_line:
-                lines.append(indent + string.join(cur_line, ''))
-
-        return lines
-
-
-    # -- Public interface ----------------------------------------------
-
-    def wrap(self, text):
-        """wrap(text : string) -> [string]
-
-        Reformat the single paragraph in 'text' so it fits in lines of
-        no more than 'self.width' columns, and return a list of wrapped
-        lines.  Tabs in 'text' are expanded with string.expandtabs(),
-        and all other whitespace characters (including newline) are
-        converted to space.
-        """
-        text = self._munge_whitespace(text)
-        indent = self.initial_indent
-        chunks = self._split(text)
-        if self.fix_sentence_endings:
-            self._fix_sentence_endings(chunks)
-        return self._wrap_chunks(chunks)
-
-    def fill(self, text):
-        """fill(text : string) -> string
-
-        Reformat the single paragraph in 'text' to fit in lines of no
-        more than 'self.width' columns, and return a new string
-        containing the entire wrapped paragraph.
-        """
-        return string.join(self.wrap(text), "\n")
-
-
-# -- Convenience interface ---------------------------------------------
-
-def wrap(text, width=70, **kwargs):
-    """Wrap a single paragraph of text, returning a list of wrapped lines.
-
-    Reformat the single paragraph in 'text' so it fits in lines of no
-    more than 'width' columns, and return a list of wrapped lines.  By
-    default, tabs in 'text' are expanded with string.expandtabs(), and
-    all other whitespace characters (including newline) are converted to
-    space.  See TextWrapper class for available keyword args to customize
-    wrapping behaviour.
-    """
-    kw = kwargs.copy()
-    kw['width'] = width
-    w = apply(TextWrapper, (), kw)
-    return w.wrap(text)
-
-def fill(text, width=70, **kwargs):
-    """Fill a single paragraph of text, returning a new string.
-
-    Reformat the single paragraph in 'text' to fit in lines of no more
-    than 'width' columns, and return a new string containing the entire
-    wrapped paragraph.  As with wrap(), tabs are expanded and other
-    whitespace characters converted to space.  See TextWrapper class for
-    available keyword args to customize wrapping behaviour.
-    """
-    kw = kwargs.copy()
-    kw['width'] = width
-    w = apply(TextWrapper, (), kw)
-    return w.fill(text)
-
-
-# -- Loosely related functionality -------------------------------------
-
-def dedent(text):
-    """dedent(text : string) -> string
-
-    Remove any whitespace than can be uniformly removed from the left
-    of every line in `text`.
-
-    This can be used e.g. to make triple-quoted strings line up with
-    the left edge of screen/whatever, while still presenting it in the
-    source code in indented form.
-
-    For example:
-
-        def test():
-            # end first line with \ to avoid the empty line!
-            s = '''\
-            hello
-              world
-            '''
-            print repr(s)          # prints '    hello\n      world\n    '
-            print repr(dedent(s))  # prints 'hello\n  world\n'
-    """
-    lines = text.expandtabs().split('\n')
-    margin = None
-    for line in lines:
-        content = line.lstrip()
-        if not content:
-            continue
-        indent = len(line) - len(content)
-        if margin is None:
-            margin = indent
-        else:
-            margin = min(margin, indent)
-
-    if margin is not None and margin > 0:
-        for i in range(len(lines)):
-            lines[i] = lines[i][margin:]
-
-    return string.join(lines, '\n')
-
-# Local Variables:
-# tab-width:4
-# indent-tabs-mode:nil
-# End:
-# vim: set expandtab tabstop=4 shiftwidth=4: