# Autodetecting setup.py script for building the Python extensions

#

__version__ = "$Revision: 67099 $"

import sys, os, imp, re, optparse

from glob import glob

from platform import machine as platform_machine

from distutils import log

from distutils import sysconfig

from distutils import text_file

from distutils.errors import *

from distutils.core import Extension, setup

from distutils.command.build_ext import build_ext

from distutils.command.install import install

from distutils.command.install_lib import install_lib

# This global variable is used to hold the list of modules to be disabled.

disabled_module_list = []

def add_dir_to_list(dirlist, dir):

    """Add the directory 'dir' to the list 'dirlist' (at the front) if

    1) 'dir' is not already in 'dirlist'

    2) 'dir' actually exists, and is a directory."""

    if dir is not None and os.path.isdir(dir) and dir not in dirlist:

        dirlist.insert(0, dir)

def find_file(filename, std_dirs, paths):

    """Searches for the directory where a given file is located,

    and returns a possibly-empty list of additional directories, or None

    if the file couldn't be found at all.

    'filename' is the name of a file, such as readline.h or libcrypto.a.

    'std_dirs' is the list of standard system directories; if the

        file is found in one of them, no additional directives are needed.

    'paths' is a list of additional locations to check; if the file is

        found in one of them, the resulting list will contain the directory.

    """

    # Check the standard locations

    for dir in std_dirs:

        f = os.path.join(dir, filename)

        if os.path.exists(f): return []

    # Check the additional directories

    for dir in paths:

        f = os.path.join(dir, filename)

        if os.path.exists(f):

            return [dir]

    # Not found anywhere

    return None

def find_library_file(compiler, libname, std_dirs, paths):

    result = compiler.find_library_file(std_dirs + paths, libname)

    if result is None:

        return None

    # Check whether the found file is in one of the standard directories

    dirname = os.path.dirname(result)

    for p in std_dirs:

        # Ensure path doesn't end with path separator

        p = p.rstrip(os.sep)

        if p == dirname:

            return [ ]

    # Otherwise, it must have been in one of the additional directories,

    # so we have to figure out which one.

    for p in paths:

        # Ensure path doesn't end with path separator

        p = p.rstrip(os.sep)

        if p == dirname:

            return [p]

    else:

        assert False, "Internal error: Path not found in std_dirs or paths"

def module_enabled(extlist, modname):

    """Returns whether the module 'modname' is present in the list

    of extensions 'extlist'."""

    extlist = [ext for ext in extlist if ext.name == modname]

    return len(extlist)

def find_module_file(module, dirlist):

    """Find a module in a set of possible folders. If it is not found

    return the unadorned filename"""

    list = find_file(module, [], dirlist)

    if not list:

        return module

    if len(list) > 1:

        log.info("WARNING: multiple copies of %s found"%module)

    return os.path.join(list[0], module)

class PyBuildExt(build_ext):

    def __init__(self, dist):

        build_ext.__init__(self, dist)

        self.failed = []

    def build_extensions(self):

        # Detect which modules should be compiled

        missing = self.detect_modules()

        # Remove modules that are present on the disabled list

        extensions = [ext for ext in self.extensions

                      if ext.name not in disabled_module_list]

        # move ctypes to the end, it depends on other modules

        ext_map = dict((ext.name, i) for i, ext in enumerate(extensions))

        if "_ctypes" in ext_map:

            ctypes = extensions.pop(ext_map["_ctypes"])

            extensions.append(ctypes)

        self.extensions = extensions

        # Fix up the autodetected modules, prefixing all the source files

        # with Modules/ and adding Python's include directory to the path.

        (srcdir,) = sysconfig.get_config_vars('srcdir')

        if not srcdir:

            # Maybe running on Windows but not using CYGWIN?

            raise ValueError("No source directory; cannot proceed.")

        # Figure out the location of the source code for extension modules

        # (This logic is copied in distutils.test.test_sysconfig,

        # so building in a separate directory does not break test_distutils.)

        moddir = os.path.join(os.getcwd(), srcdir, 'Modules')

        moddir = os.path.normpath(moddir)

        srcdir, tail = os.path.split(moddir)

        srcdir = os.path.normpath(srcdir)

        moddir = os.path.normpath(moddir)

        moddirlist = [moddir]

        incdirlist = ['./Include']

        # Platform-dependent module source and include directories

        platform = self.get_platform()

        if platform in ('darwin', 'mac') and ("--disable-toolbox-glue" not in

            sysconfig.get_config_var("CONFIG_ARGS")):

            # Mac OS X also includes some mac-specific modules

            macmoddir = os.path.join(os.getcwd(), srcdir, 'Mac/Modules')

            moddirlist.append(macmoddir)

            incdirlist.append('./Mac/Include')

        alldirlist = moddirlist + incdirlist

        # Fix up the paths for scripts, too

        self.distribution.scripts = [os.path.join(srcdir, filename)

                                     for filename in self.distribution.scripts]

        # Python header files

        headers = glob("Include/*.h") + ["pyconfig.h"]

        for ext in self.extensions[:]:

            ext.sources = [ find_module_file(filename, moddirlist)

                            for filename in ext.sources ]

            if ext.depends is not None:

                ext.depends = [find_module_file(filename, alldirlist)

                               for filename in ext.depends]

            else:

                ext.depends = []

            # re-compile extensions if a header file has been changed

            ext.depends.extend(headers)

            ext.include_dirs.append( '.' ) # to get config.h

            for incdir in incdirlist:

                ext.include_dirs.append( os.path.join(srcdir, incdir) )

            # If a module has already been built statically,

            # don't build it here

            if ext.name in sys.builtin_module_names:

                self.extensions.remove(ext)

        if platform != 'mac':

            # Parse Modules/Setup and Modules/Setup.local to figure out which

            # modules are turned on in the file.

            remove_modules = []

            for filename in ('Modules/Setup', 'Modules/Setup.local'):

                input = text_file.TextFile(filename, join_lines=1)

                while 1:

                    line = input.readline()

                    if not line: break

                    line = line.split()

                    remove_modules.append(line[0])

                input.close()

            for ext in self.extensions[:]:

                if ext.name in remove_modules:

                    self.extensions.remove(ext)

        # When you run "make CC=altcc" or something similar, you really want

        # those environment variables passed into the setup.py phase.  Here's

        # a small set of useful ones.

        compiler = os.environ.get('CC')

        args = {}

        # unfortunately, distutils doesn't let us provide separate C and C++

        # compilers

        if compiler is not None:

            (ccshared,cflags) = sysconfig.get_config_vars('CCSHARED','CFLAGS')

            args['compiler_so'] = compiler + ' ' + ccshared + ' ' + cflags

        self.compiler.set_executables(**args)

        build_ext.build_extensions(self)

        longest = max([len(e.name) for e in self.extensions])

        if self.failed:

            longest = max(longest, max([len(name) for name in self.failed]))

        def print_three_column(lst):

            lst.sort(key=str.lower)

            # guarantee zip() doesn't drop anything

            while len(lst) % 3:

                lst.append("")

            for e, f, g in zip(lst[::3], lst[1::3], lst[2::3]):

                print "%-*s   %-*s   %-*s" % (longest, e, longest, f,

                                              longest, g)

        if missing:

            print

            print "Failed to find the necessary bits to build these modules:"

            print_three_column(missing)

            print ("To find the necessary bits, look in setup.py in"

                   " detect_modules() for the module's name.")

            print

        if self.failed:

            failed = self.failed[:]

            print

            print "Failed to build these modules:"

            print_three_column(failed)

            print

    def build_extension(self, ext):

        if ext.name == '_ctypes':

            if not self.configure_ctypes(ext):

                return

        try:

            build_ext.build_extension(self, ext)

        except (CCompilerError, DistutilsError), why:

            self.announce('WARNING: building of extension "%s" failed: %s' %

                          (ext.name, sys.exc_info()[1]))

            self.failed.append(ext.name)

            return

        # Workaround for Mac OS X: The Carbon-based modules cannot be

        # reliably imported into a command-line Python

        if 'Carbon' in ext.extra_link_args:

            self.announce(

                'WARNING: skipping import check for Carbon-based "%s"' %

                ext.name)

            return

        if self.get_platform() == 'darwin' and (

                sys.maxint > 2**32 and '-arch' in ext.extra_link_args):

            # Don't bother doing an import check when an extension was

            # build with an explicit '-arch' flag on OSX. That's currently

            # only used to build 32-bit only extensions in a 4-way

            # universal build and loading 32-bit code into a 64-bit

            # process will fail.

            self.announce(

                'WARNING: skipping import check for "%s"' %

                ext.name)

            return

        # Workaround for Cygwin: Cygwin currently has fork issues when many

        # modules have been imported

        if self.get_platform() == 'cygwin':

            self.announce('WARNING: skipping import check for Cygwin-based "%s"'

                % ext.name)

            return

        ext_filename = os.path.join(

            self.build_lib,

            self.get_ext_filename(self.get_ext_fullname(ext.name)))

        try:

            imp.load_dynamic(ext.name, ext_filename)

        except ImportError, why:

            self.failed.append(ext.name)

            self.announce('*** WARNING: renaming "%s" since importing it'

                          ' failed: %s' % (ext.name, why), level=3)

            assert not self.inplace

            basename, tail = os.path.splitext(ext_filename)

            newname = basename + "_failed" + tail

            if os.path.exists(newname):

                os.remove(newname)

            os.rename(ext_filename, newname)

            # XXX -- This relies on a Vile HACK in

            # distutils.command.build_ext.build_extension().  The

            # _built_objects attribute is stored there strictly for

            # use here.

            # If there is a failure, _built_objects may not be there,

            # so catch the AttributeError and move on.

            try:

                for filename in self._built_objects:

                    os.remove(filename)

            except AttributeError:

                self.announce('unable to remove files (ignored)')

        except:

            exc_type, why, tb = sys.exc_info()

            self.announce('*** WARNING: importing extension "%s" '

                          'failed with %s: %s' % (ext.name, exc_type, why),

                          level=3)

            self.failed.append(ext.name)

    def get_platform(self):

        # Get value of sys.platform

        for platform in ['cygwin', 'beos', 'darwin', 'atheos', 'osf1']:

            if sys.platform.startswith(platform):

                return platform

        return sys.platform

    def detect_modules(self):

        # Ensure that /usr/local is always used

        add_dir_to_list(self.compiler.library_dirs, '/usr/local/lib')

        add_dir_to_list(self.compiler.include_dirs, '/usr/local/include')

        # Add paths specified in the environment variables LDFLAGS and

        # CPPFLAGS for header and library files.

        # We must get the values from the Makefile and not the environment

        # directly since an inconsistently reproducible issue comes up where

        # the environment variable is not set even though the value were passed

        # into configure and stored in the Makefile (issue found on OS X 10.3).

        for env_var, arg_name, dir_list in (

                ('LDFLAGS', '-R', self.compiler.runtime_library_dirs),

                ('LDFLAGS', '-L', self.compiler.library_dirs),

                ('CPPFLAGS', '-I', self.compiler.include_dirs)):

            env_val = sysconfig.get_config_var(env_var)

            if env_val:

                # To prevent optparse from raising an exception about any

                # options in env_val that it doesn't know about we strip out

                # all double dashes and any dashes followed by a character

                # that is not for the option we are dealing with.

                #

                # Please note that order of the regex is important!  We must

                # strip out double-dashes first so that we don't end up with

                # substituting "--Long" to "-Long" and thus lead to "ong" being

                # used for a library directory.

                env_val = re.sub(r'(^|\s+)-(-|(?!%s))' % arg_name[1],

                                 ' ', env_val)

                parser = optparse.OptionParser()

                # Make sure that allowing args interspersed with options is

                # allowed

                parser.allow_interspersed_args = True

                parser.error = lambda msg: None

                parser.add_option(arg_name, dest="dirs", action="append")

                options = parser.parse_args(env_val.split())[0]

                if options.dirs:

                    for directory in reversed(options.dirs):

                        add_dir_to_list(dir_list, directory)

        if os.path.normpath(sys.prefix) != '/usr':

            add_dir_to_list(self.compiler.library_dirs,

                            sysconfig.get_config_var("LIBDIR"))

            add_dir_to_list(self.compiler.include_dirs,

                            sysconfig.get_config_var("INCLUDEDIR"))

        try:

            have_unicode = unicode

        except NameError:

            have_unicode = 0

        # lib_dirs and inc_dirs are used to search for files;

        # if a file is found in one of those directories, it can

        # be assumed that no additional -I,-L directives are needed.

        lib_dirs = self.compiler.library_dirs + [

            '/lib64', '/usr/lib64',

            '/lib', '/usr/lib',

            ]

        inc_dirs = self.compiler.include_dirs + ['/usr/include']

        exts = []

        missing = []

        config_h = sysconfig.get_config_h_filename()

        config_h_vars = sysconfig.parse_config_h(open(config_h))

        platform = self.get_platform()

        (srcdir,) = sysconfig.get_config_vars('srcdir')

        # Check for AtheOS which has libraries in non-standard locations

        if platform == 'atheos':

            lib_dirs += ['/system/libs', '/atheos/autolnk/lib']

            lib_dirs += os.getenv('LIBRARY_PATH', '').split(os.pathsep)

            inc_dirs += ['/system/include', '/atheos/autolnk/include']

            inc_dirs += os.getenv('C_INCLUDE_PATH', '').split(os.pathsep)

        # OSF/1 and Unixware have some stuff in /usr/ccs/lib (like -ldb)

        if platform in ['osf1', 'unixware7', 'openunix8']:

            lib_dirs += ['/usr/ccs/lib']

        if platform == 'darwin':

            # This should work on any unixy platform ;-)

            # If the user has bothered specifying additional -I and -L flags

            # in OPT and LDFLAGS we might as well use them here.

            #   NOTE: using shlex.split would technically be more correct, but

            # also gives a bootstrap problem. Let's hope nobody uses directories

            # with whitespace in the name to store libraries.

            cflags, ldflags = sysconfig.get_config_vars(

                    'CFLAGS', 'LDFLAGS')

            for item in cflags.split():

                if item.startswith('-I'):

                    inc_dirs.append(item[2:])

            for item in ldflags.split():

                if item.startswith('-L'):

                    lib_dirs.append(item[2:])

        # Check for MacOS X, which doesn't need libm.a at all

        math_libs = ['m']

        if platform in ['darwin', 'beos', 'mac']:

            math_libs = []

        # XXX Omitted modules: gl, pure, dl, SGI-specific modules

        #

        # The following modules are all pretty straightforward, and compile

        # on pretty much any POSIXish platform.

        #

        # Some modules that are normally always on:

        exts.append( Extension('_weakref', ['_weakref.c']) )

        # array objects

        exts.append( Extension('array', ['arraymodule.c']) )

        # complex math library functions

        exts.append( Extension('cmath', ['cmathmodule.c'],

                               libraries=math_libs) )

        # math library functions, e.g. sin()

        exts.append( Extension('math',  ['mathmodule.c'],

                               libraries=math_libs) )

        # fast string operations implemented in C

        exts.append( Extension('strop', ['stropmodule.c']) )

        # time operations and variables

        exts.append( Extension('time', ['timemodule.c'],

                               libraries=math_libs) )

        exts.append( Extension('datetime', ['datetimemodule.c', 'timemodule.c'],

                               libraries=math_libs) )

        # fast iterator tools implemented in C

        exts.append( Extension("itertools", ["itertoolsmodule.c"]) )

        # code that will be builtins in the future, but conflict with the

        #  current builtins

        exts.append( Extension('future_builtins', ['future_builtins.c']) )

        # random number generator implemented in C

        exts.append( Extension("_random", ["_randommodule.c"]) )

        # high-performance collections

        exts.append( Extension("_collections", ["_collectionsmodule.c"]) )

        # bisect

        exts.append( Extension("_bisect", ["_bisectmodule.c"]) )

        # heapq

        exts.append( Extension("_heapq", ["_heapqmodule.c"]) )

        # operator.add() and similar goodies

        exts.append( Extension('operator', ['operator.c']) )

        # Python 3.0 _fileio module

        exts.append( Extension("_fileio", ["_fileio.c"]) )

        # Python 3.0 _bytesio module

        exts.append( Extension("_bytesio", ["_bytesio.c"]) )

        # _functools

        exts.append( Extension("_functools", ["_functoolsmodule.c"]) )

        # _json speedups

        exts.append( Extension("_json", ["_json.c"]) )

        # Python C API test module

        exts.append( Extension('_testcapi', ['_testcapimodule.c']) )

        # profilers (_lsprof is for cProfile.py)

        exts.append( Extension('_hotshot', ['_hotshot.c']) )

        exts.append( Extension('_lsprof', ['_lsprof.c', 'rotatingtree.c']) )

        # static Unicode character database

        if have_unicode:

            exts.append( Extension('unicodedata', ['unicodedata.c']) )

        else:

            missing.append('unicodedata')

        # access to ISO C locale support

        data = open('pyconfig.h').read()

        m = re.search(r"#s*define\s+WITH_LIBINTL\s+1\s*", data)

        if m is not None:

            locale_libs = ['intl']

        else:

            locale_libs = []

        if platform == 'darwin':

            locale_extra_link_args = ['-framework', 'CoreFoundation']

        else:

            locale_extra_link_args = []

        exts.append( Extension('_locale', ['_localemodule.c'],

                               libraries=locale_libs,

                               extra_link_args=locale_extra_link_args) )

        # Modules with some UNIX dependencies -- on by default:

        # (If you have a really backward UNIX, select and socket may not be

        # supported...)

        # fcntl(2) and ioctl(2)

        exts.append( Extension('fcntl', ['fcntlmodule.c']) )

        if platform not in ['mac']:

            # pwd(3)

            exts.append( Extension('pwd', ['pwdmodule.c']) )

            # grp(3)

            exts.append( Extension('grp', ['grpmodule.c']) )

            # spwd, shadow passwords

            if (config_h_vars.get('HAVE_GETSPNAM', False) or

                    config_h_vars.get('HAVE_GETSPENT', False)):

                exts.append( Extension('spwd', ['spwdmodule.c']) )

            else:

                missing.append('spwd')

        else:

            missing.extend(['pwd', 'grp', 'spwd'])

        # select(2); not on ancient System V

        exts.append( Extension('select', ['selectmodule.c']) )

        # Fred Drake's interface to the Python parser

        exts.append( Extension('parser', ['parsermodule.c']) )

        # cStringIO and cPickle

        exts.append( Extension('cStringIO', ['cStringIO.c']) )

        exts.append( Extension('cPickle', ['cPickle.c']) )

        # Memory-mapped files (also works on Win32).

        if platform not in ['atheos', 'mac']:

            exts.append( Extension('mmap', ['mmapmodule.c']) )

        else:

            missing.append('mmap')

        # Lance Ellinghaus's syslog module

        if platform not in ['mac']:

            # syslog daemon interface

            exts.append( Extension('syslog', ['syslogmodule.c']) )

        else:

            missing.append('syslog')