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