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