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 md5c.c and md5.h are included here.
 553             exts.append( Extension('_md5', ['md5module.c', 'md5c.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.1.3"
 756             sqlite_defines = []
 757             if sys.platform != "win32":
 758                 sqlite_defines.append(('PYSQLITE_VERSION',
 759                                         '"%s"' % PYSQLITE_VERSION))
 760             else:
 761                 sqlite_defines.append(('PYSQLITE_VERSION',
 762                                         '\\"'+PYSQLITE_VERSION+'\\"'))
 763             sqlite_defines.append(('PY_MAJOR_VERSION',
 764                                         str(sys.version_info[0])))
 765             sqlite_defines.append(('PY_MINOR_VERSION',
 766                                         str(sys.version_info[1])))
 767
 768             exts.append(Extension('_sqlite3', sqlite_srcs,
 769                                   define_macros=sqlite_defines,
 770                                   include_dirs=["Modules/_sqlite",
 771                                                 sqlite_incdir],
 772                                   library_dirs=sqlite_libdir,
 773                                   runtime_library_dirs=sqlite_libdir,
 774                                   libraries=["sqlite3",]))
 775
 776         # Look for Berkeley db 1.85.   Note that it is built as a different
 777         # module name so it can be included even when later versions are
 778         # available.  A very restrictive search is performed to avoid
 779         # accidentally building this module with a later version of the
 780         # underlying db library.  May BSD-ish Unixes incorporate db 1.85
 781         # symbols into libc and place the include file in /usr/include.
 782         f = "/usr/include/db.h"
 783         if os.path.exists(f):
 784             data = open(f).read()
 785             m = re.search(r"#s*define\s+HASHVERSION\s+2\s*", data)
 786             if m is not None:
 787                 # bingo - old version used hash file format version 2
 788                 ### XXX this should be fixed to not be platform-dependent
 789                 ### but I don't have direct access to an osf1 platform and
 790                 ### seemed to be muffing the search somehow
 791                 libraries = platform == "osf1" and ['db'] or None
 792                 if libraries is not None:
 793                     exts.append(Extension('bsddb185', ['bsddbmodule.c'],
 794                                           libraries=libraries))
 795                 else:
 796                     exts.append(Extension('bsddb185', ['bsddbmodule.c']))
 797
 798         # The standard Unix dbm module:
 799         if platform not in ['cygwin']:
 800             if find_file("ndbm.h", inc_dirs, []) is not None:
 801                 # Some systems have -lndbm, others don't
 802                 if self.compiler.find_library_file(lib_dirs, 'ndbm'):
 803                     ndbm_libs = ['ndbm']
 804                 else:
 805                     ndbm_libs = []
 806                 exts.append( Extension('dbm', ['dbmmodule.c'],
 807                                        define_macros=[('HAVE_NDBM_H',None)],
 808                                        libraries = ndbm_libs ) )
 809             elif (self.compiler.find_library_file(lib_dirs, 'gdbm')
 810                   and find_file("gdbm/ndbm.h", inc_dirs, []) is not None):
 811                 exts.append( Extension('dbm', ['dbmmodule.c'],
 812                                        define_macros=[('HAVE_GDBM_NDBM_H',None)],
 813                                        libraries = ['gdbm'] ) )
 814             elif db_incs is not None:
 815                 exts.append( Extension('dbm', ['dbmmodule.c'],
 816                                        library_dirs=dblib_dir,
 817                                        runtime_library_dirs=dblib_dir,
 818                                        include_dirs=db_incs,
 819                                        define_macros=[('HAVE_BERKDB_H',None),
 820                                                       ('DB_DBM_HSEARCH',None)],
 821                                        libraries=dblibs))
 822
 823         # Anthony Baxter's gdbm module.  GNU dbm(3) will require -lgdbm:
 824         if (self.compiler.find_library_file(lib_dirs, 'gdbm')):
 825             exts.append( Extension('gdbm', ['gdbmmodule.c'],
 826                                    libraries = ['gdbm'] ) )
 827
 828         # Unix-only modules
 829         if platform not in ['mac', 'win32']:
 830             # Steen Lumholt's termios module
 831             exts.append( Extension('termios', ['termios.c']) )
 832             # Jeremy Hylton's rlimit interface
 833             if platform not in ['atheos']:
 834                 exts.append( Extension('resource', ['resource.c']) )
 835
 836             # Sun yellow pages. Some systems have the functions in libc.
 837             if platform not in ['cygwin', 'atheos']:
 838                 if (self.compiler.find_library_file(lib_dirs, 'nsl')):
 839                     libs = ['nsl']
 840                 else:
 841                     libs = []
 842                 exts.append( Extension('nis', ['nismodule.c'],
 843                                        libraries = libs) )
 844
 845         # Curses support, requiring the System V version of curses, often
 846         # provided by the ncurses library.
 847         if (self.compiler.find_library_file(lib_dirs, 'ncursesw')):
 848             curses_libs = ['ncursesw']
 849             exts.append( Extension('_curses', ['_cursesmodule.c'],
 850                                    libraries = curses_libs) )
 851         elif (self.compiler.find_library_file(lib_dirs, 'ncurses')):
 852             curses_libs = ['ncurses']
 853             exts.append( Extension('_curses', ['_cursesmodule.c'],
 854                                    libraries = curses_libs) )
 855         elif (self.compiler.find_library_file(lib_dirs, 'curses')
 856               and platform != 'darwin'):
 857                 # OSX has an old Berkeley curses, not good enough for
 858                 # the _curses module.
 859             if (self.compiler.find_library_file(lib_dirs, 'terminfo')):
 860                 curses_libs = ['curses', 'terminfo']
 861             elif (self.compiler.find_library_file(lib_dirs, 'termcap')):
 862                 curses_libs = ['curses', 'termcap']
 863             else:
 864                 curses_libs = ['curses']
 865
 866             exts.append( Extension('_curses', ['_cursesmodule.c'],
 867                                    libraries = curses_libs) )
 868
 869         # If the curses module is enabled, check for the panel module
 870         if (module_enabled(exts, '_curses') and
 871             self.compiler.find_library_file(lib_dirs, 'panel')):
 872             exts.append( Extension('_curses_panel', ['_curses_panel.c'],
 873                                    libraries = ['panel'] + curses_libs) )
 874
 875
 876         # Andrew Kuchling's zlib module.  Note that some versions of zlib
 877         # 1.1.3 have security problems.  See CERT Advisory CA-2002-07:
 878         # http://www.cert.org/advisories/CA-2002-07.html
 879         #
 880         # zlib 1.1.4 is fixed, but at least one vendor (RedHat) has decided to
 881         # patch its zlib 1.1.3 package instead of upgrading to 1.1.4.  For
 882         # now, we still accept 1.1.3, because we think it's difficult to
 883         # exploit this in Python, and we'd rather make it RedHat's problem
 884         # than our problem <wink>.
 885         #
 886         # You can upgrade zlib to version 1.1.4 yourself by going to
 887         # http://www.gzip.org/zlib/
 888         zlib_inc = find_file('zlib.h', [], inc_dirs)
 889         if zlib_inc is not None:
 890             zlib_h = zlib_inc[0] + '/zlib.h'
 891             version = '"0.0.0"'
 892             version_req = '"1.1.3"'
 893             fp = open(zlib_h)
 894             while 1:
 895                 line = fp.readline()
 896                 if not line:
 897                     break
 898                 if line.startswith('#define ZLIB_VERSION'):
 899                     version = line.split()[2]
 900                     break
 901             if version >= version_req:
 902                 if (self.compiler.find_library_file(lib_dirs, 'z')):
 903                     exts.append( Extension('zlib', ['zlibmodule.c'],
 904                                            libraries = ['z']) )
 905
 906         # Gustavo Niemeyer's bz2 module.
 907         if (self.compiler.find_library_file(lib_dirs, 'bz2')):
 908             exts.append( Extension('bz2', ['bz2module.c'],
 909                                    libraries = ['bz2']) )
 910
 911         # Interface to the Expat XML parser
 912         #
 913         # Expat was written by James Clark and is now maintained by a
 914         # group of developers on SourceForge; see www.libexpat.org for
 915         # more information.  The pyexpat module was written by Paul
 916         # Prescod after a prototype by Jack Jansen.  The Expat source
 917         # is included in Modules/expat/.  Usage of a system
 918         # shared libexpat.so/expat.dll is not advised.
 919         #
 920         # More information on Expat can be found at www.libexpat.org.
 921         #
 922         if sys.byteorder == "little":
 923             xmlbo = "1234"
 924         else:
 925             xmlbo = "4321"
 926         expatinc = os.path.join(os.getcwd(), srcdir, 'Modules', 'expat')
 927         define_macros = [
 928             ('XML_NS', '1'),
 929             ('XML_DTD', '1'),
 930             ('BYTEORDER', xmlbo),
 931             ('XML_CONTEXT_BYTES','1024'),
 932             ]
 933         for feature_macro in ['HAVE_MEMMOVE', 'HAVE_BCOPY']:
 934             if config_h_vars.has_key(feature_macro):
 935                 define_macros.append((feature_macro, '1'))
 936         exts.append(Extension('pyexpat',
 937                               define_macros = define_macros,
 938                               include_dirs = [expatinc],
 939                               sources = ['pyexpat.c',
 940                                          'expat/xmlparse.c',
 941                                          'expat/xmlrole.c',
 942                                          'expat/xmltok.c',
 943                                          ],
 944                               ))
 945
 946         # Fredrik Lundh's cElementTree module.  Note that this also
 947         # uses expat (via the CAPI hook in pyexpat).
 948
 949         if os.path.isfile(os.path.join(srcdir, 'Modules', '_elementtree.c')):
 950             define_macros.append(('USE_PYEXPAT_CAPI', None))
 951             exts.append(Extension('_elementtree',
 952                                   define_macros = define_macros,
 953                                   include_dirs = [expatinc],
 954                                   sources = ['_elementtree.c'],
 955                                   ))
 956
 957         # Hye-Shik Chang's CJKCodecs modules.
 958         if have_unicode:
 959             exts.append(Extension('_multibytecodec',
 960                                   ['cjkcodecs/multibytecodec.c']))
 961             for loc in ('kr', 'jp', 'cn', 'tw', 'hk', 'iso2022'):
 962                 exts.append(Extension('_codecs_' + loc,
 963                                       ['cjkcodecs/_codecs_%s.c' % loc]))
 964
 965         # Dynamic loading module
 966         if sys.maxint == 0x7fffffff:
 967             # This requires sizeof(int) == sizeof(long) == sizeof(char*)
 968             dl_inc = find_file('dlfcn.h', [], inc_dirs)
 969             if (dl_inc is not None) and (platform not in ['atheos', 'darwin']):
 970                 exts.append( Extension('dl', ['dlmodule.c']) )
 971
 972         # Thomas Heller's _ctypes module
 973         self.detect_ctypes()
 974
 975         # Platform-specific libraries
 976         if platform == 'linux2':
 977             # Linux-specific modules
 978             exts.append( Extension('linuxaudiodev', ['linuxaudiodev.c']) )
 979
 980         if platform in ('linux2', 'freebsd4', 'freebsd5', 'freebsd6',
 981                         'freebsd7'):
 982             exts.append( Extension('ossaudiodev', ['ossaudiodev.c']) )
 983
 984         if platform == 'sunos5':
 985             # SunOS specific modules
 986             exts.append( Extension('sunaudiodev', ['sunaudiodev.c']) )
 987
 988         if platform == 'darwin' and ("--disable-toolbox-glue" not in
 989                 sysconfig.get_config_var("CONFIG_ARGS")):
 990
 991             if os.uname()[2] > '8.':
 992                 # We're on Mac OS X 10.4 or later, the compiler should
 993                 # support '-Wno-deprecated-declarations'. This will
 994                 # surpress deprecation warnings for the Carbon extensions,
 995                 # these extensions wrap the Carbon APIs and even those
 996                 # parts that are deprecated.
 997                 carbon_extra_compile_args = ['-Wno-deprecated-declarations']
 998             else:
 999                 carbon_extra_compile_args = []
1000
1001             # Mac OS X specific modules.
1002             def macSrcExists(name1, name2=''):
1003                 if not name1:
1004                     return None
1005                 names = (name1,)
1006                 if name2:
1007                     names = (name1, name2)
1008                 path = os.path.join(srcdir, 'Mac', 'Modules', *names)
1009                 return os.path.exists(path)
1010
1011             def addMacExtension(name, kwds, extra_srcs=[]):
1012                 dirname = ''
1013                 if name[0] == '_':
1014                     dirname = name[1:].lower()
1015                 cname = name + '.c'
1016                 cmodulename = name + 'module.c'
1017                 # Check for NNN.c, NNNmodule.c, _nnn/NNN.c, _nnn/NNNmodule.c
1018                 if macSrcExists(cname):
1019                     srcs = [cname]
1020                 elif macSrcExists(cmodulename):
1021                     srcs = [cmodulename]
1022                 elif macSrcExists(dirname, cname):
1023                     # XXX(nnorwitz): If all the names ended with module, we
1024                     # wouldn't need this condition.  ibcarbon is the only one.
1025                     srcs = [os.path.join(dirname, cname)]
1026                 elif macSrcExists(dirname, cmodulename):
1027                     srcs = [os.path.join(dirname, cmodulename)]
1028                 else:
1029                     raise RuntimeError("%s not found" % name)
1030
1031                 # Here's the whole point:  add the extension with sources
1032                 exts.append(Extension(name, srcs + extra_srcs, **kwds))
1033
1034             # Core Foundation
1035             core_kwds = {'extra_compile_args': carbon_extra_compile_args,
1036                          'extra_link_args': ['-framework', 'CoreFoundation'],
1037                         }
1038             addMacExtension('_CF', core_kwds, ['cf/pycfbridge.c'])
1039             addMacExtension('autoGIL', core_kwds)
1040
1041             # Carbon
1042             carbon_kwds = {'extra_compile_args': carbon_extra_compile_args,
1043                            'extra_link_args': ['-framework', 'Carbon'],
1044                           }
1045             CARBON_EXTS = ['ColorPicker', 'gestalt', 'MacOS', 'Nav',
1046                            'OSATerminology', 'icglue',
1047                            # All these are in subdirs
1048                            '_AE', '_AH', '_App', '_CarbonEvt', '_Cm', '_Ctl',
1049                            '_Dlg', '_Drag', '_Evt', '_File', '_Folder', '_Fm',
1050                            '_Help', '_Icn', '_IBCarbon', '_List',
1051                            '_Menu', '_Mlte', '_OSA', '_Res', '_Qd', '_Qdoffs',
1052                            '_Scrap', '_Snd', '_TE', '_Win',
1053                           ]
1054             for name in CARBON_EXTS:
1055                 addMacExtension(name, carbon_kwds)
1056
1057             # Application Services & QuickTime
1058             app_kwds = {'extra_compile_args': carbon_extra_compile_args,
1059                         'extra_link_args': ['-framework','ApplicationServices'],
1060                        }
1061             addMacExtension('_Launch', app_kwds)
1062             addMacExtension('_CG', app_kwds)
1063
1064             exts.append( Extension('_Qt', ['qt/_Qtmodule.c'],
1065                         extra_compile_args=carbon_extra_compile_args,
1066                         extra_link_args=['-framework', 'QuickTime',
1067                                      '-framework', 'Carbon']) )
1068
1069             # As there is no standardized place (yet) to put
1070             # user-installed Mac libraries on OSX, we search for "waste"
1071             # in parent directories of the Python source tree. You
1072             # should put a symlink to your Waste installation in the
1073             # same folder as your python source tree.  Or modify the
1074             # next few lines:-)
1075             waste_incs = find_file("WASTE.h", [],
1076                     ['../'*n + 'waste/C_C++ Headers' for n in (0,1,2,3,4)])
1077             waste_libs = find_library_file(self.compiler, "WASTE", [],
1078                     ["../"*n + "waste/Static Libraries" for n in (0,1,2,3,4)])
1079             if waste_incs != None and waste_libs != None:
1080                 exts.append( Extension('waste',
1081                                ['waste/wastemodule.c'] + [
1082                                 os.path.join(srcdir, d) for d in
1083                                 'Mac/Wastemods/WEObjectHandlers.c',
1084                                 'Mac/Wastemods/WETabHooks.c',
1085                                 'Mac/Wastemods/WETabs.c'
1086                                ],
1087                                include_dirs = waste_incs + [os.path.join(srcdir, 'Mac/Wastemods')],
1088                                library_dirs = waste_libs,
1089                                libraries = ['WASTE'],
1090                                extra_link_args = ['-framework', 'Carbon'],
1091                 ) )
1092
1093         self.extensions.extend(exts)
1094
1095         # Call the method for detecting whether _tkinter can be compiled
1096         self.detect_tkinter(inc_dirs, lib_dirs)
1097
1098     def detect_tkinter_darwin(self, inc_dirs, lib_dirs):
1099         # The _tkinter module, using frameworks. Since frameworks are quite
1100         # different the UNIX search logic is not sharable.
1101         from os.path import join, exists
1102         framework_dirs = [
1103             '/System/Library/Frameworks/',
1104             '/Library/Frameworks',
1105             join(os.getenv('HOME'), '/Library/Frameworks')
1106         ]
1107
1108         # Find the directory that contains the Tcl.framework and Tk.framework
1109         # bundles.
1110         # XXX distutils should support -F!
1111         for F in framework_dirs:
1112             # both Tcl.framework and Tk.framework should be present
1113             for fw in 'Tcl', 'Tk':
1114                 if not exists(join(F, fw + '.framework')):
1115                     break
1116             else:
1117                 # ok, F is now directory with both frameworks. Continure
1118                 # building
1119                 break
1120         else:
1121             # Tk and Tcl frameworks not found. Normal "unix" tkinter search
1122             # will now resume.
1123             return 0
1124
1125         # For 8.4a2, we must add -I options that point inside the Tcl and Tk
1126         # frameworks. In later release we should hopefully be able to pass
1127         # the -F option to gcc, which specifies a framework lookup path.
1128         #
1129         include_dirs = [
1130             join(F, fw + '.framework', H)
1131             for fw in 'Tcl', 'Tk'
1132             for H in 'Headers', 'Versions/Current/PrivateHeaders'
1133         ]
1134
1135         # For 8.4a2, the X11 headers are not included. Rather than include a
1136         # complicated search, this is a hard-coded path. It could bail out
1137         # if X11 libs are not found...
1138         include_dirs.append('/usr/X11R6/include')
1139         frameworks = ['-framework', 'Tcl', '-framework', 'Tk']
1140
1141         ext = Extension('_tkinter', ['_tkinter.c', 'tkappinit.c'],
1142                         define_macros=[('WITH_APPINIT', 1)],
1143                         include_dirs = include_dirs,
1144                         libraries = [],
1145                         extra_compile_args = frameworks,
1146                         extra_link_args = frameworks,
1147                         )
1148         self.extensions.append(ext)
1149         return 1
1150
1151
1152     def detect_tkinter(self, inc_dirs, lib_dirs):
1153         # The _tkinter module.
1154
1155         # Rather than complicate the code below, detecting and building
1156         # AquaTk is a separate method. Only one Tkinter will be built on
1157         # Darwin - either AquaTk, if it is found, or X11 based Tk.
1158         platform = self.get_platform()
1159         if (platform == 'darwin' and
1160             self.detect_tkinter_darwin(inc_dirs, lib_dirs)):
1161             return
1162
1163         # Assume we haven't found any of the libraries or include files
1164         # The versions with dots are used on Unix, and the versions without
1165         # dots on Windows, for detection by cygwin.
1166         tcllib = tklib = tcl_includes = tk_includes = None
1167         for version in ['8.5', '85', '8.4', '84', '8.3', '83', '8.2',
1168                         '82', '8.1', '81', '8.0', '80']:
1169             tklib = self.compiler.find_library_file(lib_dirs, 'tk' + version)
1170             tcllib = self.compiler.find_library_file(lib_dirs, 'tcl' + version)
1171             if tklib and tcllib:
1172                 # Exit the loop when we've found the Tcl/Tk libraries
1173                 break
1174
1175         # Now check for the header files
1176         if tklib and tcllib:
1177             # Check for the include files on Debian and {Free,Open}BSD, where
1178             # they're put in /usr/include/{tcl,tk}X.Y
1179             dotversion = version
1180             if '.' not in dotversion and "bsd" in sys.platform.lower():
1181                 # OpenBSD and FreeBSD use Tcl/Tk library names like libtcl83.a,
1182                 # but the include subdirs are named like .../include/tcl8.3.
1183                 dotversion = dotversion[:-1] + '.' + dotversion[-1]
1184             tcl_include_sub = []
1185             tk_include_sub = []
1186             for dir in inc_dirs:
1187                 tcl_include_sub += [dir + os.sep + "tcl" + dotversion]
1188                 tk_include_sub += [dir + os.sep + "tk" + dotversion]
1189             tk_include_sub += tcl_include_sub
1190             tcl_includes = find_file('tcl.h', inc_dirs, tcl_include_sub)
1191             tk_includes = find_file('tk.h', inc_dirs, tk_include_sub)
1192
1193         if (tcllib is None or tklib is None or
1194             tcl_includes is None or tk_includes is None):
1195             self.announce("INFO: Can't locate Tcl/Tk libs and/or headers", 2)
1196             return
1197
1198         # OK... everything seems to be present for Tcl/Tk.
1199
1200         include_dirs = [] ; libs = [] ; defs = [] ; added_lib_dirs = []
1201         for dir in tcl_includes + tk_includes:
1202             if dir not in include_dirs:
1203                 include_dirs.append(dir)
1204
1205         # Check for various platform-specific directories
1206         if platform == 'sunos5':
1207             include_dirs.append('/usr/openwin/include')
1208             added_lib_dirs.append('/usr/openwin/lib')
1209         elif os.path.exists('/usr/X11R6/include'):
1210             include_dirs.append('/usr/X11R6/include')
1211             added_lib_dirs.append('/usr/X11R6/lib64')
1212             added_lib_dirs.append('/usr/X11R6/lib')
1213         elif os.path.exists('/usr/X11R5/include'):
1214             include_dirs.append('/usr/X11R5/include')
1215             added_lib_dirs.append('/usr/X11R5/lib')
1216         else:
1217             # Assume default location for X11
1218             include_dirs.append('/usr/X11/include')
1219             added_lib_dirs.append('/usr/X11/lib')
1220
1221         # If Cygwin, then verify that X is installed before proceeding
1222         if platform == 'cygwin':
1223             x11_inc = find_file('X11/Xlib.h', [], include_dirs)
1224             if x11_inc is None:
1225                 return
1226
1227         # Check for BLT extension
1228         if self.compiler.find_library_file(lib_dirs + added_lib_dirs,
1229                                            'BLT8.0'):
1230             defs.append( ('WITH_BLT', 1) )
1231             libs.append('BLT8.0')
1232         elif self.compiler.find_library_file(lib_dirs + added_lib_dirs,
1233                                            'BLT'):
1234             defs.append( ('WITH_BLT', 1) )
1235             libs.append('BLT')
1236
1237         # Add the Tcl/Tk libraries
1238         libs.append('tk'+ version)
1239         libs.append('tcl'+ version)
1240
1241         if platform in ['aix3', 'aix4']:
1242             libs.append('ld')
1243
1244         # Finally, link with the X11 libraries (not appropriate on cygwin)
1245         if platform != "cygwin":
1246             libs.append('X11')
1247
1248         ext = Extension('_tkinter', ['_tkinter.c', 'tkappinit.c'],
1249                         define_macros=[('WITH_APPINIT', 1)] + defs,
1250                         include_dirs = include_dirs,
1251                         libraries = libs,
1252                         library_dirs = added_lib_dirs,
1253                         )
1254         self.extensions.append(ext)
1255
1256 ##         # Uncomment these lines if you want to play with xxmodule.c
1257 ##         ext = Extension('xx', ['xxmodule.c'])
1258 ##         self.extensions.append(ext)
1259
1260         # XXX handle these, but how to detect?
1261         # *** Uncomment and edit for PIL (TkImaging) extension only:
1262         #       -DWITH_PIL -I../Extensions/Imaging/libImaging  tkImaging.c \
1263         # *** Uncomment and edit for TOGL extension only:
1264         #       -DWITH_TOGL togl.c \
1265         # *** Uncomment these for TOGL extension only:
1266         #       -lGL -lGLU -lXext -lXmu \
1267
1268     def detect_ctypes(self):
1269         (srcdir,) = sysconfig.get_config_vars('srcdir')
1270         ffi_builddir = os.path.join(self.build_temp, 'libffi')
1271         ffi_srcdir = os.path.abspath(os.path.join(srcdir, 'Modules',
1272                                      '_ctypes', 'libffi'))
1273         ffi_configfile = os.path.join(ffi_builddir, 'fficonfig.py')
1274
1275         if self.force or not os.path.exists(ffi_configfile):
1276             from distutils.dir_util import mkpath
1277             mkpath(ffi_builddir)
1278             config_args = []
1279
1280             # Pass empty CFLAGS because we'll just append the resulting CFLAGS
1281             # to Python's; -g or -O2 is to be avoided.
1282             cmd = "cd %s && env CFLAGS='' '%s/configure' %s" \
1283                   % (ffi_builddir, ffi_srcdir, " ".join(config_args))
1284
1285             res = os.system(cmd)
1286             if res or not os.path.exists(ffi_configfile):
1287                 print "Failed to configure _ctypes module"
1288                 return
1289
1290         fficonfig = {}
1291         execfile(ffi_configfile, globals(), fficonfig)
1292         ffi_srcdir = os.path.join(fficonfig['ffi_srcdir'], 'src')
1293
1294         # Add .S (preprocessed assembly) to C compiler source extensions.
1295         self.compiler.src_extensions.append('.S')
1296
1297         include_dirs = [os.path.join(ffi_builddir, 'include'),
1298                         ffi_builddir, ffi_srcdir]
1299         extra_compile_args = fficonfig['ffi_cflags'].split()
1300         sources = ['_ctypes/_ctypes.c',
1301                    '_ctypes/callbacks.c',
1302                    '_ctypes/callproc.c',
1303                    '_ctypes/stgdict.c',
1304                    '_ctypes/cfield.c',
1305                    '_ctypes/malloc_closure.c'] + fficonfig['ffi_sources']
1306         depends = ['_ctypes/ctypes.h']
1307
1308         if sys.platform == 'darwin':
1309             sources.append('_ctypes/darwin/dlfcn_simple.c')
1310             include_dirs.append('_ctypes/darwin')
1311 # XXX Is this still needed?
1312 ##            extra_link_args.extend(['-read_only_relocs', 'warning'])
1313
1314         ext = Extension('_ctypes',
1315                         include_dirs=include_dirs,
1316                         extra_compile_args=extra_compile_args,
1317                         sources=sources,
1318                         depends=depends)
1319         ext_test = Extension('_ctypes_test',
1320                              sources=['_ctypes/_ctypes_test.c'])
1321         self.extensions.extend([ext, ext_test])
1322
1323 class PyBuildInstall(install):
1324     # Suppress the warning about installation into the lib_dynload
1325     # directory, which is not in sys.path when running Python during
1326     # installation:
1327     def initialize_options (self):
1328         install.initialize_options(self)
1329         self.warn_dir=0
1330
1331 class PyBuildInstallLib(install_lib):
1332     # Do exactly what install_lib does but make sure correct access modes get
1333     # set on installed directories and files. All installed files with get
1334     # mode 644 unless they are a shared library in which case they will get
1335     # mode 755. All installed directories will get mode 755.
1336
1337     so_ext = sysconfig.get_config_var("SO")
1338
1339     def install(self):
1340         outfiles = install_lib.install(self)
1341         self.set_file_modes(outfiles, 0644, 0755)
1342         self.set_dir_modes(self.install_dir, 0755)
1343         return outfiles
1344
1345     def set_file_modes(self, files, defaultMode, sharedLibMode):
1346         if not self.is_chmod_supported(): return
1347         if not files: return
1348
1349         for filename in files:
1350             if os.path.islink(filename): continue
1351             mode = defaultMode
1352             if filename.endswith(self.so_ext): mode = sharedLibMode
1353             log.info("changing mode of %s to %o", filename, mode)
1354             if not self.dry_run: os.chmod(filename, mode)
1355
1356     def set_dir_modes(self, dirname, mode):
1357         if not self.is_chmod_supported(): return
1358         os.path.walk(dirname, self.set_dir_modes_visitor, mode)
1359
1360     def set_dir_modes_visitor(self, mode, dirname, names):
1361         if os.path.islink(dirname): return
1362         log.info("changing mode of %s to %o", dirname, mode)
1363         if not self.dry_run: os.chmod(dirname, mode)
1364
1365     def is_chmod_supported(self):
1366         return hasattr(os, 'chmod')
1367
1368 SUMMARY = """
1369 Python is an interpreted, interactive, object-oriented programming
1370 language. It is often compared to Tcl, Perl, Scheme or Java.
1371
1372 Python combines remarkable power with very clear syntax. It has
1373 modules, classes, exceptions, very high level dynamic data types, and
1374 dynamic typing. There are interfaces to many system calls and
1375 libraries, as well as to various windowing systems (X11, Motif, Tk,
1376 Mac, MFC). New built-in modules are easily written in C or C++. Python
1377 is also usable as an extension language for applications that need a
1378 programmable interface.
1379
1380 The Python implementation is portable: it runs on many brands of UNIX,
1381 on Windows, DOS, OS/2, Mac, Amiga... If your favorite system isn't
1382 listed here, it may still be supported, if there's a C compiler for
1383 it. Ask around on comp.lang.python -- or just try compiling Python
1384 yourself.
1385 """
1386
1387 CLASSIFIERS = """
1388 Development Status :: 3 - Alpha
1389 Development Status :: 6 - Mature
1390 License :: OSI Approved :: Python Software Foundation License
1391 Natural Language :: English
1392 Programming Language :: C
1393 Programming Language :: Python
1394 Topic :: Software Development
1395 """
1396
1397 def main():
1398     # turn off warnings when deprecated modules are imported
1399     import warnings
1400     warnings.filterwarnings("ignore",category=DeprecationWarning)
1401     setup(# PyPI Metadata (PEP 301)
1402           name = "Python",
1403           version = sys.version.split()[0],
1404           url = "http://www.python.org/%s" % sys.version[:3],
1405           maintainer = "Guido van Rossum and the Python community",
1406           maintainer_email = "python-dev@python.org",
1407           description = "A high-level object-oriented programming language",
1408           long_description = SUMMARY.strip(),
1409           license = "PSF license",
1410           classifiers = filter(None, CLASSIFIERS.split("\n")),
1411           platforms = ["Many"],
1412
1413           # Build info
1414           cmdclass = {'build_ext':PyBuildExt, 'install':PyBuildInstall,
1415                       'install_lib':PyBuildInstallLib},
1416           # The struct module is defined here, because build_ext won't be
1417           # called unless there's at least one extension module defined.
1418           ext_modules=[Extension('struct', ['structmodule.c'])],
1419
1420           # Scripts to install
1421           scripts = ['Tools/scripts/pydoc', 'Tools/scripts/idle',
1422                      'Lib/smtpd.py']
1423         )
1424
1425 # --install-platlib
1426 if __name__ == '__main__':
1427     main()