Added an unmodified copy of SCons to third_party.

scons-2.0.1/setup.py

+#
+# 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/setup.py 5134 2010/08/16 23:02:40 bdeegan"
+
+import os
+import os.path
+import stat
+import sys
+
+Version = "2.0.1"
+
+man_pages = [
+    'scons.1',
+    'sconsign.1',
+    'scons-time.1',
+]
+
+(head, tail) = os.path.split(sys.argv[0])
+
+if head:
+    os.chdir(head)
+    sys.argv[0] = tail
+
+is_win32 = 0
+if not sys.platform == 'win32':
+    try:
+        if sys.argv[1] == 'bdist_wininst':
+            is_win32 = 1
+    except IndexError:
+        pass
+else:
+    is_win32 = 1
+
+try:
+    import distutils
+    import distutils.core
+    import distutils.command.install
+    import distutils.command.install_data
+    import distutils.command.install_lib
+    import distutils.command.install_scripts
+    import distutils.command.build_scripts
+except ImportError:
+    sys.stderr.write("""Could not import distutils.
+
+Building or installing SCons from this package requires that the Python
+distutils be installed.  See the README or README.txt file from this
+package for instructions on where to find distutils for installation on
+your system, or on how to install SCons from a different package.
+""")
+    sys.exit(1)
+
+_install = distutils.command.install.install
+_install_data = distutils.command.install_data.install_data
+_install_lib = distutils.command.install_lib.install_lib
+_install_scripts = distutils.command.install_scripts.install_scripts
+_build_scripts = distutils.command.build_scripts.build_scripts
+
+class _options(object):
+    pass
+
+Options = _options()
+
+Installed = []
+
+def set_explicitly(name, args):
+    """
+    Return if the installation directory was set explicitly by the
+    user on the command line.  This is complicated by the fact that
+    "install --install-lib=/foo" gets turned into "install_lib
+    --install-dir=/foo" internally.
+    """
+    if args[0] == "install_" + name:
+        s = "--install-dir="
+    else:
+        # The command is something else (usually "install")
+        s = "--install-%s=" % name
+    set = 0
+    length = len(s)
+    for a in args[1:]:
+        if a[:length] == s:
+            set = 1
+            break
+    return set
+
+class install(_install):
+    user_options = _install.user_options + [
+                    ('no-scons-script', None,
+                     "don't install 'scons', only install 'scons-%s'" % Version),
+                    ('no-version-script', None,
+                     "don't install 'scons-%s', only install 'scons'" % Version),
+                    ('install-bat', None,
+                     "install 'scons.bat' script"),
+                    ('no-install-bat', None,
+                     "do not install 'scons.bat' script"),
+                    ('install-man', None,
+                     "install SCons man pages"),
+                    ('no-install-man', None,
+                     "do not install SCons man pages"),
+                    ('standard-lib', None,
+                     "install SCons library in standard Python location"),
+                    ('standalone-lib', None,
+                     "install SCons library in separate standalone directory"),
+                    ('version-lib', None,
+                     "install SCons library in version-numbered directory"),
+                   ]
+    boolean_options = _install.boolean_options + [
+                       'no-scons-script',
+                       'no-version-script',
+                       'install-bat',
+                       'no-install-bat',
+                       'install-man',
+                       'no-install-man',
+                       'standard-lib',
+                       'standalone-lib',
+                       'version-lib'
+                      ]
+
+    if hasattr(os, 'symlink'):
+        user_options.append(
+                    ('hardlink-scons', None,
+                     "hard link 'scons' to the version-numbered script, don't make a separate 'scons' copy"),
+                     )
+        boolean_options.append('hardlink-script')
+
+    if hasattr(os, 'symlink'):
+        user_options.append(
+                    ('symlink-scons', None,
+                     "make 'scons' a symbolic link to the version-numbered script, don't make a separate 'scons' copy"),
+                     )
+        boolean_options.append('symlink-script')
+
+    def initialize_options(self):
+        _install.initialize_options(self)
+        self.no_scons_script = 0
+        self.no_version_script = 0
+        self.install_bat = 0
+        self.no_install_bat = not is_win32
+        self.install_man = 0
+        self.no_install_man = is_win32
+        self.standard_lib = 0
+        self.standalone_lib = 0
+        self.version_lib = 0
+        self.hardlink_scons = 0
+        self.symlink_scons = 0
+        # Don't warn about having to put the library directory in the
+        # search path.
+        self.warn_dir = 0
+
+    def finalize_options(self):
+        _install.finalize_options(self)
+        if self.install_bat:
+            Options.install_bat = 1
+        else:
+            Options.install_bat = not self.no_install_bat
+        if self.install_man:
+            Options.install_man = 1
+        else:
+            Options.install_man = not self.no_install_man
+        Options.standard_lib = self.standard_lib
+        Options.standalone_lib = self.standalone_lib
+        Options.version_lib = self.version_lib
+        Options.install_scons_script = not self.no_scons_script
+        Options.install_version_script = not self.no_version_script
+        Options.hardlink_scons = self.hardlink_scons
+        Options.symlink_scons = self.symlink_scons
+
+def get_scons_prefix(libdir, is_win32):
+    """
+    Return the right prefix for SCons library installation.  Find
+    this by starting with the library installation directory
+    (.../site-packages, most likely) and crawling back up until we reach
+    a directory name beginning with "python" (or "Python").
+    """
+    drive, head = os.path.splitdrive(libdir)
+    while head:
+        if head == os.sep:
+            break
+        head, tail = os.path.split(head)
+        if tail.lower()[:6] == "python":
+            # Found the Python library directory...
+            if is_win32:
+                # ...on Win32 systems, "scons" goes in the directory:
+                #    C:\PythonXX => C:\PythonXX\scons
+                return os.path.join(drive + head, tail)
+            else:
+                # ...on other systems, "scons" goes above the directory:
+                #    /usr/lib/pythonX.X => /usr/lib/scons
+                return os.path.join(drive + head)
+    return libdir
+
+def force_to_usr_local(self):
+    """
+    A hack to decide if we need to "force" the installation directories
+    to be under /usr/local.  This is because Mac Os X Tiger and
+    Leopard, by default, put the libraries and scripts in their own
+    directories under /Library or /System/Library.
+    """
+    return (sys.platform[:6] == 'darwin' and
+            (self.install_dir[:9] == '/Library/' or
+             self.install_dir[:16] == '/System/Library/'))
+
+class install_lib(_install_lib):
+    def finalize_options(self):
+        _install_lib.finalize_options(self)
+        if force_to_usr_local(self):
+            self.install_dir = '/usr/local/lib'
+        args = self.distribution.script_args
+        if not set_explicitly("lib", args):
+            # They didn't explicitly specify the installation
+            # directory for libraries...
+            is_win32 = sys.platform == "win32" or args[0] == 'bdist_wininst'
+            prefix = get_scons_prefix(self.install_dir, is_win32)
+            if Options.standalone_lib:
+                # ...but they asked for a standalone directory.
+                self.install_dir = os.path.join(prefix, "scons")
+            elif Options.version_lib or not Options.standard_lib:
+                # ...they asked for a version-specific directory,
+                # or they get it by default.
+                self.install_dir = os.path.join(prefix, "scons-%s" % Version)
+
+        msg = "Installed SCons library modules into %s" % self.install_dir
+        Installed.append(msg)
+
+class install_scripts(_install_scripts):
+    def finalize_options(self):
+        _install_scripts.finalize_options(self)
+        if force_to_usr_local(self):
+            self.install_dir = '/usr/local/bin'
+        self.build_dir = os.path.join('build', 'scripts')
+        msg = "Installed SCons scripts into %s" % self.install_dir
+        Installed.append(msg)
+
+    def do_nothing(self, *args, **kw):
+        pass
+
+    def hardlink_scons(self, src, dst, ver):
+        try: os.unlink(dst)
+        except OSError: pass
+        os.link(ver, dst)
+
+    def symlink_scons(self, src, dst, ver):
+        try: os.unlink(dst)
+        except OSError: pass
+        os.symlink(os.path.split(ver)[1], dst)
+
+    def copy_scons(self, src, dst, *args):
+        try: os.unlink(dst)
+        except OSError: pass
+        self.copy_file(src, dst)
+        self.outfiles.append(dst)
+
+    def report(self, msg, args):
+        # Wrapper around self.announce, used by older distutils versions.
+        self.announce(msg % args)
+
+    def run(self):
+        # This "skip_build/build_scripts" block is cut-and-paste from
+        # distutils.
+        if not self.skip_build:
+            self.run_command('build_scripts')
+
+        # Custom SCons installation stuff.
+        if Options.hardlink_scons:
+            create_basename_script = self.hardlink_scons
+        elif Options.symlink_scons:
+            create_basename_script = self.symlink_scons
+        elif Options.install_scons_script:
+            create_basename_script = self.copy_scons
+        else:
+            create_basename_script = self.do_nothing
+
+        if Options.install_version_script:
+            create_version_script = self.copy_scons
+        else:
+            create_version_script = self.do_nothing
+
+        inputs = self.get_inputs()
+        bat_scripts = [x for x in inputs if x[-4:] == '.bat']
+        non_bat_scripts = [x for x in inputs if x[-4:] != '.bat']
+
+        self.outfiles = []
+        self.mkpath(self.install_dir)
+
+        for src in non_bat_scripts:
+            base = os.path.basename(src)
+            scons = os.path.join(self.install_dir, base)
+            scons_ver = scons + '-' + Version
+            create_version_script(src, scons_ver)
+            create_basename_script(src, scons, scons_ver)
+
+        if Options.install_bat:
+            if is_win32:
+                bat_install_dir = get_scons_prefix(self.install_dir, is_win32)
+            else:
+                bat_install_dir = self.install_dir
+            for src in bat_scripts:
+                scons_bat = os.path.join(bat_install_dir, 'scons.bat')
+                scons_version_bat = os.path.join(bat_install_dir,
+                                                 'scons-' + Version + '.bat')
+                self.copy_scons(src, scons_bat)
+                self.copy_scons(src, scons_version_bat)
+
+        # This section is cut-and-paste from distutils, modulo being
+        # able 
+        if os.name == 'posix':
+            try: report = distutils.log.info
+            except AttributeError: report = self.report
+            # Set the executable bits (owner, group, and world) on
+            # all the scripts we just installed.
+            for file in self.get_outputs():
+                if self.dry_run:
+                    report("changing mode of %s", file)
+                else:
+                    mode = ((os.stat(file)[stat.ST_MODE]) | 0555) & 07777
+                    report("changing mode of %s", file)
+                    os.chmod(file, mode)
+
+class build_scripts(_build_scripts):
+    def finalize_options(self):
+        _build_scripts.finalize_options(self)
+        self.build_dir = os.path.join('build', 'scripts')
+
+class install_data(_install_data):
+    def initialize_options(self):
+        _install_data.initialize_options(self)
+    def finalize_options(self):
+        _install_data.finalize_options(self)
+        if force_to_usr_local(self):
+            self.install_dir = '/usr/local'
+        if Options.install_man:
+            if is_win32:
+                dir = 'Doc'
+            else:
+                dir = os.path.join('man', 'man1')
+            self.data_files = [(dir, man_pages)]
+            man_dir = os.path.join(self.install_dir, dir)
+            msg = "Installed SCons man pages into %s" % man_dir
+            Installed.append(msg)
+        else:
+            self.data_files = []
+
+description = "Open Source next-generation build tool."
+
+long_description = """Open Source next-generation build tool.
+Improved, cross-platform substitute for the classic Make
+utility.  In short, SCons is an easier, more reliable
+and faster way to build software."""
+
+scripts = [
+    'script/scons',
+    'script/sconsign',
+    'script/scons-time',
+
+    # We include scons.bat in the list of scripts, even on UNIX systems,
+    # because we provide an option to allow it be installed explicitly,
+    # for example if you're installing from UNIX on a share that's
+    # accessible to Windows and you want the scons.bat.
+    'script/scons.bat',
+]
+
+#if is_win32:
+#    scripts = scripts + [
+#        'script/scons-post-install.py'
+#    ]
+
+arguments = {
+    'name'             : "scons",
+    'version'          : Version,
+    'description'      : description,
+    'long_description' : long_description,
+    'author'           : 'Steven Knight',
+    'author_email'     : 'knight@baldmt.com',
+    'url'              : "http://www.scons.org/",
+    'packages'         : ["SCons",
+                          "SCons.compat",
+                          "SCons.Node",
+                          "SCons.Options",
+                          "SCons.Platform",
+                          "SCons.Scanner",
+                          "SCons.Script",
+                          "SCons.Tool",
+                          "SCons.Tool.MSCommon",
+                          "SCons.Tool.packaging",
+                          "SCons.Variables",
+                         ],
+    'package_dir'      : {'' : 'engine'},
+    'data_files'       : [('man/man1', man_pages)],
+    'scripts'          : scripts,
+    'cmdclass'         : {'install'         : install,
+                          'install_lib'     : install_lib,
+                          'install_data'    : install_data,
+                          'install_scripts' : install_scripts,
+                          'build_scripts'   : build_scripts}
+}
+
+distutils.core.setup(**arguments)
+
+if Installed:
+    print '\n'.join(Installed)
+
+# Local Variables:
+# tab-width:4
+# indent-tabs-mode:nil
+# End:
+# vim: set expandtab tabstop=4 shiftwidth=4: