# Autodetecting setup.py script for building the Python extensions

#

__version__ = "$Revision: 66914 $"

import sys, os, imp, re, optparse

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 build_extensions(self):

        # Detect which modules should be compiled

        self.detect_modules()

        # Remove modules that are present on the disabled list

        self.extensions = [ext for ext in self.extensions

                           if ext.name not in disabled_module_list]

        # 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

        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]

        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]

            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)

    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]))

            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

        # 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.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)

    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 is 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 = []

        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) )

        # random number generator implemented in C

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

        # fast iterator tools implemented in C

        exts.append( Extension("itertools", ["itertoolsmodule.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']) )

        # _functools

        exts.append( Extension("_functools", ["_functoolsmodule.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']) )

        # 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']) )

        # select(2); not on ancient System V

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

        # Helper module for various ascii-encoders

        exts.append( Extension('binascii', ['binascii.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']) )

        # Lance Ellinghaus's syslog module

        if platform not in ['mac']:

            # syslog daemon interface

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

        # George Neville-Neil's timing module:

        # Deprecated in PEP 4 http://www.python.org/peps/pep-0004.html

        # http://mail.python.org/pipermail/python-dev/2006-January/060023.html

        #exts.append( Extension('timing', ['timingmodule.c']) )

        #

        # Here ends the simple stuff.  From here on, modules need certain

        # libraries, are platform-specific, or present other surprises.

        #

        # Multimedia modules

        # These don't work for 64-bit platforms!!!

        # These represent audio samples or images as strings:

        # Operations on audio samples

        # According to #993173, this one should actually work fine on

        # 64-bit platforms.

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

        # Disabled on 64-bit platforms

        if sys.maxint != 9223372036854775807L:

            # Operations on images

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

            # Read SGI RGB image files (but coded portably)

            exts.append( Extension('rgbimg', ['rgbimgmodule.c']) )

        # readline

        do_readline = self.compiler.find_library_file(lib_dirs, 'readline')

        if platform == 'darwin':

            # MacOSX 10.4 has a broken readline. Don't try to build

            # the readline module unless the user has installed a fixed

            # readline package

            if find_file('readline/rlconf.h', inc_dirs, []) is None:

                do_readline = False

        if do_readline:

            if sys.platform == 'darwin':

                # In every directory on the search path search for a dynamic

                # library and then a static library, instead of first looking

                # for dynamic libraries on the entiry path.

                # This way a staticly linked custom readline gets picked up

                # before the (broken) dynamic library in /usr/lib.

                readline_extra_link_args = ('-Wl,-search_paths_first',)

            else:

                readline_extra_link_args = ()

            readline_libs = ['readline']

            if self.compiler.find_library_file(lib_dirs,

                                                 'ncursesw'):

                readline_libs.append('ncursesw')

            elif self.compiler.find_library_file(lib_dirs,

                                                 'ncurses'):

                readline_libs.append('ncurses')

            elif self.compiler.find_library_file(lib_dirs, 'curses'):

                readline_libs.append('curses')

            elif self.compiler.find_library_file(lib_dirs +

                                               ['/usr/lib/termcap'],

                                               'termcap'):

                readline_libs.append('termcap')

            exts.append( Extension('readline', ['readline.c'],

                                   library_dirs=['/usr/lib/termcap'],

                                   extra_link_args=readline_extra_link_args,

                                   libraries=readline_libs) )

        if platform not in ['mac']:

            # crypt module.

            if self.compiler.find_library_file(lib_dirs, 'crypt'):

                libs = ['crypt']

            else:

                libs = []

            exts.append( Extension('crypt', ['cryptmodule.c'], libraries=libs) )

        # CSV files

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

        # socket(2)

        exts.append( Extension('_socket', ['socketmodule.c'],

                               depends = ['socketmodule.h']) )

        # Detect SSL support for the socket module (via _ssl)

        search_for_ssl_incs_in = [

                              '/usr/local/ssl/include',

                              '/usr/contrib/ssl/include/'

                             ]

        ssl_incs = find_file('openssl/ssl.h', inc_dirs,

                             search_for_ssl_incs_in