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, 5)
 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,5):
 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 (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                             if db_setup_debug:
 683                                 print "db.h: found", db_ver, "in", d
 684                         else:
 685                             # we already found a header for this library version
 686                             if db_setup_debug: print "db.h: ignoring", d
 687                     else:
 688                         # ignore this header, it didn't contain a version number
 689                         if db_setup_debug: print "db.h: unsupported version", db_ver, "in", d
 690
 691             db_found_vers = db_ver_inc_map.keys()
 692             db_found_vers.sort()
 693
 694             while db_found_vers:
 695                 db_ver = db_found_vers.pop()
 696                 db_incdir = db_ver_inc_map[db_ver]
 697
 698                 # check lib directories parallel to the location of the header
 699                 db_dirs_to_check = [
 700                     os.path.join(db_incdir, '..', 'lib64'),
 701                     os.path.join(db_incdir, '..', 'lib'),
 702                     os.path.join(db_incdir, '..', '..', 'lib64'),
 703                     os.path.join(db_incdir, '..', '..', 'lib'),
 704                 ]
 705                 db_dirs_to_check = filter(os.path.isdir, db_dirs_to_check)
 706
 707                 # Look for a version specific db-X.Y before an ambiguoius dbX
 708                 # XXX should we -ever- look for a dbX name?  Do any
 709                 # systems really not name their library by version and
 710                 # symlink to more general names?
 711                 for dblib in (('db-%d.%d' % db_ver),
 712                               ('db%d%d' % db_ver),
 713                               ('db%d' % db_ver[0])):
 714                     dblib_file = self.compiler.find_library_file(
 715                                     db_dirs_to_check + lib_dirs, dblib )
 716                     if dblib_file:
 717                         dblib_dir = [ os.path.abspath(os.path.dirname(dblib_file)) ]
 718                         raise db_found
 719                     else:
 720                         if db_setup_debug: print "db lib: ", dblib, "not found"
 721
 722         except db_found:
 723             if db_setup_debug:
 724                 print "db lib: using", db_ver, dblib
 725                 print "db: lib dir", dblib_dir, "inc dir", db_incdir
 726             db_incs = [db_incdir]
 727             dblibs = [dblib]
 728             # We add the runtime_library_dirs argument because the
 729             # BerkeleyDB lib we're linking against often isn't in the
 730             # system dynamic library search path.  This is usually
 731             # correct and most trouble free, but may cause problems in
 732             # some unusual system configurations (e.g. the directory
 733             # is on an NFS server that goes away).
 734             exts.append(Extension('_bsddb', ['_bsddb.c'],
 735                                   library_dirs=dblib_dir,
 736                                   runtime_library_dirs=dblib_dir,
 737                                   include_dirs=db_incs,
 738                                   libraries=dblibs))
 739         else:
 740             if db_setup_debug: print "db: no appropriate library found"
 741             db_incs = None
 742             dblibs = []
 743             dblib_dir = None
 744
 745         # The sqlite interface
 746         sqlite_setup_debug = False   # verbose debug prints from this script?
 747
 748         # We hunt for #define SQLITE_VERSION "n.n.n"
 749         # We need to find >= sqlite version 3.0.8
 750         sqlite_incdir = sqlite_libdir = None
 751         sqlite_inc_paths = [ '/usr/include',
 752                              '/usr/include/sqlite',
 753                              '/usr/include/sqlite3',
 754                              '/usr/local/include',
 755                              '/usr/local/include/sqlite',
 756                              '/usr/local/include/sqlite3',
 757                            ]
 758         MIN_SQLITE_VERSION_NUMBER = (3, 0, 8)
 759         MIN_SQLITE_VERSION = ".".join([str(x)
 760                                     for x in MIN_SQLITE_VERSION_NUMBER])
 761
 762         # Scan the default include directories before the SQLite specific
 763         # ones. This allows one to override the copy of sqlite on OSX,
 764         # where /usr/include contains an old version of sqlite.
 765         for d in inc_dirs + sqlite_inc_paths:
 766             f = os.path.join(d, "sqlite3.h")
 767             if os.path.exists(f):
 768                 if sqlite_setup_debug: print "sqlite: found %s"%f
 769                 incf = open(f).read()
 770                 m = re.search(
 771                     r'\s*.*#\s*.*define\s.*SQLITE_VERSION\W*"(.*)"', incf)
 772                 if m:
 773                     sqlite_version = m.group(1)
 774                     sqlite_version_tuple = tuple([int(x)
 775                                         for x in sqlite_version.split(".")])
 776                     if sqlite_version_tuple >= MIN_SQLITE_VERSION_NUMBER:
 777                         # we win!
 778                         if sqlite_setup_debug:
 779                             print "%s/sqlite3.h: version %s"%(d, sqlite_version)
 780                         sqlite_incdir = d
 781                         break
 782                     else:
 783                         if sqlite_setup_debug:
 784                             print "%s: version %d is too old, need >= %s"%(d,
 785                                         sqlite_version, MIN_SQLITE_VERSION)
 786                 elif sqlite_setup_debug:
 787                     print "sqlite: %s had no SQLITE_VERSION"%(f,)
 788
 789         if sqlite_incdir:
 790             sqlite_dirs_to_check = [
 791                 os.path.join(sqlite_incdir, '..', 'lib64'),
 792                 os.path.join(sqlite_incdir, '..', 'lib'),
 793                 os.path.join(sqlite_incdir, '..', '..', 'lib64'),
 794                 os.path.join(sqlite_incdir, '..', '..', 'lib'),
 795             ]
 796             sqlite_libfile = self.compiler.find_library_file(
 797                                 sqlite_dirs_to_check + lib_dirs, 'sqlite3')
 798             sqlite_libdir = [os.path.abspath(os.path.dirname(sqlite_libfile))]
 799
 800         if sqlite_incdir and sqlite_libdir:
 801             sqlite_srcs = ['_sqlite/cache.c',
 802                 '_sqlite/connection.c',
 803                 '_sqlite/cursor.c',
 804                 '_sqlite/microprotocols.c',
 805                 '_sqlite/module.c',
 806                 '_sqlite/prepare_protocol.c',
 807                 '_sqlite/row.c',
 808                 '_sqlite/statement.c',
 809                 '_sqlite/util.c', ]
 810
 811             sqlite_defines = []
 812             if sys.platform != "win32":
 813                 sqlite_defines.append(('MODULE_NAME', '"sqlite3"'))
 814             else:
 815                 sqlite_defines.append(('MODULE_NAME', '\\"sqlite3\\"'))
 816
 817
 818             if sys.platform == 'darwin':
 819                 # In every directory on the search path search for a dynamic
 820                 # library and then a static library, instead of first looking
 821                 # for dynamic libraries on the entiry path.
 822                 # This way a staticly linked custom sqlite gets picked up
 823                 # before the dynamic library in /usr/lib.
 824                 sqlite_extra_link_args = ('-Wl,-search_paths_first',)
 825             else:
 826                 sqlite_extra_link_args = ()
 827
 828             exts.append(Extension('_sqlite3', sqlite_srcs,
 829                                   define_macros=sqlite_defines,
 830                                   include_dirs=["Modules/_sqlite",
 831                                                 sqlite_incdir],
 832                                   library_dirs=sqlite_libdir,
 833                                   runtime_library_dirs=sqlite_libdir,
 834                                   extra_link_args=sqlite_extra_link_args,
 835                                   libraries=["sqlite3",]))
 836
 837         # Look for Berkeley db 1.85.   Note that it is built as a different
 838         # module name so it can be included even when later versions are
 839         # available.  A very restrictive search is performed to avoid
 840         # accidentally building this module with a later version of the
 841         # underlying db library.  May BSD-ish Unixes incorporate db 1.85
 842         # symbols into libc and place the include file in /usr/include.
 843         f = "/usr/include/db.h"
 844         if os.path.exists(f):
 845             data = open(f).read()
 846             m = re.search(r"#s*define\s+HASHVERSION\s+2\s*", data)
 847             if m is not None:
 848                 # bingo - old version used hash file format version 2
 849                 ### XXX this should be fixed to not be platform-dependent
 850                 ### but I don't have direct access to an osf1 platform and
 851                 ### seemed to be muffing the search somehow
 852                 libraries = platform == "osf1" and ['db'] or None
 853                 if libraries is not None:
 854                     exts.append(Extension('bsddb185', ['bsddbmodule.c'],
 855                                           libraries=libraries))
 856                 else:
 857                     exts.append(Extension('bsddb185', ['bsddbmodule.c']))
 858
 859         # The standard Unix dbm module:
 860         if platform not in ['cygwin']:
 861             if find_file("ndbm.h", inc_dirs, []) is not None:
 862                 # Some systems have -lndbm, others don't
 863                 if self.compiler.find_library_file(lib_dirs, 'ndbm'):
 864                     ndbm_libs = ['ndbm']
 865                 else:
 866                     ndbm_libs = []
 867                 exts.append( Extension('dbm', ['dbmmodule.c'],
 868                                        define_macros=[('HAVE_NDBM_H',None)],
 869                                        libraries = ndbm_libs ) )
 870             elif (self.compiler.find_library_file(lib_dirs, 'gdbm')
 871                   and find_file("gdbm/ndbm.h", inc_dirs, []) is not None):
 872                 exts.append( Extension('dbm', ['dbmmodule.c'],
 873                                        define_macros=[('HAVE_GDBM_NDBM_H',None)],
 874                                        libraries = ['gdbm'] ) )
 875             elif db_incs is not None:
 876                 exts.append( Extension('dbm', ['dbmmodule.c'],
 877                                        library_dirs=dblib_dir,
 878                                        runtime_library_dirs=dblib_dir,
 879                                        include_dirs=db_incs,
 880                                        define_macros=[('HAVE_BERKDB_H',None),
 881                                                       ('DB_DBM_HSEARCH',None)],
 882                                        libraries=dblibs))
 883
 884         # Anthony Baxter's gdbm module.  GNU dbm(3) will require -lgdbm:
 885         if (self.compiler.find_library_file(lib_dirs, 'gdbm')):
 886             exts.append( Extension('gdbm', ['gdbmmodule.c'],
 887                                    libraries = ['gdbm'] ) )
 888
 889         # Unix-only modules
 890         if platform not in ['mac', 'win32']:
 891             # Steen Lumholt's termios module
 892             exts.append( Extension('termios', ['termios.c']) )
 893             # Jeremy Hylton's rlimit interface
 894             if platform not in ['atheos']:
 895                 exts.append( Extension('resource', ['resource.c']) )
 896
 897             # Sun yellow pages. Some systems have the functions in libc.
 898             if platform not in ['cygwin', 'atheos']:
 899                 if (self.compiler.find_library_file(lib_dirs, 'nsl')):
 900                     libs = ['nsl']
 901                 else:
 902                     libs = []
 903                 exts.append( Extension('nis', ['nismodule.c'],
 904                                        libraries = libs) )
 905
 906         # Curses support, requiring the System V version of curses, often
 907         # provided by the ncurses library.
 908         panel_library = 'panel'
 909         if (self.compiler.find_library_file(lib_dirs, 'ncursesw')):
 910             curses_libs = ['ncursesw']
 911             # Bug 1464056: If _curses.so links with ncursesw,
 912             # _curses_panel.so must link with panelw.
 913             panel_library = 'panelw'
 914             exts.append( Extension('_curses', ['_cursesmodule.c'],
 915                                    libraries = curses_libs) )
 916         elif (self.compiler.find_library_file(lib_dirs, 'ncurses')):
 917             curses_libs = ['ncurses']
 918             exts.append( Extension('_curses', ['_cursesmodule.c'],
 919                                    libraries = curses_libs) )
 920         elif (self.compiler.find_library_file(lib_dirs, 'curses')
 921               and platform != 'darwin'):
 922                 # OSX has an old Berkeley curses, not good enough for
 923                 # the _curses module.
 924             if (self.compiler.find_library_file(lib_dirs, 'terminfo')):
 925                 curses_libs = ['curses', 'terminfo']
 926             elif (self.compiler.find_library_file(lib_dirs, 'termcap')):
 927                 curses_libs = ['curses', 'termcap']
 928             else:
 929                 curses_libs = ['curses']
 930
 931             exts.append( Extension('_curses', ['_cursesmodule.c'],
 932                                    libraries = curses_libs) )
 933
 934         # If the curses module is enabled, check for the panel module
 935         if (module_enabled(exts, '_curses') and
 936             self.compiler.find_library_file(lib_dirs, panel_library)):
 937             exts.append( Extension('_curses_panel', ['_curses_panel.c'],
 938                                    libraries = [panel_library] + curses_libs) )
 939
 940
 941         # Andrew Kuchling's zlib module.  Note that some versions of zlib
 942         # 1.1.3 have security problems.  See CERT Advisory CA-2002-07:
 943         # http://www.cert.org/advisories/CA-2002-07.html
 944         #
 945         # zlib 1.1.4 is fixed, but at least one vendor (RedHat) has decided to
 946         # patch its zlib 1.1.3 package instead of upgrading to 1.1.4.  For
 947         # now, we still accept 1.1.3, because we think it's difficult to
 948         # exploit this in Python, and we'd rather make it RedHat's problem
 949         # than our problem <wink>.
 950         #
 951         # You can upgrade zlib to version 1.1.4 yourself by going to
 952         # http://www.gzip.org/zlib/
 953         zlib_inc = find_file('zlib.h', [], inc_dirs)
 954         if zlib_inc is not None:
 955             zlib_h = zlib_inc[0] + '/zlib.h'
 956             version = '"0.0.0"'
 957             version_req = '"1.1.3"'
 958             fp = open(zlib_h)
 959             while 1:
 960                 line = fp.readline()
 961                 if not line:
 962                     break
 963                 if line.startswith('#define ZLIB_VERSION'):
 964                     version = line.split()[2]
 965                     break
 966             if version >= version_req:
 967                 if (self.compiler.find_library_file(lib_dirs, 'z')):
 968                     if sys.platform == "darwin":
 969                         zlib_extra_link_args = ('-Wl,-search_paths_first',)
 970                     else:
 971                         zlib_extra_link_args = ()
 972                     exts.append( Extension('zlib', ['zlibmodule.c'],
 973                                            libraries = ['z'],
 974                                            extra_link_args = zlib_extra_link_args))
 975
 976         # Gustavo Niemeyer's bz2 module.
 977         if (self.compiler.find_library_file(lib_dirs, 'bz2')):
 978             if sys.platform == "darwin":
 979                 bz2_extra_link_args = ('-Wl,-search_paths_first',)
 980             else:
 981                 bz2_extra_link_args = ()
 982             exts.append( Extension('bz2', ['bz2module.c'],
 983                                    libraries = ['bz2'],
 984                                    extra_link_args = bz2_extra_link_args) )
 985
 986         # Interface to the Expat XML parser
 987         #
 988         # Expat was written by James Clark and is now maintained by a
 989         # group of developers on SourceForge; see www.libexpat.org for
 990         # more information.  The pyexpat module was written by Paul
 991         # Prescod after a prototype by Jack Jansen.  The Expat source
 992         # is included in Modules/expat/.  Usage of a system
 993         # shared libexpat.so/expat.dll is not advised.
 994         #
 995         # More information on Expat can be found at www.libexpat.org.
 996         #
 997         expatinc = os.path.join(os.getcwd(), srcdir, 'Modules', 'expat')
 998         define_macros = [
 999             ('HAVE_EXPAT_CONFIG_H', '1'),
1000         ]
1001
1002         exts.append(Extension('pyexpat',
1003                               define_macros = define_macros,
1004                               include_dirs = [expatinc],
1005                               sources = ['pyexpat.c',
1006                                          'expat/xmlparse.c',
1007                                          'expat/xmlrole.c',
1008                                          'expat/xmltok.c',
1009                                          ],
1010                               ))
1011
1012         # Fredrik Lundh's cElementTree module.  Note that this also
1013         # uses expat (via the CAPI hook in pyexpat).
1014
1015         if os.path.isfile(os.path.join(srcdir, 'Modules', '_elementtree.c')):
1016             define_macros.append(('USE_PYEXPAT_CAPI', None))
1017             exts.append(Extension('_elementtree',
1018                                   define_macros = define_macros,
1019                                   include_dirs = [expatinc],
1020                                   sources = ['_elementtree.c'],
1021                                   ))
1022
1023         # Hye-Shik Chang's CJKCodecs modules.
1024         if have_unicode:
1025             exts.append(Extension('_multibytecodec',
1026                                   ['cjkcodecs/multibytecodec.c']))
1027             for loc in ('kr', 'jp', 'cn', 'tw', 'hk', 'iso2022'):
1028                 exts.append(Extension('_codecs_' + loc,
1029                                       ['cjkcodecs/_codecs_%s.c' % loc]))
1030
1031         # Dynamic loading module
1032         if sys.maxint == 0x7fffffff:
1033             # This requires sizeof(int) == sizeof(long) == sizeof(char*)
1034             dl_inc = find_file('dlfcn.h', [], inc_dirs)
1035             if (dl_inc is not None) and (platform not in ['atheos']):
1036                 exts.append( Extension('dl', ['dlmodule.c']) )
1037
1038         # Thomas Heller's _ctypes module
1039         self.detect_ctypes(inc_dirs, lib_dirs)
1040
1041         # Platform-specific libraries
1042         if platform == 'linux2':
1043             # Linux-specific modules
1044             exts.append( Extension('linuxaudiodev', ['linuxaudiodev.c']) )
1045
1046         if platform in ('linux2', 'freebsd4', 'freebsd5', 'freebsd6',
1047                         'freebsd7'):
1048             exts.append( Extension('ossaudiodev', ['ossaudiodev.c']) )
1049
1050         if platform == 'sunos5':
1051             # SunOS specific modules
1052             exts.append( Extension('sunaudiodev', ['sunaudiodev.c']) )
1053
1054         if platform == 'darwin' and ("--disable-toolbox-glue" not in
1055                 sysconfig.get_config_var("CONFIG_ARGS")):
1056
1057             if os.uname()[2] > '8.':
1058                 # We're on Mac OS X 10.4 or later, the compiler should
1059                 # support '-Wno-deprecated-declarations'. This will
1060                 # surpress deprecation warnings for the Carbon extensions,
1061                 # these extensions wrap the Carbon APIs and even those
1062                 # parts that are deprecated.
1063                 carbon_extra_compile_args = ['-Wno-deprecated-declarations']
1064             else:
1065                 carbon_extra_compile_args = []
1066
1067             # Mac OS X specific modules.
1068             def macSrcExists(name1, name2=''):
1069                 if not name1:
1070                     return None
1071                 names = (name1,)
1072                 if name2:
1073                     names = (name1, name2)
1074                 path = os.path.join(srcdir, 'Mac', 'Modules', *names)
1075                 return os.path.exists(path)
1076
1077             def addMacExtension(name, kwds, extra_srcs=[]):
1078                 dirname = ''
1079                 if name[0] == '_':
1080                     dirname = name[1:].lower()
1081                 cname = name + '.c'
1082                 cmodulename = name + 'module.c'
1083                 # Check for NNN.c, NNNmodule.c, _nnn/NNN.c, _nnn/NNNmodule.c
1084                 if macSrcExists(cname):
1085                     srcs = [cname]
1086                 elif macSrcExists(cmodulename):
1087                     srcs = [cmodulename]
1088                 elif macSrcExists(dirname, cname):
1089                     # XXX(nnorwitz): If all the names ended with module, we
1090                     # wouldn't need this condition.  ibcarbon is the only one.
1091                     srcs = [os.path.join(dirname, cname)]
1092                 elif macSrcExists(dirname, cmodulename):
1093                     srcs = [os.path.join(dirname, cmodulename)]
1094                 else:
1095                     raise RuntimeError("%s not found" % name)
1096
1097                 # Here's the whole point:  add the extension with sources
1098                 exts.append(Extension(name, srcs + extra_srcs, **kwds))
1099
1100             # Core Foundation
1101             core_kwds = {'extra_compile_args': carbon_extra_compile_args,
1102                          'extra_link_args': ['-framework', 'CoreFoundation'],
1103                         }
1104             addMacExtension('_CF', core_kwds, ['cf/pycfbridge.c'])
1105             addMacExtension('autoGIL', core_kwds)
1106
1107             # Carbon
1108             carbon_kwds = {'extra_compile_args': carbon_extra_compile_args,
1109                            'extra_link_args': ['-framework', 'Carbon'],
1110                           }
1111             CARBON_EXTS = ['ColorPicker', 'gestalt', 'MacOS', 'Nav',
1112                            'OSATerminology', 'icglue',
1113                            # All these are in subdirs
1114                            '_AE', '_AH', '_App', '_CarbonEvt', '_Cm', '_Ctl',
1115                            '_Dlg', '_Drag', '_Evt', '_File', '_Folder', '_Fm',
1116                            '_Help', '_Icn', '_IBCarbon', '_List',
1117                            '_Menu', '_Mlte', '_OSA', '_Res', '_Qd', '_Qdoffs',
1118                            '_Scrap', '_Snd', '_TE', '_Win',
1119                           ]
1120             for name in CARBON_EXTS:
1121                 addMacExtension(name, carbon_kwds)
1122
1123             # Application Services & QuickTime
1124             app_kwds = {'extra_compile_args': carbon_extra_compile_args,
1125                         'extra_link_args': ['-framework','ApplicationServices'],
1126                        }
1127             addMacExtension('_Launch', app_kwds)
1128             addMacExtension('_CG', app_kwds)
1129
1130             exts.append( Extension('_Qt', ['qt/_Qtmodule.c'],
1131                         extra_compile_args=carbon_extra_compile_args,
1132                         extra_link_args=['-framework', 'QuickTime',
1133                                      '-framework', 'Carbon']) )
1134
1135
1136         self.extensions.extend(exts)
1137
1138         # Call the method for detecting whether _tkinter can be compiled
1139         self.detect_tkinter(inc_dirs, lib_dirs)
1140
1141     def detect_tkinter_darwin(self, inc_dirs, lib_dirs):
1142         # The _tkinter module, using frameworks. Since frameworks are quite
1143         # different the UNIX search logic is not sharable.
1144         from os.path import join, exists
1145         framework_dirs = [
1146             '/System/Library/Frameworks/',
1147             '/Library/Frameworks',
1148             join(os.getenv('HOME'), '/Library/Frameworks')
1149         ]
1150
1151         # Find the directory that contains the Tcl.framework and Tk.framework
1152         # bundles.
1153         # XXX distutils should support -F!
1154         for F in framework_dirs:
1155             # both Tcl.framework and Tk.framework should be present
1156             for fw in 'Tcl', 'Tk':
1157                 if not exists(join(F, fw + '.framework')):
1158                     break
1159             else:
1160                 # ok, F is now directory with both frameworks. Continure
1161                 # building
1162                 break
1163         else:
1164             # Tk and Tcl frameworks not found. Normal "unix" tkinter search
1165             # will now resume.
1166             return 0
1167
1168         # For 8.4a2, we must add -I options that point inside the Tcl and Tk
1169         # frameworks. In later release we should hopefully be able to pass
1170         # the -F option to gcc, which specifies a framework lookup path.
1171         #
1172         include_dirs = [
1173             join(F, fw + '.framework', H)
1174             for fw in 'Tcl', 'Tk'
1175             for H in 'Headers', 'Versions/Current/PrivateHeaders'
1176         ]
1177
1178         # For 8.4a2, the X11 headers are not included. Rather than include a
1179         # complicated search, this is a hard-coded path. It could bail out
1180         # if X11 libs are not found...
1181         include_dirs.append('/usr/X11R6/include')
1182         frameworks = ['-framework', 'Tcl', '-framework', 'Tk']
1183
1184         ext = Extension('_tkinter', ['_tkinter.c', 'tkappinit.c'],
1185                         define_macros=[('WITH_APPINIT', 1)],
1186                         include_dirs = include_dirs,
1187                         libraries = [],
1188                         extra_compile_args = frameworks,
1189                         extra_link_args = frameworks,
1190                         )
1191         self.extensions.append(ext)
1192         return 1
1193
1194
1195     def detect_tkinter(self, inc_dirs, lib_dirs):
1196         # The _tkinter module.
1197
1198         # Rather than complicate the code below, detecting and building
1199         # AquaTk is a separate method. Only one Tkinter will be built on
1200         # Darwin - either AquaTk, if it is found, or X11 based Tk.
1201         platform = self.get_platform()
1202         if (platform == 'darwin' and
1203             self.detect_tkinter_darwin(inc_dirs, lib_dirs)):
1204             return
1205
1206         # Assume we haven't found any of the libraries or include files
1207         # The versions with dots are used on Unix, and the versions without
1208         # dots on Windows, for detection by cygwin.
1209         tcllib = tklib = tcl_includes = tk_includes = None
1210         for version in ['8.5', '85', '8.4', '84', '8.3', '83', '8.2',
1211                         '82', '8.1', '81', '8.0', '80']:
1212             tklib = self.compiler.find_library_file(lib_dirs, 'tk' + version)
1213             tcllib = self.compiler.find_library_file(lib_dirs, 'tcl' + version)
1214             if tklib and tcllib:
1215                 # Exit the loop when we've found the Tcl/Tk libraries
1216                 break
1217
1218         # Now check for the header files
1219         if tklib and tcllib:
1220             # Check for the include files on Debian and {Free,Open}BSD, where
1221             # they're put in /usr/include/{tcl,tk}X.Y
1222             dotversion = version
1223             if '.' not in dotversion and "bsd" in sys.platform.lower():
1224                 # OpenBSD and FreeBSD use Tcl/Tk library names like libtcl83.a,
1225                 # but the include subdirs are named like .../include/tcl8.3.
1226                 dotversion = dotversion[:-1] + '.' + dotversion[-1]
1227             tcl_include_sub = []
1228             tk_include_sub = []
1229             for dir in inc_dirs:
1230                 tcl_include_sub += [dir + os.sep + "tcl" + dotversion]
1231                 tk_include_sub += [dir + os.sep + "tk" + dotversion]
1232             tk_include_sub += tcl_include_sub
1233             tcl_includes = find_file('tcl.h', inc_dirs, tcl_include_sub)
1234             tk_includes = find_file('tk.h', inc_dirs, tk_include_sub)
1235
1236         if (tcllib is None or tklib is None or
1237             tcl_includes is None or tk_includes is None):
1238             self.announce("INFO: Can't locate Tcl/Tk libs and/or headers", 2)
1239             return
1240
1241         # OK... everything seems to be present for Tcl/Tk.
1242
1243         include_dirs = [] ; libs = [] ; defs = [] ; added_lib_dirs = []
1244         for dir in tcl_includes + tk_includes:
1245             if dir not in include_dirs:
1246                 include_dirs.append(dir)
1247
1248         # Check for various platform-specific directories
1249         if platform == 'sunos5':
1250             include_dirs.append('/usr/openwin/include')
1251             added_lib_dirs.append('/usr/openwin/lib')
1252         elif os.path.exists('/usr/X11R6/include'):
1253             include_dirs.append('/usr/X11R6/include')
1254             added_lib_dirs.append('/usr/X11R6/lib64')
1255             added_lib_dirs.append('/usr/X11R6/lib')
1256         elif os.path.exists('/usr/X11R5/include'):
1257             include_dirs.append('/usr/X11R5/include')
1258             added_lib_dirs.append('/usr/X11R5/lib')
1259         else:
1260             # Assume default location for X11
1261             include_dirs.append('/usr/X11/include')
1262             added_lib_dirs.append('/usr/X11/lib')
1263
1264         # If Cygwin, then verify that X is installed before proceeding
1265         if platform == 'cygwin':
1266             x11_inc = find_file('X11/Xlib.h', [], include_dirs)
1267             if x11_inc is None:
1268                 return
1269
1270         # Check for BLT extension
1271         if self.compiler.find_library_file(lib_dirs + added_lib_dirs,
1272                                            'BLT8.0'):
1273             defs.append( ('WITH_BLT', 1) )
1274             libs.append('BLT8.0')
1275         elif self.compiler.find_library_file(lib_dirs + added_lib_dirs,
1276                                            'BLT'):
1277             defs.append( ('WITH_BLT', 1) )
1278             libs.append('BLT')
1279
1280         # Add the Tcl/Tk libraries
1281         libs.append('tk'+ version)
1282         libs.append('tcl'+ version)
1283
1284         if platform in ['aix3', 'aix4']:
1285             libs.append('ld')
1286
1287         # Finally, link with the X11 libraries (not appropriate on cygwin)
1288         if platform != "cygwin":
1289             libs.append('X11')
1290
1291         ext = Extension('_tkinter', ['_tkinter.c', 'tkappinit.c'],
1292                         define_macros=[('WITH_APPINIT', 1)] + defs,
1293                         include_dirs = include_dirs,
1294                         libraries = libs,
1295                         library_dirs = added_lib_dirs,
1296                         )
1297         self.extensions.append(ext)
1298
1299 ##         # Uncomment these lines if you want to play with xxmodule.c
1300 ##         ext = Extension('xx', ['xxmodule.c'])
1301 ##         self.extensions.append(ext)
1302
1303         # XXX handle these, but how to detect?
1304         # *** Uncomment and edit for PIL (TkImaging) extension only:
1305         #       -DWITH_PIL -I../Extensions/Imaging/libImaging  tkImaging.c \
1306         # *** Uncomment and edit for TOGL extension only:
1307         #       -DWITH_TOGL togl.c \
1308         # *** Uncomment these for TOGL extension only:
1309         #       -lGL -lGLU -lXext -lXmu \
1310
1311     def configure_ctypes(self, ext):
1312         if not self.use_system_libffi:
1313             (srcdir,) = sysconfig.get_config_vars('srcdir')
1314             ffi_builddir = os.path.join(self.build_temp, 'libffi')
1315             ffi_srcdir = os.path.abspath(os.path.join(srcdir, 'Modules',
1316                                          '_ctypes', 'libffi'))
1317             ffi_configfile = os.path.join(ffi_builddir, 'fficonfig.py')
1318
1319             from distutils.dep_util import newer_group
1320
1321             config_sources = [os.path.join(ffi_srcdir, fname)
1322                               for fname in os.listdir(ffi_srcdir)]
1323             if self.force or newer_group(config_sources,
1324                                          ffi_configfile):
1325                 from distutils.dir_util import mkpath
1326                 mkpath(ffi_builddir)
1327                 config_args = []
1328
1329                 # Pass empty CFLAGS because we'll just append the resulting
1330                 # CFLAGS to Python's; -g or -O2 is to be avoided.
1331                 cmd = "cd %s && env CFLAGS='' '%s/configure' %s" \
1332                       % (ffi_builddir, ffi_srcdir, " ".join(config_args))
1333
1334                 res = os.system(cmd)
1335                 if res or not os.path.exists(ffi_configfile):
1336                     print "Failed to configure _ctypes module"
1337                     return False
1338
1339             fficonfig = {}
1340             execfile(ffi_configfile, globals(), fficonfig)
1341             ffi_srcdir = os.path.join(fficonfig['ffi_srcdir'], 'src')
1342
1343             # Add .S (preprocessed assembly) to C compiler source extensions.
1344             self.compiler.src_extensions.append('.S')
1345
1346             include_dirs = [os.path.join(ffi_builddir, 'include'),
1347                             ffi_builddir, ffi_srcdir]
1348             extra_compile_args = fficonfig['ffi_cflags'].split()
1349
1350             ext.sources.extend(fficonfig['ffi_sources'])
1351             ext.include_dirs.extend(include_dirs)
1352             ext.extra_compile_args.extend(extra_compile_args)
1353         return True
1354
1355     def detect_ctypes(self, inc_dirs, lib_dirs):
1356         self.use_system_libffi = False
1357         include_dirs = []
1358         extra_compile_args = []
1359         extra_link_args = []
1360         sources = ['_ctypes/_ctypes.c',
1361                    '_ctypes/callbacks.c',
1362                    '_ctypes/callproc.c',
1363                    '_ctypes/stgdict.c',
1364                    '_ctypes/cfield.c',
1365                    '_ctypes/malloc_closure.c']
1366         depends = ['_ctypes/ctypes.h']
1367
1368         if sys.platform == 'darwin':
1369             sources.append('_ctypes/darwin/dlfcn_simple.c')
1370             include_dirs.append('_ctypes/darwin')
1371 # XXX Is this still needed?
1372 ##            extra_link_args.extend(['-read_only_relocs', 'warning'])
1373
1374         elif sys.platform == 'sunos5':
1375             # XXX This shouldn't be necessary; it appears that some
1376             # of the assembler code is non-PIC (i.e. it has relocations
1377             # when it shouldn't. The proper fix would be to rewrite
1378             # the assembler code to be PIC.
1379             # This only works with GCC; the Sun compiler likely refuses
1380             # this option. If you want to compile ctypes with the Sun
1381             # compiler, please research a proper solution, instead of
1382             # finding some -z option for the Sun compiler.
1383             extra_link_args.append('-mimpure-text')
1384
1385         ext = Extension('_ctypes',
1386                         include_dirs=include_dirs,
1387                         extra_compile_args=extra_compile_args,
1388                         extra_link_args=extra_link_args,
1389                         libraries=[],
1390                         sources=sources,
1391                         depends=depends)
1392         ext_test = Extension('_ctypes_test',
1393                              sources=['_ctypes/_ctypes_test.c'])
1394         self.extensions.extend([ext, ext_test])
1395
1396         if not '--with-system-ffi' in sysconfig.get_config_var("CONFIG_ARGS"):
1397             return
1398
1399         ffi_inc = find_file('ffi.h', [], inc_dirs)
1400         if ffi_inc is not None:
1401             ffi_h = ffi_inc[0] + '/ffi.h'
1402             fp = open(ffi_h)
1403             while 1:
1404                 line = fp.readline()
1405                 if not line:
1406                     ffi_inc = None
1407                     break
1408                 if line.startswith('#define LIBFFI_H'):
1409                     break
1410         ffi_lib = None
1411         if ffi_inc is not None:
1412             for lib_name in ('ffi_convenience', 'ffi_pic', 'ffi'):
1413                 if (self.compiler.find_library_file(lib_dirs, lib_name)):
1414                     ffi_lib = lib_name
1415                     break
1416
1417         if ffi_inc and ffi_lib:
1418             ext.include_dirs.extend(ffi_inc)
1419             ext.libraries.append(ffi_lib)
1420             self.use_system_libffi = True
1421
1422
1423 class PyBuildInstall(install):
1424     # Suppress the warning about installation into the lib_dynload
1425     # directory, which is not in sys.path when running Python during
1426     # installation:
1427     def initialize_options (self):
1428         install.initialize_options(self)
1429         self.warn_dir=0
1430
1431 class PyBuildInstallLib(install_lib):
1432     # Do exactly what install_lib does but make sure correct access modes get
1433     # set on installed directories and files. All installed files with get
1434     # mode 644 unless they are a shared library in which case they will get
1435     # mode 755. All installed directories will get mode 755.
1436
1437     so_ext = sysconfig.get_config_var("SO")
1438
1439     def install(self):
1440         outfiles = install_lib.install(self)
1441         self.set_file_modes(outfiles, 0644, 0755)
1442         self.set_dir_modes(self.install_dir, 0755)
1443         return outfiles
1444
1445     def set_file_modes(self, files, defaultMode, sharedLibMode):
1446         if not self.is_chmod_supported(): return
1447         if not files: return
1448
1449         for filename in files:
1450             if os.path.islink(filename): continue
1451             mode = defaultMode
1452             if filename.endswith(self.so_ext): mode = sharedLibMode
1453             log.info("changing mode of %s to %o", filename, mode)
1454             if not self.dry_run: os.chmod(filename, mode)
1455
1456     def set_dir_modes(self, dirname, mode):
1457         if not self.is_chmod_supported(): return
1458         os.path.walk(dirname, self.set_dir_modes_visitor, mode)
1459
1460     def set_dir_modes_visitor(self, mode, dirname, names):
1461         if os.path.islink(dirname): return
1462         log.info("changing mode of %s to %o", dirname, mode)
1463         if not self.dry_run: os.chmod(dirname, mode)
1464
1465     def is_chmod_supported(self):
1466         return hasattr(os, 'chmod')
1467
1468 SUMMARY = """
1469 Python is an interpreted, interactive, object-oriented programming
1470 language. It is often compared to Tcl, Perl, Scheme or Java.
1471
1472 Python combines remarkable power with very clear syntax. It has
1473 modules, classes, exceptions, very high level dynamic data types, and
1474 dynamic typing. There are interfaces to many system calls and
1475 libraries, as well as to various windowing systems (X11, Motif, Tk,
1476 Mac, MFC). New built-in modules are easily written in C or C++. Python
1477 is also usable as an extension language for applications that need a
1478 programmable interface.
1479
1480 The Python implementation is portable: it runs on many brands of UNIX,
1481 on Windows, DOS, OS/2, Mac, Amiga... If your favorite system isn't
1482 listed here, it may still be supported, if there's a C compiler for
1483 it. Ask around on comp.lang.python -- or just try compiling Python
1484 yourself.
1485 """
1486
1487 CLASSIFIERS = """
1488 Development Status :: 3 - Alpha
1489 Development Status :: 6 - Mature
1490 License :: OSI Approved :: Python Software Foundation License
1491 Natural Language :: English
1492 Programming Language :: C
1493 Programming Language :: Python
1494 Topic :: Software Development
1495 """
1496
1497 def main():
1498     # turn off warnings when deprecated modules are imported
1499     import warnings
1500     warnings.filterwarnings("ignore",category=DeprecationWarning)
1501     setup(# PyPI Metadata (PEP 301)
1502           name = "Python",
1503           version = sys.version.split()[0],
1504           url = "http://www.python.org/%s" % sys.version[:3],
1505           maintainer = "Guido van Rossum and the Python community",
1506           maintainer_email = "python-dev@python.org",
1507           description = "A high-level object-oriented programming language",
1508           long_description = SUMMARY.strip(),
1509           license = "PSF license",
1510           classifiers = filter(None, CLASSIFIERS.split("\n")),
1511           platforms = ["Many"],
1512
1513           # Build info
1514           cmdclass = {'build_ext':PyBuildExt, 'install':PyBuildInstall,
1515                       'install_lib':PyBuildInstallLib},
1516           # The struct module is defined here, because build_ext won't be
1517           # called unless there's at least one extension module defined.
1518           ext_modules=[Extension('_struct', ['_struct.c'])],
1519
1520           # Scripts to install
1521           scripts = ['Tools/scripts/pydoc', 'Tools/scripts/idle',
1522                      'Lib/smtpd.py']
1523         )
1524
1525 # --install-platlib
1526 if __name__ == '__main__':
1527     main()