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