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