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