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         panel_library = 'panel'
 906         if (self.compiler.find_library_file(lib_dirs, 'ncursesw')):
 907             curses_libs = ['ncursesw']
 908             # Bug 1464056: If _curses.so links with ncursesw,
 909             # _curses_panel.so must link with panelw.
 910             panel_library = 'panelw'
 911             exts.append( Extension('_curses', ['_cursesmodule.c'],
 912                                    libraries = curses_libs) )
 913         elif (self.compiler.find_library_file(lib_dirs, 'ncurses')):
 914             curses_libs = ['ncurses']
 915             exts.append( Extension('_curses', ['_cursesmodule.c'],
 916                                    libraries = curses_libs) )
 917         elif (self.compiler.find_library_file(lib_dirs, 'curses')
 918               and platform != 'darwin'):
 919                 # OSX has an old Berkeley curses, not good enough for
 920                 # the _curses module.
 921             if (self.compiler.find_library_file(lib_dirs, 'terminfo')):
 922                 curses_libs = ['curses', 'terminfo']
 923             elif (self.compiler.find_library_file(lib_dirs, 'termcap')):
 924                 curses_libs = ['curses', 'termcap']
 925             else:
 926                 curses_libs = ['curses']
 927
 928             exts.append( Extension('_curses', ['_cursesmodule.c'],
 929                                    libraries = curses_libs) )
 930
 931         # If the curses module is enabled, check for the panel module
 932         if (module_enabled(exts, '_curses') and
 933             self.compiler.find_library_file(lib_dirs, panel_library)):
 934             exts.append( Extension('_curses_panel', ['_curses_panel.c'],
 935                                    libraries = [panel_library] + curses_libs) )
 936
 937
 938         # Andrew Kuchling's zlib module.  Note that some versions of zlib
 939         # 1.1.3 have security problems.  See CERT Advisory CA-2002-07:
 940         # http://www.cert.org/advisories/CA-2002-07.html
 941         #
 942         # zlib 1.1.4 is fixed, but at least one vendor (RedHat) has decided to
 943         # patch its zlib 1.1.3 package instead of upgrading to 1.1.4.  For
 944         # now, we still accept 1.1.3, because we think it's difficult to
 945         # exploit this in Python, and we'd rather make it RedHat's problem
 946         # than our problem <wink>.
 947         #
 948         # You can upgrade zlib to version 1.1.4 yourself by going to
 949         # http://www.gzip.org/zlib/
 950         zlib_inc = find_file('zlib.h', [], inc_dirs)
 951         if zlib_inc is not None:
 952             zlib_h = zlib_inc[0] + '/zlib.h'
 953             version = '"0.0.0"'
 954             version_req = '"1.1.3"'
 955             fp = open(zlib_h)
 956             while 1:
 957                 line = fp.readline()
 958                 if not line:
 959                     break
 960                 if line.startswith('#define ZLIB_VERSION'):
 961                     version = line.split()[2]
 962                     break
 963             if version >= version_req:
 964                 if (self.compiler.find_library_file(lib_dirs, 'z')):
 965                     if sys.platform == "darwin":
 966                         zlib_extra_link_args = ('-Wl,-search_paths_first',)
 967                     else:
 968                         zlib_extra_link_args = ()
 969                     exts.append( Extension('zlib', ['zlibmodule.c'],
 970                                            libraries = ['z'],
 971                                            extra_link_args = zlib_extra_link_args))
 972
 973         # Gustavo Niemeyer's bz2 module.
 974         if (self.compiler.find_library_file(lib_dirs, 'bz2')):
 975             if sys.platform == "darwin":
 976                 bz2_extra_link_args = ('-Wl,-search_paths_first',)
 977             else:
 978                 bz2_extra_link_args = ()
 979             exts.append( Extension('bz2', ['bz2module.c'],
 980                                    libraries = ['bz2'],
 981                                    extra_link_args = bz2_extra_link_args) )
 982
 983         # Interface to the Expat XML parser
 984         #
 985         # Expat was written by James Clark and is now maintained by a
 986         # group of developers on SourceForge; see www.libexpat.org for
 987         # more information.  The pyexpat module was written by Paul
 988         # Prescod after a prototype by Jack Jansen.  The Expat source
 989         # is included in Modules/expat/.  Usage of a system
 990         # shared libexpat.so/expat.dll is not advised.
 991         #
 992         # More information on Expat can be found at www.libexpat.org.
 993         #
 994         expatinc = os.path.join(os.getcwd(), srcdir, 'Modules', 'expat')
 995         define_macros = [
 996             ('HAVE_EXPAT_CONFIG_H', '1'),
 997         ]
 998
 999         exts.append(Extension('pyexpat',
1000                               define_macros = define_macros,
1001                               include_dirs = [expatinc],
1002                               sources = ['pyexpat.c',
1003                                          'expat/xmlparse.c',
1004                                          'expat/xmlrole.c',
1005                                          'expat/xmltok.c',
1006                                          ],
1007                               ))
1008
1009         # Fredrik Lundh's cElementTree module.  Note that this also
1010         # uses expat (via the CAPI hook in pyexpat).
1011
1012         if os.path.isfile(os.path.join(srcdir, 'Modules', '_elementtree.c')):
1013             define_macros.append(('USE_PYEXPAT_CAPI', None))
1014             exts.append(Extension('_elementtree',
1015                                   define_macros = define_macros,
1016                                   include_dirs = [expatinc],
1017                                   sources = ['_elementtree.c'],
1018                                   ))
1019
1020         # Hye-Shik Chang's CJKCodecs modules.
1021         if have_unicode:
1022             exts.append(Extension('_multibytecodec',
1023                                   ['cjkcodecs/multibytecodec.c']))
1024             for loc in ('kr', 'jp', 'cn', 'tw', 'hk', 'iso2022'):
1025                 exts.append(Extension('_codecs_' + loc,
1026                                       ['cjkcodecs/_codecs_%s.c' % loc]))
1027
1028         # Dynamic loading module
1029         if sys.maxint == 0x7fffffff:
1030             # This requires sizeof(int) == sizeof(long) == sizeof(char*)
1031             dl_inc = find_file('dlfcn.h', [], inc_dirs)
1032             if (dl_inc is not None) and (platform not in ['atheos']):
1033                 exts.append( Extension('dl', ['dlmodule.c']) )
1034
1035         # Thomas Heller's _ctypes module
1036         self.detect_ctypes(inc_dirs, lib_dirs)
1037
1038         # Platform-specific libraries
1039         if platform == 'linux2':
1040             # Linux-specific modules
1041             exts.append( Extension('linuxaudiodev', ['linuxaudiodev.c']) )
1042
1043         if platform in ('linux2', 'freebsd4', 'freebsd5', 'freebsd6',
1044                         'freebsd7'):
1045             exts.append( Extension('ossaudiodev', ['ossaudiodev.c']) )
1046
1047         if platform == 'sunos5':
1048             # SunOS specific modules
1049             exts.append( Extension('sunaudiodev', ['sunaudiodev.c']) )
1050
1051         if platform == 'darwin' and ("--disable-toolbox-glue" not in
1052                 sysconfig.get_config_var("CONFIG_ARGS")):
1053
1054             if os.uname()[2] > '8.':
1055                 # We're on Mac OS X 10.4 or later, the compiler should
1056                 # support '-Wno-deprecated-declarations'. This will
1057                 # surpress deprecation warnings for the Carbon extensions,
1058                 # these extensions wrap the Carbon APIs and even those
1059                 # parts that are deprecated.
1060                 carbon_extra_compile_args = ['-Wno-deprecated-declarations']
1061             else:
1062                 carbon_extra_compile_args = []
1063
1064             # Mac OS X specific modules.
1065             def macSrcExists(name1, name2=''):
1066                 if not name1:
1067                     return None
1068                 names = (name1,)
1069                 if name2:
1070                     names = (name1, name2)
1071                 path = os.path.join(srcdir, 'Mac', 'Modules', *names)
1072                 return os.path.exists(path)
1073
1074             def addMacExtension(name, kwds, extra_srcs=[]):
1075                 dirname = ''
1076                 if name[0] == '_':
1077                     dirname = name[1:].lower()
1078                 cname = name + '.c'
1079                 cmodulename = name + 'module.c'
1080                 # Check for NNN.c, NNNmodule.c, _nnn/NNN.c, _nnn/NNNmodule.c
1081                 if macSrcExists(cname):
1082                     srcs = [cname]
1083                 elif macSrcExists(cmodulename):
1084                     srcs = [cmodulename]
1085                 elif macSrcExists(dirname, cname):
1086                     # XXX(nnorwitz): If all the names ended with module, we
1087                     # wouldn't need this condition.  ibcarbon is the only one.
1088                     srcs = [os.path.join(dirname, cname)]
1089                 elif macSrcExists(dirname, cmodulename):
1090                     srcs = [os.path.join(dirname, cmodulename)]
1091                 else:
1092                     raise RuntimeError("%s not found" % name)
1093
1094                 # Here's the whole point:  add the extension with sources
1095                 exts.append(Extension(name, srcs + extra_srcs, **kwds))
1096
1097             # Core Foundation
1098             core_kwds = {'extra_compile_args': carbon_extra_compile_args,
1099                          'extra_link_args': ['-framework', 'CoreFoundation'],
1100                         }
1101             addMacExtension('_CF', core_kwds, ['cf/pycfbridge.c'])
1102             addMacExtension('autoGIL', core_kwds)
1103
1104             # Carbon
1105             carbon_kwds = {'extra_compile_args': carbon_extra_compile_args,
1106                            'extra_link_args': ['-framework', 'Carbon'],
1107                           }
1108             CARBON_EXTS = ['ColorPicker', 'gestalt', 'MacOS', 'Nav',
1109                            'OSATerminology', 'icglue',
1110                            # All these are in subdirs
1111                            '_AE', '_AH', '_App', '_CarbonEvt', '_Cm', '_Ctl',
1112                            '_Dlg', '_Drag', '_Evt', '_File', '_Folder', '_Fm',
1113                            '_Help', '_Icn', '_IBCarbon', '_List',
1114                            '_Menu', '_Mlte', '_OSA', '_Res', '_Qd', '_Qdoffs',
1115                            '_Scrap', '_Snd', '_TE', '_Win',
1116                           ]
1117             for name in CARBON_EXTS:
1118                 addMacExtension(name, carbon_kwds)
1119
1120             # Application Services & QuickTime
1121             app_kwds = {'extra_compile_args': carbon_extra_compile_args,
1122                         'extra_link_args': ['-framework','ApplicationServices'],
1123                        }
1124             addMacExtension('_Launch', app_kwds)
1125             addMacExtension('_CG', app_kwds)
1126
1127             exts.append( Extension('_Qt', ['qt/_Qtmodule.c'],
1128                         extra_compile_args=carbon_extra_compile_args,
1129                         extra_link_args=['-framework', 'QuickTime',
1130                                      '-framework', 'Carbon']) )
1131
1132
1133         self.extensions.extend(exts)
1134
1135         # Call the method for detecting whether _tkinter can be compiled
1136         self.detect_tkinter(inc_dirs, lib_dirs)
1137
1138     def detect_tkinter_darwin(self, inc_dirs, lib_dirs):
1139         # The _tkinter module, using frameworks. Since frameworks are quite
1140         # different the UNIX search logic is not sharable.
1141         from os.path import join, exists
1142         framework_dirs = [
1143             '/System/Library/Frameworks/',
1144             '/Library/Frameworks',
1145             join(os.getenv('HOME'), '/Library/Frameworks')
1146         ]
1147
1148         # Find the directory that contains the Tcl.framework and Tk.framework
1149         # bundles.
1150         # XXX distutils should support -F!
1151         for F in framework_dirs:
1152             # both Tcl.framework and Tk.framework should be present
1153             for fw in 'Tcl', 'Tk':
1154                 if not exists(join(F, fw + '.framework')):
1155                     break
1156             else:
1157                 # ok, F is now directory with both frameworks. Continure
1158                 # building
1159                 break
1160         else:
1161             # Tk and Tcl frameworks not found. Normal "unix" tkinter search
1162             # will now resume.
1163             return 0
1164
1165         # For 8.4a2, we must add -I options that point inside the Tcl and Tk
1166         # frameworks. In later release we should hopefully be able to pass
1167         # the -F option to gcc, which specifies a framework lookup path.
1168         #
1169         include_dirs = [
1170             join(F, fw + '.framework', H)
1171             for fw in 'Tcl', 'Tk'
1172             for H in 'Headers', 'Versions/Current/PrivateHeaders'
1173         ]
1174
1175         # For 8.4a2, the X11 headers are not included. Rather than include a
1176         # complicated search, this is a hard-coded path. It could bail out
1177         # if X11 libs are not found...
1178         include_dirs.append('/usr/X11R6/include')
1179         frameworks = ['-framework', 'Tcl', '-framework', 'Tk']
1180
1181         ext = Extension('_tkinter', ['_tkinter.c', 'tkappinit.c'],
1182                         define_macros=[('WITH_APPINIT', 1)],
1183                         include_dirs = include_dirs,
1184                         libraries = [],
1185                         extra_compile_args = frameworks,
1186                         extra_link_args = frameworks,
1187                         )
1188         self.extensions.append(ext)
1189         return 1
1190
1191
1192     def detect_tkinter(self, inc_dirs, lib_dirs):
1193         # The _tkinter module.
1194
1195         # Rather than complicate the code below, detecting and building
1196         # AquaTk is a separate method. Only one Tkinter will be built on
1197         # Darwin - either AquaTk, if it is found, or X11 based Tk.
1198         platform = self.get_platform()
1199         if (platform == 'darwin' and
1200             self.detect_tkinter_darwin(inc_dirs, lib_dirs)):
1201             return
1202
1203         # Assume we haven't found any of the libraries or include files
1204         # The versions with dots are used on Unix, and the versions without
1205         # dots on Windows, for detection by cygwin.
1206         tcllib = tklib = tcl_includes = tk_includes = None
1207         for version in ['8.5', '85', '8.4', '84', '8.3', '83', '8.2',
1208                         '82', '8.1', '81', '8.0', '80']:
1209             tklib = self.compiler.find_library_file(lib_dirs, 'tk' + version)
1210             tcllib = self.compiler.find_library_file(lib_dirs, 'tcl' + version)
1211             if tklib and tcllib:
1212                 # Exit the loop when we've found the Tcl/Tk libraries
1213                 break
1214
1215         # Now check for the header files
1216         if tklib and tcllib:
1217             # Check for the include files on Debian and {Free,Open}BSD, where
1218             # they're put in /usr/include/{tcl,tk}X.Y
1219             dotversion = version
1220             if '.' not in dotversion and "bsd" in sys.platform.lower():
1221                 # OpenBSD and FreeBSD use Tcl/Tk library names like libtcl83.a,
1222                 # but the include subdirs are named like .../include/tcl8.3.
1223                 dotversion = dotversion[:-1] + '.' + dotversion[-1]
1224             tcl_include_sub = []
1225             tk_include_sub = []
1226             for dir in inc_dirs:
1227                 tcl_include_sub += [dir + os.sep + "tcl" + dotversion]
1228                 tk_include_sub += [dir + os.sep + "tk" + dotversion]
1229             tk_include_sub += tcl_include_sub
1230             tcl_includes = find_file('tcl.h', inc_dirs, tcl_include_sub)
1231             tk_includes = find_file('tk.h', inc_dirs, tk_include_sub)
1232
1233         if (tcllib is None or tklib is None or
1234             tcl_includes is None or tk_includes is None):
1235             self.announce("INFO: Can't locate Tcl/Tk libs and/or headers", 2)
1236             return
1237
1238         # OK... everything seems to be present for Tcl/Tk.
1239
1240         include_dirs = [] ; libs = [] ; defs = [] ; added_lib_dirs = []
1241         for dir in tcl_includes + tk_includes:
1242             if dir not in include_dirs:
1243                 include_dirs.append(dir)
1244
1245         # Check for various platform-specific directories
1246         if platform == 'sunos5':
1247             include_dirs.append('/usr/openwin/include')
1248             added_lib_dirs.append('/usr/openwin/lib')
1249         elif os.path.exists('/usr/X11R6/include'):
1250             include_dirs.append('/usr/X11R6/include')
1251             added_lib_dirs.append('/usr/X11R6/lib64')
1252             added_lib_dirs.append('/usr/X11R6/lib')
1253         elif os.path.exists('/usr/X11R5/include'):
1254             include_dirs.append('/usr/X11R5/include')
1255             added_lib_dirs.append('/usr/X11R5/lib')
1256         else:
1257             # Assume default location for X11
1258             include_dirs.append('/usr/X11/include')
1259             added_lib_dirs.append('/usr/X11/lib')
1260
1261         # If Cygwin, then verify that X is installed before proceeding
1262         if platform == 'cygwin':
1263             x11_inc = find_file('X11/Xlib.h', [], include_dirs)
1264             if x11_inc is None:
1265                 return
1266
1267         # Check for BLT extension
1268         if self.compiler.find_library_file(lib_dirs + added_lib_dirs,
1269                                            'BLT8.0'):
1270             defs.append( ('WITH_BLT', 1) )
1271             libs.append('BLT8.0')
1272         elif self.compiler.find_library_file(lib_dirs + added_lib_dirs,
1273                                            'BLT'):
1274             defs.append( ('WITH_BLT', 1) )
1275             libs.append('BLT')
1276
1277         # Add the Tcl/Tk libraries
1278         libs.append('tk'+ version)
1279         libs.append('tcl'+ version)
1280
1281         if platform in ['aix3', 'aix4']:
1282             libs.append('ld')
1283
1284         # Finally, link with the X11 libraries (not appropriate on cygwin)
1285         if platform != "cygwin":
1286             libs.append('X11')
1287
1288         ext = Extension('_tkinter', ['_tkinter.c', 'tkappinit.c'],
1289                         define_macros=[('WITH_APPINIT', 1)] + defs,
1290                         include_dirs = include_dirs,
1291                         libraries = libs,
1292                         library_dirs = added_lib_dirs,
1293                         )
1294         self.extensions.append(ext)
1295
1296 ##         # Uncomment these lines if you want to play with xxmodule.c
1297 ##         ext = Extension('xx', ['xxmodule.c'])
1298 ##         self.extensions.append(ext)
1299
1300         # XXX handle these, but how to detect?
1301         # *** Uncomment and edit for PIL (TkImaging) extension only:
1302         #       -DWITH_PIL -I../Extensions/Imaging/libImaging  tkImaging.c \
1303         # *** Uncomment and edit for TOGL extension only:
1304         #       -DWITH_TOGL togl.c \
1305         # *** Uncomment these for TOGL extension only:
1306         #       -lGL -lGLU -lXext -lXmu \
1307
1308     def configure_ctypes(self, ext):
1309         if not self.use_system_libffi:
1310             (srcdir,) = sysconfig.get_config_vars('srcdir')
1311             ffi_builddir = os.path.join(self.build_temp, 'libffi')
1312             ffi_srcdir = os.path.abspath(os.path.join(srcdir, 'Modules',
1313                                          '_ctypes', 'libffi'))
1314             ffi_configfile = os.path.join(ffi_builddir, 'fficonfig.py')
1315
1316             from distutils.dep_util import newer_group
1317
1318             config_sources = [os.path.join(ffi_srcdir, fname)
1319                               for fname in os.listdir(ffi_srcdir)]
1320             if self.force or newer_group(config_sources,
1321                                          ffi_configfile):
1322                 from distutils.dir_util import mkpath
1323                 mkpath(ffi_builddir)
1324                 config_args = []
1325
1326                 # Pass empty CFLAGS because we'll just append the resulting
1327                 # CFLAGS to Python's; -g or -O2 is to be avoided.
1328                 cmd = "cd %s && env CFLAGS='' '%s/configure' %s" \
1329                       % (ffi_builddir, ffi_srcdir, " ".join(config_args))
1330
1331                 res = os.system(cmd)
1332                 if res or not os.path.exists(ffi_configfile):
1333                     print "Failed to configure _ctypes module"
1334                     return False
1335
1336             fficonfig = {}
1337             execfile(ffi_configfile, globals(), fficonfig)
1338             ffi_srcdir = os.path.join(fficonfig['ffi_srcdir'], 'src')
1339
1340             # Add .S (preprocessed assembly) to C compiler source extensions.
1341             self.compiler.src_extensions.append('.S')
1342
1343             include_dirs = [os.path.join(ffi_builddir, 'include'),
1344                             ffi_builddir, ffi_srcdir]
1345             extra_compile_args = fficonfig['ffi_cflags'].split()
1346
1347             ext.sources.extend(fficonfig['ffi_sources'])
1348             ext.include_dirs.extend(include_dirs)
1349             ext.extra_compile_args.extend(extra_compile_args)
1350         return True
1351
1352     def detect_ctypes(self, inc_dirs, lib_dirs):
1353         self.use_system_libffi = False
1354         include_dirs = []
1355         extra_compile_args = []
1356         extra_link_args = []
1357         sources = ['_ctypes/_ctypes.c',
1358                    '_ctypes/callbacks.c',
1359                    '_ctypes/callproc.c',
1360                    '_ctypes/stgdict.c',
1361                    '_ctypes/cfield.c',
1362                    '_ctypes/malloc_closure.c']
1363         depends = ['_ctypes/ctypes.h']
1364
1365         if sys.platform == 'darwin':
1366             sources.append('_ctypes/darwin/dlfcn_simple.c')
1367             include_dirs.append('_ctypes/darwin')
1368 # XXX Is this still needed?
1369 ##            extra_link_args.extend(['-read_only_relocs', 'warning'])
1370
1371         elif sys.platform == 'sunos5':
1372             # XXX This shouldn't be necessary; it appears that some
1373             # of the assembler code is non-PIC (i.e. it has relocations
1374             # when it shouldn't. The proper fix would be to rewrite
1375             # the assembler code to be PIC.
1376             # This only works with GCC; the Sun compiler likely refuses
1377             # this option. If you want to compile ctypes with the Sun
1378             # compiler, please research a proper solution, instead of
1379             # finding some -z option for the Sun compiler.
1380             extra_link_args.append('-mimpure-text')
1381
1382         ext = Extension('_ctypes',
1383                         include_dirs=include_dirs,
1384                         extra_compile_args=extra_compile_args,
1385                         extra_link_args=extra_link_args,
1386                         libraries=[],
1387                         sources=sources,
1388                         depends=depends)
1389         ext_test = Extension('_ctypes_test',
1390                              sources=['_ctypes/_ctypes_test.c'])
1391         self.extensions.extend([ext, ext_test])
1392
1393         if not '--with-system-ffi' in sysconfig.get_config_var("CONFIG_ARGS"):
1394             return
1395
1396         ffi_inc = find_file('ffi.h', [], inc_dirs)
1397         if ffi_inc is not None:
1398             ffi_h = ffi_inc[0] + '/ffi.h'
1399             fp = open(ffi_h)
1400             while 1:
1401                 line = fp.readline()
1402                 if not line:
1403                     ffi_inc = None
1404                     break
1405                 if line.startswith('#define LIBFFI_H'):
1406                     break
1407         ffi_lib = None
1408         if ffi_inc is not None:
1409             for lib_name in ('ffi_convenience', 'ffi_pic', 'ffi'):
1410                 if (self.compiler.find_library_file(lib_dirs, lib_name)):
1411                     ffi_lib = lib_name
1412                     break
1413
1414         if ffi_inc and ffi_lib:
1415             ext.include_dirs.extend(ffi_inc)
1416             ext.libraries.append(ffi_lib)
1417             self.use_system_libffi = True
1418
1419
1420 class PyBuildInstall(install):
1421     # Suppress the warning about installation into the lib_dynload
1422     # directory, which is not in sys.path when running Python during
1423     # installation:
1424     def initialize_options (self):
1425         install.initialize_options(self)
1426         self.warn_dir=0
1427
1428 class PyBuildInstallLib(install_lib):
1429     # Do exactly what install_lib does but make sure correct access modes get
1430     # set on installed directories and files. All installed files with get
1431     # mode 644 unless they are a shared library in which case they will get
1432     # mode 755. All installed directories will get mode 755.
1433
1434     so_ext = sysconfig.get_config_var("SO")
1435
1436     def install(self):
1437         outfiles = install_lib.install(self)
1438         self.set_file_modes(outfiles, 0644, 0755)
1439         self.set_dir_modes(self.install_dir, 0755)
1440         return outfiles
1441
1442     def set_file_modes(self, files, defaultMode, sharedLibMode):
1443         if not self.is_chmod_supported(): return
1444         if not files: return
1445
1446         for filename in files:
1447             if os.path.islink(filename): continue
1448             mode = defaultMode
1449             if filename.endswith(self.so_ext): mode = sharedLibMode
1450             log.info("changing mode of %s to %o", filename, mode)
1451             if not self.dry_run: os.chmod(filename, mode)
1452
1453     def set_dir_modes(self, dirname, mode):
1454         if not self.is_chmod_supported(): return
1455         os.path.walk(dirname, self.set_dir_modes_visitor, mode)
1456
1457     def set_dir_modes_visitor(self, mode, dirname, names):
1458         if os.path.islink(dirname): return
1459         log.info("changing mode of %s to %o", dirname, mode)
1460         if not self.dry_run: os.chmod(dirname, mode)
1461
1462     def is_chmod_supported(self):
1463         return hasattr(os, 'chmod')
1464
1465 SUMMARY = """
1466 Python is an interpreted, interactive, object-oriented programming
1467 language. It is often compared to Tcl, Perl, Scheme or Java.
1468
1469 Python combines remarkable power with very clear syntax. It has
1470 modules, classes, exceptions, very high level dynamic data types, and
1471 dynamic typing. There are interfaces to many system calls and
1472 libraries, as well as to various windowing systems (X11, Motif, Tk,
1473 Mac, MFC). New built-in modules are easily written in C or C++. Python
1474 is also usable as an extension language for applications that need a
1475 programmable interface.
1476
1477 The Python implementation is portable: it runs on many brands of UNIX,
1478 on Windows, DOS, OS/2, Mac, Amiga... If your favorite system isn't
1479 listed here, it may still be supported, if there's a C compiler for
1480 it. Ask around on comp.lang.python -- or just try compiling Python
1481 yourself.
1482 """
1483
1484 CLASSIFIERS = """
1485 Development Status :: 3 - Alpha
1486 Development Status :: 6 - Mature
1487 License :: OSI Approved :: Python Software Foundation License
1488 Natural Language :: English
1489 Programming Language :: C
1490 Programming Language :: Python
1491 Topic :: Software Development
1492 """
1493
1494 def main():
1495     # turn off warnings when deprecated modules are imported
1496     import warnings
1497     warnings.filterwarnings("ignore",category=DeprecationWarning)
1498     setup(# PyPI Metadata (PEP 301)
1499           name = "Python",
1500           version = sys.version.split()[0],
1501           url = "http://www.python.org/%s" % sys.version[:3],
1502           maintainer = "Guido van Rossum and the Python community",
1503           maintainer_email = "python-dev@python.org",
1504           description = "A high-level object-oriented programming language",
1505           long_description = SUMMARY.strip(),
1506           license = "PSF license",
1507           classifiers = filter(None, CLASSIFIERS.split("\n")),
1508           platforms = ["Many"],
1509
1510           # Build info
1511           cmdclass = {'build_ext':PyBuildExt, 'install':PyBuildInstall,
1512                       'install_lib':PyBuildInstallLib},
1513           # The struct module is defined here, because build_ext won't be
1514           # called unless there's at least one extension module defined.
1515           ext_modules=[Extension('_struct', ['_struct.c'])],
1516
1517           # Scripts to install
1518           scripts = ['Tools/scripts/pydoc', 'Tools/scripts/idle',
1519                      'Lib/smtpd.py']
1520         )
1521
1522 # --install-platlib
1523 if __name__ == '__main__':
1524     main()