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             # Read SGI RGB image files (but coded portably)
 512             exts.append( Extension('rgbimg', ['rgbimgmodule.c']) )
 513         else:
 514             missing.extend(['imageop', 'rgbimg'])
 515
 516         # readline
 517         do_readline = self.compiler.find_library_file(lib_dirs, 'readline')
 518         if platform == 'darwin':
 519             # MacOSX 10.4 has a broken readline. Don't try to build
 520             # the readline module unless the user has installed a fixed
 521             # readline package
 522             if find_file('readline/rlconf.h', inc_dirs, []) is None:
 523                 do_readline = False
 524         if do_readline:
 525             if sys.platform == 'darwin':
 526                 # In every directory on the search path search for a dynamic
 527                 # library and then a static library, instead of first looking
 528                 # for dynamic libraries on the entiry path.
 529                 # This way a staticly linked custom readline gets picked up
 530                 # before the (broken) dynamic library in /usr/lib.
 531                 readline_extra_link_args = ('-Wl,-search_paths_first',)
 532             else:
 533                 readline_extra_link_args = ()
 534
 535             readline_libs = ['readline']
 536             if self.compiler.find_library_file(lib_dirs,
 537                                                  'ncursesw'):
 538                 readline_libs.append('ncursesw')
 539             elif self.compiler.find_library_file(lib_dirs,
 540                                                  'ncurses'):
 541                 readline_libs.append('ncurses')
 542             elif self.compiler.find_library_file(lib_dirs, 'curses'):
 543                 readline_libs.append('curses')
 544             elif self.compiler.find_library_file(lib_dirs +
 545                                                ['/usr/lib/termcap'],
 546                                                'termcap'):
 547                 readline_libs.append('termcap')
 548             exts.append( Extension('readline', ['readline.c'],
 549                                    library_dirs=['/usr/lib/termcap'],
 550                                    extra_link_args=readline_extra_link_args,
 551                                    libraries=readline_libs) )
 552         else:
 553             missing.append('readline')
 554
 555         if platform not in ['mac']:
 556             # crypt module.
 557
 558             if self.compiler.find_library_file(lib_dirs, 'crypt'):
 559                 libs = ['crypt']
 560             else:
 561                 libs = []
 562             exts.append( Extension('crypt', ['cryptmodule.c'], libraries=libs) )
 563         else:
 564             missing.append('crypt')
 565
 566         # CSV files
 567         exts.append( Extension('_csv', ['_csv.c']) )
 568
 569         # socket(2)
 570         exts.append( Extension('_socket', ['socketmodule.c'],
 571                                depends = ['socketmodule.h']) )
 572         # Detect SSL support for the socket module (via _ssl)
 573         search_for_ssl_incs_in = [
 574                               '/usr/local/ssl/include',
 575                               '/usr/contrib/ssl/include/'
 576                              ]
 577         ssl_incs = find_file('openssl/ssl.h', inc_dirs,
 578                              search_for_ssl_incs_in
 579                              )
 580         if ssl_incs is not None:
 581             krb5_h = find_file('krb5.h', inc_dirs,
 582                                ['/usr/kerberos/include'])
 583             if krb5_h:
 584                 ssl_incs += krb5_h
 585         ssl_libs = find_library_file(self.compiler, 'ssl',lib_dirs,
 586                                      ['/usr/local/ssl/lib',
 587                                       '/usr/contrib/ssl/lib/'
 588                                      ] )
 589
 590         if (ssl_incs is not None and
 591             ssl_libs is not None):
 592             exts.append( Extension('_ssl', ['_ssl.c'],
 593                                    include_dirs = ssl_incs,
 594                                    library_dirs = ssl_libs,
 595                                    libraries = ['ssl', 'crypto'],
 596                                    depends = ['socketmodule.h']), )
 597         else:
 598             missing.append('_ssl')
 599
 600         # find out which version of OpenSSL we have
 601         openssl_ver = 0
 602         openssl_ver_re = re.compile(
 603             '^\s*#\s*define\s+OPENSSL_VERSION_NUMBER\s+(0x[0-9a-fA-F]+)' )
 604         for ssl_inc_dir in inc_dirs + search_for_ssl_incs_in:
 605             name = os.path.join(ssl_inc_dir, 'openssl', 'opensslv.h')
 606             if os.path.isfile(name):
 607                 try:
 608                     incfile = open(name, 'r')
 609                     for line in incfile:
 610                         m = openssl_ver_re.match(line)
 611                         if m:
 612                             openssl_ver = eval(m.group(1))
 613                             break
 614                 except IOError:
 615                     pass
 616
 617             # first version found is what we'll use (as the compiler should)
 618             if openssl_ver:
 619                 break
 620
 621         #print 'openssl_ver = 0x%08x' % openssl_ver
 622
 623         if (ssl_incs is not None and
 624             ssl_libs is not None and
 625             openssl_ver >= 0x00907000):
 626             # The _hashlib module wraps optimized implementations
 627             # of hash functions from the OpenSSL library.
 628             exts.append( Extension('_hashlib', ['_hashopenssl.c'],
 629                                    include_dirs = ssl_incs,
 630                                    library_dirs = ssl_libs,
 631                                    libraries = ['ssl', 'crypto']) )
 632             missing.extend(['_sha', '_md5'])
 633         else:
 634             # The _sha module implements the SHA1 hash algorithm.
 635             exts.append( Extension('_sha', ['shamodule.c']) )
 636             # The _md5 module implements the RSA Data Security, Inc. MD5
 637             # Message-Digest Algorithm, described in RFC 1321.  The
 638             # necessary files md5.c and md5.h are included here.
 639             exts.append( Extension('_md5',
 640                             sources = ['md5module.c', 'md5.c'],
 641                             depends = ['md5.h']) )
 642             missing.append('_hashlib')
 643
 644         if (openssl_ver < 0x00908000):
 645             # OpenSSL doesn't do these until 0.9.8 so we'll bring our own hash
 646             exts.append( Extension('_sha256', ['sha256module.c']) )
 647             exts.append( Extension('_sha512', ['sha512module.c']) )
 648         else:
 649             missing.extend(['_sha256', '_sha512'])
 650
 651         # Modules that provide persistent dictionary-like semantics.  You will
 652         # probably want to arrange for at least one of them to be available on
 653         # your machine, though none are defined by default because of library
 654         # dependencies.  The Python module anydbm.py provides an
 655         # implementation independent wrapper for these; dumbdbm.py provides
 656         # similar functionality (but slower of course) implemented in Python.
 657
 658         # Sleepycat Berkeley DB interface.  http://www.sleepycat.com
 659         #
 660         # This requires the Sleepycat DB code. The supported versions
 661         # are set below.  Visit http://www.sleepycat.com/ to download
 662         # a release.  Most open source OSes come with one or more
 663         # versions of BerkeleyDB already installed.
 664
 665         max_db_ver = (4, 5)
 666         min_db_ver = (3, 3)
 667         db_setup_debug = False   # verbose debug prints from this script?
 668
 669         # construct a list of paths to look for the header file in on
 670         # top of the normal inc_dirs.
 671         db_inc_paths = [
 672             '/usr/include/db4',
 673             '/usr/local/include/db4',
 674             '/opt/sfw/include/db4',
 675             '/usr/include/db3',
 676             '/usr/local/include/db3',
 677             '/opt/sfw/include/db3',
 678             # Fink defaults (http://fink.sourceforge.net/)
 679             '/sw/include/db4',
 680             '/sw/include/db3',
 681         ]
 682         # 4.x minor number specific paths
 683         for x in (0,1,2,3,4,5):
 684             db_inc_paths.append('/usr/include/db4%d' % x)
 685             db_inc_paths.append('/usr/include/db4.%d' % x)
 686             db_inc_paths.append('/usr/local/BerkeleyDB.4.%d/include' % x)
 687             db_inc_paths.append('/usr/local/include/db4%d' % x)
 688             db_inc_paths.append('/pkg/db-4.%d/include' % x)
 689             db_inc_paths.append('/opt/db-4.%d/include' % x)
 690             # MacPorts default (http://www.macports.org/)
 691             db_inc_paths.append('/opt/local/include/db4%d' % x)
 692         # 3.x minor number specific paths
 693         for x in (3,):
 694             db_inc_paths.append('/usr/include/db3%d' % x)
 695             db_inc_paths.append('/usr/local/BerkeleyDB.3.%d/include' % x)
 696             db_inc_paths.append('/usr/local/include/db3%d' % x)
 697             db_inc_paths.append('/pkg/db-3.%d/include' % x)
 698             db_inc_paths.append('/opt/db-3.%d/include' % x)
 699
 700         # Add some common subdirectories for Sleepycat DB to the list,
 701         # based on the standard include directories. This way DB3/4 gets
 702         # picked up when it is installed in a non-standard prefix and
 703         # the user has added that prefix into inc_dirs.
 704         std_variants = []
 705         for dn in inc_dirs:
 706             std_variants.append(os.path.join(dn, 'db3'))
 707             std_variants.append(os.path.join(dn, 'db4'))
 708             for x in (0,1,2,3,4):
 709                 std_variants.append(os.path.join(dn, "db4%d"%x))
 710                 std_variants.append(os.path.join(dn, "db4.%d"%x))
 711             for x in (2,3):
 712                 std_variants.append(os.path.join(dn, "db3%d"%x))
 713                 std_variants.append(os.path.join(dn, "db3.%d"%x))
 714
 715         db_inc_paths = std_variants + db_inc_paths
 716         db_inc_paths = [p for p in db_inc_paths if os.path.exists(p)]
 717
 718         db_ver_inc_map = {}
 719
 720         class db_found(Exception): pass
 721         try:
 722             # See whether there is a Sleepycat header in the standard
 723             # search path.
 724             for d in inc_dirs + db_inc_paths:
 725                 f = os.path.join(d, "db.h")
 726                 if db_setup_debug: print "db: looking for db.h in", f
 727                 if os.path.exists(f):
 728                     f = open(f).read()
 729                     m = re.search(r"#define\WDB_VERSION_MAJOR\W(\d+)", f)
 730                     if m:
 731                         db_major = int(m.group(1))
 732                         m = re.search(r"#define\WDB_VERSION_MINOR\W(\d+)", f)
 733                         db_minor = int(m.group(1))
 734                         db_ver = (db_major, db_minor)
 735
 736                         if ( (not db_ver_inc_map.has_key(db_ver)) and
 737                            (db_ver <= max_db_ver and db_ver >= min_db_ver) ):
 738                             # save the include directory with the db.h version
 739                             # (first occurrence only)
 740                             db_ver_inc_map[db_ver] = d
 741                             if db_setup_debug:
 742                                 print "db.h: found", db_ver, "in", d
 743                         else:
 744                             # we already found a header for this library version
 745                             if db_setup_debug: print "db.h: ignoring", d
 746                     else:
 747                         # ignore this header, it didn't contain a version number
 748                         if db_setup_debug:
 749                             print "db.h: no version number version in", d
 750
 751             db_found_vers = db_ver_inc_map.keys()
 752             db_found_vers.sort()
 753
 754             while db_found_vers:
 755                 db_ver = db_found_vers.pop()
 756                 db_incdir = db_ver_inc_map[db_ver]
 757
 758                 # check lib directories parallel to the location of the header
 759                 db_dirs_to_check = [
 760                     db_incdir.replace("include", 'lib64'),
 761                     db_incdir.replace("include", 'lib'),
 762                 ]
 763                 db_dirs_to_check = filter(os.path.isdir, db_dirs_to_check)
 764
 765                 # Look for a version specific db-X.Y before an ambiguoius dbX
 766                 # XXX should we -ever- look for a dbX name?  Do any
 767                 # systems really not name their library by version and
 768                 # symlink to more general names?
 769                 for dblib in (('db-%d.%d' % db_ver),
 770                               ('db%d%d' % db_ver),
 771                               ('db%d' % db_ver[0])):
 772                     dblib_file = self.compiler.find_library_file(
 773                                     db_dirs_to_check + lib_dirs, dblib )
 774                     if dblib_file:
 775                         dblib_dir = [ os.path.abspath(os.path.dirname(dblib_file)) ]
 776                         raise db_found
 777                     else:
 778                         if db_setup_debug: print "db lib: ", dblib, "not found"
 779
 780         except db_found:
 781             if db_setup_debug:
 782                 print "db lib: using", db_ver, dblib
 783                 print "db: lib dir", dblib_dir, "inc dir", db_incdir
 784             db_incs = [db_incdir]
 785             dblibs = [dblib]
 786             # We add the runtime_library_dirs argument because the
 787             # BerkeleyDB lib we're linking against often isn't in the
 788             # system dynamic library search path.  This is usually
 789             # correct and most trouble free, but may cause problems in
 790             # some unusual system configurations (e.g. the directory
 791             # is on an NFS server that goes away).
 792             exts.append(Extension('_bsddb', ['_bsddb.c'],
 793                                   library_dirs=dblib_dir,
 794                                   runtime_library_dirs=dblib_dir,
 795                                   include_dirs=db_incs,
 796                                   libraries=dblibs))
 797         else:
 798             if db_setup_debug: print "db: no appropriate library found"
 799             db_incs = None
 800             dblibs = []
 801             dblib_dir = None
 802             missing.append('_bsddb')
 803
 804         # The sqlite interface
 805         sqlite_setup_debug = False   # verbose debug prints from this script?
 806
 807         # We hunt for #define SQLITE_VERSION "n.n.n"
 808         # We need to find >= sqlite version 3.0.8
 809         sqlite_incdir = sqlite_libdir = None
 810         sqlite_inc_paths = [ '/usr/include',
 811                              '/usr/include/sqlite',
 812                              '/usr/include/sqlite3',
 813                              '/usr/local/include',
 814                              '/usr/local/include/sqlite',
 815                              '/usr/local/include/sqlite3',
 816                            ]
 817         MIN_SQLITE_VERSION_NUMBER = (3, 0, 8)
 818         MIN_SQLITE_VERSION = ".".join([str(x)
 819                                     for x in MIN_SQLITE_VERSION_NUMBER])
 820
 821         # Scan the default include directories before the SQLite specific
 822         # ones. This allows one to override the copy of sqlite on OSX,
 823         # where /usr/include contains an old version of sqlite.
 824         for d in inc_dirs + sqlite_inc_paths:
 825             f = os.path.join(d, "sqlite3.h")
 826             if os.path.exists(f):
 827                 if sqlite_setup_debug: print "sqlite: found %s"%f
 828                 incf = open(f).read()
 829                 m = re.search(
 830                     r'\s*.*#\s*.*define\s.*SQLITE_VERSION\W*"(.*)"', incf)
 831                 if m:
 832                     sqlite_version = m.group(1)
 833                     sqlite_version_tuple = tuple([int(x)
 834                                         for x in sqlite_version.split(".")])
 835                     if sqlite_version_tuple >= MIN_SQLITE_VERSION_NUMBER:
 836                         # we win!
 837                         if sqlite_setup_debug:
 838                             print "%s/sqlite3.h: version %s"%(d, sqlite_version)
 839                         sqlite_incdir = d
 840                         break
 841                     else:
 842                         if sqlite_setup_debug:
 843                             print "%s: version %d is too old, need >= %s"%(d,
 844                                         sqlite_version, MIN_SQLITE_VERSION)
 845                 elif sqlite_setup_debug:
 846                     print "sqlite: %s had no SQLITE_VERSION"%(f,)
 847
 848         if sqlite_incdir:
 849             sqlite_dirs_to_check = [
 850                 os.path.join(sqlite_incdir, '..', 'lib64'),
 851                 os.path.join(sqlite_incdir, '..', 'lib'),
 852                 os.path.join(sqlite_incdir, '..', '..', 'lib64'),
 853                 os.path.join(sqlite_incdir, '..', '..', 'lib'),
 854             ]
 855             sqlite_libfile = self.compiler.find_library_file(
 856                                 sqlite_dirs_to_check + lib_dirs, 'sqlite3')
 857             sqlite_libdir = [os.path.abspath(os.path.dirname(sqlite_libfile))]
 858
 859         if sqlite_incdir and sqlite_libdir:
 860             sqlite_srcs = ['_sqlite/cache.c',
 861                 '_sqlite/connection.c',
 862                 '_sqlite/cursor.c',
 863                 '_sqlite/microprotocols.c',
 864                 '_sqlite/module.c',
 865                 '_sqlite/prepare_protocol.c',
 866                 '_sqlite/row.c',
 867                 '_sqlite/statement.c',
 868                 '_sqlite/util.c', ]
 869
 870             sqlite_defines = []
 871             if sys.platform != "win32":
 872                 sqlite_defines.append(('MODULE_NAME', '"sqlite3"'))
 873             else:
 874                 sqlite_defines.append(('MODULE_NAME', '\\"sqlite3\\"'))
 875
 876
 877             if sys.platform == 'darwin':
 878                 # In every directory on the search path search for a dynamic
 879                 # library and then a static library, instead of first looking
 880                 # for dynamic libraries on the entiry path.
 881                 # This way a staticly linked custom sqlite gets picked up
 882                 # before the dynamic library in /usr/lib.
 883                 sqlite_extra_link_args = ('-Wl,-search_paths_first',)
 884             else:
 885                 sqlite_extra_link_args = ()
 886
 887             exts.append(Extension('_sqlite3', sqlite_srcs,
 888                                   define_macros=sqlite_defines,
 889                                   include_dirs=["Modules/_sqlite",
 890                                                 sqlite_incdir],
 891                                   library_dirs=sqlite_libdir,
 892                                   runtime_library_dirs=sqlite_libdir,
 893                                   extra_link_args=sqlite_extra_link_args,
 894                                   libraries=["sqlite3",]))
 895         else:
 896             missing.append('_sqlite3')
 897
 898         # Look for Berkeley db 1.85.   Note that it is built as a different
 899         # module name so it can be included even when later versions are
 900         # available.  A very restrictive search is performed to avoid
 901         # accidentally building this module with a later version of the
 902         # underlying db library.  May BSD-ish Unixes incorporate db 1.85
 903         # symbols into libc and place the include file in /usr/include.
 904         f = "/usr/include/db.h"
 905         if os.path.exists(f):
 906             data = open(f).read()
 907             m = re.search(r"#s*define\s+HASHVERSION\s+2\s*", data)
 908             if m is not None:
 909                 # bingo - old version used hash file format version 2
 910                 ### XXX this should be fixed to not be platform-dependent
 911                 ### but I don't have direct access to an osf1 platform and
 912                 ### seemed to be muffing the search somehow
 913                 libraries = platform == "osf1" and ['db'] or None
 914                 if libraries is not None:
 915                     exts.append(Extension('bsddb185', ['bsddbmodule.c'],
 916                                           libraries=libraries))
 917                 else:
 918                     exts.append(Extension('bsddb185', ['bsddbmodule.c']))
 919             else:
 920                 missing.append('bsddb185')
 921         else:
 922             missing.append('bsddb185')
 923
 924         # The standard Unix dbm module:
 925         if platform not in ['cygwin']:
 926             if find_file("ndbm.h", inc_dirs, []) is not None:
 927                 # Some systems have -lndbm, others don't
 928                 if self.compiler.find_library_file(lib_dirs, 'ndbm'):
 929                     ndbm_libs = ['ndbm']
 930                 else:
 931                     ndbm_libs = []
 932                 exts.append( Extension('dbm', ['dbmmodule.c'],
 933                                        define_macros=[('HAVE_NDBM_H',None)],
 934                                        libraries = ndbm_libs ) )
 935             elif (self.compiler.find_library_file(lib_dirs, 'gdbm')
 936                   and find_file("gdbm/ndbm.h", inc_dirs, []) is not None):
 937                 exts.append( Extension('dbm', ['dbmmodule.c'],
 938                                        define_macros=[('HAVE_GDBM_NDBM_H',None)],
 939                                        libraries = ['gdbm'] ) )
 940             elif db_incs is not None:
 941                 exts.append( Extension('dbm', ['dbmmodule.c'],
 942                                        library_dirs=dblib_dir,
 943                                        runtime_library_dirs=dblib_dir,
 944                                        include_dirs=db_incs,
 945                                        define_macros=[('HAVE_BERKDB_H',None),
 946                                                       ('DB_DBM_HSEARCH',None)],
 947                                        libraries=dblibs))
 948             else:
 949                 missing.append('dbm')
 950
 951         # Anthony Baxter's gdbm module.  GNU dbm(3) will require -lgdbm:
 952         if (self.compiler.find_library_file(lib_dirs, 'gdbm')):
 953             exts.append( Extension('gdbm', ['gdbmmodule.c'],
 954                                    libraries = ['gdbm'] ) )
 955         else:
 956             missing.append('gdbm')
 957
 958         # Unix-only modules
 959         if platform not in ['mac', 'win32']:
 960             # Steen Lumholt's termios module
 961             exts.append( Extension('termios', ['termios.c']) )
 962             # Jeremy Hylton's rlimit interface
 963             if platform not in ['atheos']:
 964                 exts.append( Extension('resource', ['resource.c']) )
 965             else:
 966                 missing.append('resource')
 967
 968             # Sun yellow pages. Some systems have the functions in libc.
 969             if platform not in ['cygwin', 'atheos']:
 970                 if (self.compiler.find_library_file(lib_dirs, 'nsl')):
 971                     libs = ['nsl']
 972                 else:
 973                     libs = []
 974                 exts.append( Extension('nis', ['nismodule.c'],
 975                                        libraries = libs) )
 976             else:
 977                 missing.append('nis')
 978         else:
 979             missing.extend(['nis', 'resource', 'termios'])
 980
 981         # Curses support, requiring the System V version of curses, often
 982         # provided by the ncurses library.
 983         panel_library = 'panel'
 984         if (self.compiler.find_library_file(lib_dirs, 'ncursesw')):
 985             curses_libs = ['ncursesw']
 986             # Bug 1464056: If _curses.so links with ncursesw,
 987             # _curses_panel.so must link with panelw.
 988             panel_library = 'panelw'
 989             exts.append( Extension('_curses', ['_cursesmodule.c'],
 990                                    libraries = curses_libs) )
 991         elif (self.compiler.find_library_file(lib_dirs, 'ncurses')):
 992             curses_libs = ['ncurses']
 993             exts.append( Extension('_curses', ['_cursesmodule.c'],
 994                                    libraries = curses_libs) )
 995         elif (self.compiler.find_library_file(lib_dirs, 'curses')
 996               and platform != 'darwin'):
 997                 # OSX has an old Berkeley curses, not good enough for
 998                 # the _curses module.
 999             if (self.compiler.find_library_file(lib_dirs, 'terminfo')):
1000                 curses_libs = ['curses', 'terminfo']
1001             elif (self.compiler.find_library_file(lib_dirs, 'termcap')):
1002                 curses_libs = ['curses', 'termcap']
1003             else:
1004                 curses_libs = ['curses']
1005
1006             exts.append( Extension('_curses', ['_cursesmodule.c'],
1007                                    libraries = curses_libs) )
1008         else:
1009             missing.append('_curses')
1010
1011         # If the curses module is enabled, check for the panel module
1012         if (module_enabled(exts, '_curses') and
1013             self.compiler.find_library_file(lib_dirs, panel_library)):
1014             exts.append( Extension('_curses_panel', ['_curses_panel.c'],
1015                                    libraries = [panel_library] + curses_libs) )
1016         else:
1017             missing.append('_curses_panel')
1018
1019         # Andrew Kuchling's zlib module.  Note that some versions of zlib
1020         # 1.1.3 have security problems.  See CERT Advisory CA-2002-07:
1021         # http://www.cert.org/advisories/CA-2002-07.html
1022         #
1023         # zlib 1.1.4 is fixed, but at least one vendor (RedHat) has decided to
1024         # patch its zlib 1.1.3 package instead of upgrading to 1.1.4.  For
1025         # now, we still accept 1.1.3, because we think it's difficult to
1026         # exploit this in Python, and we'd rather make it RedHat's problem
1027         # than our problem <wink>.
1028         #
1029         # You can upgrade zlib to version 1.1.4 yourself by going to
1030         # http://www.gzip.org/zlib/
1031         zlib_inc = find_file('zlib.h', [], inc_dirs)
1032         if zlib_inc is not None:
1033             zlib_h = zlib_inc[0] + '/zlib.h'
1034             version = '"0.0.0"'
1035             version_req = '"1.1.3"'
1036             fp = open(zlib_h)
1037             while 1:
1038                 line = fp.readline()
1039                 if not line:
1040                     break
1041                 if line.startswith('#define ZLIB_VERSION'):
1042                     version = line.split()[2]
1043                     break
1044             if version >= version_req:
1045                 if (self.compiler.find_library_file(lib_dirs, 'z')):
1046                     if sys.platform == "darwin":
1047                         zlib_extra_link_args = ('-Wl,-search_paths_first',)
1048                     else:
1049                         zlib_extra_link_args = ()
1050                     exts.append( Extension('zlib', ['zlibmodule.c'],
1051                                            libraries = ['z'],
1052                                            extra_link_args = zlib_extra_link_args))
1053                 else:
1054                     missing.append('zlib')
1055             else:
1056                 missing.append('zlib')
1057         else:
1058             missing.append('zlib')
1059
1060         # Gustavo Niemeyer's bz2 module.
1061         if (self.compiler.find_library_file(lib_dirs, 'bz2')):
1062             if sys.platform == "darwin":
1063                 bz2_extra_link_args = ('-Wl,-search_paths_first',)
1064             else:
1065                 bz2_extra_link_args = ()
1066             exts.append( Extension('bz2', ['bz2module.c'],
1067                                    libraries = ['bz2'],
1068                                    extra_link_args = bz2_extra_link_args) )
1069         else:
1070             missing.append('bz2')
1071
1072         # Interface to the Expat XML parser
1073         #
1074         # Expat was written by James Clark and is now maintained by a
1075         # group of developers on SourceForge; see www.libexpat.org for
1076         # more information.  The pyexpat module was written by Paul
1077         # Prescod after a prototype by Jack Jansen.  The Expat source
1078         # is included in Modules/expat/.  Usage of a system
1079         # shared libexpat.so/expat.dll is not advised.
1080         #
1081         # More information on Expat can be found at www.libexpat.org.
1082         #
1083         expatinc = os.path.join(os.getcwd(), srcdir, 'Modules', 'expat')
1084         define_macros = [
1085             ('HAVE_EXPAT_CONFIG_H', '1'),
1086         ]
1087
1088         exts.append(Extension('pyexpat',
1089                               define_macros = define_macros,
1090                               include_dirs = [expatinc],
1091                               sources = ['pyexpat.c',
1092                                          'expat/xmlparse.c',
1093                                          'expat/xmlrole.c',
1094                                          'expat/xmltok.c',
1095                                          ],
1096                               ))
1097
1098         # Fredrik Lundh's cElementTree module.  Note that this also
1099         # uses expat (via the CAPI hook in pyexpat).
1100
1101         if os.path.isfile(os.path.join(srcdir, 'Modules', '_elementtree.c')):
1102             define_macros.append(('USE_PYEXPAT_CAPI', None))
1103             exts.append(Extension('_elementtree',
1104                                   define_macros = define_macros,
1105                                   include_dirs = [expatinc],
1106                                   sources = ['_elementtree.c'],
1107                                   ))
1108         else:
1109             missing.append('_elementtree')
1110
1111         # Hye-Shik Chang's CJKCodecs modules.
1112         if have_unicode:
1113             exts.append(Extension('_multibytecodec',
1114                                   ['cjkcodecs/multibytecodec.c']))
1115             for loc in ('kr', 'jp', 'cn', 'tw', 'hk', 'iso2022'):
1116                 exts.append(Extension('_codecs_%s' % loc,
1117                                       ['cjkcodecs/_codecs_%s.c' % loc]))
1118         else:
1119             missing.append('_multibytecodec')
1120             for loc in ('kr', 'jp', 'cn', 'tw', 'hk', 'iso2022'):
1121                 missing.append('_codecs_%s' % loc)
1122
1123         # Dynamic loading module
1124         if sys.maxint == 0x7fffffff:
1125             # This requires sizeof(int) == sizeof(long) == sizeof(char*)
1126             dl_inc = find_file('dlfcn.h', [], inc_dirs)
1127             if (dl_inc is not None) and (platform not in ['atheos']):
1128                 exts.append( Extension('dl', ['dlmodule.c']) )
1129             else:
1130                 missing.append('dl')
1131         else:
1132             missing.append('dl')
1133
1134         # Thomas Heller's _ctypes module
1135         self.detect_ctypes(inc_dirs, lib_dirs)
1136
1137         # Platform-specific libraries
1138         if platform == 'linux2':
1139             # Linux-specific modules
1140             exts.append( Extension('linuxaudiodev', ['linuxaudiodev.c']) )
1141         else:
1142             missing.append('linuxaudiodev')
1143
1144         if platform in ('linux2', 'freebsd4', 'freebsd5', 'freebsd6',
1145                         'freebsd7'):
1146             exts.append( Extension('ossaudiodev', ['ossaudiodev.c']) )
1147         else:
1148             missing.append('ossaudiodev')
1149
1150         if platform == 'sunos5':
1151             # SunOS specific modules
1152             exts.append( Extension('sunaudiodev', ['sunaudiodev.c']) )
1153         else:
1154             missing.append('sunaudiodev')
1155
1156         if platform == 'darwin' and ("--disable-toolbox-glue" not in
1157                 sysconfig.get_config_var("CONFIG_ARGS")):
1158
1159             if os.uname()[2] > '8.':
1160                 # We're on Mac OS X 10.4 or later, the compiler should
1161                 # support '-Wno-deprecated-declarations'. This will
1162                 # surpress deprecation warnings for the Carbon extensions,
1163                 # these extensions wrap the Carbon APIs and even those
1164                 # parts that are deprecated.
1165                 carbon_extra_compile_args = ['-Wno-deprecated-declarations']
1166             else:
1167                 carbon_extra_compile_args = []
1168
1169             # Mac OS X specific modules.
1170             def macSrcExists(name1, name2=''):
1171                 if not name1:
1172                     return None
1173                 names = (name1,)
1174                 if name2:
1175                     names = (name1, name2)
1176                 path = os.path.join(srcdir, 'Mac', 'Modules', *names)
1177                 return os.path.exists(path)
1178
1179             def addMacExtension(name, kwds, extra_srcs=[]):
1180                 dirname = ''
1181                 if name[0] == '_':
1182                     dirname = name[1:].lower()
1183                 cname = name + '.c'
1184                 cmodulename = name + 'module.c'
1185                 # Check for NNN.c, NNNmodule.c, _nnn/NNN.c, _nnn/NNNmodule.c
1186                 if macSrcExists(cname):
1187                     srcs = [cname]
1188                 elif macSrcExists(cmodulename):
1189                     srcs = [cmodulename]
1190                 elif macSrcExists(dirname, cname):
1191                     # XXX(nnorwitz): If all the names ended with module, we
1192                     # wouldn't need this condition.  ibcarbon is the only one.
1193                     srcs = [os.path.join(dirname, cname)]
1194                 elif macSrcExists(dirname, cmodulename):
1195                     srcs = [os.path.join(dirname, cmodulename)]
1196                 else:
1197                     raise RuntimeError("%s not found" % name)
1198
1199                 # Here's the whole point:  add the extension with sources
1200                 exts.append(Extension(name, srcs + extra_srcs, **kwds))
1201
1202             # Core Foundation
1203             core_kwds = {'extra_compile_args': carbon_extra_compile_args,
1204                          'extra_link_args': ['-framework', 'CoreFoundation'],
1205                         }
1206             addMacExtension('_CF', core_kwds, ['cf/pycfbridge.c'])
1207             addMacExtension('autoGIL', core_kwds)
1208
1209             # Carbon
1210             carbon_kwds = {'extra_compile_args': carbon_extra_compile_args,
1211                            'extra_link_args': ['-framework', 'Carbon'],
1212                           }
1213             CARBON_EXTS = ['ColorPicker', 'gestalt', 'MacOS', 'Nav',
1214                            'OSATerminology', 'icglue',
1215                            # All these are in subdirs
1216                            '_AE', '_AH', '_App', '_CarbonEvt', '_Cm', '_Ctl',
1217                            '_Dlg', '_Drag', '_Evt', '_File', '_Folder', '_Fm',
1218                            '_Help', '_Icn', '_IBCarbon', '_List',
1219                            '_Menu', '_Mlte', '_OSA', '_Res', '_Qd', '_Qdoffs',
1220                            '_Scrap', '_Snd', '_TE', '_Win',
1221                           ]
1222             for name in CARBON_EXTS:
1223                 addMacExtension(name, carbon_kwds)
1224
1225             # Application Services & QuickTime
1226             app_kwds = {'extra_compile_args': carbon_extra_compile_args,
1227                         'extra_link_args': ['-framework','ApplicationServices'],
1228                        }
1229             addMacExtension('_Launch', app_kwds)
1230             addMacExtension('_CG', app_kwds)
1231
1232             exts.append( Extension('_Qt', ['qt/_Qtmodule.c'],
1233                         extra_compile_args=carbon_extra_compile_args,
1234                         extra_link_args=['-framework', 'QuickTime',
1235                                      '-framework', 'Carbon']) )
1236
1237
1238         self.extensions.extend(exts)
1239
1240         # Call the method for detecting whether _tkinter can be compiled
1241         self.detect_tkinter(inc_dirs, lib_dirs)
1242
1243         if '_tkinter' not in [e.name for e in self.extensions]:
1244             missing.append('_tkinter')
1245
1246         return missing
1247
1248     def detect_tkinter_darwin(self, inc_dirs, lib_dirs):
1249         # The _tkinter module, using frameworks. Since frameworks are quite
1250         # different the UNIX search logic is not sharable.
1251         from os.path import join, exists
1252         framework_dirs = [
1253             '/System/Library/Frameworks/',
1254             '/Library/Frameworks',
1255             join(os.getenv('HOME'), '/Library/Frameworks')
1256         ]
1257
1258         # Find the directory that contains the Tcl.framework and Tk.framework
1259         # bundles.
1260         # XXX distutils should support -F!
1261         for F in framework_dirs:
1262             # both Tcl.framework and Tk.framework should be present
1263             for fw in 'Tcl', 'Tk':
1264                 if not exists(join(F, fw + '.framework')):
1265                     break
1266             else:
1267                 # ok, F is now directory with both frameworks. Continure
1268                 # building
1269                 break
1270         else:
1271             # Tk and Tcl frameworks not found. Normal "unix" tkinter search
1272             # will now resume.
1273             return 0
1274
1275         # For 8.4a2, we must add -I options that point inside the Tcl and Tk
1276         # frameworks. In later release we should hopefully be able to pass
1277         # the -F option to gcc, which specifies a framework lookup path.
1278         #
1279         include_dirs = [
1280             join(F, fw + '.framework', H)
1281             for fw in 'Tcl', 'Tk'
1282             for H in 'Headers', 'Versions/Current/PrivateHeaders'
1283         ]
1284
1285         # For 8.4a2, the X11 headers are not included. Rather than include a
1286         # complicated search, this is a hard-coded path. It could bail out
1287         # if X11 libs are not found...
1288         include_dirs.append('/usr/X11R6/include')
1289         frameworks = ['-framework', 'Tcl', '-framework', 'Tk']
1290
1291         ext = Extension('_tkinter', ['_tkinter.c', 'tkappinit.c'],
1292                         define_macros=[('WITH_APPINIT', 1)],
1293                         include_dirs = include_dirs,
1294                         libraries = [],
1295                         extra_compile_args = frameworks,
1296                         extra_link_args = frameworks,
1297                         )
1298         self.extensions.append(ext)
1299         return 1
1300
1301
1302     def detect_tkinter(self, inc_dirs, lib_dirs):
1303         # The _tkinter module.
1304
1305         # Rather than complicate the code below, detecting and building
1306         # AquaTk is a separate method. Only one Tkinter will be built on
1307         # Darwin - either AquaTk, if it is found, or X11 based Tk.
1308         platform = self.get_platform()
1309         if (platform == 'darwin' and
1310             self.detect_tkinter_darwin(inc_dirs, lib_dirs)):
1311             return
1312
1313         # Assume we haven't found any of the libraries or include files
1314         # The versions with dots are used on Unix, and the versions without
1315         # dots on Windows, for detection by cygwin.
1316         tcllib = tklib = tcl_includes = tk_includes = None
1317         for version in ['8.5', '85', '8.4', '84', '8.3', '83', '8.2',
1318                         '82', '8.1', '81', '8.0', '80']:
1319             tklib = self.compiler.find_library_file(lib_dirs, 'tk' + version)
1320             tcllib = self.compiler.find_library_file(lib_dirs, 'tcl' + version)
1321             if tklib and tcllib:
1322                 # Exit the loop when we've found the Tcl/Tk libraries
1323                 break
1324
1325         # Now check for the header files
1326         if tklib and tcllib:
1327             # Check for the include files on Debian and {Free,Open}BSD, where
1328             # they're put in /usr/include/{tcl,tk}X.Y
1329             dotversion = version
1330             if '.' not in dotversion and "bsd" in sys.platform.lower():
1331                 # OpenBSD and FreeBSD use Tcl/Tk library names like libtcl83.a,
1332                 # but the include subdirs are named like .../include/tcl8.3.
1333                 dotversion = dotversion[:-1] + '.' + dotversion[-1]
1334             tcl_include_sub = []
1335             tk_include_sub = []
1336             for dir in inc_dirs:
1337                 tcl_include_sub += [dir + os.sep + "tcl" + dotversion]
1338                 tk_include_sub += [dir + os.sep + "tk" + dotversion]
1339             tk_include_sub += tcl_include_sub
1340             tcl_includes = find_file('tcl.h', inc_dirs, tcl_include_sub)
1341             tk_includes = find_file('tk.h', inc_dirs, tk_include_sub)
1342
1343         if (tcllib is None or tklib is None or
1344             tcl_includes is None or tk_includes is None):
1345             self.announce("INFO: Can't locate Tcl/Tk libs and/or headers", 2)
1346             return
1347
1348         # OK... everything seems to be present for Tcl/Tk.
1349
1350         include_dirs = [] ; libs = [] ; defs = [] ; added_lib_dirs = []
1351         for dir in tcl_includes + tk_includes:
1352             if dir not in include_dirs:
1353                 include_dirs.append(dir)
1354
1355         # Check for various platform-specific directories
1356         if platform == 'sunos5':
1357             include_dirs.append('/usr/openwin/include')
1358             added_lib_dirs.append('/usr/openwin/lib')
1359         elif os.path.exists('/usr/X11R6/include'):
1360             include_dirs.append('/usr/X11R6/include')
1361             added_lib_dirs.append('/usr/X11R6/lib64')
1362             added_lib_dirs.append('/usr/X11R6/lib')
1363         elif os.path.exists('/usr/X11R5/include'):
1364             include_dirs.append('/usr/X11R5/include')
1365             added_lib_dirs.append('/usr/X11R5/lib')
1366         else:
1367             # Assume default location for X11
1368             include_dirs.append('/usr/X11/include')
1369             added_lib_dirs.append('/usr/X11/lib')
1370
1371         # If Cygwin, then verify that X is installed before proceeding
1372         if platform == 'cygwin':
1373             x11_inc = find_file('X11/Xlib.h', [], include_dirs)
1374             if x11_inc is None:
1375                 return
1376
1377         # Check for BLT extension
1378         if self.compiler.find_library_file(lib_dirs + added_lib_dirs,
1379                                            'BLT8.0'):
1380             defs.append( ('WITH_BLT', 1) )
1381             libs.append('BLT8.0')
1382         elif self.compiler.find_library_file(lib_dirs + added_lib_dirs,
1383                                            'BLT'):
1384             defs.append( ('WITH_BLT', 1) )
1385             libs.append('BLT')
1386
1387         # Add the Tcl/Tk libraries
1388         libs.append('tk'+ version)
1389         libs.append('tcl'+ version)
1390
1391         if platform in ['aix3', 'aix4']:
1392             libs.append('ld')
1393
1394         # Finally, link with the X11 libraries (not appropriate on cygwin)
1395         if platform != "cygwin":
1396             libs.append('X11')
1397
1398         ext = Extension('_tkinter', ['_tkinter.c', 'tkappinit.c'],
1399                         define_macros=[('WITH_APPINIT', 1)] + defs,
1400                         include_dirs = include_dirs,
1401                         libraries = libs,
1402                         library_dirs = added_lib_dirs,
1403                         )
1404         self.extensions.append(ext)
1405
1406 ##         # Uncomment these lines if you want to play with xxmodule.c
1407 ##         ext = Extension('xx', ['xxmodule.c'])
1408 ##         self.extensions.append(ext)
1409
1410         # XXX handle these, but how to detect?
1411         # *** Uncomment and edit for PIL (TkImaging) extension only:
1412         #       -DWITH_PIL -I../Extensions/Imaging/libImaging  tkImaging.c \
1413         # *** Uncomment and edit for TOGL extension only:
1414         #       -DWITH_TOGL togl.c \
1415         # *** Uncomment these for TOGL extension only:
1416         #       -lGL -lGLU -lXext -lXmu \
1417
1418     def configure_ctypes(self, ext):
1419         if not self.use_system_libffi:
1420             (srcdir,) = sysconfig.get_config_vars('srcdir')
1421             ffi_builddir = os.path.join(self.build_temp, 'libffi')
1422             ffi_srcdir = os.path.abspath(os.path.join(srcdir, 'Modules',
1423                                          '_ctypes', 'libffi'))
1424             ffi_configfile = os.path.join(ffi_builddir, 'fficonfig.py')
1425
1426             from distutils.dep_util import newer_group
1427
1428             config_sources = [os.path.join(ffi_srcdir, fname)
1429                               for fname in os.listdir(ffi_srcdir)
1430                               if os.path.isfile(os.path.join(ffi_srcdir, fname))]
1431             if self.force or newer_group(config_sources,
1432                                          ffi_configfile):
1433                 from distutils.dir_util import mkpath
1434                 mkpath(ffi_builddir)
1435                 config_args = []
1436
1437                 # Pass empty CFLAGS because we'll just append the resulting
1438                 # CFLAGS to Python's; -g or -O2 is to be avoided.
1439                 cmd = "cd %s && env CFLAGS='' '%s/configure' %s" \
1440                       % (ffi_builddir, ffi_srcdir, " ".join(config_args))
1441
1442                 res = os.system(cmd)
1443                 if res or not os.path.exists(ffi_configfile):
1444                     print "Failed to configure _ctypes module"
1445                     return False
1446
1447             fficonfig = {}
1448             execfile(ffi_configfile, globals(), fficonfig)
1449             ffi_srcdir = os.path.join(fficonfig['ffi_srcdir'], 'src')
1450
1451             # Add .S (preprocessed assembly) to C compiler source extensions.
1452             self.compiler.src_extensions.append('.S')
1453
1454             include_dirs = [os.path.join(ffi_builddir, 'include'),
1455                             ffi_builddir, ffi_srcdir]
1456             extra_compile_args = fficonfig['ffi_cflags'].split()
1457
1458             ext.sources.extend(fficonfig['ffi_sources'])
1459             ext.include_dirs.extend(include_dirs)
1460             ext.extra_compile_args.extend(extra_compile_args)
1461         return True
1462
1463     def detect_ctypes(self, inc_dirs, lib_dirs):
1464         self.use_system_libffi = False
1465         include_dirs = []
1466         extra_compile_args = []
1467         extra_link_args = []
1468         sources = ['_ctypes/_ctypes.c',
1469                    '_ctypes/callbacks.c',
1470                    '_ctypes/callproc.c',
1471                    '_ctypes/stgdict.c',
1472                    '_ctypes/cfield.c',
1473                    '_ctypes/malloc_closure.c']
1474         depends = ['_ctypes/ctypes.h']
1475
1476         if sys.platform == 'darwin':
1477             sources.append('_ctypes/darwin/dlfcn_simple.c')
1478             include_dirs.append('_ctypes/darwin')
1479 # XXX Is this still needed?
1480 ##            extra_link_args.extend(['-read_only_relocs', 'warning'])
1481
1482         elif sys.platform == 'sunos5':
1483             # XXX This shouldn't be necessary; it appears that some
1484             # of the assembler code is non-PIC (i.e. it has relocations
1485             # when it shouldn't. The proper fix would be to rewrite
1486             # the assembler code to be PIC.
1487             # This only works with GCC; the Sun compiler likely refuses
1488             # this option. If you want to compile ctypes with the Sun
1489             # compiler, please research a proper solution, instead of
1490             # finding some -z option for the Sun compiler.
1491             extra_link_args.append('-mimpure-text')
1492
1493         ext = Extension('_ctypes',
1494                         include_dirs=include_dirs,
1495                         extra_compile_args=extra_compile_args,
1496                         extra_link_args=extra_link_args,
1497                         libraries=[],
1498                         sources=sources,
1499                         depends=depends)
1500         ext_test = Extension('_ctypes_test',
1501                              sources=['_ctypes/_ctypes_test.c'])
1502         self.extensions.extend([ext, ext_test])
1503
1504         if not '--with-system-ffi' in sysconfig.get_config_var("CONFIG_ARGS"):
1505             return
1506
1507         ffi_inc = find_file('ffi.h', [], inc_dirs)
1508         if ffi_inc is not None:
1509             ffi_h = ffi_inc[0] + '/ffi.h'
1510             fp = open(ffi_h)
1511             while 1:
1512                 line = fp.readline()
1513                 if not line:
1514                     ffi_inc = None
1515                     break
1516                 if line.startswith('#define LIBFFI_H'):
1517                     break
1518         ffi_lib = None
1519         if ffi_inc is not None:
1520             for lib_name in ('ffi_convenience', 'ffi_pic', 'ffi'):
1521                 if (self.compiler.find_library_file(lib_dirs, lib_name)):
1522                     ffi_lib = lib_name
1523                     break
1524
1525         if ffi_inc and ffi_lib:
1526             ext.include_dirs.extend(ffi_inc)
1527             ext.libraries.append(ffi_lib)
1528             self.use_system_libffi = True
1529
1530
1531 class PyBuildInstall(install):
1532     # Suppress the warning about installation into the lib_dynload
1533     # directory, which is not in sys.path when running Python during
1534     # installation:
1535     def initialize_options (self):
1536         install.initialize_options(self)
1537         self.warn_dir=0
1538
1539 class PyBuildInstallLib(install_lib):
1540     # Do exactly what install_lib does but make sure correct access modes get
1541     # set on installed directories and files. All installed files with get
1542     # mode 644 unless they are a shared library in which case they will get
1543     # mode 755. All installed directories will get mode 755.
1544
1545     so_ext = sysconfig.get_config_var("SO")
1546
1547     def install(self):
1548         outfiles = install_lib.install(self)
1549         self.set_file_modes(outfiles, 0644, 0755)
1550         self.set_dir_modes(self.install_dir, 0755)
1551         return outfiles
1552
1553     def set_file_modes(self, files, defaultMode, sharedLibMode):
1554         if not self.is_chmod_supported(): return
1555         if not files: return
1556
1557         for filename in files:
1558             if os.path.islink(filename): continue
1559             mode = defaultMode
1560             if filename.endswith(self.so_ext): mode = sharedLibMode
1561             log.info("changing mode of %s to %o", filename, mode)
1562             if not self.dry_run: os.chmod(filename, mode)
1563
1564     def set_dir_modes(self, dirname, mode):
1565         if not self.is_chmod_supported(): return
1566         os.path.walk(dirname, self.set_dir_modes_visitor, mode)
1567
1568     def set_dir_modes_visitor(self, mode, dirname, names):
1569         if os.path.islink(dirname): return
1570         log.info("changing mode of %s to %o", dirname, mode)
1571         if not self.dry_run: os.chmod(dirname, mode)
1572
1573     def is_chmod_supported(self):
1574         return hasattr(os, 'chmod')
1575
1576 SUMMARY = """
1577 Python is an interpreted, interactive, object-oriented programming
1578 language. It is often compared to Tcl, Perl, Scheme or Java.
1579
1580 Python combines remarkable power with very clear syntax. It has
1581 modules, classes, exceptions, very high level dynamic data types, and
1582 dynamic typing. There are interfaces to many system calls and
1583 libraries, as well as to various windowing systems (X11, Motif, Tk,
1584 Mac, MFC). New built-in modules are easily written in C or C++. Python
1585 is also usable as an extension language for applications that need a
1586 programmable interface.
1587
1588 The Python implementation is portable: it runs on many brands of UNIX,
1589 on Windows, DOS, OS/2, Mac, Amiga... If your favorite system isn't
1590 listed here, it may still be supported, if there's a C compiler for
1591 it. Ask around on comp.lang.python -- or just try compiling Python
1592 yourself.
1593 """
1594
1595 CLASSIFIERS = """
1596 Development Status :: 3 - Alpha
1597 Development Status :: 6 - Mature
1598 License :: OSI Approved :: Python Software Foundation License
1599 Natural Language :: English
1600 Programming Language :: C
1601 Programming Language :: Python
1602 Topic :: Software Development
1603 """
1604
1605 def main():
1606     # turn off warnings when deprecated modules are imported
1607     import warnings
1608     warnings.filterwarnings("ignore",category=DeprecationWarning)
1609     setup(# PyPI Metadata (PEP 301)
1610           name = "Python",
1611           version = sys.version.split()[0],
1612           url = "http://www.python.org/%s" % sys.version[:3],
1613           maintainer = "Guido van Rossum and the Python community",
1614           maintainer_email = "python-dev@python.org",
1615           description = "A high-level object-oriented programming language",
1616           long_description = SUMMARY.strip(),
1617           license = "PSF license",
1618           classifiers = filter(None, CLASSIFIERS.split("\n")),
1619           platforms = ["Many"],
1620
1621           # Build info
1622           cmdclass = {'build_ext':PyBuildExt, 'install':PyBuildInstall,
1623                       'install_lib':PyBuildInstallLib},
1624           # The struct module is defined here, because build_ext won't be
1625           # called unless there's at least one extension module defined.
1626           ext_modules=[Extension('_struct', ['_struct.c'])],
1627
1628           # Scripts to install
1629           scripts = ['Tools/scripts/pydoc', 'Tools/scripts/idle',
1630                      'Lib/smtpd.py']
1631         )
1632
1633 # --install-platlib
1634 if __name__ == '__main__':
1635     main()