therubyracer-heroku 0.8.1.pre2 → 0.8.1.pre3

data/ext/v8/upstream/build/scons/build/lib/SCons/CacheDir.py

@@ -1,217 +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/CacheDir.py 4629 2010/01/17 22:23:21 scons"
-
-__doc__ = """
-CacheDir support
-"""
-
-import os.path
-import stat
-import string
-import sys
-
-import SCons.Action
-
-cache_enabled = True
-cache_debug = False
-cache_force = False
-cache_show = False
-
-def CacheRetrieveFunc(target, source, env):
-    t = target[0]
-    fs = t.fs
-    cd = env.get_CacheDir()
-    cachedir, cachefile = cd.cachepath(t)
-    if not fs.exists(cachefile):
-        cd.CacheDebug('CacheRetrieve(%s):  %s not in cache\n', t, cachefile)
-        return 1
-    cd.CacheDebug('CacheRetrieve(%s):  retrieving from %s\n', t, cachefile)
-    if SCons.Action.execute_actions:
-        if fs.islink(cachefile):
-            fs.symlink(fs.readlink(cachefile), t.path)
-        else:
-            env.copy_from_cache(cachefile, t.path)
-        st = fs.stat(cachefile)
-        fs.chmod(t.path, stat.S_IMODE(st[stat.ST_MODE]) | stat.S_IWRITE)
-    return 0
-
-def CacheRetrieveString(target, source, env):
-    t = target[0]
-    fs = t.fs
-    cd = env.get_CacheDir()
-    cachedir, cachefile = cd.cachepath(t)
-    if t.fs.exists(cachefile):
-        return "Retrieved `%s' from cache" % t.path
-    return None
-
-CacheRetrieve = SCons.Action.Action(CacheRetrieveFunc, CacheRetrieveString)
-
-CacheRetrieveSilent = SCons.Action.Action(CacheRetrieveFunc, None)
-
-def CachePushFunc(target, source, env):
-    t = target[0]
-    if t.nocache:
-        return
-    fs = t.fs
-    cd = env.get_CacheDir()
-    cachedir, cachefile = cd.cachepath(t)
-    if fs.exists(cachefile):
-        # Don't bother copying it if it's already there.  Note that
-        # usually this "shouldn't happen" because if the file already
-        # existed in cache, we'd have retrieved the file from there,
-        # not built it.  This can happen, though, in a race, if some
-        # other person running the same build pushes their copy to
-        # the cache after we decide we need to build it but before our
-        # build completes.
-        cd.CacheDebug('CachePush(%s):  %s already exists in cache\n', t, cachefile)
-        return
-
-    cd.CacheDebug('CachePush(%s):  pushing to %s\n', t, cachefile)
-
-    tempfile = cachefile+'.tmp'+str(os.getpid())
-    errfmt = "Unable to copy %s to cache. Cache file is %s"
-
-    if not fs.isdir(cachedir):
-        try:
-            fs.makedirs(cachedir)
-        except EnvironmentError:
-            # We may have received an exception because another process
-            # has beaten us creating the directory.
-            if not fs.isdir(cachedir):
-                msg = errfmt % (str(target), cachefile)
-                raise SCons.Errors.EnvironmentError, msg
-
-    try:
-        if fs.islink(t.path):
-            fs.symlink(fs.readlink(t.path), tempfile)
-        else:
-            fs.copy2(t.path, tempfile)
-        fs.rename(tempfile, cachefile)
-        st = fs.stat(t.path)
-        fs.chmod(cachefile, stat.S_IMODE(st[stat.ST_MODE]) | stat.S_IWRITE)
-    except EnvironmentError:
-        # It's possible someone else tried writing the file at the
-        # same time we did, or else that there was some problem like
-        # the CacheDir being on a separate file system that's full.
-        # In any case, inability to push a file to cache doesn't affect
-        # the correctness of the build, so just print a warning.
-        msg = errfmt % (str(target), cachefile)
-        SCons.Warnings.warn(SCons.Warnings.CacheWriteErrorWarning, msg)
-
-CachePush = SCons.Action.Action(CachePushFunc, None)
-
-class CacheDir:
-
-    def __init__(self, path):
-        try:
-            import hashlib
-        except ImportError:
-            msg = "No hashlib or MD5 module available, CacheDir() not supported"
-            SCons.Warnings.warn(SCons.Warnings.NoMD5ModuleWarning, msg)
-            self.path = None
-        else:
-            self.path = path
-        self.current_cache_debug = None
-        self.debugFP = None
-
-    def CacheDebug(self, fmt, target, cachefile):
-        if cache_debug != self.current_cache_debug:
-            if cache_debug == '-':
-                self.debugFP = sys.stdout
-            elif cache_debug:
-                self.debugFP = open(cache_debug, 'w')
-            else:
-                self.debugFP = None
-            self.current_cache_debug = cache_debug
-        if self.debugFP:
-            self.debugFP.write(fmt % (target, os.path.split(cachefile)[1]))
-
-    def is_enabled(self):
-        return (cache_enabled and not self.path is None)
-
-    def cachepath(self, node):
-        """
-        """
-        if not self.is_enabled():
-            return None, None
-
-        sig = node.get_cachedir_bsig()
-        subdir = string.upper(sig[0])
-        dir = os.path.join(self.path, subdir)
-        return dir, os.path.join(dir, sig)
-
-    def retrieve(self, node):
-        """
-        This method is called from multiple threads in a parallel build,
-        so only do thread safe stuff here. Do thread unsafe stuff in
-        built().
-
-        Note that there's a special trick here with the execute flag
-        (one that's not normally done for other actions).  Basically
-        if the user requested a no_exec (-n) build, then
-        SCons.Action.execute_actions is set to 0 and when any action
-        is called, it does its showing but then just returns zero
-        instead of actually calling the action execution operation.
-        The problem for caching is that if the file does NOT exist in
-        cache then the CacheRetrieveString won't return anything to
-        show for the task, but the Action.__call__ won't call
-        CacheRetrieveFunc; instead it just returns zero, which makes
-        the code below think that the file *was* successfully
-        retrieved from the cache, therefore it doesn't do any
-        subsequent building.  However, the CacheRetrieveString didn't
-        print anything because it didn't actually exist in the cache,
-        and no more build actions will be performed, so the user just
-        sees nothing.  The fix is to tell Action.__call__ to always
-        execute the CacheRetrieveFunc and then have the latter
-        explicitly check SCons.Action.execute_actions itself.
-        """
-        if not self.is_enabled():
-            return False
-
-        env = node.get_build_env()
-        if cache_show:
-            if CacheRetrieveSilent(node, [], env, execute=1) == 0:
-                node.build(presub=0, execute=0)
-                return True
-        else:
-            if CacheRetrieve(node, [], env, execute=1) == 0:
-                return True
-
-        return False
-
-    def push(self, node):
-        if not self.is_enabled():
-            return
-        return CachePush(node, [], node.get_build_env())
-
-    def push_if_forced(self, node):
-        if cache_force:
-            return self.push(node)
-
-# 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/Conftest.py

@@ -1,794 +0,0 @@
-"""SCons.Conftest
-
-Autoconf-like configuration support; low level implementation of tests.
-"""
-
-#
-# Copyright (c) 2003 Stichting NLnet Labs
-# Copyright (c) 2001, 2002, 2003 Steven Knight
-#
-# 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.
-#
-
-#
-# The purpose of this module is to define how a check is to be performed.
-# Use one of the Check...() functions below.
-#
-
-#
-# A context class is used that defines functions for carrying out the tests,
-# logging and messages.  The following methods and members must be present:
-#
-# context.Display(msg)  Function called to print messages that are normally
-#                       displayed for the user.  Newlines are explicitly used.
-#                       The text should also be written to the logfile!
-#
-# context.Log(msg)      Function called to write to a log file.
-#
-# context.BuildProg(text, ext)
-#                       Function called to build a program, using "ext" for the
-#                       file extention.  Must return an empty string for
-#                       success, an error message for failure.
-#                       For reliable test results building should be done just
-#                       like an actual program would be build, using the same
-#                       command and arguments (including configure results so
-#                       far).
-#
-# context.CompileProg(text, ext)
-#                       Function called to compile a program, using "ext" for
-#                       the file extention.  Must return an empty string for
-#                       success, an error message for failure.
-#                       For reliable test results compiling should be done just
-#                       like an actual source file would be compiled, using the
-#                       same command and arguments (including configure results
-#                       so far).
-#
-# context.AppendLIBS(lib_name_list)
-#                       Append "lib_name_list" to the value of LIBS.
-#                       "lib_namelist" is a list of strings.
-#                       Return the value of LIBS before changing it (any type
-#                       can be used, it is passed to SetLIBS() later.)
-#
-# context.PrependLIBS(lib_name_list)
-#                       Prepend "lib_name_list" to the value of LIBS.
-#                       "lib_namelist" is a list of strings.
-#                       Return the value of LIBS before changing it (any type
-#                       can be used, it is passed to SetLIBS() later.)
-#
-# context.SetLIBS(value)
-#                       Set LIBS to "value".  The type of "value" is what
-#                       AppendLIBS() returned.
-#                       Return the value of LIBS before changing it (any type
-#                       can be used, it is passed to SetLIBS() later.)
-#
-# context.headerfilename
-#                       Name of file to append configure results to, usually
-#                       "confdefs.h".
-#                       The file must not exist or be empty when starting.
-#                       Empty or None to skip this (some tests will not work!).
-#
-# context.config_h      (may be missing). If present, must be a string, which
-#                       will be filled with the contents of a config_h file.
-#
-# context.vardict       Dictionary holding variables used for the tests and
-#                       stores results from the tests, used for the build
-#                       commands.
-#                       Normally contains "CC", "LIBS", "CPPFLAGS", etc.
-#
-# context.havedict      Dictionary holding results from the tests that are to
-#                       be used inside a program.
-#                       Names often start with "HAVE_".  These are zero
-#                       (feature not present) or one (feature present).  Other
-#                       variables may have any value, e.g., "PERLVERSION" can
-#                       be a number and "SYSTEMNAME" a string.
-#
-
-import re
-import string
-from types import IntType
-
-#
-# PUBLIC VARIABLES
-#
-
-LogInputFiles = 1    # Set that to log the input files in case of a failed test
-LogErrorMessages = 1 # Set that to log Conftest-generated error messages
-
-#
-# PUBLIC FUNCTIONS
-#
-
-# Generic remarks:
-# - When a language is specified which is not supported the test fails.  The
-#   message is a bit different, because not all the arguments for the normal
-#   message are available yet (chicken-egg problem).
-
-
-def CheckBuilder(context, text = None, language = None):
-    """
-    Configure check to see if the compiler works.
-    Note that this uses the current value of compiler and linker flags, make
-    sure $CFLAGS, $CPPFLAGS and $LIBS are set correctly.
-    "language" should be "C" or "C++" and is used to select the compiler.
-    Default is "C".
-    "text" may be used to specify the code to be build.
-    Returns an empty string for success, an error message for failure.
-    """
-    lang, suffix, msg = _lang2suffix(language)
-    if msg:
-        context.Display("%s\n" % msg)
-        return msg
-
-    if not text:
-        text = """
-int main() {
-    return 0;
-}
-"""
-
-    context.Display("Checking if building a %s file works... " % lang)
-    ret = context.BuildProg(text, suffix)
-    _YesNoResult(context, ret, None, text)
-    return ret
-
-def CheckCC(context):
-    """
-    Configure check for a working C compiler.
-
-    This checks whether the C compiler, as defined in the $CC construction
-    variable, can compile a C source file. It uses the current $CCCOM value
-    too, so that it can test against non working flags.
-
-    """
-    context.Display("Checking whether the C compiler works")
-    text = """
-int main()
-{
-    return 0;
-}
-"""
-    ret = _check_empty_program(context, 'CC', text, 'C')
-    _YesNoResult(context, ret, None, text)
-    return ret
-
-def CheckSHCC(context):
-    """
-    Configure check for a working shared C compiler.
-
-    This checks whether the C compiler, as defined in the $SHCC construction
-    variable, can compile a C source file. It uses the current $SHCCCOM value
-    too, so that it can test against non working flags.
-
-    """
-    context.Display("Checking whether the (shared) C compiler works")
-    text = """
-int foo()
-{
-    return 0;
-}
-"""
-    ret = _check_empty_program(context, 'SHCC', text, 'C', use_shared = True)
-    _YesNoResult(context, ret, None, text)
-    return ret
-
-def CheckCXX(context):
-    """
-    Configure check for a working CXX compiler.
-
-    This checks whether the CXX compiler, as defined in the $CXX construction
-    variable, can compile a CXX source file. It uses the current $CXXCOM value
-    too, so that it can test against non working flags.
-
-    """
-    context.Display("Checking whether the C++ compiler works")
-    text = """
-int main()
-{
-    return 0;
-}
-"""
-    ret = _check_empty_program(context, 'CXX', text, 'C++')
-    _YesNoResult(context, ret, None, text)
-    return ret
-
-def CheckSHCXX(context):
-    """
-    Configure check for a working shared CXX compiler.
-
-    This checks whether the CXX compiler, as defined in the $SHCXX construction
-    variable, can compile a CXX source file. It uses the current $SHCXXCOM value
-    too, so that it can test against non working flags.
-
-    """
-    context.Display("Checking whether the (shared) C++ compiler works")
-    text = """
-int main()
-{
-    return 0;
-}
-"""
-    ret = _check_empty_program(context, 'SHCXX', text, 'C++', use_shared = True)
-    _YesNoResult(context, ret, None, text)
-    return ret
-
-def _check_empty_program(context, comp, text, language, use_shared = False):
-    """Return 0 on success, 1 otherwise."""
-    if not context.env.has_key(comp) or not context.env[comp]:
-        # The compiler construction variable is not set or empty
-        return 1
-
-    lang, suffix, msg = _lang2suffix(language)
-    if msg:
-        return 1
-
-    if use_shared:
-        return context.CompileSharedObject(text, suffix)
-    else:
-        return context.CompileProg(text, suffix)
-
-
-def CheckFunc(context, function_name, header = None, language = None):
-    """
-    Configure check for a function "function_name".
-    "language" should be "C" or "C++" and is used to select the compiler.
-    Default is "C".
-    Optional "header" can be defined to define a function prototype, include a
-    header file or anything else that comes before main().
-    Sets HAVE_function_name in context.havedict according to the result.
-    Note that this uses the current value of compiler and linker flags, make
-    sure $CFLAGS, $CPPFLAGS and $LIBS are set correctly.
-    Returns an empty string for success, an error message for failure.
-    """
-
-    # Remarks from autoconf:
-    # - Don't include <ctype.h> because on OSF/1 3.0 it includes <sys/types.h>
-    #   which includes <sys/select.h> which contains a prototype for select.
-    #   Similarly for bzero.
-    # - assert.h is included to define __stub macros and hopefully few
-    #   prototypes, which can conflict with char $1(); below.
-    # - Override any gcc2 internal prototype to avoid an error.
-    # - We use char for the function declaration because int might match the
-    #   return type of a gcc2 builtin and then its argument prototype would
-    #   still apply.
-    # - The GNU C library defines this for functions which it implements to
-    #   always fail with ENOSYS.  Some functions are actually named something
-    #   starting with __ and the normal name is an alias.
-
-    if context.headerfilename:
-        includetext = '#include "%s"' % context.headerfilename
-    else:
-        includetext = ''
-    if not header:
-        header = """
-#ifdef __cplusplus
-extern "C"
-#endif
-char %s();""" % function_name
-
-    lang, suffix, msg = _lang2suffix(language)
-    if msg:
-        context.Display("Cannot check for %s(): %s\n" % (function_name, msg))
-        return msg
-
-    text = """
-%(include)s
-#include <assert.h>
-%(hdr)s
-
-int main() {
-#if defined (__stub_%(name)s) || defined (__stub___%(name)s)
-  fail fail fail
-#else
-  %(name)s();
-#endif
-
-  return 0;
-}
-""" % { 'name': function_name,
-        'include': includetext,
-        'hdr': header }
-
-    context.Display("Checking for %s function %s()... " % (lang, function_name))
-    ret = context.BuildProg(text, suffix)
-    _YesNoResult(context, ret, "HAVE_" + function_name, text,
-                 "Define to 1 if the system has the function `%s'." %\
-                 function_name)
-    return ret
-
-
-def CheckHeader(context, header_name, header = None, language = None,
-                                                        include_quotes = None):
-    """
-    Configure check for a C or C++ header file "header_name".
-    Optional "header" can be defined to do something before including the
-    header file (unusual, supported for consistency).
-    "language" should be "C" or "C++" and is used to select the compiler.
-    Default is "C".
-    Sets HAVE_header_name in context.havedict according to the result.
-    Note that this uses the current value of compiler and linker flags, make
-    sure $CFLAGS and $CPPFLAGS are set correctly.
-    Returns an empty string for success, an error message for failure.
-    """
-    # Why compile the program instead of just running the preprocessor?
-    # It is possible that the header file exists, but actually using it may
-    # fail (e.g., because it depends on other header files).  Thus this test is
-    # more strict.  It may require using the "header" argument.
-    #
-    # Use <> by default, because the check is normally used for system header
-    # files.  SCons passes '""' to overrule this.
-
-    # Include "confdefs.h" first, so that the header can use HAVE_HEADER_H.
-    if context.headerfilename:
-        includetext = '#include "%s"\n' % context.headerfilename
-    else:
-        includetext = ''
-    if not header:
-        header = ""
-
-    lang, suffix, msg = _lang2suffix(language)
-    if msg:
-        context.Display("Cannot check for header file %s: %s\n"
-                                                          % (header_name, msg))
-        return msg
-
-    if not include_quotes:
-        include_quotes = "<>"
-
-    text = "%s%s\n#include %s%s%s\n\n" % (includetext, header,
-                             include_quotes[0], header_name, include_quotes[1])
-
-    context.Display("Checking for %s header file %s... " % (lang, header_name))
-    ret = context.CompileProg(text, suffix)
-    _YesNoResult(context, ret, "HAVE_" + header_name, text, 
-                 "Define to 1 if you have the <%s> header file." % header_name)
-    return ret
-
-
-def CheckType(context, type_name, fallback = None,
-                                               header = None, language = None):
-    """
-    Configure check for a C or C++ type "type_name".
-    Optional "header" can be defined to include a header file.
-    "language" should be "C" or "C++" and is used to select the compiler.
-    Default is "C".
-    Sets HAVE_type_name in context.havedict according to the result.
-    Note that this uses the current value of compiler and linker flags, make
-    sure $CFLAGS, $CPPFLAGS and $LIBS are set correctly.
-    Returns an empty string for success, an error message for failure.
-    """
-
-    # Include "confdefs.h" first, so that the header can use HAVE_HEADER_H.
-    if context.headerfilename:
-        includetext = '#include "%s"' % context.headerfilename
-    else:
-        includetext = ''
-    if not header:
-        header = ""
-
-    lang, suffix, msg = _lang2suffix(language)
-    if msg:
-        context.Display("Cannot check for %s type: %s\n" % (type_name, msg))
-        return msg
-
-    # Remarks from autoconf about this test:
-    # - Grepping for the type in include files is not reliable (grep isn't
-    #   portable anyway).
-    # - Using "TYPE my_var;" doesn't work for const qualified types in C++.
-    #   Adding an initializer is not valid for some C++ classes.
-    # - Using the type as parameter to a function either fails for K&$ C or for
-    #   C++.
-    # - Using "TYPE *my_var;" is valid in C for some types that are not
-    #   declared (struct something).
-    # - Using "sizeof(TYPE)" is valid when TYPE is actually a variable.
-    # - Using the previous two together works reliably.
-    text = """
-%(include)s
-%(header)s
-
-int main() {
-  if ((%(name)s *) 0)
-    return 0;
-  if (sizeof (%(name)s))
-    return 0;
-}
-""" % { 'include': includetext,
-        'header': header,
-        'name': type_name }
-
-    context.Display("Checking for %s type %s... " % (lang, type_name))
-    ret = context.BuildProg(text, suffix)
-    _YesNoResult(context, ret, "HAVE_" + type_name, text,
-                 "Define to 1 if the system has the type `%s'." % type_name)
-    if ret and fallback and context.headerfilename:
-        f = open(context.headerfilename, "a")
-        f.write("typedef %s %s;\n" % (fallback, type_name))
-        f.close()
-
-    return ret
-
-def CheckTypeSize(context, type_name, header = None, language = None, expect = None):
-    """This check can be used to get the size of a given type, or to check whether
-    the type is of expected size.
-
-    Arguments:
-        - type : str
-            the type to check
-        - includes : sequence
-            list of headers to include in the test code before testing the type
-        - language : str
-            'C' or 'C++'
-        - expect : int
-            if given, will test wether the type has the given number of bytes.
-            If not given, will automatically find the size.
-
-        Returns:
-            status : int
-                0 if the check failed, or the found size of the type if the check succeeded."""
-    
-    # Include "confdefs.h" first, so that the header can use HAVE_HEADER_H.
-    if context.headerfilename:
-        includetext = '#include "%s"' % context.headerfilename
-    else:
-        includetext = ''
-
-    if not header:
-        header = ""
-
-    lang, suffix, msg = _lang2suffix(language)
-    if msg:
-        context.Display("Cannot check for %s type: %s\n" % (type_name, msg))
-        return msg
-
-    src = includetext + header 
-    if not expect is None:
-        # Only check if the given size is the right one
-        context.Display('Checking %s is %d bytes... ' % (type_name, expect))
-
-        # test code taken from autoconf: this is a pretty clever hack to find that
-        # a type is of a given size using only compilation. This speeds things up
-        # quite a bit compared to straightforward code using TryRun
-        src = src + r"""
-typedef %s scons_check_type;
-
-int main()
-{
-    static int test_array[1 - 2 * !(((long int) (sizeof(scons_check_type))) == %d)];
-    test_array[0] = 0;
-
-    return 0;
-}
-"""
-
-        st = context.CompileProg(src % (type_name, expect), suffix)
-        if not st:
-            context.Display("yes\n")
-            _Have(context, "SIZEOF_%s" % type_name, expect, 
-                  "The size of `%s', as computed by sizeof." % type_name)
-            return expect
-        else:
-            context.Display("no\n")
-            _LogFailed(context, src, st)
-            return 0
-    else:
-        # Only check if the given size is the right one
-        context.Message('Checking size of %s ... ' % type_name)
-
-        # We have to be careful with the program we wish to test here since
-        # compilation will be attempted using the current environment's flags.
-        # So make sure that the program will compile without any warning. For
-        # example using: 'int main(int argc, char** argv)' will fail with the
-        # '-Wall -Werror' flags since the variables argc and argv would not be
-        # used in the program...
-        #
-        src = src + """
-#include <stdlib.h>
-#include <stdio.h>
-int main() {
-    printf("%d", (int)sizeof(""" + type_name + """));
-    return 0;
-}
-    """
-        st, out = context.RunProg(src, suffix)
-        try:
-            size = int(out)
-        except ValueError:
-            # If cannot convert output of test prog to an integer (the size),
-            # something went wront, so just fail
-            st = 1
-            size = 0
-
-        if not st:
-            context.Display("yes\n")
-            _Have(context, "SIZEOF_%s" % type_name, size,
-                  "The size of `%s', as computed by sizeof." % type_name)
-            return size
-        else:
-            context.Display("no\n")
-            _LogFailed(context, src, st)
-            return 0
-
-    return 0
-
-def CheckDeclaration(context, symbol, includes = None, language = None):
-    """Checks whether symbol is declared.
-
-    Use the same test as autoconf, that is test whether the symbol is defined
-    as a macro or can be used as an r-value.
-
-    Arguments:
-        symbol : str
-            the symbol to check
-        includes : str
-            Optional "header" can be defined to include a header file.
-        language : str
-            only C and C++ supported.
-
-    Returns:
-        status : bool
-            True if the check failed, False if succeeded."""
-    
-    # Include "confdefs.h" first, so that the header can use HAVE_HEADER_H.
-    if context.headerfilename:
-        includetext = '#include "%s"' % context.headerfilename
-    else:
-        includetext = ''
-
-    if not includes:
-        includes = ""
-
-    lang, suffix, msg = _lang2suffix(language)
-    if msg:
-        context.Display("Cannot check for declaration %s: %s\n" % (type_name, msg))
-        return msg
-
-    src = includetext + includes 
-    context.Display('Checking whether %s is declared... ' % symbol)
-
-    src = src + r"""
-int main()
-{
-#ifndef %s
-    (void) %s;
-#endif
-    ;
-    return 0;
-}
-""" % (symbol, symbol)
-
-    st = context.CompileProg(src, suffix)
-    _YesNoResult(context, st, "HAVE_DECL_" + symbol, src,
-                 "Set to 1 if %s is defined." % symbol)
-    return st
-
-def CheckLib(context, libs, func_name = None, header = None,
-             extra_libs = None, call = None, language = None, autoadd = 1,
-             append = True):
-    """
-    Configure check for a C or C++ libraries "libs".  Searches through
-    the list of libraries, until one is found where the test succeeds.
-    Tests if "func_name" or "call" exists in the library.  Note: if it exists
-    in another library the test succeeds anyway!
-    Optional "header" can be defined to include a header file.  If not given a
-    default prototype for "func_name" is added.
-    Optional "extra_libs" is a list of library names to be added after
-    "lib_name" in the build command.  To be used for libraries that "lib_name"
-    depends on.
-    Optional "call" replaces the call to "func_name" in the test code.  It must
-    consist of complete C statements, including a trailing ";".
-    Both "func_name" and "call" arguments are optional, and in that case, just
-    linking against the libs is tested.
-    "language" should be "C" or "C++" and is used to select the compiler.
-    Default is "C".
-    Note that this uses the current value of compiler and linker flags, make
-    sure $CFLAGS, $CPPFLAGS and $LIBS are set correctly.
-    Returns an empty string for success, an error message for failure.
-    """
-    # Include "confdefs.h" first, so that the header can use HAVE_HEADER_H.
-    if context.headerfilename:
-        includetext = '#include "%s"' % context.headerfilename
-    else:
-        includetext = ''
-    if not header:
-        header = ""
-
-    text = """
-%s
-%s""" % (includetext, header)
-
-    # Add a function declaration if needed.
-    if func_name and func_name != "main":
-        if not header:
-            text = text + """
-#ifdef __cplusplus
-extern "C"
-#endif
-char %s();
-""" % func_name
-
-        # The actual test code.
-        if not call:
-            call = "%s();" % func_name
-
-    # if no function to test, leave main() blank
-    text = text + """
-int
-main() {
-  %s
-return 0;
-}
-""" % (call or "")
-
-    if call:
-        i = string.find(call, "\n")
-        if i > 0:
-            calltext = call[:i] + ".."
-        elif call[-1] == ';':
-            calltext = call[:-1]
-        else:
-            calltext = call
-
-    for lib_name in libs:
-
-        lang, suffix, msg = _lang2suffix(language)
-        if msg:
-            context.Display("Cannot check for library %s: %s\n" % (lib_name, msg))
-            return msg
-
-        # if a function was specified to run in main(), say it
-        if call:
-                context.Display("Checking for %s in %s library %s... "
-                                % (calltext, lang, lib_name))
-        # otherwise, just say the name of library and language
-        else:
-                context.Display("Checking for %s library %s... "
-                                % (lang, lib_name))
-
-        if lib_name:
-            l = [ lib_name ]
-            if extra_libs:
-                l.extend(extra_libs)
-            if append:
-                oldLIBS = context.AppendLIBS(l)
-            else:
-                oldLIBS = context.PrependLIBS(l)
-            sym = "HAVE_LIB" + lib_name
-        else:
-            oldLIBS = -1
-            sym = None
-
-        ret = context.BuildProg(text, suffix)
-
-        _YesNoResult(context, ret, sym, text,
-                     "Define to 1 if you have the `%s' library." % lib_name)
-        if oldLIBS != -1 and (ret or not autoadd):
-            context.SetLIBS(oldLIBS)
-            
-        if not ret:
-            return ret
-
-    return ret
-
-#
-# END OF PUBLIC FUNCTIONS
-#
-
-def _YesNoResult(context, ret, key, text, comment = None):
-    """
-    Handle the result of a test with a "yes" or "no" result.
-    "ret" is the return value: empty if OK, error message when not.
-    "key" is the name of the symbol to be defined (HAVE_foo).
-    "text" is the source code of the program used for testing.
-    "comment" is the C comment to add above the line defining the symbol (the
-    comment is automatically put inside a /* */). If None, no comment is added.
-    """
-    if key:
-        _Have(context, key, not ret, comment)
-    if ret:
-        context.Display("no\n")
-        _LogFailed(context, text, ret)
-    else:
-        context.Display("yes\n")
-
-
-def _Have(context, key, have, comment = None):
-    """
-    Store result of a test in context.havedict and context.headerfilename.
-    "key" is a "HAVE_abc" name.  It is turned into all CAPITALS and non-
-    alphanumerics are replaced by an underscore.
-    The value of "have" can be:
-    1      - Feature is defined, add "#define key".
-    0      - Feature is not defined, add "/* #undef key */".
-             Adding "undef" is what autoconf does.  Not useful for the
-             compiler, but it shows that the test was done.
-    number - Feature is defined to this number "#define key have".
-             Doesn't work for 0 or 1, use a string then.
-    string - Feature is defined to this string "#define key have".
-             Give "have" as is should appear in the header file, include quotes
-             when desired and escape special characters!
-    """
-    key_up = string.upper(key)
-    key_up = re.sub('[^A-Z0-9_]', '_', key_up)
-    context.havedict[key_up] = have
-    if have == 1:
-        line = "#define %s 1\n" % key_up
-    elif have == 0:
-        line = "/* #undef %s */\n" % key_up
-    elif type(have) == IntType:
-        line = "#define %s %d\n" % (key_up, have)
-    else:
-        line = "#define %s %s\n" % (key_up, str(have))
-    
-    if comment is not None:
-        lines = "\n/* %s */\n" % comment + line
-    else:
-        lines = "\n" + line
-
-    if context.headerfilename:
-        f = open(context.headerfilename, "a")
-        f.write(lines)
-        f.close()
-    elif hasattr(context,'config_h'):
-        context.config_h = context.config_h + lines
-
-
-def _LogFailed(context, text, msg):
-    """
-    Write to the log about a failed program.
-    Add line numbers, so that error messages can be understood.
-    """
-    if LogInputFiles:
-        context.Log("Failed program was:\n")
-        lines = string.split(text, '\n')
-        if len(lines) and lines[-1] == '':
-            lines = lines[:-1]              # remove trailing empty line
-        n = 1
-        for line in lines:
-            context.Log("%d: %s\n" % (n, line))
-            n = n + 1
-    if LogErrorMessages:
-        context.Log("Error message: %s\n" % msg)
-
-
-def _lang2suffix(lang):
-    """
-    Convert a language name to a suffix.
-    When "lang" is empty or None C is assumed.
-    Returns a tuple (lang, suffix, None) when it works.
-    For an unrecognized language returns (None, None, msg).
-    Where:
-        lang   = the unified language name
-        suffix = the suffix, including the leading dot
-        msg    = an error message
-    """
-    if not lang or lang in ["C", "c"]:
-        return ("C", ".c", None)
-    if lang in ["c++", "C++", "cpp", "CXX", "cxx"]:
-        return ("C++", ".cpp", None)
-
-    return None, None, "Unsupported language: %s" % lang
-
-
-# vim: set sw=4 et sts=4 tw=79 fo+=l:
-
-# Local Variables:
-# tab-width:4
-# indent-tabs-mode:nil
-# End:
-# vim: set expandtab tabstop=4 shiftwidth=4: