setup.py

   1 # Autodetecting setup.py script for building the Python extensions
   2 #
   3
   4 __version__ = "$Revision$"
   5
   6 import sys, os, imp, re, optparse
   7
   8 from distutils import log
   9 from distutils import sysconfig
  10 from distutils import text_file
  11 from distutils.errors import *
  12 from distutils.core import Extension, setup
  13 from distutils.command.build_ext import build_ext
  14 from distutils.command.install import install
  15 from distutils.command.install_lib import install_lib
  16
  17 # This global variable is used to hold the list of modules to be disabled.
  18 disabled_module_list = []
  19
  20 def add_dir_to_list(dirlist, dir):
  21     """Add the directory 'dir' to the list 'dirlist' (at the front) if
  22     1) 'dir' is not already in 'dirlist'
  23     2) 'dir' actually exists, and is a directory."""
  24     if dir is not None and os.path.isdir(dir) and dir not in dirlist:
  25         dirlist.insert(0, dir)
  26
  27 def find_file(filename, std_dirs, paths):
  28     """Searches for the directory where a given file is located,
  29     and returns a possibly-empty list of additional directories, or None
  30     if the file couldn't be found at all.
  31
  32     'filename' is the name of a file, such as readline.h or libcrypto.a.
  33     'std_dirs' is the list of standard system directories; if the
  34         file is found in one of them, no additional directives are needed.
  35     'paths' is a list of additional locations to check; if the file is
  36         found in one of them, the resulting list will contain the directory.
  37     """
  38
  39     # Check the standard locations
  40     for dir in std_dirs:
  41         f = os.path.join(dir, filename)
  42         if os.path.exists(f): return []
  43
  44     # Check the additional directories
  45     for dir in paths:
  46         f = os.path.join(dir, filename)
  47         if os.path.exists(f):
  48             return [dir]
  49
  50     # Not found anywhere
  51     return None
  52
  53 def find_library_file(compiler, libname, std_dirs, paths):
  54     result = compiler.find_library_file(std_dirs + paths, libname)
  55     if result is None:
  56         return None
  57
  58     # Check whether the found file is in one of the standard directories
  59     dirname = os.path.dirname(result)
  60     for p in std_dirs:
  61         # Ensure path doesn't end with path separator
  62         p = p.rstrip(os.sep)
  63         if p == dirname:
  64             return [ ]
  65
  66     # Otherwise, it must have been in one of the additional directories,
  67     # so we have to figure out which one.
  68     for p in paths:
  69         # Ensure path doesn't end with path separator
  70         p = p.rstrip(os.sep)
  71         if p == dirname:
  72             return [p]
  73     else:
  74         assert False, "Internal error: Path not found in std_dirs or paths"
  75
  76 def module_enabled(extlist, modname):
  77     """Returns whether the module 'modname' is present in the list
  78     of extensions 'extlist'."""
  79     extlist = [ext for ext in extlist if ext.name == modname]
  80     return len(extlist)
  81
  82 def find_module_file(module, dirlist):
  83     """Find a module in a set of possible folders. If it is not found
  84     return the unadorned filename"""
  85     list = find_file(module, [], dirlist)
  86     if not list:
  87         return module
  88     if len(list) > 1:
  89         log.info("WARNING: multiple copies of %s found"%module)
  90     return os.path.join(list[0], module)
  91
  92 class PyBuildExt(build_ext):
  93
  94     def build_extensions(self):
  95
  96         # Detect which modules should be compiled
  97         self.detect_modules()
  98
  99         # Remove modules that are present on the disabled list
 100         self.extensions = [ext for ext in self.extensions
 101                            if ext.name not in disabled_module_list]
 102
 103         # Fix up the autodetected modules, prefixing all the source files
 104         # with Modules/ and adding Python's include directory to the path.
 105         (srcdir,) = sysconfig.get_config_vars('srcdir')
 106         if not srcdir:
 107             # Maybe running on Windows but not using CYGWIN?
 108             raise ValueError("No source directory; cannot proceed.")
 109
 110         # Figure out the location of the source code for extension modules
 111         moddir = os.path.join(os.getcwd(), srcdir, 'Modules')
 112         moddir = os.path.normpath(moddir)
 113         srcdir, tail = os.path.split(moddir)
 114         srcdir = os.path.normpath(srcdir)
 115         moddir = os.path.normpath(moddir)
 116
 117         moddirlist = [moddir]
 118         incdirlist = ['./Include']
 119
 120         # Platform-dependent module source and include directories
 121         platform = self.get_platform()
 122         if platform in ('darwin', 'mac') and ("--disable-toolbox-glue" not in
 123             sysconfig.get_config_var("CONFIG_ARGS")):
 124             # Mac OS X also includes some mac-specific modules
 125             macmoddir = os.path.join(os.getcwd(), srcdir, 'Mac/Modules')
 126             moddirlist.append(macmoddir)
 127             incdirlist.append('./Mac/Include')
 128
 129         alldirlist = moddirlist + incdirlist
 130
 131         # Fix up the paths for scripts, too
 132         self.distribution.scripts = [os.path.join(srcdir, filename)
 133                                      for filename in self.distribution.scripts]
 134
 135         for ext in self.extensions[:]:
 136             ext.sources = [ find_module_file(filename, moddirlist)
 137                             for filename in ext.sources ]
 138             if ext.depends is not None:
 139                 ext.depends = [find_module_file(filename, alldirlist)
 140                                for filename in ext.depends]
 141             ext.include_dirs.append( '.' ) # to get config.h
 142             for incdir in incdirlist:
 143                 ext.include_dirs.append( os.path.join(srcdir, incdir) )
 144
 145             # If a module has already been built statically,
 146             # don't build it here
 147             if ext.name in sys.builtin_module_names:
 148                 self.extensions.remove(ext)
 149
 150         if platform != 'mac':
 151             # Parse Modules/Setup and Modules/Setup.local to figure out which
 152             # modules are turned on in the file.
 153             remove_modules = []
 154             for filename in ('Modules/Setup', 'Modules/Setup.local'):
 155                 input = text_file.TextFile(filename, join_lines=1)
 156                 while 1:
 157                     line = input.readline()
 158                     if not line: break
 159                     line = line.split()
 160                     remove_modules.append(line[0])
 161                 input.close()
 162
 163             for ext in self.extensions[:]:
 164                 if ext.name in remove_modules:
 165                     self.extensions.remove(ext)
 166
 167         # When you run "make CC=altcc" or something similar, you really want
 168         # those environment variables passed into the setup.py phase.  Here's
 169         # a small set of useful ones.
 170         compiler = os.environ.get('CC')
 171         args = {}
 172         # unfortunately, distutils doesn't let us provide separate C and C++
 173         # compilers
 174         if compiler is not None:
 175             (ccshared,cflags) = sysconfig.get_config_vars('CCSHARED','CFLAGS')
 176             args['compiler_so'] = compiler + ' ' + ccshared + ' ' + cflags
 177         self.compiler.set_executables(**args)
 178
 179         build_ext.build_extensions(self)
 180
 181     def build_extension(self, ext):
 182
 183         try:
 184             build_ext.build_extension(self, ext)
 185         except (CCompilerError, DistutilsError), why:
 186             self.announce('WARNING: building of extension "%s" failed: %s' %
 187                           (ext.name, sys.exc_info()[1]))
 188             return
 189         # Workaround for Mac OS X: The Carbon-based modules cannot be
 190         # reliably imported into a command-line Python
 191         if 'Carbon' in ext.extra_link_args:
 192             self.announce(
 193                 'WARNING: skipping import check for Carbon-based "%s"' %
 194                 ext.name)
 195             return
 196         # Workaround for Cygwin: Cygwin currently has fork issues when many
 197         # modules have been imported
 198         if self.get_platform() == 'cygwin':
 199             self.announce('WARNING: skipping import check for Cygwin-based "%s"'
 200                 % ext.name)
 201             return
 202         ext_filename = os.path.join(
 203             self.build_lib,
 204             self.get_ext_filename(self.get_ext_fullname(ext.name)))
 205         try:
 206             imp.load_dynamic(ext.name, ext_filename)
 207         except ImportError, why:
 208             self.announce('*** WARNING: renaming "%s" since importing it'
 209                           ' failed: %s' % (ext.name, why), level=3)
 210             assert not self.inplace
 211             basename, tail = os.path.splitext(ext_filename)
 212             newname = basename + "_failed" + tail
 213             if os.path.exists(newname):
 214                 os.remove(newname)
 215             os.rename(ext_filename, newname)
 216
 217             # XXX -- This relies on a Vile HACK in
 218             # distutils.command.build_ext.build_extension().  The
 219             # _built_objects attribute is stored there strictly for
 220             # use here.
 221             # If there is a failure, _built_objects may not be there,
 222             # so catch the AttributeError and move on.
 223             try:
 224                 for filename in self._built_objects:
 225                     os.remove(filename)
 226             except AttributeError:
 227                 self.announce('unable to remove files (ignored)')
 228         except:
 229             exc_type, why, tb = sys.exc_info()
 230             self.announce('*** WARNING: importing extension "%s" '
 231                           'failed with %s: %s' % (ext.name, exc_type, why),
 232                           level=3)
 233
 234     def get_platform(self):
 235         # Get value of sys.platform
 236         for platform in ['cygwin', 'beos', 'darwin', 'atheos', 'osf1']:
 237             if sys.platform.startswith(platform):
 238                 return platform
 239         return sys.platform
 240
 241     def detect_modules(self):
 242         # Ensure that /usr/local is always used
 243         add_dir_to_list(self.compiler.library_dirs, '/usr/local/lib')
 244         add_dir_to_list(self.compiler.include_dirs, '/usr/local/include')
 245
 246         # Add paths specified in the environment variables LDFLAGS and
 247         # CPPFLAGS for header and library files.
 248         # We must get the values from the Makefile and not the environment
 249         # directly since an inconsistently reproducible issue comes up where
 250         # the environment variable is not set even though the value were passed
 251         # into configure and stored in the Makefile (issue found on OS X 10.3).
 252         for env_var, arg_name, dir_list in (
 253                 ('LDFLAGS', '-L', self.compiler.library_dirs),
 254                 ('CPPFLAGS', '-I', self.compiler.include_dirs)):
 255             env_val = sysconfig.get_config_var(env_var)
 256             if env_val:
 257                 # To prevent optparse from raising an exception about any
 258                 # options in env_val that is doesn't know about we strip out
 259                 # all double dashes and any dashes followed by a character
 260                 # that is not for the option we are dealing with.
 261                 #
 262                 # Please note that order of the regex is important!  We must
 263                 # strip out double-dashes first so that we don't end up with
 264                 # substituting "--Long" to "-Long" and thus lead to "ong" being
 265                 # used for a library directory.
 266                 env_val = re.sub(r'(^|\s+)-(-|(?!%s))' % arg_name[1], '', env_val)
 267                 parser = optparse.OptionParser()
 268                 # Make sure that allowing args interspersed with options is
 269                 # allowed
 270                 parser.allow_interspersed_args = True
 271                 parser.error = lambda msg: None
 272                 parser.add_option(arg_name, dest="dirs", action="append")
 273                 options = parser.parse_args(env_val.split())[0]
 274                 if options.dirs:
 275                     for directory in options.dirs:
 276                         add_dir_to_list(dir_list, directory)
 277
 278         if os.path.normpath(sys.prefix) != '/usr':
 279             add_dir_to_list(self.compiler.library_dirs,
 280                             sysconfig.get_config_var("LIBDIR"))
 281             add_dir_to_list(self.compiler.include_dirs,
 282                             sysconfig.get_config_var("INCLUDEDIR"))
 283
 284         try:
 285             have_unicode = unicode
 286         except NameError:
 287             have_unicode = 0
 288
 289         # lib_dirs and inc_dirs are used to search for files;
 290         # if a file is found in one of those directories, it can
 291         # be assumed that no additional -I,-L directives are needed.
 292         lib_dirs = self.compiler.library_dirs + [
 293             '/lib64', '/usr/lib64',
 294             '/lib', '/usr/lib',
 295             ]
 296         inc_dirs = self.compiler.include_dirs + ['/usr/include']
 297         exts = []
 298
 299         config_h = sysconfig.get_config_h_filename()
 300         config_h_vars = sysconfig.parse_config_h(open(config_h))
 301
 302         platform = self.get_platform()
 303         (srcdir,) = sysconfig.get_config_vars('srcdir')
 304
 305         # Check for AtheOS which has libraries in non-standard locations
 306         if platform == 'atheos':
 307             lib_dirs += ['/system/libs', '/atheos/autolnk/lib']
 308             lib_dirs += os.getenv('LIBRARY_PATH', '').split(os.pathsep)
 309             inc_dirs += ['/system/include', '/atheos/autolnk/include']
 310             inc_dirs += os.getenv('C_INCLUDE_PATH', '').split(os.pathsep)
 311
 312         # OSF/1 and Unixware have some stuff in /usr/ccs/lib (like -ldb)
 313         if platform in ['osf1', 'unixware7', 'openunix8']:
 314             lib_dirs += ['/usr/ccs/lib']
 315
 316         # Check for MacOS X, which doesn't need libm.a at all
 317         math_libs = ['m']
 318         if platform in ['darwin', 'beos', 'mac']:
 319             math_libs = []
 320
 321         # XXX Omitted modules: gl, pure, dl, SGI-specific modules
 322
 323         #
 324         # The following modules are all pretty straightforward, and compile
 325         # on pretty much any POSIXish platform.
 326         #
 327
 328         # Some modules that are normally always on:
 329         exts.append( Extension('regex', ['regexmodule.c', 'regexpr.c']) )
 330
 331         exts.append( Extension('_weakref', ['_weakref.c']) )
 332
 333         # array objects
 334         exts.append( Extension('array', ['arraymodule.c']) )
 335         # complex math library functions
 336         exts.append( Extension('cmath', ['cmathmodule.c'],
 337                                libraries=math_libs) )
 338
 339         # math library functions, e.g. sin()
 340         exts.append( Extension('math',  ['mathmodule.c'],
 341                                libraries=math_libs) )
 342         # fast string operations implemented in C
 343         exts.append( Extension('strop', ['stropmodule.c']) )
 344         # time operations and variables
 345         exts.append( Extension('time', ['timemodule.c'],
 346                                libraries=math_libs) )
 347         exts.append( Extension('datetime', ['datetimemodule.c', 'timemodule.c'],
 348                                libraries=math_libs) )
 349         # random number generator implemented in C
 350         exts.append( Extension("_random", ["_randommodule.c"]) )
 351         # fast iterator tools implemented in C
 352         exts.append( Extension("itertools", ["itertoolsmodule.c"]) )
 353         # high-performance collections
 354         exts.append( Extension("collections", ["collectionsmodule.c"]) )
 355         # bisect
 356         exts.append( Extension("_bisect", ["_bisectmodule.c"]) )
 357         # heapq
 358         exts.append( Extension("_heapq", ["_heapqmodule.c"]) )
 359         # operator.add() and similar goodies
 360         exts.append( Extension('operator', ['operator.c']) )
 361         # functional
 362         exts.append( Extension("functional", ["functionalmodule.c"]) )
 363         # Python C API test module
 364         exts.append( Extension('_testcapi', ['_testcapimodule.c']) )
 365         # profilers (_lsprof is for cProfile.py)
 366         exts.append( Extension('_hotshot', ['_hotshot.c']) )
 367         exts.append( Extension('_lsprof', ['_lsprof.c', 'rotatingtree.c']) )
 368         # static Unicode character database
 369         if have_unicode:
 370             exts.append( Extension('unicodedata', ['unicodedata.c']) )
 371         # access to ISO C locale support
 372         data = open('pyconfig.h').read()
 373         m = re.search(r"#s*define\s+WITH_LIBINTL\s+1\s*", data)
 374         if m is not None:
 375             locale_libs = ['intl']
 376         else:
 377             locale_libs = []
 378         if platform == 'darwin':
 379             locale_extra_link_args = ['-framework', 'CoreFoundation']
 380         else:
 381             locale_extra_link_args = []
 382
 383
 384         exts.append( Extension('_locale', ['_localemodule.c'],
 385                                libraries=locale_libs,
 386                                extra_link_args=locale_extra_link_args) )
 387
 388         # Modules with some UNIX dependencies -- on by default:
 389         # (If you have a really backward UNIX, select and socket may not be
 390         # supported...)
 391
 392         # fcntl(2) and ioctl(2)
 393         exts.append( Extension('fcntl', ['fcntlmodule.c']) )
 394         if platform not in ['mac']:
 395             # pwd(3)
 396             exts.append( Extension('pwd', ['pwdmodule.c']) )
 397             # grp(3)
 398             exts.append( Extension('grp', ['grpmodule.c']) )
 399             # spwd, shadow passwords
 400             if (config_h_vars.get('HAVE_GETSPNAM', False) or
 401                     config_h_vars.get('HAVE_GETSPENT', False)):
 402                 exts.append( Extension('spwd', ['spwdmodule.c']) )
 403         # select(2); not on ancient System V
 404         exts.append( Extension('select', ['selectmodule.c']) )
 405
 406         # Helper module for various ascii-encoders
 407         exts.append( Extension('binascii', ['binascii.c']) )
 408
 409         # Fred Drake's interface to the Python parser
 410         exts.append( Extension('parser', ['parsermodule.c']) )
 411
 412         # cStringIO and cPickle
 413         exts.append( Extension('cStringIO', ['cStringIO.c']) )
 414         exts.append( Extension('cPickle', ['cPickle.c']) )
 415
 416         # Memory-mapped files (also works on Win32).
 417         if platform not in ['atheos', 'mac']:
 418             exts.append( Extension('mmap', ['mmapmodule.c']) )
 419
 420         # Lance Ellinghaus's syslog module
 421         if platform not in ['mac']:
 422             # syslog daemon interface
 423             exts.append( Extension('syslog', ['syslogmodule.c']) )
 424
 425         # George Neville-Neil's timing module:
 426         # Deprecated in PEP 4 http://www.python.org/peps/pep-0004.html
 427         # http://mail.python.org/pipermail/python-dev/2006-January/060023.html
 428         #exts.append( Extension('timing', ['timingmodule.c']) )
 429
 430         #
 431         # Here ends the simple stuff.  From here on, modules need certain
 432         # libraries, are platform-specific, or present other surprises.
 433         #
 434
 435         # Multimedia modules
 436         # These don't work for 64-bit platforms!!!
 437         # These represent audio samples or images as strings:
 438
 439         # Operations on audio samples
 440         # According to #993173, this one should actually work fine on
 441         # 64-bit platforms.
 442         exts.append( Extension('audioop', ['audioop.c']) )
 443
 444         # Disabled on 64-bit platforms
 445         if sys.maxint != 9223372036854775807L:
 446             # Operations on images
 447             exts.append( Extension('imageop', ['imageop.c']) )
 448             # Read SGI RGB image files (but coded portably)
 449             exts.append( Extension('rgbimg', ['rgbimgmodule.c']) )
 450
 451         # readline
 452         do_readline = self.compiler.find_library_file(lib_dirs, 'readline')
 453         if platform == 'darwin':
 454             # MacOSX 10.4 has a broken readline. Don't try to build
 455             # the readline module unless the user has installed a fixed
 456             # readline package
 457             if find_file('readline/rlconf.h', inc_dirs, []) is None:
 458                 do_readline = False
 459         if do_readline:
 460             readline_libs = ['readline']
 461             if self.compiler.find_library_file(lib_dirs,
 462                                                  'ncursesw'):
 463                 readline_libs.append('ncursesw')
 464             elif self.compiler.find_library_file(lib_dirs,
 465                                                  'ncurses'):
 466                 readline_libs.append('ncurses')
 467             elif self.compiler.find_library_file(lib_dirs, 'curses'):
 468                 readline_libs.append('curses')
 469             elif self.compiler.find_library_file(lib_dirs +
 470                                                ['/usr/lib/termcap'],
 471                                                'termcap'):
 472                 readline_libs.append('termcap')
 473             exts.append( Extension('readline', ['readline.c'],
 474                                    library_dirs=['/usr/lib/termcap'],
 475                                    libraries=readline_libs) )
 476         if platform not in ['mac']:
 477             # crypt module.
 478
 479             if self.compiler.find_library_file(lib_dirs, 'crypt'):
 480                 libs = ['crypt']
 481             else:
 482                 libs = []
 483             exts.append( Extension('crypt', ['cryptmodule.c'], libraries=libs) )
 484
 485         # CSV files
 486         exts.append( Extension('_csv', ['_csv.c']) )
 487
 488         # socket(2)
 489         exts.append( Extension('_socket', ['socketmodule.c'],
 490                                depends = ['socketmodule.h']) )
 491         # Detect SSL support for the socket module (via _ssl)
 492         search_for_ssl_incs_in = [
 493                               '/usr/local/ssl/include',
 494                               '/usr/contrib/ssl/include/'
 495                              ]
 496         ssl_incs = find_file('openssl/ssl.h', inc_dirs,
 497                              search_for_ssl_incs_in
 498                              )
 499         if ssl_incs is not None:
 500             krb5_h = find_file('krb5.h', inc_dirs,
 501                                ['/usr/kerberos/include'])
 502             if krb5_h:
 503                 ssl_incs += krb5_h
 504         ssl_libs = find_library_file(self.compiler, 'ssl',lib_dirs,
 505                                      ['/usr/local/ssl/lib',
 506                                       '/usr/contrib/ssl/lib/'
 507                                      ] )
 508
 509         if (ssl_incs is not None and
 510             ssl_libs is not None):
 511             exts.append( Extension('_ssl', ['_ssl.c'],
 512                                    include_dirs = ssl_incs,
 513                                    library_dirs = ssl_libs,
 514                                    libraries = ['ssl', 'crypto'],
 515                                    depends = ['socketmodule.h']), )
 516
 517         # find out which version of OpenSSL we have
 518         openssl_ver = 0
 519         openssl_ver_re = re.compile(
 520             '^\s*#\s*define\s+OPENSSL_VERSION_NUMBER\s+(0x[0-9a-fA-F]+)' )
 521         for ssl_inc_dir in inc_dirs + search_for_ssl_incs_in:
 522             name = os.path.join(ssl_inc_dir, 'openssl', 'opensslv.h')
 523             if os.path.isfile(name):
 524                 try:
 525                     incfile = open(name, 'r')
 526                     for line in incfile:
 527                         m = openssl_ver_re.match(line)
 528                         if m:
 529                             openssl_ver = eval(m.group(1))
 530                             break
 531                 except IOError:
 532                     pass
 533
 534             # first version found is what we'll use (as the compiler should)
 535             if openssl_ver:
 536                 break
 537
 538         #print 'openssl_ver = 0x%08x' % openssl_ver
 539
 540         if (ssl_incs is not None and
 541             ssl_libs is not None and
 542             openssl_ver >= 0x00907000):
 543             # The _hashlib module wraps optimized implementations
 544             # of hash functions from the OpenSSL library.
 545             exts.append( Extension('_hashlib', ['_hashopenssl.c'],
 546                                    include_dirs = ssl_incs,
 547                                    library_dirs = ssl_libs,
 548                                    libraries = ['ssl', 'crypto']) )
 549         else:
 550             # The _sha module implements the SHA1 hash algorithm.
 551             exts.append( Extension('_sha', ['shamodule.c']) )
 552             # The _md5 module implements the RSA Data Security, Inc. MD5
 553             # Message-Digest Algorithm, described in RFC 1321.  The
 554             # necessary files md5c.c and md5.h are included here.
 555             exts.append( Extension('_md5', ['md5module.c', 'md5c.c']) )
 556
 557         if (openssl_ver < 0x00908000):
 558             # OpenSSL doesn't do these until 0.9.8 so we'll bring our own hash
 559             exts.append( Extension('_sha256', ['sha256module.c']) )
 560             exts.append( Extension('_sha512', ['sha512module.c']) )
 561
 562
 563         # Modules that provide persistent dictionary-like semantics.  You will
 564         # probably want to arrange for at least one of them to be available on
 565         # your machine, though none are defined by default because of library
 566         # dependencies.  The Python module anydbm.py provides an
 567         # implementation independent wrapper for these; dumbdbm.py provides
 568         # similar functionality (but slower of course) implemented in Python.
 569
 570         # Sleepycat Berkeley DB interface.  http://www.sleepycat.com
 571         #
 572         # This requires the Sleepycat DB code. The earliest supported version
 573         # of that library is 3.2, the latest supported version is 4.4.  A list
 574         # of available releases can be found at
 575         #
 576         # http://www.sleepycat.com/update/index.html
 577
 578         max_db_ver = (4, 4)
 579         min_db_ver = (3, 2)
 580         db_setup_debug = False   # verbose debug prints from this script?
 581
 582         # construct a list of paths to look for the header file in on
 583         # top of the normal inc_dirs.
 584         db_inc_paths = [
 585             '/usr/include/db4',
 586             '/usr/local/include/db4',
 587             '/opt/sfw/include/db4',
 588             '/sw/include/db4',
 589             '/usr/include/db3',
 590             '/usr/local/include/db3',
 591             '/opt/sfw/include/db3',
 592             '/sw/include/db3',
 593         ]
 594         # 4.x minor number specific paths
 595         for x in (0,1,2,3,4):
 596             db_inc_paths.append('/usr/include/db4%d' % x)
 597             db_inc_paths.append('/usr/include/db4.%d' % x)
 598             db_inc_paths.append('/usr/local/BerkeleyDB.4.%d/include' % x)
 599             db_inc_paths.append('/usr/local/include/db4%d' % x)
 600             db_inc_paths.append('/pkg/db-4.%d/include' % x)
 601             db_inc_paths.append('/opt/db-4.%d/include' % x)
 602         # 3.x minor number specific paths
 603         for x in (2,3):
 604             db_inc_paths.append('/usr/include/db3%d' % x)
 605             db_inc_paths.append('/usr/local/BerkeleyDB.3.%d/include' % x)
 606             db_inc_paths.append('/usr/local/include/db3%d' % x)
 607             db_inc_paths.append('/pkg/db-3.%d/include' % x)
 608             db_inc_paths.append('/opt/db-3.%d/include' % x)
 609
 610         db_ver_inc_map = {}
 611
 612         class db_found(Exception): pass
 613         try:
 614             # See whether there is a Sleepycat header in the standard
 615             # search path.
 616             for d in inc_dirs + db_inc_paths:
 617                 f = os.path.join(d, "db.h")
 618                 if db_setup_debug: print "db: looking for db.h in", f
 619                 if os.path.exists(f):
 620                     f = open(f).read()
 621                     m = re.search(r"#define\WDB_VERSION_MAJOR\W(\d+)", f)
 622                     if m:
 623                         db_major = int(m.group(1))
 624                         m = re.search(r"#define\WDB_VERSION_MINOR\W(\d+)", f)
 625                         db_minor = int(m.group(1))
 626                         db_ver = (db_major, db_minor)
 627
 628                         if ( (not db_ver_inc_map.has_key(db_ver)) and
 629                            (db_ver <= max_db_ver and db_ver >= min_db_ver) ):
 630                             # save the include directory with the db.h version
 631                             # (first occurrance only)
 632                             db_ver_inc_map[db_ver] = d
 633                             print "db.h: found", db_ver, "in", d
 634                         else:
 635                             # we already found a header for this library version
 636                             if db_setup_debug: print "db.h: ignoring", d
 637                     else:
 638                         # ignore this header, it didn't contain a version number
 639                         if db_setup_debug: print "db.h: unsupported version", db_ver, "in", d
 640
 641             db_found_vers = db_ver_inc_map.keys()
 642             db_found_vers.sort()
 643
 644             while db_found_vers:
 645                 db_ver = db_found_vers.pop()
 646                 db_incdir = db_ver_inc_map[db_ver]
 647
 648                 # check lib directories parallel to the location of the header
 649                 db_dirs_to_check = [
 650                     os.path.join(db_incdir, '..', 'lib64'),
 651                     os.path.join(db_incdir, '..', 'lib'),
 652                     os.path.join(db_incdir, '..', '..', 'lib64'),
 653                     os.path.join(db_incdir, '..', '..', 'lib'),
 654                 ]
 655                 db_dirs_to_check = filter(os.path.isdir, db_dirs_to_check)
 656
 657                 # Look for a version specific db-X.Y before an ambiguoius dbX
 658                 # XXX should we -ever- look for a dbX name?  Do any
 659                 # systems really not name their library by version and
 660                 # symlink to more general names?
 661                 for dblib in (('db-%d.%d' % db_ver),
 662                               ('db%d%d' % db_ver),
 663                               ('db%d' % db_ver[0])):
 664                     dblib_file = self.compiler.find_library_file(
 665                                     db_dirs_to_check + lib_dirs, dblib )
 666                     if dblib_file:
 667                         dblib_dir = [ os.path.abspath(os.path.dirname(dblib_file)) ]
 668                         raise db_found
 669                     else:
 670                         if db_setup_debug: print "db lib: ", dblib, "not found"
 671
 672         except db_found:
 673             print "db lib: using", db_ver, dblib
 674             if db_setup_debug: print "db: lib dir", dblib_dir, "inc dir", db_incdir
 675             db_incs = [db_incdir]
 676             dblibs = [dblib]
 677             # We add the runtime_library_dirs argument because the
 678             # BerkeleyDB lib we're linking against often isn't in the
 679             # system dynamic library search path.  This is usually
 680             # correct and most trouble free, but may cause problems in
 681             # some unusual system configurations (e.g. the directory
 682             # is on an NFS server that goes away).
 683             exts.append(Extension('_bsddb', ['_bsddb.c'],
 684                                   library_dirs=dblib_dir,
 685                                   runtime_library_dirs=dblib_dir,
 686                                   include_dirs=db_incs,
 687                                   libraries=dblibs))
 688         else:
 689             if db_setup_debug: print "db: no appropriate library found"
 690             db_incs = None
 691             dblibs = []
 692             dblib_dir = None
 693
 694
 695         # Look for Berkeley db 1.85.   Note that it is built as a different
 696         # module name so it can be included even when later versions are
 697         # available.  A very restrictive search is performed to avoid
 698         # accidentally building this module with a later version of the
 699         # underlying db library.  May BSD-ish Unixes incorporate db 1.85
 700         # symbols into libc and place the include file in /usr/include.
 701         f = "/usr/include/db.h"
 702         if os.path.exists(f):
 703             data = open(f).read()
 704             m = re.search(r"#s*define\s+HASHVERSION\s+2\s*", data)
 705             if m is not None:
 706                 # bingo - old version used hash file format version 2
 707                 ### XXX this should be fixed to not be platform-dependent
 708                 ### but I don't have direct access to an osf1 platform and
 709                 ### seemed to be muffing the search somehow
 710                 libraries = platform == "osf1" and ['db'] or None
 711                 if libraries is not None:
 712                     exts.append(Extension('bsddb185', ['bsddbmodule.c'],
 713                                           libraries=libraries))
 714                 else:
 715                     exts.append(Extension('bsddb185', ['bsddbmodule.c']))
 716
 717         # The standard Unix dbm module:
 718         if platform not in ['cygwin']:
 719             if find_file("ndbm.h", inc_dirs, []) is not None:
 720                 # Some systems have -lndbm, others don't
 721                 if self.compiler.find_library_file(lib_dirs, 'ndbm'):
 722                     ndbm_libs = ['ndbm']
 723                 else:
 724                     ndbm_libs = []
 725                 exts.append( Extension('dbm', ['dbmmodule.c'],
 726                                        define_macros=[('HAVE_NDBM_H',None)],
 727                                        libraries = ndbm_libs ) )
 728             elif (self.compiler.find_library_file(lib_dirs, 'gdbm')
 729                   and find_file("gdbm/ndbm.h", inc_dirs, []) is not None):
 730                 exts.append( Extension('dbm', ['dbmmodule.c'],
 731                                        define_macros=[('HAVE_GDBM_NDBM_H',None)],
 732                                        libraries = ['gdbm'] ) )
 733             elif db_incs is not None:
 734                 exts.append( Extension('dbm', ['dbmmodule.c'],
 735                                        library_dirs=dblib_dir,
 736                                        runtime_library_dirs=dblib_dir,
 737                                        include_dirs=db_incs,
 738                                        define_macros=[('HAVE_BERKDB_H',None),
 739                                                       ('DB_DBM_HSEARCH',None)],
 740                                        libraries=dblibs))
 741
 742         # Anthony Baxter's gdbm module.  GNU dbm(3) will require -lgdbm:
 743         if (self.compiler.find_library_file(lib_dirs, 'gdbm')):
 744             exts.append( Extension('gdbm', ['gdbmmodule.c'],
 745                                    libraries = ['gdbm'] ) )
 746
 747         # Unix-only modules
 748         if platform not in ['mac', 'win32']:
 749             # Steen Lumholt's termios module
 750             exts.append( Extension('termios', ['termios.c']) )
 751             # Jeremy Hylton's rlimit interface
 752             if platform not in ['atheos']:
 753                 exts.append( Extension('resource', ['resource.c']) )
 754
 755             # Sun yellow pages. Some systems have the functions in libc.
 756             if platform not in ['cygwin', 'atheos']:
 757                 if (self.compiler.find_library_file(lib_dirs, 'nsl')):
 758                     libs = ['nsl']
 759                 else:
 760                     libs = []
 761                 exts.append( Extension('nis', ['nismodule.c'],
 762                                        libraries = libs) )
 763
 764         # Curses support, requiring the System V version of curses, often
 765         # provided by the ncurses library.
 766         if (self.compiler.find_library_file(lib_dirs, 'ncursesw')):
 767             curses_libs = ['ncursesw']
 768             exts.append( Extension('_curses', ['_cursesmodule.c'],
 769                                    libraries = curses_libs) )
 770         elif (self.compiler.find_library_file(lib_dirs, 'ncurses')):
 771             curses_libs = ['ncurses']
 772             exts.append( Extension('_curses', ['_cursesmodule.c'],
 773                                    libraries = curses_libs) )
 774         elif (self.compiler.find_library_file(lib_dirs, 'curses')
 775               and platform != 'darwin'):
 776                 # OSX has an old Berkeley curses, not good enough for
 777                 # the _curses module.
 778             if (self.compiler.find_library_file(lib_dirs, 'terminfo')):
 779                 curses_libs = ['curses', 'terminfo']
 780             elif (self.compiler.find_library_file(lib_dirs, 'termcap')):
 781                 curses_libs = ['curses', 'termcap']
 782             else:
 783                 curses_libs = ['curses']
 784
 785             exts.append( Extension('_curses', ['_cursesmodule.c'],
 786                                    libraries = curses_libs) )
 787
 788         # If the curses module is enabled, check for the panel module
 789         if (module_enabled(exts, '_curses') and
 790             self.compiler.find_library_file(lib_dirs, 'panel')):
 791             exts.append( Extension('_curses_panel', ['_curses_panel.c'],
 792                                    libraries = ['panel'] + curses_libs) )
 793
 794
 795         # Andrew Kuchling's zlib module.  Note that some versions of zlib
 796         # 1.1.3 have security problems.  See CERT Advisory CA-2002-07:
 797         # http://www.cert.org/advisories/CA-2002-07.html
 798         #
 799         # zlib 1.1.4 is fixed, but at least one vendor (RedHat) has decided to
 800         # patch its zlib 1.1.3 package instead of upgrading to 1.1.4.  For
 801         # now, we still accept 1.1.3, because we think it's difficult to
 802         # exploit this in Python, and we'd rather make it RedHat's problem
 803         # than our problem <wink>.
 804         #
 805         # You can upgrade zlib to version 1.1.4 yourself by going to
 806         # http://www.gzip.org/zlib/
 807         zlib_inc = find_file('zlib.h', [], inc_dirs)
 808         if zlib_inc is not None:
 809             zlib_h = zlib_inc[0] + '/zlib.h'
 810             version = '"0.0.0"'
 811             version_req = '"1.1.3"'
 812             fp = open(zlib_h)
 813             while 1:
 814                 line = fp.readline()
 815                 if not line:
 816                     break
 817                 if line.startswith('#define ZLIB_VERSION'):
 818                     version = line.split()[2]
 819                     break
 820             if version >= version_req:
 821                 if (self.compiler.find_library_file(lib_dirs, 'z')):
 822                     exts.append( Extension('zlib', ['zlibmodule.c'],
 823                                            libraries = ['z']) )
 824
 825         # Gustavo Niemeyer's bz2 module.
 826         if (self.compiler.find_library_file(lib_dirs, 'bz2')):
 827             exts.append( Extension('bz2', ['bz2module.c'],
 828                                    libraries = ['bz2']) )
 829
 830         # Interface to the Expat XML parser
 831         #
 832         # Expat was written by James Clark and is now maintained by a
 833         # group of developers on SourceForge; see www.libexpat.org for
 834         # more information.  The pyexpat module was written by Paul
 835         # Prescod after a prototype by Jack Jansen.  The Expat source
 836         # is included in Modules/expat/.  Usage of a system
 837         # shared libexpat.so/expat.dll is not advised.
 838         #
 839         # More information on Expat can be found at www.libexpat.org.
 840         #
 841         if sys.byteorder == "little":
 842             xmlbo = "1234"
 843         else:
 844             xmlbo = "4321"
 845         expatinc = os.path.join(os.getcwd(), srcdir, 'Modules', 'expat')
 846         define_macros = [
 847             ('XML_NS', '1'),
 848             ('XML_DTD', '1'),
 849             ('BYTEORDER', xmlbo),
 850             ('XML_CONTEXT_BYTES','1024'),
 851             ]
 852         for feature_macro in ['HAVE_MEMMOVE', 'HAVE_BCOPY']:
 853             if config_h_vars.has_key(feature_macro):
 854                 define_macros.append((feature_macro, '1'))
 855         exts.append(Extension('pyexpat',
 856                               define_macros = define_macros,
 857                               include_dirs = [expatinc],
 858                               sources = ['pyexpat.c',
 859                                          'expat/xmlparse.c',
 860                                          'expat/xmlrole.c',
 861                                          'expat/xmltok.c',
 862                                          ],
 863                               ))
 864
 865         # Fredrik Lundh's cElementTree module.  Note that this also
 866         # uses expat (via the CAPI hook in pyexpat).
 867
 868         if os.path.isfile('Modules/_elementtree.c'):
 869             define_macros.append(('USE_PYEXPAT_CAPI', None))
 870             exts.append(Extension('_elementtree',
 871                                   define_macros = define_macros,
 872                                   include_dirs = [expatinc],
 873                                   sources = ['_elementtree.c'],
 874                                   ))
 875
 876         # Hye-Shik Chang's CJKCodecs modules.
 877         if have_unicode:
 878             exts.append(Extension('_multibytecodec',
 879                                   ['cjkcodecs/multibytecodec.c']))
 880             for loc in ('kr', 'jp', 'cn', 'tw', 'hk', 'iso2022'):
 881                 exts.append(Extension('_codecs_' + loc,
 882                                       ['cjkcodecs/_codecs_%s.c' % loc]))
 883
 884         # Dynamic loading module
 885         if sys.maxint == 0x7fffffff:
 886             # This requires sizeof(int) == sizeof(long) == sizeof(char*)
 887             dl_inc = find_file('dlfcn.h', [], inc_dirs)
 888             if (dl_inc is not None) and (platform not in ['atheos', 'darwin']):
 889                 exts.append( Extension('dl', ['dlmodule.c']) )
 890
 891         # Thomas Heller's _ctypes module
 892         self.detect_ctypes()
 893
 894         # Platform-specific libraries
 895         if platform == 'linux2':
 896             # Linux-specific modules
 897             exts.append( Extension('linuxaudiodev', ['linuxaudiodev.c']) )
 898
 899         if platform in ('linux2', 'freebsd4', 'freebsd5', 'freebsd6',
 900                         'freebsd7'):
 901             exts.append( Extension('ossaudiodev', ['ossaudiodev.c']) )
 902
 903         if platform == 'sunos5':
 904             # SunOS specific modules
 905             exts.append( Extension('sunaudiodev', ['sunaudiodev.c']) )
 906
 907         if platform == 'darwin' and ("--disable-toolbox-glue" not in
 908             sysconfig.get_config_var("CONFIG_ARGS")):
 909             # Mac OS X specific modules.
 910             exts.append( Extension('_CF', ['cf/_CFmodule.c', 'cf/pycfbridge.c'],
 911                         extra_link_args=['-framework', 'CoreFoundation']) )
 912
 913             exts.append( Extension('ColorPicker', ['ColorPickermodule.c'],
 914                         extra_link_args=['-framework', 'Carbon']) )
 915             exts.append( Extension('autoGIL', ['autoGIL.c'],
 916                         extra_link_args=['-framework', 'CoreFoundation']) )
 917             exts.append( Extension('gestalt', ['gestaltmodule.c'],
 918                         extra_link_args=['-framework', 'Carbon']) )
 919             exts.append( Extension('MacOS', ['macosmodule.c'],
 920                         extra_link_args=['-framework', 'Carbon']) )
 921             exts.append( Extension('OSATerminology', ['OSATerminology.c'],
 922                         extra_link_args=['-framework', 'Carbon']) )
 923             exts.append( Extension('icglue', ['icgluemodule.c'],
 924                         extra_link_args=['-framework', 'Carbon']) )
 925             exts.append( Extension('_Res', ['res/_Resmodule.c'],
 926                         extra_link_args=['-framework', 'Carbon']) )
 927             exts.append( Extension('_Snd', ['snd/_Sndmodule.c'],
 928                         extra_link_args=['-framework', 'Carbon']) )
 929             exts.append( Extension('Nav', ['Nav.c'],
 930                     extra_link_args=['-framework', 'Carbon']) )
 931             exts.append( Extension('_AE', ['ae/_AEmodule.c'],
 932                     extra_link_args=['-framework', 'Carbon']) )
 933             exts.append( Extension('_AH', ['ah/_AHmodule.c'],
 934                     extra_link_args=['-framework', 'Carbon']) )
 935             exts.append( Extension('_App', ['app/_Appmodule.c'],
 936                     extra_link_args=['-framework', 'Carbon']) )
 937             exts.append( Extension('_CarbonEvt', ['carbonevt/_CarbonEvtmodule.c'],
 938                     extra_link_args=['-framework', 'Carbon']) )
 939             exts.append( Extension('_CG', ['cg/_CGmodule.c'],
 940                     extra_link_args=['-framework', 'ApplicationServices']) )
 941             exts.append( Extension('_Cm', ['cm/_Cmmodule.c'],
 942                     extra_link_args=['-framework', 'Carbon']) )
 943             exts.append( Extension('_Ctl', ['ctl/_Ctlmodule.c'],
 944                     extra_link_args=['-framework', 'Carbon']) )
 945             exts.append( Extension('_Dlg', ['dlg/_Dlgmodule.c'],
 946                     extra_link_args=['-framework', 'Carbon']) )
 947             exts.append( Extension('_Drag', ['drag/_Dragmodule.c'],
 948                     extra_link_args=['-framework', 'Carbon']) )
 949             exts.append( Extension('_Evt', ['evt/_Evtmodule.c'],
 950                     extra_link_args=['-framework', 'Carbon']) )
 951             exts.append( Extension('_File', ['file/_Filemodule.c'],
 952                     extra_link_args=['-framework', 'Carbon']) )
 953             exts.append( Extension('_Folder', ['folder/_Foldermodule.c'],
 954                     extra_link_args=['-framework', 'Carbon']) )
 955             exts.append( Extension('_Fm', ['fm/_Fmmodule.c'],
 956                     extra_link_args=['-framework', 'Carbon']) )
 957             exts.append( Extension('_Help', ['help/_Helpmodule.c'],
 958                     extra_link_args=['-framework', 'Carbon']) )
 959             exts.append( Extension('_Icn', ['icn/_Icnmodule.c'],
 960                     extra_link_args=['-framework', 'Carbon']) )
 961             exts.append( Extension('_IBCarbon', ['ibcarbon/_IBCarbon.c'],
 962                     extra_link_args=['-framework', 'Carbon']) )
 963             exts.append( Extension('_Launch', ['launch/_Launchmodule.c'],
 964                     extra_link_args=['-framework', 'ApplicationServices']) )
 965             exts.append( Extension('_List', ['list/_Listmodule.c'],
 966                     extra_link_args=['-framework', 'Carbon']) )
 967             exts.append( Extension('_Menu', ['menu/_Menumodule.c'],
 968                     extra_link_args=['-framework', 'Carbon']) )
 969             exts.append( Extension('_Mlte', ['mlte/_Mltemodule.c'],
 970                     extra_link_args=['-framework', 'Carbon']) )
 971             exts.append( Extension('_OSA', ['osa/_OSAmodule.c'],
 972                     extra_link_args=['-framework', 'Carbon']) )
 973             exts.append( Extension('_Qd', ['qd/_Qdmodule.c'],
 974                     extra_link_args=['-framework', 'Carbon']) )
 975             exts.append( Extension('_Qdoffs', ['qdoffs/_Qdoffsmodule.c'],
 976                     extra_link_args=['-framework', 'Carbon']) )
 977             exts.append( Extension('_Qt', ['qt/_Qtmodule.c'],
 978                     extra_link_args=['-framework', 'QuickTime',
 979                                      '-framework', 'Carbon']) )
 980             exts.append( Extension('_Scrap', ['scrap/_Scrapmodule.c'],
 981                     extra_link_args=['-framework', 'Carbon']) )
 982             exts.append( Extension('_TE', ['te/_TEmodule.c'],
 983                     extra_link_args=['-framework', 'Carbon']) )
 984             # As there is no standardized place (yet) to put
 985             # user-installed Mac libraries on OSX, we search for "waste"
 986             # in parent directories of the Python source tree. You
 987             # should put a symlink to your Waste installation in the
 988             # same folder as your python source tree.  Or modify the
 989             # next few lines:-)
 990             waste_incs = find_file("WASTE.h", [],
 991                     ['../'*n + 'waste/C_C++ Headers' for n in (0,1,2,3,4)])
 992             waste_libs = find_library_file(self.compiler, "WASTE", [],
 993                     ["../"*n + "waste/Static Libraries" for n in (0,1,2,3,4)])
 994             if waste_incs != None and waste_libs != None:
 995                 (srcdir,) = sysconfig.get_config_vars('srcdir')
 996                 exts.append( Extension('waste',
 997                                ['waste/wastemodule.c'] + [
 998                                 os.path.join(srcdir, d) for d in
 999                                 'Mac/Wastemods/WEObjectHandlers.c',
1000                                 'Mac/Wastemods/WETabHooks.c',
1001                                 'Mac/Wastemods/WETabs.c'
1002                                ],
1003                                include_dirs = waste_incs + [os.path.join(srcdir, 'Mac/Wastemods')],
1004                                library_dirs = waste_libs,
1005                                libraries = ['WASTE'],
1006                                extra_link_args = ['-framework', 'Carbon'],
1007                 ) )
1008             exts.append( Extension('_Win', ['win/_Winmodule.c'],
1009                     extra_link_args=['-framework', 'Carbon']) )
1010
1011         self.extensions.extend(exts)
1012
1013         # Call the method for detecting whether _tkinter can be compiled
1014         self.detect_tkinter(inc_dirs, lib_dirs)
1015
1016     def detect_tkinter_darwin(self, inc_dirs, lib_dirs):
1017         # The _tkinter module, using frameworks. Since frameworks are quite
1018         # different the UNIX search logic is not sharable.
1019         from os.path import join, exists
1020         framework_dirs = [
1021             '/System/Library/Frameworks/',
1022             '/Library/Frameworks',
1023             join(os.getenv('HOME'), '/Library/Frameworks')
1024         ]
1025
1026         # Find the directory that contains the Tcl.framework and Tk.framework
1027         # bundles.
1028         # XXX distutils should support -F!
1029         for F in framework_dirs:
1030             # both Tcl.framework and Tk.framework should be present
1031             for fw in 'Tcl', 'Tk':
1032                 if not exists(join(F, fw + '.framework')):
1033                     break
1034             else:
1035                 # ok, F is now directory with both frameworks. Continure
1036                 # building
1037                 break
1038         else:
1039             # Tk and Tcl frameworks not found. Normal "unix" tkinter search
1040             # will now resume.
1041             return 0
1042
1043         # For 8.4a2, we must add -I options that point inside the Tcl and Tk
1044         # frameworks. In later release we should hopefully be able to pass
1045         # the -F option to gcc, which specifies a framework lookup path.
1046         #
1047         include_dirs = [
1048             join(F, fw + '.framework', H)
1049             for fw in 'Tcl', 'Tk'
1050             for H in 'Headers', 'Versions/Current/PrivateHeaders'
1051         ]
1052
1053         # For 8.4a2, the X11 headers are not included. Rather than include a
1054         # complicated search, this is a hard-coded path. It could bail out
1055         # if X11 libs are not found...
1056         include_dirs.append('/usr/X11R6/include')
1057         frameworks = ['-framework', 'Tcl', '-framework', 'Tk']
1058
1059         ext = Extension('_tkinter', ['_tkinter.c', 'tkappinit.c'],
1060                         define_macros=[('WITH_APPINIT', 1)],
1061                         include_dirs = include_dirs,
1062                         libraries = [],
1063                         extra_compile_args = frameworks,
1064                         extra_link_args = frameworks,
1065                         )
1066         self.extensions.append(ext)
1067         return 1
1068
1069
1070     def detect_tkinter(self, inc_dirs, lib_dirs):
1071         # The _tkinter module.
1072
1073         # Rather than complicate the code below, detecting and building
1074         # AquaTk is a separate method. Only one Tkinter will be built on
1075         # Darwin - either AquaTk, if it is found, or X11 based Tk.
1076         platform = self.get_platform()
1077         if (platform == 'darwin' and
1078             self.detect_tkinter_darwin(inc_dirs, lib_dirs)):
1079             return
1080
1081         # Assume we haven't found any of the libraries or include files
1082         # The versions with dots are used on Unix, and the versions without
1083         # dots on Windows, for detection by cygwin.
1084         tcllib = tklib = tcl_includes = tk_includes = None
1085         for version in ['8.5', '85', '8.4', '84', '8.3', '83', '8.2',
1086                         '82', '8.1', '81', '8.0', '80']:
1087             tklib = self.compiler.find_library_file(lib_dirs, 'tk' + version)
1088             tcllib = self.compiler.find_library_file(lib_dirs, 'tcl' + version)
1089             if tklib and tcllib:
1090                 # Exit the loop when we've found the Tcl/Tk libraries
1091                 break
1092
1093         # Now check for the header files
1094         if tklib and tcllib:
1095             # Check for the include files on Debian and {Free,Open}BSD, where
1096             # they're put in /usr/include/{tcl,tk}X.Y
1097             dotversion = version
1098             if '.' not in dotversion and "bsd" in sys.platform.lower():
1099                 # OpenBSD and FreeBSD use Tcl/Tk library names like libtcl83.a,
1100                 # but the include subdirs are named like .../include/tcl8.3.
1101                 dotversion = dotversion[:-1] + '.' + dotversion[-1]
1102             tcl_include_sub = []
1103             tk_include_sub = []
1104             for dir in inc_dirs:
1105                 tcl_include_sub += [dir + os.sep + "tcl" + dotversion]
1106                 tk_include_sub += [dir + os.sep + "tk" + dotversion]
1107             tk_include_sub += tcl_include_sub
1108             tcl_includes = find_file('tcl.h', inc_dirs, tcl_include_sub)
1109             tk_includes = find_file('tk.h', inc_dirs, tk_include_sub)
1110
1111         if (tcllib is None or tklib is None or
1112             tcl_includes is None or tk_includes is None):
1113             self.announce("INFO: Can't locate Tcl/Tk libs and/or headers", 2)
1114             return
1115
1116         # OK... everything seems to be present for Tcl/Tk.
1117
1118         include_dirs = [] ; libs = [] ; defs = [] ; added_lib_dirs = []
1119         for dir in tcl_includes + tk_includes:
1120             if dir not in include_dirs:
1121                 include_dirs.append(dir)
1122
1123         # Check for various platform-specific directories
1124         if platform == 'sunos5':
1125             include_dirs.append('/usr/openwin/include')
1126             added_lib_dirs.append('/usr/openwin/lib')
1127         elif os.path.exists('/usr/X11R6/include'):
1128             include_dirs.append('/usr/X11R6/include')
1129             added_lib_dirs.append('/usr/X11R6/lib64')
1130             added_lib_dirs.append('/usr/X11R6/lib')
1131         elif os.path.exists('/usr/X11R5/include'):
1132             include_dirs.append('/usr/X11R5/include')
1133             added_lib_dirs.append('/usr/X11R5/lib')
1134         else:
1135             # Assume default location for X11
1136             include_dirs.append('/usr/X11/include')
1137             added_lib_dirs.append('/usr/X11/lib')
1138
1139         # If Cygwin, then verify that X is installed before proceeding
1140         if platform == 'cygwin':
1141             x11_inc = find_file('X11/Xlib.h', [], include_dirs)
1142             if x11_inc is None:
1143                 return
1144
1145         # Check for BLT extension
1146         if self.compiler.find_library_file(lib_dirs + added_lib_dirs,
1147                                            'BLT8.0'):
1148             defs.append( ('WITH_BLT', 1) )
1149             libs.append('BLT8.0')
1150         elif self.compiler.find_library_file(lib_dirs + added_lib_dirs,
1151                                            'BLT'):
1152             defs.append( ('WITH_BLT', 1) )
1153             libs.append('BLT')
1154
1155         # Add the Tcl/Tk libraries
1156         libs.append('tk'+ version)
1157         libs.append('tcl'+ version)
1158
1159         if platform in ['aix3', 'aix4']:
1160             libs.append('ld')
1161
1162         # Finally, link with the X11 libraries (not appropriate on cygwin)
1163         if platform != "cygwin":
1164             libs.append('X11')
1165
1166         ext = Extension('_tkinter', ['_tkinter.c', 'tkappinit.c'],
1167                         define_macros=[('WITH_APPINIT', 1)] + defs,
1168                         include_dirs = include_dirs,
1169                         libraries = libs,
1170                         library_dirs = added_lib_dirs,
1171                         )
1172         self.extensions.append(ext)
1173
1174 ##         # Uncomment these lines if you want to play with xxmodule.c
1175 ##         ext = Extension('xx', ['xxmodule.c'])
1176 ##         self.extensions.append(ext)
1177
1178         # XXX handle these, but how to detect?
1179         # *** Uncomment and edit for PIL (TkImaging) extension only:
1180         #       -DWITH_PIL -I../Extensions/Imaging/libImaging  tkImaging.c \
1181         # *** Uncomment and edit for TOGL extension only:
1182         #       -DWITH_TOGL togl.c \
1183         # *** Uncomment these for TOGL extension only:
1184         #       -lGL -lGLU -lXext -lXmu \
1185
1186     def detect_ctypes(self):
1187         (srcdir,) = sysconfig.get_config_vars('srcdir')
1188         ffi_builddir = os.path.join(self.build_temp, 'libffi')
1189         ffi_srcdir = os.path.abspath(os.path.join(srcdir, 'Modules',
1190                                      '_ctypes', 'libffi'))
1191         ffi_configfile = os.path.join(ffi_builddir, 'fficonfig.py')
1192
1193         if self.force or not os.path.exists(ffi_configfile):
1194             from distutils.dir_util import mkpath
1195             mkpath(ffi_builddir)
1196             config_args = []
1197
1198             # Pass empty CFLAGS because we'll just append the resulting CFLAGS
1199             # to Python's; -g or -O2 is to be avoided.
1200             cmd = "cd %s && env CFLAGS='' '%s/configure' %s" \
1201                   % (ffi_builddir, ffi_srcdir, " ".join(config_args))
1202
1203             res = os.system(cmd)
1204             if res or not os.path.exists(ffi_configfile):
1205                 print "Failed to configure _ctypes module"
1206                 return
1207
1208         fficonfig = {}
1209         execfile(ffi_configfile, globals(), fficonfig)
1210         ffi_srcdir = os.path.join(fficonfig['ffi_srcdir'], 'src')
1211
1212         # Add .S (preprocessed assembly) to C compiler source extensions.
1213         self.compiler.src_extensions.append('.S')
1214
1215         include_dirs = [os.path.join(ffi_builddir, 'include'),
1216                         ffi_builddir, ffi_srcdir]
1217         extra_compile_args = fficonfig['ffi_cflags'].split()
1218         sources = ['_ctypes/_ctypes.c',
1219                    '_ctypes/callbacks.c',
1220                    '_ctypes/callproc.c',
1221                    '_ctypes/stgdict.c',
1222                    '_ctypes/cfield.c',
1223                    '_ctypes/malloc_closure.c'] + fficonfig['ffi_sources']
1224         depends = ['_ctypes/ctypes.h']
1225
1226         if sys.platform == 'darwin':
1227             sources.append('_ctypes/darwin/dlfcn_simple.c')
1228             include_dirs.append('_ctypes/darwin')
1229 # XXX Is this still needed?
1230 ##            extra_link_args.extend(['-read_only_relocs', 'warning'])
1231
1232         ext = Extension('_ctypes',
1233                         include_dirs=include_dirs,
1234                         extra_compile_args=extra_compile_args,
1235                         sources=sources,
1236                         depends=depends)
1237         ext_test = Extension('_ctypes_test',
1238                              sources=['_ctypes/_ctypes_test.c'])
1239         self.extensions.extend([ext, ext_test])
1240
1241 class PyBuildInstall(install):
1242     # Suppress the warning about installation into the lib_dynload
1243     # directory, which is not in sys.path when running Python during
1244     # installation:
1245     def initialize_options (self):
1246         install.initialize_options(self)
1247         self.warn_dir=0
1248
1249 class PyBuildInstallLib(install_lib):
1250     # Do exactly what install_lib does but make sure correct access modes get
1251     # set on installed directories and files. All installed files with get
1252     # mode 644 unless they are a shared library in which case they will get
1253     # mode 755. All installed directories will get mode 755.
1254
1255     so_ext = sysconfig.get_config_var("SO")
1256
1257     def install(self):
1258         outfiles = install_lib.install(self)
1259         self.set_file_modes(outfiles, 0644, 0755)
1260         self.set_dir_modes(self.install_dir, 0755)
1261         return outfiles
1262
1263     def set_file_modes(self, files, defaultMode, sharedLibMode):
1264         if not self.is_chmod_supported(): return
1265         if not files: return
1266
1267         for filename in files:
1268             if os.path.islink(filename): continue
1269             mode = defaultMode
1270             if filename.endswith(self.so_ext): mode = sharedLibMode
1271             log.info("changing mode of %s to %o", filename, mode)
1272             if not self.dry_run: os.chmod(filename, mode)
1273
1274     def set_dir_modes(self, dirname, mode):
1275         if not self.is_chmod_supported(): return
1276         os.path.walk(dirname, self.set_dir_modes_visitor, mode)
1277
1278     def set_dir_modes_visitor(self, mode, dirname, names):
1279         if os.path.islink(dirname): return
1280         log.info("changing mode of %s to %o", dirname, mode)
1281         if not self.dry_run: os.chmod(dirname, mode)
1282
1283     def is_chmod_supported(self):
1284         return hasattr(os, 'chmod')
1285
1286 SUMMARY = """
1287 Python is an interpreted, interactive, object-oriented programming
1288 language. It is often compared to Tcl, Perl, Scheme or Java.
1289
1290 Python combines remarkable power with very clear syntax. It has
1291 modules, classes, exceptions, very high level dynamic data types, and
1292 dynamic typing. There are interfaces to many system calls and
1293 libraries, as well as to various windowing systems (X11, Motif, Tk,
1294 Mac, MFC). New built-in modules are easily written in C or C++. Python
1295 is also usable as an extension language for applications that need a
1296 programmable interface.
1297
1298 The Python implementation is portable: it runs on many brands of UNIX,
1299 on Windows, DOS, OS/2, Mac, Amiga... If your favorite system isn't
1300 listed here, it may still be supported, if there's a C compiler for
1301 it. Ask around on comp.lang.python -- or just try compiling Python
1302 yourself.
1303 """
1304
1305 CLASSIFIERS = """
1306 Development Status :: 3 - Alpha
1307 Development Status :: 6 - Mature
1308 License :: OSI Approved :: Python Software Foundation License
1309 Natural Language :: English
1310 Programming Language :: C
1311 Programming Language :: Python
1312 Topic :: Software Development
1313 """
1314
1315 def main():
1316     # turn off warnings when deprecated modules are imported
1317     import warnings
1318     warnings.filterwarnings("ignore",category=DeprecationWarning)
1319     setup(# PyPI Metadata (PEP 301)
1320           name = "Python",
1321           version = sys.version.split()[0],
1322           url = "http://www.python.org/%s" % sys.version[:3],
1323           maintainer = "Guido van Rossum and the Python community",
1324           maintainer_email = "python-dev@python.org",
1325           description = "A high-level object-oriented programming language",
1326           long_description = SUMMARY.strip(),
1327           license = "PSF license",
1328           classifiers = filter(None, CLASSIFIERS.split("\n")),
1329           platforms = ["Many"],
1330
1331           # Build info
1332           cmdclass = {'build_ext':PyBuildExt, 'install':PyBuildInstall,
1333                       'install_lib':PyBuildInstallLib},
1334           # The struct module is defined here, because build_ext won't be
1335           # called unless there's at least one extension module defined.
1336           ext_modules=[Extension('struct', ['structmodule.c'])],
1337
1338           # Scripts to install
1339           scripts = ['Tools/scripts/pydoc', 'Tools/scripts/idle',
1340                      'Lib/smtpd.py']
1341         )
1342
1343 # --install-platlib
1344 if __name__ == '__main__':
1345     main()