setup.py

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