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