setup.py 30.2 KB
Newer Older
1 2
# Autodetecting setup.py script for building the Python extensions
#
3

4 5 6
__version__ = "$Revision$"

import sys, os, getopt
7
from distutils import sysconfig
8
from distutils import text_file
9
from distutils.errors import *
10 11
from distutils.core import Extension, setup
from distutils.command.build_ext import build_ext
12
from distutils.command.install import install
13 14 15 16

# This global variable is used to hold the list of modules to be disabled.
disabled_module_list = []

17 18 19 20
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.
21

22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40
    '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
41 42
    return None

43 44 45 46
def find_library_file(compiler, libname, std_dirs, paths):
    filename = compiler.library_filename(libname, lib_type='shared')
    result = find_file(filename, std_dirs, paths)
    if result is not None: return result
47

48 49 50 51
    filename = compiler.library_filename(libname, lib_type='static')
    result = find_file(filename, std_dirs, paths)
    return result

52 53 54 55 56
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)
57

58 59 60 61 62 63 64 65 66 67
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:
        self.announce("WARNING: multiple copies of %s found"%module)
    return os.path.join(list[0], module)
    
68
class PyBuildExt(build_ext):
69

70 71 72 73 74 75 76 77
    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]
78

79 80 81 82
        # 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')

83 84
        # Figure out the location of the source code for extension modules
        moddir = os.path.join(os.getcwd(), srcdir, 'Modules')
85 86 87 88
        moddir = os.path.normpath(moddir)
        srcdir, tail = os.path.split(moddir)
        srcdir = os.path.normpath(srcdir)
        moddir = os.path.normpath(moddir)
89 90 91 92 93 94 95 96 97 98 99
        
        moddirlist = [moddir]
        incdirlist = ['./Include']
        
        # Platform-dependent module source and include directories
        platform = self.get_platform()
        if platform == 'darwin1':
            # 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')
100

101 102 103 104
        # Fix up the paths for scripts, too
        self.distribution.scripts = [os.path.join(srcdir, filename)
                                     for filename in self.distribution.scripts]

105
        for ext in self.extensions[:]:
106
            ext.sources = [ find_module_file(filename, moddirlist)
107
                            for filename in ext.sources ]
108 109 110
            ext.include_dirs.append( '.' ) # to get config.h
            for incdir in incdirlist:
                ext.include_dirs.append( os.path.join(srcdir, incdir) )
111

112
            # If a module has already been built statically,
113
            # don't build it here
114
            if ext.name in sys.builtin_module_names:
115
                self.extensions.remove(ext)
116

117 118 119 120 121 122 123 124 125 126 127 128 129 130 131
        # Parse Modules/Setup to figure out which modules are turned
        # on in the file. 
        input = text_file.TextFile('Modules/Setup', join_lines=1)
        remove_modules = []
        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)
        
132 133 134 135 136 137 138 139 140
        # 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')
        linker_so = os.environ.get('LDSHARED')
        args = {}
        # unfortunately, distutils doesn't let us provide separate C and C++
        # compilers
        if compiler is not None:
141 142
            (ccshared,opt) = sysconfig.get_config_vars('CCSHARED','OPT')
            args['compiler_so'] = compiler + ' ' + opt + ' ' + ccshared
143
        if linker_so is not None:
144
            args['linker_so'] = linker_so
145 146
        self.compiler.set_executables(**args)

147 148
        build_ext.build_extensions(self)

149 150 151 152 153 154 155
    def build_extension(self, ext):

        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]))
156 157 158 159 160 161 162 163 164 165 166
            return
        try:
            __import__(ext.name)
        except ImportError:
            self.announce('WARNING: removing "%s" since importing it failed' %
                          ext.name)
            assert not self.inplace
            fullname = self.get_ext_fullname(ext.name)
            ext_filename = os.path.join(self.build_lib,
                                        self.get_ext_filename(fullname))
            os.remove(ext_filename)
167

168
    def get_platform (self):
169 170 171 172
        # Get value of sys.platform
        platform = sys.platform
        if platform[:6] =='cygwin':
            platform = 'cygwin'
173 174
        elif platform[:4] =='beos':
            platform = 'beos'
175

176
        return platform
177

178
    def detect_modules(self):
179
        # Ensure that /usr/local is always used
180
        if '/usr/local/lib' not in self.compiler.library_dirs:
181
            self.compiler.library_dirs.insert(0, '/usr/local/lib')
182
        if '/usr/local/include' not in self.compiler.include_dirs:
183
            self.compiler.include_dirs.insert(0, '/usr/local/include' )
184

185 186 187 188 189
        try:
            have_unicode = unicode
        except NameError:
            have_unicode = 0

190 191 192 193
        # 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 + ['/lib', '/usr/lib']
194
        inc_dirs = self.compiler.include_dirs + ['/usr/include'] 
195 196
        exts = []

197
        platform = self.get_platform()
198
        
199 200
        # Check for MacOS X, which doesn't need libm.a at all
        math_libs = ['m']
201
        if platform in ['Darwin1.2', 'beos']:
202
            math_libs = []
203
        
204 205 206 207 208 209
        # XXX Omitted modules: gl, pure, dl, SGI-specific modules

        #
        # The following modules are all pretty straightforward, and compile
        # on pretty much any POSIXish platform.
        #
210

211 212 213
        # Some modules that are normally always on:
        exts.append( Extension('regex', ['regexmodule.c', 'regexpr.c']) )
        exts.append( Extension('pcre', ['pcremodule.c', 'pypcre.c']) )
214

215
        exts.append( Extension('_weakref', ['_weakref.c']) )
216
        exts.append( Extension('_symtable', ['symtablemodule.c']) )
Andrew M. Kuchling's avatar
Andrew M. Kuchling committed
217
        exts.append( Extension('xreadlines', ['xreadlinesmodule.c']) )
218 219 220 221

        # array objects
        exts.append( Extension('array', ['arraymodule.c']) )
        # complex math library functions
222 223
        exts.append( Extension('cmath', ['cmathmodule.c'],
                               libraries=math_libs) )
224

225
        # math library functions, e.g. sin()
226 227
        exts.append( Extension('math',  ['mathmodule.c'],
                               libraries=math_libs) )
228 229 230
        # fast string operations implemented in C
        exts.append( Extension('strop', ['stropmodule.c']) )
        # time operations and variables
231 232
        exts.append( Extension('time', ['timemodule.c'],
                               libraries=math_libs) )
233 234 235 236
        # operator.add() and similar goodies
        exts.append( Extension('operator', ['operator.c']) )
        # access to the builtin codecs and codec registry
        exts.append( Extension('_codecs', ['_codecsmodule.c']) )
237
        # Python C API test module
238
        exts.append( Extension('_testcapi', ['_testcapimodule.c']) )
239
        # static Unicode character database
240 241
        if have_unicode:
            exts.append( Extension('unicodedata', ['unicodedata.c']) )
242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291
        # access to ISO C locale support
        exts.append( Extension('_locale', ['_localemodule.c']) )

        # 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']) )
        # pwd(3)
        exts.append( Extension('pwd', ['pwdmodule.c']) )
        # grp(3)
        exts.append( Extension('grp', ['grpmodule.c']) )
        # posix (UNIX) errno values
        exts.append( Extension('errno', ['errnomodule.c']) )
        # select(2); not on ancient System V
        exts.append( Extension('select', ['selectmodule.c']) )

        # The md5 module implements the RSA Data Security, Inc. MD5
        # Message-Digest Algorithm, described in RFC 1321.  The necessary files
        # md5c.c and md5.h are included here.
        exts.append( Extension('md5', ['md5module.c', 'md5c.c']) )

        # The sha module implements the SHA checksum algorithm.
        # (NIST's Secure Hash Algorithm.)
        exts.append( Extension('sha', ['shamodule.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']) )

        # Digital Creations' cStringIO and cPickle
        exts.append( Extension('cStringIO', ['cStringIO.c']) )
        exts.append( Extension('cPickle', ['cPickle.c']) )

        # Memory-mapped files (also works on Win32).
        exts.append( Extension('mmap', ['mmapmodule.c']) )

        # Lance Ellinghaus's modules:
        # enigma-inspired encryption
        exts.append( Extension('rotor', ['rotormodule.c']) )
        # syslog daemon interface
        exts.append( Extension('syslog', ['syslogmodule.c']) )

        # George Neville-Neil's timing module:
        exts.append( Extension('timing', ['timingmodule.c']) )

        #
292 293
        # Here ends the simple stuff.  From here on, modules need certain
        # libraries, are platform-specific, or present other surprises.
294 295 296 297 298 299
        #

        # Multimedia modules
        # These don't work for 64-bit platforms!!!
        # These represent audio samples or images as strings:

300
        # Disabled on 64-bit platforms
301 302 303 304 305 306 307 308 309
        if sys.maxint != 9223372036854775807L:
            # Operations on audio samples
            exts.append( Extension('audioop', ['audioop.c']) )
            # Operations on images
            exts.append( Extension('imageop', ['imageop.c']) )
            # Read SGI RGB image files (but coded portably)
            exts.append( Extension('rgbimg', ['rgbimgmodule.c']) )

        # readline
310 311
        if self.compiler.find_library_file(lib_dirs, 'readline'):
            readline_libs = ['readline']
312 313 314 315
            if self.compiler.find_library_file(lib_dirs,
                                                 'ncurses'):
                readline_libs.append('ncurses')
            elif self.compiler.find_library_file(lib_dirs +
316 317 318
                                               ['/usr/lib/termcap'],
                                               'termcap'):
                readline_libs.append('termcap')
319
            exts.append( Extension('readline', ['readline.c'],
320
                                   library_dirs=['/usr/lib/termcap'],
321
                                   libraries=readline_libs) )
322

323
        # crypt module.
324 325 326 327 328 329 330 331 332

        if self.compiler.find_library_file(lib_dirs, 'crypt'):
            libs = ['crypt']
        else:
            libs = []
        exts.append( Extension('crypt', ['cryptmodule.c'], libraries=libs) )

        # socket(2)
        # Detect SSL support for the socket module
333
        ssl_incs = find_file('openssl/ssl.h', inc_dirs,
334 335 336
                             ['/usr/local/ssl/include',
                              '/usr/contrib/ssl/include/'
                             ]
337 338
                             )
        ssl_libs = find_library_file(self.compiler, 'ssl',lib_dirs,
339 340 341
                                     ['/usr/local/ssl/lib',
                                      '/usr/contrib/ssl/lib/'
                                     ] )
342

343 344
        if (ssl_incs is not None and
            ssl_libs is not None):
345
            exts.append( Extension('_socket', ['socketmodule.c'],
346
                                   include_dirs = ssl_incs,
347
                                   library_dirs = ssl_libs,
348 349 350 351 352 353 354 355 356 357 358 359 360
                                   libraries = ['ssl', 'crypto'],
                                   define_macros = [('USE_SSL',1)] ) )
        else:
            exts.append( Extension('_socket', ['socketmodule.c']) )

        # Modules that provide persistent dictionary-like semantics.  You will
        # probably want to arrange for at least one of them to be available on
        # your machine, though none are defined by default because of library
        # dependencies.  The Python module anydbm.py provides an
        # implementation independent wrapper for these; dumbdbm.py provides
        # similar functionality (but slower of course) implemented in Python.

        # The standard Unix dbm module:
361 362 363 364 365 366
        if platform not in ['cygwin']:
            if (self.compiler.find_library_file(lib_dirs, 'ndbm')):
                exts.append( Extension('dbm', ['dbmmodule.c'],
                                       libraries = ['ndbm'] ) )
            else:
                exts.append( Extension('dbm', ['dbmmodule.c']) )
367

368 369 370 371 372 373 374 375 376 377 378 379 380
        # Anthony Baxter's gdbm module.  GNU dbm(3) will require -lgdbm:
        if (self.compiler.find_library_file(lib_dirs, 'gdbm')):
            exts.append( Extension('gdbm', ['gdbmmodule.c'],
                                   libraries = ['gdbm'] ) )

        # Berkeley DB interface.
        #
        # This requires the Berkeley DB code, see
        # ftp://ftp.cs.berkeley.edu/pub/4bsd/db.1.85.tar.gz
        #
        # Edit the variables DB and DBPORT to point to the db top directory
        # and the subdirectory of PORT where you built it.
        #
381 382
        # (See http://pybsddb.sourceforge.net/ for an interface to
        # Berkeley DB 3.x.)
383

384
        dblib = []
385 386 387 388 389 390 391
        if self.compiler.find_library_file(lib_dirs, 'db-3.1'):
            dblib = ['db-3.1']
        elif self.compiler.find_library_file(lib_dirs, 'db2'):
            dblib = ['db2']
        elif self.compiler.find_library_file(lib_dirs, 'db1'):
            dblib = ['db1']
        elif self.compiler.find_library_file(lib_dirs, 'db'):
392 393 394 395 396 397
            dblib = ['db']
        
        db185_incs = find_file('db_185.h', inc_dirs,
                               ['/usr/include/db3', '/usr/include/db2'])
        db_inc = find_file('db.h', inc_dirs, ['/usr/include/db1'])
        if db185_incs is not None:
398
            exts.append( Extension('bsddb', ['bsddbmodule.c'],
399 400 401 402 403 404 405
                                   include_dirs = db185_incs,
                                   define_macros=[('HAVE_DB_185_H',1)],
                                   libraries = dblib ) )
        elif db_inc is not None:
            exts.append( Extension('bsddb', ['bsddbmodule.c'],
                                   include_dirs = db_inc,
                                   libraries = dblib) )
406 407

        # The mpz module interfaces to the GNU Multiple Precision library.
408
        # You need to ftp the GNU MP library.
409 410 411 412 413
        # This was originally written and tested against GMP 1.2 and 1.3.2.
        # It has been modified by Rob Hooft to work with 2.0.2 as well, but I
        # haven't tested it recently.   For a more complete module,
        # refer to pympz.sourceforge.net.

414
        # A compatible MP library unencumbered by the GPL also exists.  It was
415 416 417 418 419 420 421 422 423 424
        # posted to comp.sources.misc in volume 40 and is widely available from
        # FTP archive sites. One URL for it is:
        # ftp://gatekeeper.dec.com/.b/usenet/comp.sources.misc/volume40/fgmp/part01.Z

        if (self.compiler.find_library_file(lib_dirs, 'gmp')):
            exts.append( Extension('mpz', ['mpzmodule.c'],
                                   libraries = ['gmp'] ) )


        # Unix-only modules
425
        if platform not in ['mac', 'win32']:
426 427 428
            # Steen Lumholt's termios module
            exts.append( Extension('termios', ['termios.c']) )
            # Jeremy Hylton's rlimit interface
429
            exts.append( Extension('resource', ['resource.c']) )
430

431
            # Sun yellow pages. Some systems have the functions in libc.
432 433 434 435 436 437 438
            if platform not in ['cygwin']:
                if (self.compiler.find_library_file(lib_dirs, 'nsl')):
                    libs = ['nsl']
                else:
                    libs = []
                exts.append( Extension('nis', ['nismodule.c'],
                                       libraries = libs) )
439 440

        # Curses support, requring the System V version of curses, often
441
        # provided by the ncurses library.
442
        if platform == 'sunos4':
443
            inc_dirs += ['/usr/5include']
444 445 446 447 448 449
            lib_dirs += ['/usr/5lib']

        if (self.compiler.find_library_file(lib_dirs, 'ncurses')):
            curses_libs = ['ncurses']
            exts.append( Extension('_curses', ['_cursesmodule.c'],
                                   libraries = curses_libs) )
450 451
        elif (self.compiler.find_library_file(lib_dirs, 'curses')) and platform != 'darwin1':
        	# OSX has an old Berkeley curses, not good enough for the _curses module.
452 453 454 455
            if (self.compiler.find_library_file(lib_dirs, 'terminfo')):
                curses_libs = ['curses', 'terminfo']
            else:
                curses_libs = ['curses', 'termcap']
456

457 458
            exts.append( Extension('_curses', ['_cursesmodule.c'],
                                   libraries = curses_libs) )
459

460 461 462 463 464 465
        # If the curses module is enabled, check for the panel module
        if (os.path.exists('Modules/_curses_panel.c') and
            module_enabled(exts, '_curses') and
            self.compiler.find_library_file(lib_dirs, 'panel')):
            exts.append( Extension('_curses_panel', ['_curses_panel.c'],
                                   libraries = ['panel'] + curses_libs) )
466 467


468 469 470 471 472

        # Lee Busby's SIGFPE modules.
        # The library to link fpectl with is platform specific.
        # Choose *one* of the options below for fpectl:

473
        if platform == 'irix5':
474 475 476
            # For SGI IRIX (tested on 5.3):
            exts.append( Extension('fpectl', ['fpectlmodule.c'],
                                   libraries=['fpe']) )
477
        elif 0: # XXX how to detect SunPro?
478 479 480 481 482 483 484 485 486 487 488 489 490
            # For Solaris with SunPro compiler (tested on Solaris 2.5 with SunPro C 4.2):
            # (Without the compiler you don't have -lsunmath.)
            #fpectl fpectlmodule.c -R/opt/SUNWspro/lib -lsunmath -lm
            pass
        else:
            # For other systems: see instructions in fpectlmodule.c.
            #fpectl fpectlmodule.c ...
            exts.append( Extension('fpectl', ['fpectlmodule.c']) )


        # Andrew Kuchling's zlib module.
        # This require zlib 1.1.3 (or later).
        # See http://www.cdrom.com/pub/infozip/zlib/
491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507
        zlib_inc = find_file('zlib.h', [], inc_dirs)
        if zlib_inc is not None:
            zlib_h = zlib_inc[0] + '/zlib.h'
            version = '"0.0.0"'
            version_req = '"1.1.3"'
            fp = open(zlib_h)
            while 1:
                line = fp.readline()
                if not line:
                    break
                if line.find('#define ZLIB_VERSION', 0) == 0:
                    version = line.split()[2]
                    break
            if version >= version_req:
                if (self.compiler.find_library_file(lib_dirs, 'z')):
                    exts.append( Extension('zlib', ['zlibmodule.c'],
                                           libraries = ['z']) )
508 509 510 511 512 513 514

        # Interface to the Expat XML parser
        #
        # Expat is written by James Clark and must be downloaded separately
        # (see below).  The pyexpat module was written by Paul Prescod after a
        # prototype by Jack Jansen.
        #
515 516 517
        # The Expat dist includes Windows .lib and .dll files.  Home page is
        # at http://www.jclark.com/xml/expat.html, the current production
        # release is always ftp://ftp.jclark.com/pub/xml/expat.zip.
518 519 520 521
        #
        # EXPAT_DIR, below, should point to the expat/ directory created by
        # unpacking the Expat source distribution.
        #
522 523 524 525
        # Note: the expat build process doesn't yet build a libexpat.a; you
        # can do this manually while we try convince the author to add it.  To
        # do so, cd to EXPAT_DIR, run "make" if you have not done so, then
        # run:
526 527 528
        #
        #    ar cr libexpat.a xmltok/*.o xmlparse/*.o
        #
529 530 531 532 533 534 535
        expat_defs = []
        expat_incs = find_file('expat.h', inc_dirs, [])
        if expat_incs is not None:
            # expat.h was found
            expat_defs = [('HAVE_EXPAT_H', 1)]
        else:
            expat_incs = find_file('xmlparse.h', inc_dirs, [])
536

537
        if (expat_incs is not None and
538 539 540 541
            self.compiler.find_library_file(lib_dirs, 'expat')):
            exts.append( Extension('pyexpat', ['pyexpat.c'],
                                   define_macros = expat_defs,
                                   libraries = ['expat']) )
542 543

        # Platform-specific libraries
544
        if platform == 'linux2':
545 546 547
            # Linux-specific modules
            exts.append( Extension('linuxaudiodev', ['linuxaudiodev.c']) )

548
        if platform == 'sunos5':
549
            # SunOS specific modules
550
            exts.append( Extension('sunaudiodev', ['sunaudiodev.c']) )
551 552 553 554 555 556
        
        if platform == 'darwin1':
            # Mac OS X specific modules. These are ported over from MacPython
            # and still experimental. Some (such as gestalt or icglue) are
            # already generally useful, some (the GUI ones) really need to
            # be used from a framework.
557 558 559 560 561
            #
            # I would like to trigger on WITH_NEXT_FRAMEWORK but that isn't
            # available here. This Makefile variable is also what the install
            # procedure triggers on.
            frameworkdir = sysconfig.get_config_var('PYTHONFRAMEWORKDIR')
562 563 564 565
            exts.append( Extension('gestalt', ['gestaltmodule.c']) )
            exts.append( Extension('MacOS', ['macosmodule.c']) )
            exts.append( Extension('icglue', ['icgluemodule.c']) )
            exts.append( Extension('macfs', ['macfsmodule.c', '../Python/getapplbycreator.c']) )
566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591
            exts.append( Extension('_CF', ['cf/_CFmodule.c'],
                    extra_link_args=['-framework', 'CoreFoundation']) )
            exts.append( Extension('_Res', ['res/_Resmodule.c'] ) )
            exts.append( Extension('_Snd', ['snd/_Sndmodule.c']) )
            if frameworkdir:
                exts.append( Extension('Nav', ['Nav.c']) )
                exts.append( Extension('_AE', ['ae/_AEmodule.c']) )
                exts.append( Extension('_App', ['app/_Appmodule.c']) )
                exts.append( Extension('_Cm', ['cm/_Cmmodule.c']) )
                exts.append( Extension('_Ctl', ['ctl/_Ctlmodule.c']) )
                exts.append( Extension('_Dlg', ['dlg/_Dlgmodule.c']) )
                exts.append( Extension('_Drag', ['drag/_Dragmodule.c']) )
                exts.append( Extension('_Evt', ['evt/_Evtmodule.c']) )
                exts.append( Extension('_Fm', ['fm/_Fmmodule.c']) )
                exts.append( Extension('_Icn', ['icn/_Icnmodule.c']) )
                exts.append( Extension('_List', ['list/_Listmodule.c']) )
                exts.append( Extension('_Menu', ['menu/_Menumodule.c']) )
                exts.append( Extension('_Mlte', ['mlte/_Mltemodule.c']) )
                exts.append( Extension('_Qd', ['qd/_Qdmodule.c']) )
                exts.append( Extension('_Qdoffs', ['qdoffs/_Qdoffsmodule.c']) )
                exts.append( Extension('_Qt', ['qt/_Qtmodule.c'],
                        extra_link_args=['-framework', 'QuickTime']) )
##              exts.append( Extension('_Scrap', ['scrap/_Scrapmodule.c']) )
                exts.append( Extension('_TE', ['te/_TEmodule.c']) )
##              exts.append( Extension('waste', ['waste/wastemodule.c']) )
                exts.append( Extension('_Win', ['win/_Winmodule.c']) )
592
            
593 594 595 596
        self.extensions.extend(exts)

        # Call the method for detecting whether _tkinter can be compiled
        self.detect_tkinter(inc_dirs, lib_dirs)
597

598 599

    def detect_tkinter(self, inc_dirs, lib_dirs):
600
        # The _tkinter module.
601
        
602
        # Assume we haven't found any of the libraries or include files
603 604
        # The versions with dots are used on Unix, and the versions without
        # dots on Windows, for detection by cygwin.
605
        tcllib = tklib = tcl_includes = tk_includes = None
606 607
        for version in ['8.4', '84', '8.3', '83', '8.2',
                        '82', '8.1', '81', '8.0', '80']:
608 609 610 611
             tklib = self.compiler.find_library_file(lib_dirs,
                                                     'tk' + version )
             tcllib = self.compiler.find_library_file(lib_dirs,
                                                      'tcl' + version )
612
             if tklib and tcllib:
613 614
                # Exit the loop when we've found the Tcl/Tk libraries
                break
615

616
        # Now check for the header files
617 618 619
        if tklib and tcllib:
            # Check for the include files on Debian, where
            # they're put in /usr/include/{tcl,tk}X.Y
620 621 622 623
            debian_tcl_include = [ '/usr/include/tcl' + version ]
            debian_tk_include =  [ '/usr/include/tk'  + version ] + debian_tcl_include
            tcl_includes = find_file('tcl.h', inc_dirs, debian_tcl_include)
            tk_includes = find_file('tk.h', inc_dirs, debian_tk_include)
624 625 626 627 628

        if (tcllib is None or tklib is None and
            tcl_includes is None or tk_includes is None):
            # Something's missing, so give up
            return
629

630 631 632 633 634 635
        # OK... everything seems to be present for Tcl/Tk.

        include_dirs = [] ; libs = [] ; defs = [] ; added_lib_dirs = []
        for dir in tcl_includes + tk_includes:
            if dir not in include_dirs:
                include_dirs.append(dir)
636

637
        # Check for various platform-specific directories
638 639
        platform = self.get_platform()
        if platform == 'sunos5':
640 641 642 643 644 645 646 647 648
            include_dirs.append('/usr/openwin/include')
            added_lib_dirs.append('/usr/openwin/lib')
        elif os.path.exists('/usr/X11R6/include'):
            include_dirs.append('/usr/X11R6/include')
            added_lib_dirs.append('/usr/X11R6/lib')
        elif os.path.exists('/usr/X11R5/include'):
            include_dirs.append('/usr/X11R5/include')
            added_lib_dirs.append('/usr/X11R5/lib')
        else:
649
            # Assume default location for X11
650 651 652
            include_dirs.append('/usr/X11/include')
            added_lib_dirs.append('/usr/X11/lib')

653 654 655 656 657 658 659
        # If Cygwin, then verify that X is installed before proceeding
        if platform == 'cygwin':
            x11_inc = find_file('X11/Xlib.h', [], inc_dirs)
            if x11_inc is None:
                # X header files missing, so give up
                return

660 661 662 663 664 665
        # Check for BLT extension
        if self.compiler.find_library_file(lib_dirs + added_lib_dirs, 'BLT8.0'):
            defs.append( ('WITH_BLT', 1) )
            libs.append('BLT8.0')

        # Add the Tcl/Tk libraries
666
        libs.append('tk'+version)
667
        libs.append('tcl'+version)
668

669
        if platform in ['aix3', 'aix4']:
670 671
            libs.append('ld')

672 673 674
        # Finally, link with the X11 libraries (not appropriate on cygwin)
        if platform != "cygwin":
            libs.append('X11')
675 676 677 678 679 680 681 682

        ext = Extension('_tkinter', ['_tkinter.c', 'tkappinit.c'],
                        define_macros=[('WITH_APPINIT', 1)] + defs,
                        include_dirs = include_dirs,
                        libraries = libs,
                        library_dirs = added_lib_dirs,
                        )
        self.extensions.append(ext)
683

684
        # XXX handle these, but how to detect?
685
        # *** Uncomment and edit for PIL (TkImaging) extension only:
686
        #       -DWITH_PIL -I../Extensions/Imaging/libImaging  tkImaging.c \
687
        # *** Uncomment and edit for TOGL extension only:
688
        #       -DWITH_TOGL togl.c \
689
        # *** Uncomment these for TOGL extension only:
690
        #       -lGL -lGLU -lXext -lXmu \
691

692 693 694 695 696 697 698 699
class PyBuildInstall(install):
    # Suppress the warning about installation into the lib_dynload
    # directory, which is not in sys.path when running Python during
    # installation:
    def initialize_options (self):
        install.initialize_options(self)
        self.warn_dir=0
    
700
def main():
701 702 703
    # turn off warnings when deprecated modules are imported
    import warnings
    warnings.filterwarnings("ignore",category=DeprecationWarning)
704
    setup(name = 'Python standard library',
705
          version = '%d.%d' % sys.version_info[:2],
706
          cmdclass = {'build_ext':PyBuildExt, 'install':PyBuildInstall},
707 708
          # The struct module is defined here, because build_ext won't be
          # called unless there's at least one extension module defined.
709 710 711 712
          ext_modules=[Extension('struct', ['structmodule.c'])],

          # Scripts to install
          scripts = ['Tools/scripts/pydoc']
713
        )
714

715 716 717 718
# --install-platlib
if __name__ == '__main__':
    sysconfig.set_python_build()
    main()