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