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