setup.py

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