therubyracer-heroku 0.8.1.pre2 → 0.8.1.pre3

data/ext/v8/upstream/build/scons/build/lib/SCons/Platform/irix.py

@@ -1,44 +0,0 @@
-"""SCons.Platform.irix
-
-Platform-specific initialization for SGI IRIX systems.
-
-There normally shouldn't be any need to import this module directly.  It
-will usually be imported through the generic SCons.Platform.Platform()
-selection method.
-"""
-
-#
-# 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/Platform/irix.py 4629 2010/01/17 22:23:21 scons"
-
-import posix
-
-def generate(env):
-    posix.generate(env)
-
-# Local Variables:
-# tab-width:4
-# indent-tabs-mode:nil
-# End:
-# vim: set expandtab tabstop=4 shiftwidth=4:

data/ext/v8/upstream/build/scons/build/lib/SCons/Platform/os2.py

@@ -1,58 +0,0 @@
-"""SCons.Platform.os2
-
-Platform-specific initialization for OS/2 systems.
-
-There normally shouldn't be any need to import this module directly.  It
-will usually be imported through the generic SCons.Platform.Platform()
-selection method.
-"""
-
-#
-# 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/Platform/os2.py 4629 2010/01/17 22:23:21 scons"
-import win32
-
-def generate(env):
-    if not env.has_key('ENV'):
-        env['ENV']        = {}
-    env['OBJPREFIX']      = ''
-    env['OBJSUFFIX']      = '.obj'
-    env['SHOBJPREFIX']    = '$OBJPREFIX'
-    env['SHOBJSUFFIX']    = '$OBJSUFFIX'
-    env['PROGPREFIX']     = ''
-    env['PROGSUFFIX']     = '.exe'
-    env['LIBPREFIX']      = ''
-    env['LIBSUFFIX']      = '.lib'
-    env['SHLIBPREFIX']    = ''
-    env['SHLIBSUFFIX']    = '.dll'
-    env['LIBPREFIXES']    = '$LIBPREFIX'
-    env['LIBSUFFIXES']    = [ '$LIBSUFFIX', '$SHLIBSUFFIX' ]
-    env['HOST_OS']        = 'os2'
-    env['HOST_ARCH']      = win32.get_architecture().arch
-
-# Local Variables:
-# tab-width:4
-# indent-tabs-mode:nil
-# End:
-# vim: set expandtab tabstop=4 shiftwidth=4:

data/ext/v8/upstream/build/scons/build/lib/SCons/Platform/posix.py

@@ -1,264 +0,0 @@
-"""SCons.Platform.posix
-
-Platform-specific initialization for POSIX (Linux, UNIX, etc.) systems.
-
-There normally shouldn't be any need to import this module directly.  It
-will usually be imported through the generic SCons.Platform.Platform()
-selection method.
-"""
-
-#
-# 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/Platform/posix.py 4629 2010/01/17 22:23:21 scons"
-
-import errno
-import os
-import os.path
-import string
-import subprocess
-import sys
-import select
-
-import SCons.Util
-from SCons.Platform import TempFileMunge
-
-exitvalmap = {
-    2 : 127,
-    13 : 126,
-}
-
-def escape(arg):
-    "escape shell special characters"
-    slash = '\\'
-    special = '"$()'
-
-    arg = string.replace(arg, slash, slash+slash)
-    for c in special:
-        arg = string.replace(arg, c, slash+c)
-
-    return '"' + arg + '"'
-
-def exec_system(l, env):
-    stat = os.system(string.join(l))
-    if stat & 0xff:
-        return stat | 0x80
-    return stat >> 8
-
-def exec_spawnvpe(l, env):
-    stat = os.spawnvpe(os.P_WAIT, l[0], l, env)
-    # os.spawnvpe() returns the actual exit code, not the encoding
-    # returned by os.waitpid() or os.system().
-    return stat
-
-def exec_fork(l, env): 
-    pid = os.fork()
-    if not pid:
-        # Child process.
-        exitval = 127
-        try:
-            os.execvpe(l[0], l, env)
-        except OSError, e:
-            exitval = exitvalmap.get(e[0], e[0])
-            sys.stderr.write("scons: %s: %s\n" % (l[0], e[1]))
-        os._exit(exitval)
-    else:
-        # Parent process.
-        pid, stat = os.waitpid(pid, 0)
-        if stat & 0xff:
-            return stat | 0x80
-        return stat >> 8
-
-def _get_env_command(sh, escape, cmd, args, env):
-    s = string.join(args)
-    if env:
-        l = ['env', '-'] + \
-            map(lambda t, e=escape: e(t[0])+'='+e(t[1]), env.items()) + \
-            [sh, '-c', escape(s)]
-        s = string.join(l)
-    return s
-
-def env_spawn(sh, escape, cmd, args, env):
-    return exec_system([_get_env_command( sh, escape, cmd, args, env)], env)
-
-def spawnvpe_spawn(sh, escape, cmd, args, env):
-    return exec_spawnvpe([sh, '-c', string.join(args)], env)
-
-def fork_spawn(sh, escape, cmd, args, env):
-    return exec_fork([sh, '-c', string.join(args)], env)
-
-def process_cmd_output(cmd_stdout, cmd_stderr, stdout, stderr):
-    stdout_eof = stderr_eof = 0
-    while not (stdout_eof and stderr_eof):
-        try:
-            (i,o,e) = select.select([cmd_stdout, cmd_stderr], [], [])
-            if cmd_stdout in i:
-                str = cmd_stdout.read()
-                if len(str) == 0:
-                    stdout_eof = 1
-                elif stdout is not None:
-                    stdout.write(str)
-            if cmd_stderr in i:
-                str = cmd_stderr.read()
-                if len(str) == 0:
-                    #sys.__stderr__.write( "stderr_eof=1\n" )
-                    stderr_eof = 1
-                else:
-                    #sys.__stderr__.write( "str(stderr) = %s\n" % str )
-                    stderr.write(str)
-        except select.error, (_errno, _strerror):
-            if _errno != errno.EINTR:
-                raise
-
-def exec_popen3(l, env, stdout, stderr):
-    proc = subprocess.Popen(string.join(l),
-                            stdout=stdout,
-                            stderr=stderr,
-                            shell=True)
-    stat = proc.wait()
-    if stat & 0xff:
-        return stat | 0x80
-    return stat >> 8
-
-def exec_piped_fork(l, env, stdout, stderr):
-    # spawn using fork / exec and providing a pipe for the command's
-    # stdout / stderr stream
-    if stdout != stderr:
-        (rFdOut, wFdOut) = os.pipe()
-        (rFdErr, wFdErr) = os.pipe()
-    else:
-        (rFdOut, wFdOut) = os.pipe()
-        rFdErr = rFdOut
-        wFdErr = wFdOut
-    # do the fork
-    pid = os.fork()
-    if not pid:
-        # Child process
-        os.close( rFdOut )
-        if rFdOut != rFdErr:
-            os.close( rFdErr )
-        os.dup2( wFdOut, 1 ) # is there some symbolic way to do that ?
-        os.dup2( wFdErr, 2 )
-        os.close( wFdOut )
-        if stdout != stderr:
-            os.close( wFdErr )
-        exitval = 127
-        try:
-            os.execvpe(l[0], l, env)
-        except OSError, e:
-            exitval = exitvalmap.get(e[0], e[0])
-            stderr.write("scons: %s: %s\n" % (l[0], e[1]))
-        os._exit(exitval)
-    else:
-        # Parent process
-        pid, stat = os.waitpid(pid, 0)
-        os.close( wFdOut )
-        if stdout != stderr:
-            os.close( wFdErr )
-        childOut = os.fdopen( rFdOut )
-        if stdout != stderr:
-            childErr = os.fdopen( rFdErr )
-        else:
-            childErr = childOut
-        process_cmd_output(childOut, childErr, stdout, stderr)
-        os.close( rFdOut )
-        if stdout != stderr:
-            os.close( rFdErr )
-        if stat & 0xff:
-            return stat | 0x80
-        return stat >> 8
-
-def piped_env_spawn(sh, escape, cmd, args, env, stdout, stderr):
-    # spawn using Popen3 combined with the env command
-    # the command name and the command's stdout is written to stdout
-    # the command's stderr is written to stderr
-    return exec_popen3([_get_env_command(sh, escape, cmd, args, env)],
-                       env, stdout, stderr)
-
-def piped_fork_spawn(sh, escape, cmd, args, env, stdout, stderr):
-    # spawn using fork / exec and providing a pipe for the command's
-    # stdout / stderr stream
-    return exec_piped_fork([sh, '-c', string.join(args)],
-                           env, stdout, stderr)
-
-
-
-def generate(env):
-    # If os.spawnvpe() exists, we use it to spawn commands.  Otherwise
-    # if the env utility exists, we use os.system() to spawn commands,
-    # finally we fall back on os.fork()/os.exec().  
-    #
-    # os.spawnvpe() is prefered because it is the most efficient.  But
-    # for Python versions without it, os.system() is prefered because it
-    # is claimed that it works better with threads (i.e. -j) and is more
-    # efficient than forking Python.
-    #
-    # NB: Other people on the scons-users mailing list have claimed that
-    # os.fork()/os.exec() works better than os.system().  There may just
-    # not be a default that works best for all users.
-
-    if os.__dict__.has_key('spawnvpe'):
-        spawn = spawnvpe_spawn
-    elif env.Detect('env'):
-        spawn = env_spawn
-    else:
-        spawn = fork_spawn
-
-    if env.Detect('env'):
-        pspawn = piped_env_spawn
-    else:
-        pspawn = piped_fork_spawn
-
-    if not env.has_key('ENV'):
-        env['ENV']        = {}
-    env['ENV']['PATH']    = '/usr/local/bin:/opt/bin:/bin:/usr/bin'
-    env['OBJPREFIX']      = ''
-    env['OBJSUFFIX']      = '.o'
-    env['SHOBJPREFIX']    = '$OBJPREFIX'
-    env['SHOBJSUFFIX']    = '$OBJSUFFIX'
-    env['PROGPREFIX']     = ''
-    env['PROGSUFFIX']     = ''
-    env['LIBPREFIX']      = 'lib'
-    env['LIBSUFFIX']      = '.a'
-    env['SHLIBPREFIX']    = '$LIBPREFIX'
-    env['SHLIBSUFFIX']    = '.so'
-    env['LIBPREFIXES']    = [ '$LIBPREFIX' ]
-    env['LIBSUFFIXES']    = [ '$LIBSUFFIX', '$SHLIBSUFFIX' ]
-    env['PSPAWN']         = pspawn
-    env['SPAWN']          = spawn
-    env['SHELL']          = 'sh'
-    env['ESCAPE']         = escape
-    env['TEMPFILE']       = TempFileMunge
-    env['TEMPFILEPREFIX'] = '@'
-    #Based on LINUX: ARG_MAX=ARG_MAX=131072 - 3000 for environment expansion
-    #Note: specific platforms might rise or lower this value
-    env['MAXLINELENGTH']  = 128072
-
-    # This platform supports RPATH specifications.
-    env['__RPATH'] = '$_RPATH'
-
-# Local Variables:
-# tab-width:4
-# indent-tabs-mode:nil
-# End:
-# vim: set expandtab tabstop=4 shiftwidth=4:

data/ext/v8/upstream/build/scons/build/lib/SCons/Platform/sunos.py

@@ -1,50 +0,0 @@
-"""engine.SCons.Platform.sunos
-
-Platform-specific initialization for Sun systems.
-
-There normally shouldn't be any need to import this module directly.  It
-will usually be imported through the generic SCons.Platform.Platform()
-selection method.
-"""
-
-#
-# 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/Platform/sunos.py 4629 2010/01/17 22:23:21 scons"
-
-import posix
-
-def generate(env):
-    posix.generate(env)
-    # Based on sunSparc 8:32bit
-    # ARG_MAX=1048320 - 3000 for environment expansion
-    env['MAXLINELENGTH']  = 1045320
-    env['PKGINFO'] = 'pkginfo'
-    env['PKGCHK'] = '/usr/sbin/pkgchk'
-    env['ENV']['PATH'] = env['ENV']['PATH'] + ':/opt/SUNWspro/bin:/usr/ccs/bin'
-
-# Local Variables:
-# tab-width:4
-# indent-tabs-mode:nil
-# End:
-# vim: set expandtab tabstop=4 shiftwidth=4:

data/ext/v8/upstream/build/scons/build/lib/SCons/Platform/win32.py

@@ -1,386 +0,0 @@
-"""SCons.Platform.win32
-
-Platform-specific initialization for Win32 systems.
-
-There normally shouldn't be any need to import this module directly.  It
-will usually be imported through the generic SCons.Platform.Platform()
-selection method.
-"""
-
-#
-# 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/Platform/win32.py 4629 2010/01/17 22:23:21 scons"
-
-import os
-import os.path
-import string
-import sys
-import tempfile
-
-from SCons.Platform.posix import exitvalmap
-from SCons.Platform import TempFileMunge
-import SCons.Util
-
-try:
-    import msvcrt
-    import win32api
-    import win32con
-
-    msvcrt.get_osfhandle
-    win32api.SetHandleInformation
-    win32con.HANDLE_FLAG_INHERIT
-except ImportError:
-    parallel_msg = \
-        "you do not seem to have the pywin32 extensions installed;\n" + \
-        "\tparallel (-j) builds may not work reliably with open Python files."
-except AttributeError:
-    parallel_msg = \
-        "your pywin32 extensions do not support file handle operations;\n" + \
-        "\tparallel (-j) builds may not work reliably with open Python files."
-else:
-    parallel_msg = None
-
-    import __builtin__
-
-    _builtin_file = __builtin__.file
-    _builtin_open = __builtin__.open
-    
-    def _scons_file(*args, **kw):
-        fp = apply(_builtin_file, args, kw)
-        win32api.SetHandleInformation(msvcrt.get_osfhandle(fp.fileno()),
-                                      win32con.HANDLE_FLAG_INHERIT,
-                                      0)
-        return fp
-
-    def _scons_open(*args, **kw):
-        fp = apply(_builtin_open, args, kw)
-        win32api.SetHandleInformation(msvcrt.get_osfhandle(fp.fileno()),
-                                      win32con.HANDLE_FLAG_INHERIT,
-                                      0)
-        return fp
-
-    __builtin__.file = _scons_file
-    __builtin__.open = _scons_open
-
-
-
-# The upshot of all this is that, if you are using Python 1.5.2,
-# you had better have cmd or command.com in your PATH when you run
-# scons.
-
-def piped_spawn(sh, escape, cmd, args, env, stdout, stderr):
-    # There is no direct way to do that in python. What we do
-    # here should work for most cases:
-    #   In case stdout (stderr) is not redirected to a file,
-    #   we redirect it into a temporary file tmpFileStdout
-    #   (tmpFileStderr) and copy the contents of this file
-    #   to stdout (stderr) given in the argument
-    if not sh:
-        sys.stderr.write("scons: Could not find command interpreter, is it in your PATH?\n")
-        return 127
-    else:
-        # one temporary file for stdout and stderr
-        tmpFileStdout = os.path.normpath(tempfile.mktemp())
-        tmpFileStderr = os.path.normpath(tempfile.mktemp())
-
-        # check if output is redirected
-        stdoutRedirected = 0
-        stderrRedirected = 0
-        for arg in args:
-            # are there more possibilities to redirect stdout ?
-            if (string.find( arg, ">", 0, 1 ) != -1 or
-                string.find( arg, "1>", 0, 2 ) != -1):
-                stdoutRedirected = 1
-            # are there more possibilities to redirect stderr ?
-            if string.find( arg, "2>", 0, 2 ) != -1:
-                stderrRedirected = 1
-
-        # redirect output of non-redirected streams to our tempfiles
-        if stdoutRedirected == 0:
-            args.append(">" + str(tmpFileStdout))
-        if stderrRedirected == 0:
-            args.append("2>" + str(tmpFileStderr))
-
-        # actually do the spawn
-        try:
-            args = [sh, '/C', escape(string.join(args)) ]
-            ret = os.spawnve(os.P_WAIT, sh, args, env)
-        except OSError, e:
-            # catch any error
-            try:
-                ret = exitvalmap[e[0]]
-            except KeyError:
-                sys.stderr.write("scons: unknown OSError exception code %d - %s: %s\n" % (e[0], cmd, e[1]))
-            if stderr is not None:
-                stderr.write("scons: %s: %s\n" % (cmd, e[1]))
-        # copy child output from tempfiles to our streams
-        # and do clean up stuff
-        if stdout is not None and stdoutRedirected == 0:
-            try:
-                stdout.write(open( tmpFileStdout, "r" ).read())
-                os.remove( tmpFileStdout )
-            except (IOError, OSError):
-                pass
-
-        if stderr is not None and stderrRedirected == 0:
-            try:
-                stderr.write(open( tmpFileStderr, "r" ).read())
-                os.remove( tmpFileStderr )
-            except (IOError, OSError):
-                pass
-        return ret
-
-def exec_spawn(l, env):
-    try:
-        result = os.spawnve(os.P_WAIT, l[0], l, env)
-    except OSError, e:
-        try:
-            result = exitvalmap[e[0]]
-            sys.stderr.write("scons: %s: %s\n" % (l[0], e[1]))
-        except KeyError:
-            result = 127
-            if len(l) > 2:
-                if len(l[2]) < 1000:
-                    command = string.join(l[0:3])
-                else:
-                    command = l[0]
-            else:
-                command = l[0]
-            sys.stderr.write("scons: unknown OSError exception code %d - '%s': %s\n" % (e[0], command, e[1]))
-    return result
-
-def spawn(sh, escape, cmd, args, env):
-    if not sh:
-        sys.stderr.write("scons: Could not find command interpreter, is it in your PATH?\n")
-        return 127
-    return exec_spawn([sh, '/C', escape(string.join(args))], env)
-
-# Windows does not allow special characters in file names anyway, so no
-# need for a complex escape function, we will just quote the arg, except
-# that "cmd /c" requires that if an argument ends with a backslash it
-# needs to be escaped so as not to interfere with closing double quote
-# that we add.
-def escape(x):
-    if x[-1] == '\\':
-        x = x + '\\'
-    return '"' + x + '"'
-
-# Get the windows system directory name
-_system_root = None
-
-def get_system_root():
-    global _system_root
-    if _system_root is not None:
-        return _system_root
-
-    # A resonable default if we can't read the registry
-    val = os.environ.get('SystemRoot', "C:\\WINDOWS")
-
-    if SCons.Util.can_read_reg:
-        try:
-            # Look for Windows NT system root
-            k=SCons.Util.RegOpenKeyEx(SCons.Util.hkey_mod.HKEY_LOCAL_MACHINE,
-                                      'Software\\Microsoft\\Windows NT\\CurrentVersion')
-            val, tok = SCons.Util.RegQueryValueEx(k, 'SystemRoot')
-        except SCons.Util.RegError:
-            try:
-                # Okay, try the Windows 9x system root
-                k=SCons.Util.RegOpenKeyEx(SCons.Util.hkey_mod.HKEY_LOCAL_MACHINE,
-                                          'Software\\Microsoft\\Windows\\CurrentVersion')
-                val, tok = SCons.Util.RegQueryValueEx(k, 'SystemRoot')
-            except KeyboardInterrupt:
-                raise
-            except:
-                pass
-    _system_root = val
-    return val
-
-# Get the location of the program files directory
-def get_program_files_dir():
-    # Now see if we can look in the registry...
-    val = ''
-    if SCons.Util.can_read_reg:
-        try:
-            # Look for Windows Program Files directory
-            k=SCons.Util.RegOpenKeyEx(SCons.Util.hkey_mod.HKEY_LOCAL_MACHINE,
-                                      'Software\\Microsoft\\Windows\\CurrentVersion')
-            val, tok = SCons.Util.RegQueryValueEx(k, 'ProgramFilesDir')
-        except SCons.Util.RegError:
-            val = ''
-            pass
-
-    if val == '':
-        # A reasonable default if we can't read the registry
-        # (Actually, it's pretty reasonable even if we can :-)
-        val = os.path.join(os.path.dirname(get_system_root()),"Program Files")
-        
-    return val
-
-
-
-# Determine which windows CPU were running on.
-class ArchDefinition:
-    """
-    A class for defining architecture-specific settings and logic.
-    """
-    def __init__(self, arch, synonyms=[]):
-        self.arch = arch
-        self.synonyms = synonyms
-
-SupportedArchitectureList = [
-    ArchDefinition(
-        'x86',
-        ['i386', 'i486', 'i586', 'i686'],
-    ),
-
-    ArchDefinition(
-        'x86_64',
-        ['AMD64', 'amd64', 'em64t', 'EM64T', 'x86_64'],
-    ),
-
-    ArchDefinition(
-        'ia64',
-        ['IA64'],
-    ),
-]
-
-SupportedArchitectureMap = {}
-for a in SupportedArchitectureList:
-    SupportedArchitectureMap[a.arch] = a
-    for s in a.synonyms:
-        SupportedArchitectureMap[s] = a
-
-def get_architecture(arch=None):
-    """Returns the definition for the specified architecture string.
-
-    If no string is specified, the system default is returned (as defined
-    by the PROCESSOR_ARCHITEW6432 or PROCESSOR_ARCHITECTURE environment
-    variables).
-    """
-    if arch is None:
-        arch = os.environ.get('PROCESSOR_ARCHITEW6432')
-        if not arch:
-            arch = os.environ.get('PROCESSOR_ARCHITECTURE')
-    return SupportedArchitectureMap.get(arch, ArchDefinition('', ['']))
-
-def generate(env):
-    # Attempt to find cmd.exe (for WinNT/2k/XP) or
-    # command.com for Win9x
-    cmd_interp = ''
-    # First see if we can look in the registry...
-    if SCons.Util.can_read_reg:
-        try:
-            # Look for Windows NT system root
-            k=SCons.Util.RegOpenKeyEx(SCons.Util.hkey_mod.HKEY_LOCAL_MACHINE,
-                                          'Software\\Microsoft\\Windows NT\\CurrentVersion')
-            val, tok = SCons.Util.RegQueryValueEx(k, 'SystemRoot')
-            cmd_interp = os.path.join(val, 'System32\\cmd.exe')
-        except SCons.Util.RegError:
-            try:
-                # Okay, try the Windows 9x system root
-                k=SCons.Util.RegOpenKeyEx(SCons.Util.hkey_mod.HKEY_LOCAL_MACHINE,
-                                              'Software\\Microsoft\\Windows\\CurrentVersion')
-                val, tok = SCons.Util.RegQueryValueEx(k, 'SystemRoot')
-                cmd_interp = os.path.join(val, 'command.com')
-            except KeyboardInterrupt:
-                raise
-            except:
-                pass
-
-    # For the special case of not having access to the registry, we
-    # use a temporary path and pathext to attempt to find the command
-    # interpreter.  If we fail, we try to find the interpreter through
-    # the env's PATH.  The problem with that is that it might not
-    # contain an ENV and a PATH.
-    if not cmd_interp:
-        systemroot = get_system_root()
-        tmp_path = systemroot + os.pathsep + \
-                   os.path.join(systemroot,'System32')
-        tmp_pathext = '.com;.exe;.bat;.cmd'
-        if os.environ.has_key('PATHEXT'):
-            tmp_pathext = os.environ['PATHEXT'] 
-        cmd_interp = SCons.Util.WhereIs('cmd', tmp_path, tmp_pathext)
-        if not cmd_interp:
-            cmd_interp = SCons.Util.WhereIs('command', tmp_path, tmp_pathext)
-
-    if not cmd_interp:
-        cmd_interp = env.Detect('cmd')
-        if not cmd_interp:
-            cmd_interp = env.Detect('command')
-
-    
-    if not env.has_key('ENV'):
-        env['ENV']        = {}
-
-    # Import things from the external environment to the construction
-    # environment's ENV.  This is a potential slippery slope, because we
-    # *don't* want to make builds dependent on the user's environment by
-    # default.  We're doing this for SystemRoot, though, because it's
-    # needed for anything that uses sockets, and seldom changes, and
-    # for SystemDrive because it's related.
-    #
-    # Weigh the impact carefully before adding other variables to this list.
-    import_env = [ 'SystemDrive', 'SystemRoot', 'TEMP', 'TMP' ]
-    for var in import_env:
-        v = os.environ.get(var)
-        if v:
-            env['ENV'][var] = v
-
-    if not env['ENV'].has_key('COMSPEC'):
-        v = os.environ.get("COMSPEC")
-        if v:
-            env['ENV']['COMSPEC'] = v
-
-    env.AppendENVPath('PATH', get_system_root() + '\System32')
-
-    env['ENV']['PATHEXT'] = '.COM;.EXE;.BAT;.CMD'
-    env['OBJPREFIX']      = ''
-    env['OBJSUFFIX']      = '.obj'
-    env['SHOBJPREFIX']    = '$OBJPREFIX'
-    env['SHOBJSUFFIX']    = '$OBJSUFFIX'
-    env['PROGPREFIX']     = ''
-    env['PROGSUFFIX']     = '.exe'
-    env['LIBPREFIX']      = ''
-    env['LIBSUFFIX']      = '.lib'
-    env['SHLIBPREFIX']    = ''
-    env['SHLIBSUFFIX']    = '.dll'
-    env['LIBPREFIXES']    = [ '$LIBPREFIX' ]
-    env['LIBSUFFIXES']    = [ '$LIBSUFFIX' ]
-    env['PSPAWN']         = piped_spawn
-    env['SPAWN']          = spawn
-    env['SHELL']          = cmd_interp
-    env['TEMPFILE']       = TempFileMunge
-    env['TEMPFILEPREFIX'] = '@'
-    env['MAXLINELENGTH']  = 2048
-    env['ESCAPE']         = escape
-    
-    env['HOST_OS']        = 'win32'
-    env['HOST_ARCH']      = get_architecture().arch
-    
-
-# Local Variables:
-# tab-width:4
-# indent-tabs-mode:nil
-# End:
-# vim: set expandtab tabstop=4 shiftwidth=4: