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