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':
 550             os_release = int(os.uname()[2].split('.')[0])
 551             if os_release < 9:
 552                 # MacOSX 10.4 has a broken readline. Don't try to build
 553                 # the readline module unless the user has installed a fixed
 554                 # readline package
 555                 if find_file('readline/rlconf.h', inc_dirs, []) is None:
 556                     do_readline = False
 557         if do_readline:
 558             if platform == 'darwin' and os_release < 9:
 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':
1351             # _scproxy
1352             exts.append(Extension("_scproxy", [os.path.join(srcdir, "Mac/Modules/_scproxy.c")],
1353                 extra_link_args= [
1354                     '-framework', 'SystemConfiguration',
1355                     '-framework', 'CoreFoundation'
1356                 ]))
1357
1358
1359         if platform == 'darwin' and ("--disable-toolbox-glue" not in
1360                 sysconfig.get_config_var("CONFIG_ARGS")):
1361
1362             if os.uname()[2] > '8.':
1363                 # We're on Mac OS X 10.4 or later, the compiler should
1364                 # support '-Wno-deprecated-declarations'. This will
1365                 # surpress deprecation warnings for the Carbon extensions,
1366                 # these extensions wrap the Carbon APIs and even those
1367                 # parts that are deprecated.
1368                 carbon_extra_compile_args = ['-Wno-deprecated-declarations']
1369             else:
1370                 carbon_extra_compile_args = []
1371
1372             # Mac OS X specific modules.
1373             def macSrcExists(name1, name2=''):
1374                 if not name1:
1375                     return None
1376                 names = (name1,)
1377                 if name2:
1378                     names = (name1, name2)
1379                 path = os.path.join(srcdir, 'Mac', 'Modules', *names)
1380                 return os.path.exists(path)
1381
1382             def addMacExtension(name, kwds, extra_srcs=[]):
1383                 dirname = ''
1384                 if name[0] == '_':
1385                     dirname = name[1:].lower()
1386                 cname = name + '.c'
1387                 cmodulename = name + 'module.c'
1388                 # Check for NNN.c, NNNmodule.c, _nnn/NNN.c, _nnn/NNNmodule.c
1389                 if macSrcExists(cname):
1390                     srcs = [cname]
1391                 elif macSrcExists(cmodulename):
1392                     srcs = [cmodulename]
1393                 elif macSrcExists(dirname, cname):
1394                     # XXX(nnorwitz): If all the names ended with module, we
1395                     # wouldn't need this condition.  ibcarbon is the only one.
1396                     srcs = [os.path.join(dirname, cname)]
1397                 elif macSrcExists(dirname, cmodulename):
1398                     srcs = [os.path.join(dirname, cmodulename)]
1399                 else:
1400                     raise RuntimeError("%s not found" % name)
1401
1402                 # Here's the whole point:  add the extension with sources
1403                 exts.append(Extension(name, srcs + extra_srcs, **kwds))
1404
1405             # Core Foundation
1406             core_kwds = {'extra_compile_args': carbon_extra_compile_args,
1407                          'extra_link_args': ['-framework', 'CoreFoundation'],
1408                         }
1409             addMacExtension('_CF', core_kwds, ['cf/pycfbridge.c'])
1410             addMacExtension('autoGIL', core_kwds)
1411
1412
1413
1414             # Carbon
1415             carbon_kwds = {'extra_compile_args': carbon_extra_compile_args,
1416                            'extra_link_args': ['-framework', 'Carbon'],
1417                           }
1418             CARBON_EXTS = ['ColorPicker', 'gestalt', 'MacOS', 'Nav',
1419                            'OSATerminology', 'icglue',
1420                            # All these are in subdirs
1421                            '_AE', '_AH', '_App', '_CarbonEvt', '_Cm', '_Ctl',
1422                            '_Dlg', '_Drag', '_Evt', '_File', '_Folder', '_Fm',
1423                            '_Help', '_Icn', '_IBCarbon', '_List',
1424                            '_Menu', '_Mlte', '_OSA', '_Res', '_Qd', '_Qdoffs',
1425                            '_Scrap', '_Snd', '_TE',
1426                           ]
1427             for name in CARBON_EXTS:
1428                 addMacExtension(name, carbon_kwds)
1429
1430             # Workaround for a bug in the version of gcc shipped with Xcode 3.
1431             # The _Win extension should build just like the other Carbon extensions, but
1432             # this actually results in a hard crash of the linker.
1433             #
1434             if '-arch ppc64' in cflags and '-arch ppc' in cflags:
1435                 win_kwds = {'extra_compile_args': carbon_extra_compile_args + ['-arch', 'i386', '-arch', 'ppc'],
1436                                'extra_link_args': ['-framework', 'Carbon', '-arch', 'i386', '-arch', 'ppc'],
1437                            }
1438                 addMacExtension('_Win', win_kwds)
1439             else:
1440                 addMacExtension('_Win', carbon_kwds)
1441
1442
1443             # Application Services & QuickTime
1444             app_kwds = {'extra_compile_args': carbon_extra_compile_args,
1445                         'extra_link_args': ['-framework','ApplicationServices'],
1446                        }
1447             addMacExtension('_Launch', app_kwds)
1448             addMacExtension('_CG', app_kwds)
1449
1450             exts.append( Extension('_Qt', ['qt/_Qtmodule.c'],
1451                         extra_compile_args=carbon_extra_compile_args,
1452                         extra_link_args=['-framework', 'QuickTime',
1453                                      '-framework', 'Carbon']) )
1454
1455
1456         self.extensions.extend(exts)
1457
1458         # Call the method for detecting whether _tkinter can be compiled
1459         self.detect_tkinter(inc_dirs, lib_dirs)
1460
1461         if '_tkinter' not in [e.name for e in self.extensions]:
1462             missing.append('_tkinter')
1463
1464         return missing
1465
1466     def detect_tkinter_darwin(self, inc_dirs, lib_dirs):
1467         # The _tkinter module, using frameworks. Since frameworks are quite
1468         # different the UNIX search logic is not sharable.
1469         from os.path import join, exists
1470         framework_dirs = [
1471             '/Library/Frameworks',
1472             '/System/Library/Frameworks/',
1473             join(os.getenv('HOME'), '/Library/Frameworks')
1474         ]
1475
1476         # Find the directory that contains the Tcl.framework and Tk.framework
1477         # bundles.
1478         # XXX distutils should support -F!
1479         for F in framework_dirs:
1480             # both Tcl.framework and Tk.framework should be present
1481             for fw in 'Tcl', 'Tk':
1482                 if not exists(join(F, fw + '.framework')):
1483                     break
1484             else:
1485                 # ok, F is now directory with both frameworks. Continure
1486                 # building
1487                 break
1488         else:
1489             # Tk and Tcl frameworks not found. Normal "unix" tkinter search
1490             # will now resume.
1491             return 0
1492
1493         # For 8.4a2, we must add -I options that point inside the Tcl and Tk
1494         # frameworks. In later release we should hopefully be able to pass
1495         # the -F option to gcc, which specifies a framework lookup path.
1496         #
1497         include_dirs = [
1498             join(F, fw + '.framework', H)
1499             for fw in 'Tcl', 'Tk'
1500             for H in 'Headers', 'Versions/Current/PrivateHeaders'
1501         ]
1502
1503         # For 8.4a2, the X11 headers are not included. Rather than include a
1504         # complicated search, this is a hard-coded path. It could bail out
1505         # if X11 libs are not found...
1506         include_dirs.append('/usr/X11R6/include')
1507         frameworks = ['-framework', 'Tcl', '-framework', 'Tk']
1508
1509         # All existing framework builds of Tcl/Tk don't support 64-bit
1510         # architectures.
1511         cflags = sysconfig.get_config_vars('CFLAGS')[0]
1512         archs = re.findall('-arch\s+(\w+)', cflags)
1513         fp = os.popen("file %s/Tk.framework/Tk | grep 'for architecture'"%(F,))
1514         detected_archs = []
1515         for ln in fp:
1516             a = ln.split()[-1]
1517             if a in archs:
1518                 detected_archs.append(ln.split()[-1])
1519         fp.close()
1520
1521         for a in detected_archs:
1522             frameworks.append('-arch')
1523             frameworks.append(a)
1524
1525         ext = Extension('_tkinter', ['_tkinter.c', 'tkappinit.c'],
1526                         define_macros=[('WITH_APPINIT', 1)],
1527                         include_dirs = include_dirs,
1528                         libraries = [],
1529                         extra_compile_args = frameworks[2:],
1530                         extra_link_args = frameworks,
1531                         )
1532         self.extensions.append(ext)
1533         return 1
1534
1535
1536     def detect_tkinter(self, inc_dirs, lib_dirs):
1537         # The _tkinter module.
1538
1539         # Rather than complicate the code below, detecting and building
1540         # AquaTk is a separate method. Only one Tkinter will be built on
1541         # Darwin - either AquaTk, if it is found, or X11 based Tk.
1542         platform = self.get_platform()
1543         if (platform == 'darwin' and
1544             self.detect_tkinter_darwin(inc_dirs, lib_dirs)):
1545             return
1546
1547         # Assume we haven't found any of the libraries or include files
1548         # The versions with dots are used on Unix, and the versions without
1549         # dots on Windows, for detection by cygwin.
1550         tcllib = tklib = tcl_includes = tk_includes = None
1551         for version in ['8.6', '86', '8.5', '85', '8.4', '84', '8.3', '83',
1552                         '8.2', '82', '8.1', '81', '8.0', '80']:
1553             tklib = self.compiler_obj.find_library_file(lib_dirs,
1554                                                         'tk' + version)
1555             tcllib = self.compiler_obj.find_library_file(lib_dirs,
1556                                                          'tcl' + version)
1557             if tklib and tcllib:
1558                 # Exit the loop when we've found the Tcl/Tk libraries
1559                 break
1560
1561         # Now check for the header files
1562         if tklib and tcllib:
1563             # Check for the include files on Debian and {Free,Open}BSD, where
1564             # they're put in /usr/include/{tcl,tk}X.Y
1565             dotversion = version
1566             if '.' not in dotversion and "bsd" in sys.platform.lower():
1567                 # OpenBSD and FreeBSD use Tcl/Tk library names like libtcl83.a,
1568                 # but the include subdirs are named like .../include/tcl8.3.
1569                 dotversion = dotversion[:-1] + '.' + dotversion[-1]
1570             tcl_include_sub = []
1571             tk_include_sub = []
1572             for dir in inc_dirs:
1573                 tcl_include_sub += [dir + os.sep + "tcl" + dotversion]
1574                 tk_include_sub += [dir + os.sep + "tk" + dotversion]
1575             tk_include_sub += tcl_include_sub
1576             tcl_includes = find_file('tcl.h', inc_dirs, tcl_include_sub)
1577             tk_includes = find_file('tk.h', inc_dirs, tk_include_sub)
1578
1579         if (tcllib is None or tklib is None or
1580             tcl_includes is None or tk_includes is None):
1581             self.announce("INFO: Can't locate Tcl/Tk libs and/or headers", 2)
1582             return
1583
1584         # OK... everything seems to be present for Tcl/Tk.
1585
1586         include_dirs = [] ; libs = [] ; defs = [] ; added_lib_dirs = []
1587         for dir in tcl_includes + tk_includes:
1588             if dir not in include_dirs:
1589                 include_dirs.append(dir)
1590
1591         # Check for various platform-specific directories
1592         if platform == 'sunos5':
1593             include_dirs.append('/usr/openwin/include')
1594             added_lib_dirs.append('/usr/openwin/lib')
1595         elif os.path.exists('/usr/X11R6/include'):
1596             include_dirs.append('/usr/X11R6/include')
1597             added_lib_dirs.append('/usr/X11R6/lib64')
1598             added_lib_dirs.append('/usr/X11R6/lib')
1599         elif os.path.exists('/usr/X11R5/include'):
1600             include_dirs.append('/usr/X11R5/include')
1601             added_lib_dirs.append('/usr/X11R5/lib')
1602         else:
1603             # Assume default location for X11
1604             include_dirs.append('/usr/X11/include')
1605             added_lib_dirs.append('/usr/X11/lib')
1606
1607         # If Cygwin, then verify that X is installed before proceeding
1608         if platform == 'cygwin':
1609             x11_inc = find_file('X11/Xlib.h', [], include_dirs)
1610             if x11_inc is None:
1611                 return
1612
1613         # Check for BLT extension
1614         if self.compiler_obj.find_library_file(lib_dirs + added_lib_dirs,
1615                                                'BLT8.0'):
1616             defs.append( ('WITH_BLT', 1) )
1617             libs.append('BLT8.0')
1618         elif self.compiler_obj.find_library_file(lib_dirs + added_lib_dirs,
1619                                                 'BLT'):
1620             defs.append( ('WITH_BLT', 1) )
1621             libs.append('BLT')
1622
1623         # Add the Tcl/Tk libraries
1624         libs.append('tk'+ version)
1625         libs.append('tcl'+ version)
1626
1627         if platform in ['aix3', 'aix4']:
1628             libs.append('ld')
1629
1630         # Finally, link with the X11 libraries (not appropriate on cygwin)
1631         if platform != "cygwin":
1632             libs.append('X11')
1633
1634         ext = Extension('_tkinter', ['_tkinter.c', 'tkappinit.c'],
1635                         define_macros=[('WITH_APPINIT', 1)] + defs,
1636                         include_dirs = include_dirs,
1637                         libraries = libs,
1638                         library_dirs = added_lib_dirs,
1639                         )
1640         self.extensions.append(ext)
1641
1642 ##         # Uncomment these lines if you want to play with xxmodule.c
1643 ##         ext = Extension('xx', ['xxmodule.c'])
1644 ##         self.extensions.append(ext)
1645
1646         # XXX handle these, but how to detect?
1647         # *** Uncomment and edit for PIL (TkImaging) extension only:
1648         #       -DWITH_PIL -I../Extensions/Imaging/libImaging  tkImaging.c \
1649         # *** Uncomment and edit for TOGL extension only:
1650         #       -DWITH_TOGL togl.c \
1651         # *** Uncomment these for TOGL extension only:
1652         #       -lGL -lGLU -lXext -lXmu \
1653
1654     def configure_ctypes_darwin(self, ext):
1655         # Darwin (OS X) uses preconfigured files, in
1656         # the Modules/_ctypes/libffi_osx directory.
1657         srcdir = sysconfig.get_config_var('srcdir')
1658         ffi_srcdir = os.path.abspath(os.path.join(srcdir, 'Modules',
1659                                                   '_ctypes', 'libffi_osx'))
1660         sources = [os.path.join(ffi_srcdir, p)
1661                    for p in ['ffi.c',
1662                              'x86/darwin64.S',
1663                              'x86/x86-darwin.S',
1664                              'x86/x86-ffi_darwin.c',
1665                              'x86/x86-ffi64.c',
1666                              'powerpc/ppc-darwin.S',
1667                              'powerpc/ppc-darwin_closure.S',
1668                              'powerpc/ppc-ffi_darwin.c',
1669                              'powerpc/ppc64-darwin_closure.S',
1670                              ]]
1671
1672         # Add .S (preprocessed assembly) to C compiler source extensions.
1673         self.compiler_obj.src_extensions.append('.S')
1674
1675         include_dirs = [os.path.join(ffi_srcdir, 'include'),
1676                         os.path.join(ffi_srcdir, 'powerpc')]
1677         ext.include_dirs.extend(include_dirs)
1678         ext.sources.extend(sources)
1679         return True
1680
1681     def configure_ctypes(self, ext):
1682         if not self.use_system_libffi:
1683             if sys.platform == 'darwin':
1684                 return self.configure_ctypes_darwin(ext)
1685
1686             srcdir = sysconfig.get_config_var('srcdir')
1687             ffi_builddir = os.path.join(self.build_temp, 'libffi')
1688             ffi_srcdir = os.path.abspath(os.path.join(srcdir, 'Modules',
1689                                          '_ctypes', 'libffi'))
1690             ffi_configfile = os.path.join(ffi_builddir, 'fficonfig.py')
1691
1692             from distutils.dep_util import newer_group
1693
1694             config_sources = [os.path.join(ffi_srcdir, fname)
1695                               for fname in os.listdir(ffi_srcdir)
1696                               if os.path.isfile(os.path.join(ffi_srcdir, fname))]
1697             if self.force or newer_group(config_sources,
1698                                          ffi_configfile):
1699                 from distutils.dir_util import mkpath
1700                 mkpath(ffi_builddir)
1701                 config_args = []
1702
1703                 # Pass empty CFLAGS because we'll just append the resulting
1704                 # CFLAGS to Python's; -g or -O2 is to be avoided.
1705                 cmd = "cd %s && env CFLAGS='' '%s/configure' %s" \
1706                       % (ffi_builddir, ffi_srcdir, " ".join(config_args))
1707
1708                 res = os.system(cmd)
1709                 if res or not os.path.exists(ffi_configfile):
1710                     print "Failed to configure _ctypes module"
1711                     return False
1712
1713             fficonfig = {}
1714             execfile(ffi_configfile, globals(), fficonfig)
1715             ffi_srcdir = os.path.join(fficonfig['ffi_srcdir'], 'src')
1716
1717             # Add .S (preprocessed assembly) to C compiler source extensions.
1718             self.compiler_obj.src_extensions.append('.S')
1719
1720             include_dirs = [os.path.join(ffi_builddir, 'include'),
1721                             ffi_builddir, ffi_srcdir]
1722             extra_compile_args = fficonfig['ffi_cflags'].split()
1723
1724             ext.sources.extend(fficonfig['ffi_sources'])
1725             ext.include_dirs.extend(include_dirs)
1726             ext.extra_compile_args.extend(extra_compile_args)
1727         return True
1728
1729     def detect_ctypes(self, inc_dirs, lib_dirs):
1730         self.use_system_libffi = False
1731         include_dirs = []
1732         extra_compile_args = []
1733         extra_link_args = []
1734         sources = ['_ctypes/_ctypes.c',
1735                    '_ctypes/callbacks.c',
1736                    '_ctypes/callproc.c',
1737                    '_ctypes/stgdict.c',
1738                    '_ctypes/cfield.c',
1739                    '_ctypes/malloc_closure.c']
1740         depends = ['_ctypes/ctypes.h']
1741
1742         if sys.platform == 'darwin':
1743             sources.append('_ctypes/darwin/dlfcn_simple.c')
1744             extra_compile_args.append('-DMACOSX')
1745             include_dirs.append('_ctypes/darwin')
1746 # XXX Is this still needed?
1747 ##            extra_link_args.extend(['-read_only_relocs', 'warning'])
1748
1749         elif sys.platform == 'sunos5':
1750             # XXX This shouldn't be necessary; it appears that some
1751             # of the assembler code is non-PIC (i.e. it has relocations
1752             # when it shouldn't. The proper fix would be to rewrite
1753             # the assembler code to be PIC.
1754             # This only works with GCC; the Sun compiler likely refuses
1755             # this option. If you want to compile ctypes with the Sun
1756             # compiler, please research a proper solution, instead of
1757             # finding some -z option for the Sun compiler.
1758             extra_link_args.append('-mimpure-text')
1759
1760         elif sys.platform.startswith('hp-ux'):
1761             extra_link_args.append('-fPIC')
1762
1763         ext = Extension('_ctypes',
1764                         include_dirs=include_dirs,
1765                         extra_compile_args=extra_compile_args,
1766                         extra_link_args=extra_link_args,
1767                         libraries=[],
1768                         sources=sources,
1769                         depends=depends)
1770         ext_test = Extension('_ctypes_test',
1771                              sources=['_ctypes/_ctypes_test.c'])
1772         self.extensions.extend([ext, ext_test])
1773
1774         if not '--with-system-ffi' in sysconfig.get_config_var("CONFIG_ARGS"):
1775             return
1776
1777         if sys.platform == 'darwin':
1778             # OS X 10.5 comes with libffi.dylib; the include files are
1779             # in /usr/include/ffi
1780             inc_dirs.append('/usr/include/ffi')
1781
1782         ffi_inc = find_file('ffi.h', [], inc_dirs)
1783         if ffi_inc is not None:
1784             ffi_h = ffi_inc[0] + '/ffi.h'
1785             fp = open(ffi_h)
1786             while 1:
1787                 line = fp.readline()
1788                 if not line:
1789                     ffi_inc = None
1790                     break
1791                 if line.startswith('#define LIBFFI_H'):
1792                     break
1793         ffi_lib = None
1794         if ffi_inc is not None:
1795             for lib_name in ('ffi_convenience', 'ffi_pic', 'ffi'):
1796                 if (self.compiler_obj.find_library_file(lib_dirs, lib_name)):
1797                     ffi_lib = lib_name
1798                     break
1799
1800         if ffi_inc and ffi_lib:
1801             ext.include_dirs.extend(ffi_inc)
1802             ext.libraries.append(ffi_lib)
1803             self.use_system_libffi = True
1804
1805
1806 class PyBuildInstall(install):
1807     # Suppress the warning about installation into the lib_dynload
1808     # directory, which is not in sys.path when running Python during
1809     # installation:
1810     def initialize_options (self):
1811         install.initialize_options(self)
1812         self.warn_dir=0
1813
1814 class PyBuildInstallLib(install_lib):
1815     # Do exactly what install_lib does but make sure correct access modes get
1816     # set on installed directories and files. All installed files with get
1817     # mode 644 unless they are a shared library in which case they will get
1818     # mode 755. All installed directories will get mode 755.
1819
1820     so_ext = sysconfig.get_config_var("SO")
1821
1822     def install(self):
1823         outfiles = install_lib.install(self)
1824         self.set_file_modes(outfiles, 0644, 0755)
1825         self.set_dir_modes(self.install_dir, 0755)
1826         return outfiles
1827
1828     def set_file_modes(self, files, defaultMode, sharedLibMode):
1829         if not self.is_chmod_supported(): return
1830         if not files: return
1831
1832         for filename in files:
1833             if os.path.islink(filename): continue
1834             mode = defaultMode
1835             if filename.endswith(self.so_ext): mode = sharedLibMode
1836             log.info("changing mode of %s to %o", filename, mode)
1837             if not self.dry_run: os.chmod(filename, mode)
1838
1839     def set_dir_modes(self, dirname, mode):
1840         if not self.is_chmod_supported(): return
1841         os.path.walk(dirname, self.set_dir_modes_visitor, mode)
1842
1843     def set_dir_modes_visitor(self, mode, dirname, names):
1844         if os.path.islink(dirname): return
1845         log.info("changing mode of %s to %o", dirname, mode)
1846         if not self.dry_run: os.chmod(dirname, mode)
1847
1848     def is_chmod_supported(self):
1849         return hasattr(os, 'chmod')
1850
1851 SUMMARY = """
1852 Python is an interpreted, interactive, object-oriented programming
1853 language. It is often compared to Tcl, Perl, Scheme or Java.
1854
1855 Python combines remarkable power with very clear syntax. It has
1856 modules, classes, exceptions, very high level dynamic data types, and
1857 dynamic typing. There are interfaces to many system calls and
1858 libraries, as well as to various windowing systems (X11, Motif, Tk,
1859 Mac, MFC). New built-in modules are easily written in C or C++. Python
1860 is also usable as an extension language for applications that need a
1861 programmable interface.
1862
1863 The Python implementation is portable: it runs on many brands of UNIX,
1864 on Windows, DOS, OS/2, Mac, Amiga... If your favorite system isn't
1865 listed here, it may still be supported, if there's a C compiler for
1866 it. Ask around on comp.lang.python -- or just try compiling Python
1867 yourself.
1868 """
1869
1870 CLASSIFIERS = """
1871 Development Status :: 6 - Mature
1872 License :: OSI Approved :: Python Software Foundation License
1873 Natural Language :: English
1874 Programming Language :: C
1875 Programming Language :: Python
1876 Topic :: Software Development
1877 """
1878
1879 def main():
1880     # turn off warnings when deprecated modules are imported
1881     import warnings
1882     warnings.filterwarnings("ignore",category=DeprecationWarning)
1883     setup(# PyPI Metadata (PEP 301)
1884           name = "Python",
1885           version = sys.version.split()[0],
1886           url = "http://www.python.org/%s" % sys.version[:3],
1887           maintainer = "Guido van Rossum and the Python community",
1888           maintainer_email = "python-dev@python.org",
1889           description = "A high-level object-oriented programming language",
1890           long_description = SUMMARY.strip(),
1891           license = "PSF license",
1892           classifiers = filter(None, CLASSIFIERS.split("\n")),
1893           platforms = ["Many"],
1894
1895           # Build info
1896           cmdclass = {'build_ext':PyBuildExt, 'install':PyBuildInstall,
1897                       'install_lib':PyBuildInstallLib},
1898           # The struct module is defined here, because build_ext won't be
1899           # called unless there's at least one extension module defined.
1900           ext_modules=[Extension('_struct', ['_struct.c'])],
1901
1902           # Scripts to install
1903           scripts = ['Tools/scripts/pydoc', 'Tools/scripts/idle',
1904                      'Tools/scripts/2to3',
1905                      'Lib/smtpd.py']
1906         )
1907
1908 # --install-platlib
1909 if __name__ == '__main__':
1910     main()