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