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