src/engine/SCons/compat/__init__.py

   1 #
   2 # __COPYRIGHT__
   3 #
   4 # Permission is hereby granted, free of charge, to any person obtaining
   5 # a copy of this software and associated documentation files (the
   6 # "Software"), to deal in the Software without restriction, including
   7 # without limitation the rights to use, copy, modify, merge, publish,
   8 # distribute, sublicense, and/or sell copies of the Software, and to
   9 # permit persons to whom the Software is furnished to do so, subject to
  10 # the following conditions:
  11 #
  12 # The above copyright notice and this permission notice shall be included
  13 # in all copies or substantial portions of the Software.
  14 #
  15 # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
  16 # KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
  17 # WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  18 # NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  19 # LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  20 # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  21 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  22 #
  23
  24 __doc__ = """
  25 SCons compatibility package for old Python versions
  26
  27 This subpackage holds modules that provide backwards-compatible
  28 implementations of various things that we'd like to use in SCons but which
  29 only show up in later versions of Python than the early, old version(s)
  30 we still support.
  31
  32 Other code will not generally reference things in this package through
  33 the SCons.compat namespace.  The modules included here add things to
  34 the builtins namespace or the global module list so that the rest
  35 of our code can use the objects and names imported here regardless of
  36 Python version.
  37
  38 Simply enough, things that go in the builtins name space come from
  39 our _scons_builtins module.
  40
  41 The rest of the things here will be in individual compatibility modules
  42 that are either: 1) suitably modified copies of the future modules that
  43 we want to use; or 2) backwards compatible re-implementations of the
  44 specific portions of a future module's API that we want to use.
  45
  46 GENERAL WARNINGS:  Implementations of functions in the SCons.compat
  47 modules are *NOT* guaranteed to be fully compliant with these functions in
  48 later versions of Python.  We are only concerned with adding functionality
  49 that we actually use in SCons, so be wary if you lift this code for
  50 other uses.  (That said, making these more nearly the same as later,
  51 official versions is still a desirable goal, we just don't need to be
  52 obsessive about it.)
  53
  54 We name the compatibility modules with an initial '_scons_' (for example,
  55 _scons_subprocess.py is our compatibility module for subprocess) so
  56 that we can still try to import the real module name and fall back to
  57 our compatibility module if we get an ImportError.  The import_as()
  58 function defined below loads the module as the "real" name (without the
  59 '_scons'), after which all of the "import {module}" statements in the
  60 rest of our code will find our pre-loaded compatibility module.
  61 """
  62
  63 __revision__ = "__FILE__ __REVISION__ __DATE__ __DEVELOPER__"
  64
  65 def import_as(module, name):
  66     """
  67     Imports the specified module (from our local directory) as the
  68     specified name.
  69     """
  70     import imp
  71     import os.path
  72     dir = os.path.split(__file__)[0]
  73     file, filename, suffix_mode_type = imp.find_module(module, [dir])
  74     imp.load_module(name, file, filename, suffix_mode_type)
  75
  76
  77 try:
  78     import builtins
  79 except ImportError:
  80     # Use the "imp" module to protect the import from fixers.
  81     import imp
  82     import sys
  83     _builtin = imp.load_module('__builtin__',
  84                                *imp.find_module('__builtin__'))
  85     sys.modules['builtins'] = _builtin
  86     del _builtin
  87
  88 import _scons_builtins
  89
  90
  91 try:
  92     import hashlib
  93 except ImportError:
  94     # Pre-2.5 Python has no hashlib module.
  95     try:
  96         import_as('_scons_hashlib', 'hashlib')
  97     except ImportError:
  98         # If we failed importing our compatibility module, it probably
  99         # means this version of Python has no md5 module.  Don't do
 100         # anything and let the higher layer discover this fact, so it
 101         # can fall back to using timestamp.
 102         pass
 103
 104 try:
 105     set
 106 except NameError:
 107     # Pre-2.4 Python has no native set type
 108     import_as('_scons_sets', 'sets')
 109     import builtins, sets
 110     builtins.set = sets.Set
 111
 112
 113 try:
 114     import collections
 115 except ImportError:
 116     # Pre-2.4 Python has no collections module.
 117     import_as('_scons_collections', 'collections')
 118 else:
 119     # Use the "imp" module to protect the imports below from fixers.
 120     import imp
 121     try:
 122         collections.UserDict
 123     except AttributeError:
 124         _UserDict = imp.load_module('UserDict', *imp.find_module('UserDict'))
 125         collections.UserDict = _UserDict.UserDict
 126         del _UserDict
 127     try:
 128         collections.UserList
 129     except AttributeError:
 130         _UserList = imp.load_module('UserList', *imp.find_module('UserList'))
 131         collections.UserList = _UserList.UserList
 132         del _UserList
 133     try:
 134         collections.UserString
 135     except AttributeError:
 136         _UserString = imp.load_module('UserString',
 137                                       *imp.find_module('UserString'))
 138         collections.UserString = _UserString.UserString
 139         del _UserString
 140
 141
 142 import fnmatch
 143 try:
 144     fnmatch.filter
 145 except AttributeError:
 146     # Pre-2.2 Python has no fnmatch.filter() function.
 147     def filter(names, pat):
 148         """Return the subset of the list NAMES that match PAT"""
 149         import os,posixpath
 150         result=[]
 151         pat = os.path.normcase(pat)
 152         if pat not in fnmatch._cache:
 153             import re
 154             res = fnmatch.translate(pat)
 155             fnmatch._cache[pat] = re.compile(res)
 156         match = fnmatch._cache[pat].match
 157         if os.path is posixpath:
 158             # normcase on posix is NOP. Optimize it away from the loop.
 159             for name in names:
 160                 if match(name):
 161                     result.append(name)
 162         else:
 163             for name in names:
 164                 if match(os.path.normcase(name)):
 165                     result.append(name)
 166         return result
 167     fnmatch.filter = filter
 168     del filter
 169
 170 try:
 171     import io
 172 except ImportError:
 173     # Pre-2.6 Python has no io module.
 174     import_as('_scons_io', 'io')
 175
 176 try:
 177     import itertools
 178 except ImportError:
 179     # Pre-2.3 Python has no itertools module.
 180     import_as('_scons_itertools', 'itertools')
 181
 182 # If we need the compatibility version of textwrap, it  must be imported
 183 # before optparse, which uses it.
 184 try:
 185     import textwrap
 186 except ImportError:
 187     # Pre-2.3 Python has no textwrap module.
 188     import_as('_scons_textwrap', 'textwrap')
 189
 190 try:
 191     import optparse
 192 except ImportError:
 193     # Pre-2.3 Python has no optparse module.
 194     import_as('_scons_optparse', 'optparse')
 195
 196 import os
 197 try:
 198     os.devnull
 199 except AttributeError:
 200     # Pre-2.4 Python has no os.devnull attribute
 201     import sys
 202     _names = sys.builtin_module_names
 203     if 'posix' in _names:
 204         os.devnull = '/dev/null'
 205     elif 'nt' in _names:
 206         os.devnull = 'nul'
 207     os.path.devnull = os.devnull
 208 try:
 209     os.path.lexists
 210 except AttributeError:
 211     # Pre-2.4 Python has no os.path.lexists function
 212     def lexists(path):
 213         return os.path.exists(path) or os.path.islink(path)
 214     os.path.lexists = lexists
 215
 216
 217 try:
 218     # Use the "imp" module to protect the import from fixers.
 219     import imp
 220     _cPickle = imp.load_module('cPickle', *imp.find_module('cPickle'))
 221 except ImportError, e:
 222     # The "cPickle" module has already been eliminated in favor of
 223     # having "import pickle" import the fast version when available.
 224     pass
 225 else:
 226     import sys
 227     sys.modules['pickle'] = _cPickle
 228     del _cPickle
 229
 230
 231 try:
 232     # Use the "imp" module to protect the import from fixers.
 233     import imp
 234     _cProfile = imp.load_module('cProfile', *imp.find_module('cProfile'))
 235 except ImportError:
 236     # The "cProfile" module has already been eliminated in favor of
 237     # having "import profile" import the fast version when available.
 238     pass
 239 else:
 240     import sys
 241     sys.modules['profile'] = _cProfile
 242     del _cProfile
 243
 244
 245 try:
 246     import platform
 247 except ImportError:
 248     # Pre-2.3 Python has no platform module.
 249     import_as('_scons_platform', 'platform')
 250
 251
 252 try:
 253     import queue
 254 except ImportError:
 255     # Before Python 3.0, the 'queue' module was named 'Queue'.
 256     import imp
 257     file, filename, suffix_mode_type = imp.find_module('Queue')
 258     imp.load_module('queue', file, filename, suffix_mode_type)
 259
 260
 261 import shlex
 262 try:
 263     shlex.split
 264 except AttributeError:
 265     # Pre-2.3 Python has no shlex.split() function.
 266     #
 267     # The full white-space splitting semantics of shlex.split() are
 268     # complicated to reproduce by hand, so just use a compatibility
 269     # version of the shlex module cribbed from Python 2.5 with some
 270     # minor modifications for older Python versions.
 271     del shlex
 272     import_as('_scons_shlex', 'shlex')
 273
 274
 275 import shutil
 276 try:
 277     shutil.move
 278 except AttributeError:
 279     # Pre-2.3 Python has no shutil.move() function.
 280     #
 281     # Cribbed from Python 2.5.
 282     import os
 283
 284     def move(src, dst):
 285         """Recursively move a file or directory to another location.
 286
 287         If the destination is on our current filesystem, then simply use
 288         rename.  Otherwise, copy src to the dst and then remove src.
 289         A lot more could be done here...  A look at a mv.c shows a lot of
 290         the issues this implementation glosses over.
 291
 292         """
 293         try:
 294             os.rename(src, dst)
 295         except OSError:
 296             if os.path.isdir(src):
 297                 if shutil.destinsrc(src, dst):
 298                     raise Error, "Cannot move a directory '%s' into itself '%s'." % (src, dst)
 299                 shutil.copytree(src, dst, symlinks=True)
 300                 shutil.rmtree(src)
 301             else:
 302                 shutil.copy2(src,dst)
 303                 os.unlink(src)
 304     shutil.move = move
 305     del move
 306
 307     def destinsrc(src, dst):
 308         src = os.path.abspath(src)
 309         return os.path.abspath(dst)[:len(src)] == src
 310     shutil.destinsrc = destinsrc
 311     del destinsrc
 312
 313
 314 try:
 315     import subprocess
 316 except ImportError:
 317     # Pre-2.4 Python has no subprocess module.
 318     import_as('_scons_subprocess', 'subprocess')
 319
 320 import sys
 321 try:
 322     sys.intern
 323 except AttributeError:
 324     # Pre-2.6 Python has no sys.intern() function.
 325     import builtins
 326     try:
 327         sys.intern = builtins.intern
 328     except AttributeError:
 329         # Pre-2.x Python has no builtin intern() function.
 330         def intern(x):
 331            return x
 332         sys.intern = intern
 333         del intern
 334 try:
 335     sys.maxsize
 336 except AttributeError:
 337     # Pre-2.6 Python has no sys.maxsize attribute
 338     # Wrapping sys in () is silly, but protects it from 2to3 renames fixer
 339     sys.maxsize = (sys).maxint
 340
 341
 342 import tempfile
 343 try:
 344     tempfile.mkstemp
 345 except AttributeError:
 346     # Pre-2.3 Python has no tempfile.mkstemp function, so try to simulate it.
 347     # adapted from the mkstemp implementation in python 3.
 348     import os
 349     import errno
 350     def mkstemp(*args, **kw):
 351         text = False
 352         # TODO (1.5)
 353         #if 'text' in kw :
 354         if 'text' in kw.keys() :
 355             text = kw['text']
 356             del kw['text']
 357         elif len( args ) == 4 :
 358             text = args[3]
 359             args = args[:3]
 360         flags = os.O_RDWR | os.O_CREAT | os.O_EXCL
 361         if not text and hasattr( os, 'O_BINARY' ) :
 362             flags = flags | os.O_BINARY
 363         while True:
 364             try :
 365                 name = tempfile.mktemp(*args, **kw)
 366                 fd = os.open( name, flags, 0600 )
 367                 return (fd, os.path.abspath(name))
 368             except OSError, e:
 369                 if e.errno == errno.EEXIST:
 370                     continue
 371                 raise
 372
 373     tempfile.mkstemp = mkstemp
 374     del mkstemp
 375
 376
 377 # Local Variables:
 378 # tab-width:4
 379 # indent-tabs-mode:nil
 380 # End:
 381 # vim: set expandtab tabstop=4 shiftwidth=4: