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         try:
 184             build_ext.build_extension(self, ext)
 185         except (CCompilerError, DistutilsError), why:
 186             self.announce('WARNING: building of extension "%s" failed: %s' %
 187                           (ext.name, sys.exc_info()[1]))
 188             return
 189         # Workaround for Mac OS X: The Carbon-based modules cannot be
 190         # reliably imported into a command-line Python
 191         if 'Carbon' in ext.extra_link_args:
 192             self.announce(
 193                 'WARNING: skipping import check for Carbon-based "%s"' %
 194                 ext.name)
 195             return
 196         # Workaround for Cygwin: Cygwin currently has fork issues when many
 197         # modules have been imported
 198         if self.get_platform() == 'cygwin':
 199             self.announce('WARNING: skipping import check for Cygwin-based "%s"'
 200                 % ext.name)
 201             return
 202         ext_filename = os.path.join(
 203             self.build_lib,
 204             self.get_ext_filename(self.get_ext_fullname(ext.name)))
 205         try:
 206             imp.load_dynamic(ext.name, ext_filename)
 207         except ImportError, why:
 208             self.announce('*** WARNING: renaming "%s" since importing it'
 209                           ' failed: %s' % (ext.name, why), level=3)
 210             assert not self.inplace
 211             basename, tail = os.path.splitext(ext_filename)
 212             newname = basename + "_failed" + tail
 213             if os.path.exists(newname):
 214                 os.remove(newname)
 215             os.rename(ext_filename, newname)
 216
 217             # XXX -- This relies on a Vile HACK in
 218             # distutils.command.build_ext.build_extension().  The
 219             # _built_objects attribute is stored there strictly for
 220             # use here.
 221             # If there is a failure, _built_objects may not be there,
 222             # so catch the AttributeError and move on.
 223             try:
 224                 for filename in self._built_objects:
 225                     os.remove(filename)
 226             except AttributeError:
 227                 self.announce('unable to remove files (ignored)')
 228         except:
 229             exc_type, why, tb = sys.exc_info()
 230             self.announce('*** WARNING: importing extension "%s" '
 231                           'failed with %s: %s' % (ext.name, exc_type, why),
 232                           level=3)
 233
 234     def get_platform(self):
 235         # Get value of sys.platform
 236         for platform in ['cygwin', 'beos', 'darwin', 'atheos', 'osf1']:
 237             if sys.platform.startswith(platform):
 238                 return platform
 239         return sys.platform
 240
 241     def detect_modules(self):
 242         # Ensure that /usr/local is always used
 243         add_dir_to_list(self.compiler.library_dirs, '/usr/local/lib')
 244         add_dir_to_list(self.compiler.include_dirs, '/usr/local/include')
 245
 246         # Add paths specified in the environment variables LDFLAGS and
 247         # CPPFLAGS for header and library files.
 248         # We must get the values from the Makefile and not the environment
 249         # directly since an inconsistently reproducible issue comes up where
 250         # the environment variable is not set even though the value were passed
 251         # into configure and stored in the Makefile (issue found on OS X 10.3).
 252         for env_var, arg_name, dir_list in (
 253                 ('LDFLAGS', '-L', self.compiler.library_dirs),
 254                 ('CPPFLAGS', '-I', self.compiler.include_dirs)):
 255             env_val = sysconfig.get_config_var(env_var)
 256             if env_val:
 257                 # To prevent optparse from raising an exception about any
 258                 # options in env_val that is doesn't know about we strip out
 259                 # all double dashes and any dashes followed by a character
 260                 # that is not for the option we are dealing with.
 261                 #
 262                 # Please note that order of the regex is important!  We must
 263                 # strip out double-dashes first so that we don't end up with
 264                 # substituting "--Long" to "-Long" and thus lead to "ong" being
 265                 # used for a library directory.
 266                 env_val = re.sub(r'(^|\s+)-(-|(?!%s))' % arg_name[1], '', env_val)
 267                 parser = optparse.OptionParser()
 268                 # Make sure that allowing args interspersed with options is
 269                 # allowed
 270                 parser.allow_interspersed_args = True
 271                 parser.error = lambda msg: None
 272                 parser.add_option(arg_name, dest="dirs", action="append")
 273                 options = parser.parse_args(env_val.split())[0]
 274                 if options.dirs:
 275                     for directory in options.dirs:
 276                         add_dir_to_list(dir_list, directory)
 277
 278         if os.path.normpath(sys.prefix) != '/usr':
 279             add_dir_to_list(self.compiler.library_dirs,
 280                             sysconfig.get_config_var("LIBDIR"))
 281             add_dir_to_list(self.compiler.include_dirs,
 282                             sysconfig.get_config_var("INCLUDEDIR"))
 283
 284         try:
 285             have_unicode = unicode
 286         except NameError:
 287             have_unicode = 0
 288
 289         # lib_dirs and inc_dirs are used to search for files;
 290         # if a file is found in one of those directories, it can
 291         # be assumed that no additional -I,-L directives are needed.
 292         lib_dirs = self.compiler.library_dirs + [
 293             '/lib64', '/usr/lib64',
 294             '/lib', '/usr/lib',
 295             ]
 296         inc_dirs = self.compiler.include_dirs + ['/usr/include']
 297         exts = []
 298
 299         config_h = sysconfig.get_config_h_filename()
 300         config_h_vars = sysconfig.parse_config_h(open(config_h))
 301
 302         platform = self.get_platform()
 303         (srcdir,) = sysconfig.get_config_vars('srcdir')
 304
 305         # Check for AtheOS which has libraries in non-standard locations
 306         if platform == 'atheos':
 307             lib_dirs += ['/system/libs', '/atheos/autolnk/lib']
 308             lib_dirs += os.getenv('LIBRARY_PATH', '').split(os.pathsep)
 309             inc_dirs += ['/system/include', '/atheos/autolnk/include']
 310             inc_dirs += os.getenv('C_INCLUDE_PATH', '').split(os.pathsep)
 311
 312         # OSF/1 and Unixware have some stuff in /usr/ccs/lib (like -ldb)
 313         if platform in ['osf1', 'unixware7', 'openunix8']:
 314             lib_dirs += ['/usr/ccs/lib']
 315
 316         # Check for MacOS X, which doesn't need libm.a at all
 317         math_libs = ['m']
 318         if platform in ['darwin', 'beos', 'mac']:
 319             math_libs = []
 320
 321         # XXX Omitted modules: gl, pure, dl, SGI-specific modules
 322
 323         #
 324         # The following modules are all pretty straightforward, and compile
 325         # on pretty much any POSIXish platform.
 326         #
 327
 328         # Some modules that are normally always on:
 329         exts.append( Extension('regex', ['regexmodule.c', 'regexpr.c']) )
 330
 331         exts.append( Extension('_hotshot', ['_hotshot.c']) )
 332         exts.append( Extension('_weakref', ['_weakref.c']) )
 333
 334         # array objects
 335         exts.append( Extension('array', ['arraymodule.c']) )
 336         # complex math library functions
 337         exts.append( Extension('cmath', ['cmathmodule.c'],
 338                                libraries=math_libs) )
 339
 340         # math library functions, e.g. sin()
 341         exts.append( Extension('math',  ['mathmodule.c'],
 342                                libraries=math_libs) )
 343         # fast string operations implemented in C
 344         exts.append( Extension('strop', ['stropmodule.c']) )
 345         # time operations and variables
 346         exts.append( Extension('time', ['timemodule.c'],
 347                                libraries=math_libs) )
 348         exts.append( Extension('datetime', ['datetimemodule.c', 'timemodule.c'],
 349                                libraries=math_libs) )
 350         # random number generator implemented in C
 351         exts.append( Extension("_random", ["_randommodule.c"]) )
 352         # fast iterator tools implemented in C
 353         exts.append( Extension("itertools", ["itertoolsmodule.c"]) )
 354         # high-performance collections
 355         exts.append( Extension("collections", ["collectionsmodule.c"]) )
 356         # bisect
 357         exts.append( Extension("_bisect", ["_bisectmodule.c"]) )
 358         # heapq
 359         exts.append( Extension("_heapq", ["_heapqmodule.c"]) )
 360         # operator.add() and similar goodies
 361         exts.append( Extension('operator', ['operator.c']) )
 362         # functional
 363         exts.append( Extension("functional", ["functionalmodule.c"]) )
 364         # Python C API test module
 365         exts.append( Extension('_testcapi', ['_testcapimodule.c']) )
 366         # static Unicode character database
 367         if have_unicode:
 368             exts.append( Extension('unicodedata', ['unicodedata.c']) )
 369         # access to ISO C locale support
 370         data = open('pyconfig.h').read()
 371         m = re.search(r"#s*define\s+WITH_LIBINTL\s+1\s*", data)
 372         if m is not None:
 373             locale_libs = ['intl']
 374         else:
 375             locale_libs = []
 376         if platform == 'darwin':
 377             locale_extra_link_args = ['-framework', 'CoreFoundation']
 378         else:
 379             locale_extra_link_args = []
 380
 381
 382         exts.append( Extension('_locale', ['_localemodule.c'],
 383                                libraries=locale_libs,
 384                                extra_link_args=locale_extra_link_args) )
 385
 386         # Modules with some UNIX dependencies -- on by default:
 387         # (If you have a really backward UNIX, select and socket may not be
 388         # supported...)
 389
 390         # fcntl(2) and ioctl(2)
 391         exts.append( Extension('fcntl', ['fcntlmodule.c']) )
 392         if platform not in ['mac']:
 393             # pwd(3)
 394             exts.append( Extension('pwd', ['pwdmodule.c']) )
 395             # grp(3)
 396             exts.append( Extension('grp', ['grpmodule.c']) )
 397             # spwd, shadow passwords
 398             if (config_h_vars.get('HAVE_GETSPNAM', False) or
 399                     config_h_vars.get('HAVE_GETSPENT', False)):
 400                 exts.append( Extension('spwd', ['spwdmodule.c']) )
 401         # select(2); not on ancient System V
 402         exts.append( Extension('select', ['selectmodule.c']) )
 403
 404         # Helper module for various ascii-encoders
 405         exts.append( Extension('binascii', ['binascii.c']) )
 406
 407         # Fred Drake's interface to the Python parser
 408         exts.append( Extension('parser', ['parsermodule.c']) )
 409
 410         # cStringIO and cPickle
 411         exts.append( Extension('cStringIO', ['cStringIO.c']) )
 412         exts.append( Extension('cPickle', ['cPickle.c']) )
 413
 414         # Memory-mapped files (also works on Win32).
 415         if platform not in ['atheos', 'mac']:
 416             exts.append( Extension('mmap', ['mmapmodule.c']) )
 417
 418         # Lance Ellinghaus's syslog module
 419         if platform not in ['mac']:
 420             # syslog daemon interface
 421             exts.append( Extension('syslog', ['syslogmodule.c']) )
 422
 423         # George Neville-Neil's timing module:
 424         exts.append( Extension('timing', ['timingmodule.c']) )
 425
 426         #
 427         # Here ends the simple stuff.  From here on, modules need certain
 428         # libraries, are platform-specific, or present other surprises.
 429         #
 430
 431         # Multimedia modules
 432         # These don't work for 64-bit platforms!!!
 433         # These represent audio samples or images as strings:
 434
 435         # Operations on audio samples
 436         # According to #993173, this one should actually work fine on
 437         # 64-bit platforms.
 438         exts.append( Extension('audioop', ['audioop.c']) )
 439
 440         # Disabled on 64-bit platforms
 441         if sys.maxint != 9223372036854775807L:
 442             # Operations on images
 443             exts.append( Extension('imageop', ['imageop.c']) )
 444             # Read SGI RGB image files (but coded portably)
 445             exts.append( Extension('rgbimg', ['rgbimgmodule.c']) )
 446
 447         # readline
 448         if self.compiler.find_library_file(lib_dirs, 'readline'):
 449             readline_libs = ['readline']
 450             if self.compiler.find_library_file(lib_dirs,
 451                                                  'ncurses'):
 452                 readline_libs.append('ncurses')
 453             elif self.compiler.find_library_file(lib_dirs, 'curses'):
 454                 readline_libs.append('curses')
 455             elif self.compiler.find_library_file(lib_dirs +
 456                                                ['/usr/lib/termcap'],
 457                                                'termcap'):
 458                 readline_libs.append('termcap')
 459             exts.append( Extension('readline', ['readline.c'],
 460                                    library_dirs=['/usr/lib/termcap'],
 461                                    libraries=readline_libs) )
 462         if platform not in ['mac']:
 463             # crypt module.
 464
 465             if self.compiler.find_library_file(lib_dirs, 'crypt'):
 466                 libs = ['crypt']
 467             else:
 468                 libs = []
 469             exts.append( Extension('crypt', ['cryptmodule.c'], libraries=libs) )
 470
 471         # CSV files
 472         exts.append( Extension('_csv', ['_csv.c']) )
 473
 474         # socket(2)
 475         exts.append( Extension('_socket', ['socketmodule.c'],
 476                                depends = ['socketmodule.h']) )
 477         # Detect SSL support for the socket module (via _ssl)
 478         search_for_ssl_incs_in = [
 479                               '/usr/local/ssl/include',
 480                               '/usr/contrib/ssl/include/'
 481                              ]
 482         ssl_incs = find_file('openssl/ssl.h', inc_dirs,
 483                              search_for_ssl_incs_in
 484                              )
 485         if ssl_incs is not None:
 486             krb5_h = find_file('krb5.h', inc_dirs,
 487                                ['/usr/kerberos/include'])
 488             if krb5_h:
 489                 ssl_incs += krb5_h
 490         ssl_libs = find_library_file(self.compiler, 'ssl',lib_dirs,
 491                                      ['/usr/local/ssl/lib',
 492                                       '/usr/contrib/ssl/lib/'
 493                                      ] )
 494
 495         if (ssl_incs is not None and
 496             ssl_libs is not None):
 497             exts.append( Extension('_ssl', ['_ssl.c'],
 498                                    include_dirs = ssl_incs,
 499                                    library_dirs = ssl_libs,
 500                                    libraries = ['ssl', 'crypto'],
 501                                    depends = ['socketmodule.h']), )
 502
 503         # find out which version of OpenSSL we have
 504         openssl_ver = 0
 505         openssl_ver_re = re.compile(
 506             '^\s*#\s*define\s+OPENSSL_VERSION_NUMBER\s+(0x[0-9a-fA-F]+)' )
 507         for ssl_inc_dir in inc_dirs + search_for_ssl_incs_in:
 508             name = os.path.join(ssl_inc_dir, 'openssl', 'opensslv.h')
 509             if os.path.isfile(name):
 510                 try:
 511                     incfile = open(name, 'r')
 512                     for line in incfile:
 513                         m = openssl_ver_re.match(line)
 514                         if m:
 515                             openssl_ver = eval(m.group(1))
 516                             break
 517                 except IOError:
 518                     pass
 519
 520             # first version found is what we'll use (as the compiler should)
 521             if openssl_ver:
 522                 break
 523
 524         #print 'openssl_ver = 0x%08x' % openssl_ver
 525
 526         if (ssl_incs is not None and
 527             ssl_libs is not None and
 528             openssl_ver >= 0x00907000):
 529             # The _hashlib module wraps optimized implementations
 530             # of hash functions from the OpenSSL library.
 531             exts.append( Extension('_hashlib', ['_hashopenssl.c'],
 532                                    include_dirs = ssl_incs,
 533                                    library_dirs = ssl_libs,
 534                                    libraries = ['ssl', 'crypto']) )
 535         else:
 536             # The _sha module implements the SHA1 hash algorithm.
 537             exts.append( Extension('_sha', ['shamodule.c']) )
 538             # The _md5 module implements the RSA Data Security, Inc. MD5
 539             # Message-Digest Algorithm, described in RFC 1321.  The
 540             # necessary files md5c.c and md5.h are included here.
 541             exts.append( Extension('_md5', ['md5module.c', 'md5c.c']) )
 542
 543         if (openssl_ver < 0x00908000):
 544             # OpenSSL doesn't do these until 0.9.8 so we'll bring our own hash
 545             exts.append( Extension('_sha256', ['sha256module.c']) )
 546             exts.append( Extension('_sha512', ['sha512module.c']) )
 547
 548
 549         # Modules that provide persistent dictionary-like semantics.  You will
 550         # probably want to arrange for at least one of them to be available on
 551         # your machine, though none are defined by default because of library
 552         # dependencies.  The Python module anydbm.py provides an
 553         # implementation independent wrapper for these; dumbdbm.py provides
 554         # similar functionality (but slower of course) implemented in Python.
 555
 556         # Sleepycat Berkeley DB interface.  http://www.sleepycat.com
 557         #
 558         # This requires the Sleepycat DB code. The earliest supported version
 559         # of that library is 3.2, the latest supported version is 4.4.  A list
 560         # of available releases can be found at
 561         #
 562         # http://www.sleepycat.com/update/index.html
 563
 564         max_db_ver = (4, 4)
 565         min_db_ver = (3, 2)
 566         db_setup_debug = False   # verbose debug prints from this script?
 567
 568         # construct a list of paths to look for the header file in on
 569         # top of the normal inc_dirs.
 570         db_inc_paths = [
 571             '/usr/include/db4',
 572             '/usr/local/include/db4',
 573             '/opt/sfw/include/db4',
 574             '/sw/include/db4',
 575             '/usr/include/db3',
 576             '/usr/local/include/db3',
 577             '/opt/sfw/include/db3',
 578             '/sw/include/db3',
 579         ]
 580         # 4.x minor number specific paths
 581         for x in (0,1,2,3,4):
 582             db_inc_paths.append('/usr/include/db4%d' % x)
 583             db_inc_paths.append('/usr/include/db4.%d' % x)
 584             db_inc_paths.append('/usr/local/BerkeleyDB.4.%d/include' % x)
 585             db_inc_paths.append('/usr/local/include/db4%d' % x)
 586             db_inc_paths.append('/pkg/db-4.%d/include' % x)
 587             db_inc_paths.append('/opt/db-4.%d/include' % x)
 588         # 3.x minor number specific paths
 589         for x in (2,3):
 590             db_inc_paths.append('/usr/include/db3%d' % x)
 591             db_inc_paths.append('/usr/local/BerkeleyDB.3.%d/include' % x)
 592             db_inc_paths.append('/usr/local/include/db3%d' % x)
 593             db_inc_paths.append('/pkg/db-3.%d/include' % x)
 594             db_inc_paths.append('/opt/db-3.%d/include' % x)
 595
 596         db_ver_inc_map = {}
 597
 598         class db_found(Exception): pass
 599         try:
 600             # See whether there is a Sleepycat header in the standard
 601             # search path.
 602             for d in inc_dirs + db_inc_paths:
 603                 f = os.path.join(d, "db.h")
 604                 if db_setup_debug: print "db: looking for db.h in", f
 605                 if os.path.exists(f):
 606                     f = open(f).read()
 607                     m = re.search(r"#define\WDB_VERSION_MAJOR\W(\d+)", f)
 608                     if m:
 609                         db_major = int(m.group(1))
 610                         m = re.search(r"#define\WDB_VERSION_MINOR\W(\d+)", f)
 611                         db_minor = int(m.group(1))
 612                         db_ver = (db_major, db_minor)
 613
 614                         if ( (not db_ver_inc_map.has_key(db_ver)) and
 615                            (db_ver <= max_db_ver and db_ver >= min_db_ver) ):
 616                             # save the include directory with the db.h version
 617                             # (first occurrance only)
 618                             db_ver_inc_map[db_ver] = d
 619                             print "db.h: found", db_ver, "in", d
 620                         else:
 621                             # we already found a header for this library version
 622                             if db_setup_debug: print "db.h: ignoring", d
 623                     else:
 624                         # ignore this header, it didn't contain a version number
 625                         if db_setup_debug: print "db.h: unsupported version", db_ver, "in", d
 626
 627             db_found_vers = db_ver_inc_map.keys()
 628             db_found_vers.sort()
 629
 630             while db_found_vers:
 631                 db_ver = db_found_vers.pop()
 632                 db_incdir = db_ver_inc_map[db_ver]
 633
 634                 # check lib directories parallel to the location of the header
 635                 db_dirs_to_check = [
 636                     os.path.join(db_incdir, '..', 'lib64'),
 637                     os.path.join(db_incdir, '..', 'lib'),
 638                     os.path.join(db_incdir, '..', '..', 'lib64'),
 639                     os.path.join(db_incdir, '..', '..', 'lib'),
 640                 ]
 641                 db_dirs_to_check = filter(os.path.isdir, db_dirs_to_check)
 642
 643                 # Look for a version specific db-X.Y before an ambiguoius dbX
 644                 # XXX should we -ever- look for a dbX name?  Do any
 645                 # systems really not name their library by version and
 646                 # symlink to more general names?
 647                 for dblib in (('db-%d.%d' % db_ver),
 648                               ('db%d%d' % db_ver),
 649                               ('db%d' % db_ver[0])):
 650                     dblib_file = self.compiler.find_library_file(
 651                                     db_dirs_to_check + lib_dirs, dblib )
 652                     if dblib_file:
 653                         dblib_dir = [ os.path.abspath(os.path.dirname(dblib_file)) ]
 654                         raise db_found
 655                     else:
 656                         if db_setup_debug: print "db lib: ", dblib, "not found"
 657
 658         except db_found:
 659             print "db lib: using", db_ver, dblib
 660             if db_setup_debug: print "db: lib dir", dblib_dir, "inc dir", db_incdir
 661             db_incs = [db_incdir]
 662             dblibs = [dblib]
 663             # We add the runtime_library_dirs argument because the
 664             # BerkeleyDB lib we're linking against often isn't in the
 665             # system dynamic library search path.  This is usually
 666             # correct and most trouble free, but may cause problems in
 667             # some unusual system configurations (e.g. the directory
 668             # is on an NFS server that goes away).
 669             exts.append(Extension('_bsddb', ['_bsddb.c'],
 670                                   library_dirs=dblib_dir,
 671                                   runtime_library_dirs=dblib_dir,
 672                                   include_dirs=db_incs,
 673                                   libraries=dblibs))
 674         else:
 675             if db_setup_debug: print "db: no appropriate library found"
 676             db_incs = None
 677             dblibs = []
 678             dblib_dir = None
 679
 680
 681         # Look for Berkeley db 1.85.   Note that it is built as a different
 682         # module name so it can be included even when later versions are
 683         # available.  A very restrictive search is performed to avoid
 684         # accidentally building this module with a later version of the
 685         # underlying db library.  May BSD-ish Unixes incorporate db 1.85
 686         # symbols into libc and place the include file in /usr/include.
 687         f = "/usr/include/db.h"
 688         if os.path.exists(f):
 689             data = open(f).read()
 690             m = re.search(r"#s*define\s+HASHVERSION\s+2\s*", data)
 691             if m is not None:
 692                 # bingo - old version used hash file format version 2
 693                 ### XXX this should be fixed to not be platform-dependent
 694                 ### but I don't have direct access to an osf1 platform and
 695                 ### seemed to be muffing the search somehow
 696                 libraries = platform == "osf1" and ['db'] or None
 697                 if libraries is not None:
 698                     exts.append(Extension('bsddb185', ['bsddbmodule.c'],
 699                                           libraries=libraries))
 700                 else:
 701                     exts.append(Extension('bsddb185', ['bsddbmodule.c']))
 702
 703         # The standard Unix dbm module:
 704         if platform not in ['cygwin']:
 705             if find_file("ndbm.h", inc_dirs, []) is not None:
 706                 # Some systems have -lndbm, others don't
 707                 if self.compiler.find_library_file(lib_dirs, 'ndbm'):
 708                     ndbm_libs = ['ndbm']
 709                 else:
 710                     ndbm_libs = []
 711                 exts.append( Extension('dbm', ['dbmmodule.c'],
 712                                        define_macros=[('HAVE_NDBM_H',None)],
 713                                        libraries = ndbm_libs ) )
 714             elif (self.compiler.find_library_file(lib_dirs, 'gdbm')
 715                   and find_file("gdbm/ndbm.h", inc_dirs, []) is not None):
 716                 exts.append( Extension('dbm', ['dbmmodule.c'],
 717                                        define_macros=[('HAVE_GDBM_NDBM_H',None)],
 718                                        libraries = ['gdbm'] ) )
 719             elif db_incs is not None:
 720                 exts.append( Extension('dbm', ['dbmmodule.c'],
 721                                        library_dirs=dblib_dir,
 722                                        runtime_library_dirs=dblib_dir,
 723                                        include_dirs=db_incs,
 724                                        define_macros=[('HAVE_BERKDB_H',None),
 725                                                       ('DB_DBM_HSEARCH',None)],
 726                                        libraries=dblibs))
 727
 728         # Anthony Baxter's gdbm module.  GNU dbm(3) will require -lgdbm:
 729         if (self.compiler.find_library_file(lib_dirs, 'gdbm')):
 730             exts.append( Extension('gdbm', ['gdbmmodule.c'],
 731                                    libraries = ['gdbm'] ) )
 732
 733         # Unix-only modules
 734         if platform not in ['mac', 'win32']:
 735             # Steen Lumholt's termios module
 736             exts.append( Extension('termios', ['termios.c']) )
 737             # Jeremy Hylton's rlimit interface
 738             if platform not in ['atheos']:
 739                 exts.append( Extension('resource', ['resource.c']) )
 740
 741             # Sun yellow pages. Some systems have the functions in libc.
 742             if platform not in ['cygwin', 'atheos']:
 743                 if (self.compiler.find_library_file(lib_dirs, 'nsl')):
 744                     libs = ['nsl']
 745                 else:
 746                     libs = []
 747                 exts.append( Extension('nis', ['nismodule.c'],
 748                                        libraries = libs) )
 749
 750         # Curses support, requiring the System V version of curses, often
 751         # provided by the ncurses library.
 752         if (self.compiler.find_library_file(lib_dirs, 'ncurses')):
 753             curses_libs = ['ncurses']
 754             exts.append( Extension('_curses', ['_cursesmodule.c'],
 755                                    libraries = curses_libs) )
 756         elif (self.compiler.find_library_file(lib_dirs, 'curses')
 757               and platform != 'darwin'):
 758                 # OSX has an old Berkeley curses, not good enough for
 759                 # the _curses module.
 760             if (self.compiler.find_library_file(lib_dirs, 'terminfo')):
 761                 curses_libs = ['curses', 'terminfo']
 762             elif (self.compiler.find_library_file(lib_dirs, 'termcap')):
 763                 curses_libs = ['curses', 'termcap']
 764             else:
 765                 curses_libs = ['curses']
 766
 767             exts.append( Extension('_curses', ['_cursesmodule.c'],
 768                                    libraries = curses_libs) )
 769
 770         # If the curses module is enabled, check for the panel module
 771         if (module_enabled(exts, '_curses') and
 772             self.compiler.find_library_file(lib_dirs, 'panel')):
 773             exts.append( Extension('_curses_panel', ['_curses_panel.c'],
 774                                    libraries = ['panel'] + curses_libs) )
 775
 776
 777         # Andrew Kuchling's zlib module.  Note that some versions of zlib
 778         # 1.1.3 have security problems.  See CERT Advisory CA-2002-07:
 779         # http://www.cert.org/advisories/CA-2002-07.html
 780         #
 781         # zlib 1.1.4 is fixed, but at least one vendor (RedHat) has decided to
 782         # patch its zlib 1.1.3 package instead of upgrading to 1.1.4.  For
 783         # now, we still accept 1.1.3, because we think it's difficult to
 784         # exploit this in Python, and we'd rather make it RedHat's problem
 785         # than our problem <wink>.
 786         #
 787         # You can upgrade zlib to version 1.1.4 yourself by going to
 788         # http://www.gzip.org/zlib/
 789         zlib_inc = find_file('zlib.h', [], inc_dirs)
 790         if zlib_inc is not None:
 791             zlib_h = zlib_inc[0] + '/zlib.h'
 792             version = '"0.0.0"'
 793             version_req = '"1.1.3"'
 794             fp = open(zlib_h)
 795             while 1:
 796                 line = fp.readline()
 797                 if not line:
 798                     break
 799                 if line.startswith('#define ZLIB_VERSION'):
 800                     version = line.split()[2]
 801                     break
 802             if version >= version_req:
 803                 if (self.compiler.find_library_file(lib_dirs, 'z')):
 804                     exts.append( Extension('zlib', ['zlibmodule.c'],
 805                                            libraries = ['z']) )
 806
 807         # Gustavo Niemeyer's bz2 module.
 808         if (self.compiler.find_library_file(lib_dirs, 'bz2')):
 809             exts.append( Extension('bz2', ['bz2module.c'],
 810                                    libraries = ['bz2']) )
 811
 812         # Interface to the Expat XML parser
 813         #
 814         # Expat was written by James Clark and is now maintained by a
 815         # group of developers on SourceForge; see www.libexpat.org for
 816         # more information.  The pyexpat module was written by Paul
 817         # Prescod after a prototype by Jack Jansen.  The Expat source
 818         # is included in Modules/expat/.  Usage of a system
 819         # shared libexpat.so/expat.dll is not advised.
 820         #
 821         # More information on Expat can be found at www.libexpat.org.
 822         #
 823         if sys.byteorder == "little":
 824             xmlbo = "1234"
 825         else:
 826             xmlbo = "4321"
 827         expatinc = os.path.join(os.getcwd(), srcdir, 'Modules', 'expat')
 828         define_macros = [
 829             ('XML_NS', '1'),
 830             ('XML_DTD', '1'),
 831             ('BYTEORDER', xmlbo),
 832             ('XML_CONTEXT_BYTES','1024'),
 833             ]
 834         for feature_macro in ['HAVE_MEMMOVE', 'HAVE_BCOPY']:
 835             if config_h_vars.has_key(feature_macro):
 836                 define_macros.append((feature_macro, '1'))
 837         exts.append(Extension('pyexpat',
 838                               define_macros = define_macros,
 839                               include_dirs = [expatinc],
 840                               sources = ['pyexpat.c',
 841                                          'expat/xmlparse.c',
 842                                          'expat/xmlrole.c',
 843                                          'expat/xmltok.c',
 844                                          ],
 845                               ))
 846
 847         # Fredrik Lundh's cElementTree module.  Note that this also
 848         # uses expat (via the CAPI hook in pyexpat).
 849
 850         if os.path.isfile('Modules/_elementtree.c'):
 851             define_macros.append(('USE_PYEXPAT_CAPI', None))
 852             exts.append(Extension('_elementtree',
 853                                   define_macros = define_macros,
 854                                   include_dirs = [expatinc],
 855                                   sources = ['_elementtree.c'],
 856                                   ))
 857
 858         # Hye-Shik Chang's CJKCodecs modules.
 859         if have_unicode:
 860             exts.append(Extension('_multibytecodec',
 861                                   ['cjkcodecs/multibytecodec.c']))
 862             for loc in ('kr', 'jp', 'cn', 'tw', 'hk', 'iso2022'):
 863                 exts.append(Extension('_codecs_' + loc,
 864                                       ['cjkcodecs/_codecs_%s.c' % loc]))
 865
 866         # Dynamic loading module
 867         if sys.maxint == 0x7fffffff:
 868             # This requires sizeof(int) == sizeof(long) == sizeof(char*)
 869             dl_inc = find_file('dlfcn.h', [], inc_dirs)
 870             if (dl_inc is not None) and (platform not in ['atheos', 'darwin']):
 871                 exts.append( Extension('dl', ['dlmodule.c']) )
 872
 873         # Platform-specific libraries
 874         if platform == 'linux2':
 875             # Linux-specific modules
 876             exts.append( Extension('linuxaudiodev', ['linuxaudiodev.c']) )
 877
 878         if platform in ('linux2', 'freebsd4', 'freebsd5', 'freebsd6',
 879                         'freebsd7'):
 880             exts.append( Extension('ossaudiodev', ['ossaudiodev.c']) )
 881
 882         if platform == 'sunos5':
 883             # SunOS specific modules
 884             exts.append( Extension('sunaudiodev', ['sunaudiodev.c']) )
 885
 886         if platform == 'darwin' and ("--disable-toolbox-glue" not in
 887             sysconfig.get_config_var("CONFIG_ARGS")):
 888             # Mac OS X specific modules.
 889             exts.append( Extension('_CF', ['cf/_CFmodule.c', 'cf/pycfbridge.c'],
 890                         extra_link_args=['-framework', 'CoreFoundation']) )
 891
 892             exts.append( Extension('ColorPicker', ['ColorPickermodule.c'],
 893                         extra_link_args=['-framework', 'Carbon']) )
 894             exts.append( Extension('autoGIL', ['autoGIL.c'],
 895                         extra_link_args=['-framework', 'CoreFoundation']) )
 896             exts.append( Extension('gestalt', ['gestaltmodule.c'],
 897                         extra_link_args=['-framework', 'Carbon']) )
 898             exts.append( Extension('MacOS', ['macosmodule.c'],
 899                         extra_link_args=['-framework', 'Carbon']) )
 900             exts.append( Extension('OSATerminology', ['OSATerminology.c'],
 901                         extra_link_args=['-framework', 'Carbon']) )
 902             exts.append( Extension('icglue', ['icgluemodule.c'],
 903                         extra_link_args=['-framework', 'Carbon']) )
 904             exts.append( Extension('_Res', ['res/_Resmodule.c'],
 905                         extra_link_args=['-framework', 'Carbon']) )
 906             exts.append( Extension('_Snd', ['snd/_Sndmodule.c'],
 907                         extra_link_args=['-framework', 'Carbon']) )
 908             exts.append( Extension('Nav', ['Nav.c'],
 909                     extra_link_args=['-framework', 'Carbon']) )
 910             exts.append( Extension('_AE', ['ae/_AEmodule.c'],
 911                     extra_link_args=['-framework', 'Carbon']) )
 912             exts.append( Extension('_AH', ['ah/_AHmodule.c'],
 913                     extra_link_args=['-framework', 'Carbon']) )
 914             exts.append( Extension('_App', ['app/_Appmodule.c'],
 915                     extra_link_args=['-framework', 'Carbon']) )
 916             exts.append( Extension('_CarbonEvt', ['carbonevt/_CarbonEvtmodule.c'],
 917                     extra_link_args=['-framework', 'Carbon']) )
 918             exts.append( Extension('_CG', ['cg/_CGmodule.c'],
 919                     extra_link_args=['-framework', 'ApplicationServices']) )
 920             exts.append( Extension('_Cm', ['cm/_Cmmodule.c'],
 921                     extra_link_args=['-framework', 'Carbon']) )
 922             exts.append( Extension('_Ctl', ['ctl/_Ctlmodule.c'],
 923                     extra_link_args=['-framework', 'Carbon']) )
 924             exts.append( Extension('_Dlg', ['dlg/_Dlgmodule.c'],
 925                     extra_link_args=['-framework', 'Carbon']) )
 926             exts.append( Extension('_Drag', ['drag/_Dragmodule.c'],
 927                     extra_link_args=['-framework', 'Carbon']) )
 928             exts.append( Extension('_Evt', ['evt/_Evtmodule.c'],
 929                     extra_link_args=['-framework', 'Carbon']) )
 930             exts.append( Extension('_File', ['file/_Filemodule.c'],
 931                     extra_link_args=['-framework', 'Carbon']) )
 932             exts.append( Extension('_Folder', ['folder/_Foldermodule.c'],
 933                     extra_link_args=['-framework', 'Carbon']) )
 934             exts.append( Extension('_Fm', ['fm/_Fmmodule.c'],
 935                     extra_link_args=['-framework', 'Carbon']) )
 936             exts.append( Extension('_Help', ['help/_Helpmodule.c'],
 937                     extra_link_args=['-framework', 'Carbon']) )
 938             exts.append( Extension('_Icn', ['icn/_Icnmodule.c'],
 939                     extra_link_args=['-framework', 'Carbon']) )
 940             exts.append( Extension('_IBCarbon', ['ibcarbon/_IBCarbon.c'],
 941                     extra_link_args=['-framework', 'Carbon']) )
 942             exts.append( Extension('_Launch', ['launch/_Launchmodule.c'],
 943                     extra_link_args=['-framework', 'ApplicationServices']) )
 944             exts.append( Extension('_List', ['list/_Listmodule.c'],
 945                     extra_link_args=['-framework', 'Carbon']) )
 946             exts.append( Extension('_Menu', ['menu/_Menumodule.c'],
 947                     extra_link_args=['-framework', 'Carbon']) )
 948             exts.append( Extension('_Mlte', ['mlte/_Mltemodule.c'],
 949                     extra_link_args=['-framework', 'Carbon']) )
 950             exts.append( Extension('_OSA', ['osa/_OSAmodule.c'],
 951                     extra_link_args=['-framework', 'Carbon']) )
 952             exts.append( Extension('_Qd', ['qd/_Qdmodule.c'],
 953                     extra_link_args=['-framework', 'Carbon']) )
 954             exts.append( Extension('_Qdoffs', ['qdoffs/_Qdoffsmodule.c'],
 955                     extra_link_args=['-framework', 'Carbon']) )
 956             exts.append( Extension('_Qt', ['qt/_Qtmodule.c'],
 957                     extra_link_args=['-framework', 'QuickTime',
 958                                      '-framework', 'Carbon']) )
 959             exts.append( Extension('_Scrap', ['scrap/_Scrapmodule.c'],
 960                     extra_link_args=['-framework', 'Carbon']) )
 961             exts.append( Extension('_TE', ['te/_TEmodule.c'],
 962                     extra_link_args=['-framework', 'Carbon']) )
 963             # As there is no standardized place (yet) to put
 964             # user-installed Mac libraries on OSX, we search for "waste"
 965             # in parent directories of the Python source tree. You
 966             # should put a symlink to your Waste installation in the
 967             # same folder as your python source tree.  Or modify the
 968             # next few lines:-)
 969             waste_incs = find_file("WASTE.h", [],
 970                     ['../'*n + 'waste/C_C++ Headers' for n in (0,1,2,3,4)])
 971             waste_libs = find_library_file(self.compiler, "WASTE", [],
 972                     ["../"*n + "waste/Static Libraries" for n in (0,1,2,3,4)])
 973             if waste_incs != None and waste_libs != None:
 974                 (srcdir,) = sysconfig.get_config_vars('srcdir')
 975                 exts.append( Extension('waste',
 976                                ['waste/wastemodule.c'] + [
 977                                 os.path.join(srcdir, d) for d in
 978                                 'Mac/Wastemods/WEObjectHandlers.c',
 979                                 'Mac/Wastemods/WETabHooks.c',
 980                                 'Mac/Wastemods/WETabs.c'
 981                                ],
 982                                include_dirs = waste_incs + [os.path.join(srcdir, 'Mac/Wastemods')],
 983                                library_dirs = waste_libs,
 984                                libraries = ['WASTE'],
 985                                extra_link_args = ['-framework', 'Carbon'],
 986                 ) )
 987             exts.append( Extension('_Win', ['win/_Winmodule.c'],
 988                     extra_link_args=['-framework', 'Carbon']) )
 989
 990         self.extensions.extend(exts)
 991
 992         # Call the method for detecting whether _tkinter can be compiled
 993         self.detect_tkinter(inc_dirs, lib_dirs)
 994
 995     def detect_tkinter_darwin(self, inc_dirs, lib_dirs):
 996         # The _tkinter module, using frameworks. Since frameworks are quite
 997         # different the UNIX search logic is not sharable.
 998         from os.path import join, exists
 999         framework_dirs = [
1000             '/System/Library/Frameworks/',
1001             '/Library/Frameworks',
1002             join(os.getenv('HOME'), '/Library/Frameworks')
1003         ]
1004
1005         # Find the directory that contains the Tcl.framework and Tk.framework
1006         # bundles.
1007         # XXX distutils should support -F!
1008         for F in framework_dirs:
1009             # both Tcl.framework and Tk.framework should be present
1010             for fw in 'Tcl', 'Tk':
1011                 if not exists(join(F, fw + '.framework')):
1012                     break
1013             else:
1014                 # ok, F is now directory with both frameworks. Continure
1015                 # building
1016                 break
1017         else:
1018             # Tk and Tcl frameworks not found. Normal "unix" tkinter search
1019             # will now resume.
1020             return 0
1021
1022         # For 8.4a2, we must add -I options that point inside the Tcl and Tk
1023         # frameworks. In later release we should hopefully be able to pass
1024         # the -F option to gcc, which specifies a framework lookup path.
1025         #
1026         include_dirs = [
1027             join(F, fw + '.framework', H)
1028             for fw in 'Tcl', 'Tk'
1029             for H in 'Headers', 'Versions/Current/PrivateHeaders'
1030         ]
1031
1032         # For 8.4a2, the X11 headers are not included. Rather than include a
1033         # complicated search, this is a hard-coded path. It could bail out
1034         # if X11 libs are not found...
1035         include_dirs.append('/usr/X11R6/include')
1036         frameworks = ['-framework', 'Tcl', '-framework', 'Tk']
1037
1038         ext = Extension('_tkinter', ['_tkinter.c', 'tkappinit.c'],
1039                         define_macros=[('WITH_APPINIT', 1)],
1040                         include_dirs = include_dirs,
1041                         libraries = [],
1042                         extra_compile_args = frameworks,
1043                         extra_link_args = frameworks,
1044                         )
1045         self.extensions.append(ext)
1046         return 1
1047
1048
1049     def detect_tkinter(self, inc_dirs, lib_dirs):
1050         # The _tkinter module.
1051
1052         # Rather than complicate the code below, detecting and building
1053         # AquaTk is a separate method. Only one Tkinter will be built on
1054         # Darwin - either AquaTk, if it is found, or X11 based Tk.
1055         platform = self.get_platform()
1056         if (platform == 'darwin' and
1057             self.detect_tkinter_darwin(inc_dirs, lib_dirs)):
1058             return
1059
1060         # Assume we haven't found any of the libraries or include files
1061         # The versions with dots are used on Unix, and the versions without
1062         # dots on Windows, for detection by cygwin.
1063         tcllib = tklib = tcl_includes = tk_includes = None
1064         for version in ['8.5', '85', '8.4', '84', '8.3', '83', '8.2',
1065                         '82', '8.1', '81', '8.0', '80']:
1066             tklib = self.compiler.find_library_file(lib_dirs, 'tk' + version)
1067             tcllib = self.compiler.find_library_file(lib_dirs, 'tcl' + version)
1068             if tklib and tcllib:
1069                 # Exit the loop when we've found the Tcl/Tk libraries
1070                 break
1071
1072         # Now check for the header files
1073         if tklib and tcllib:
1074             # Check for the include files on Debian and {Free,Open}BSD, where
1075             # they're put in /usr/include/{tcl,tk}X.Y
1076             dotversion = version
1077             if '.' not in dotversion and "bsd" in sys.platform.lower():
1078                 # OpenBSD and FreeBSD use Tcl/Tk library names like libtcl83.a,
1079                 # but the include subdirs are named like .../include/tcl8.3.
1080                 dotversion = dotversion[:-1] + '.' + dotversion[-1]
1081             tcl_include_sub = []
1082             tk_include_sub = []
1083             for dir in inc_dirs:
1084                 tcl_include_sub += [dir + os.sep + "tcl" + dotversion]
1085                 tk_include_sub += [dir + os.sep + "tk" + dotversion]
1086             tk_include_sub += tcl_include_sub
1087             tcl_includes = find_file('tcl.h', inc_dirs, tcl_include_sub)
1088             tk_includes = find_file('tk.h', inc_dirs, tk_include_sub)
1089
1090         if (tcllib is None or tklib is None or
1091             tcl_includes is None or tk_includes is None):
1092             self.announce("INFO: Can't locate Tcl/Tk libs and/or headers", 2)
1093             return
1094
1095         # OK... everything seems to be present for Tcl/Tk.
1096
1097         include_dirs = [] ; libs = [] ; defs = [] ; added_lib_dirs = []
1098         for dir in tcl_includes + tk_includes:
1099             if dir not in include_dirs:
1100                 include_dirs.append(dir)
1101
1102         # Check for various platform-specific directories
1103         if platform == 'sunos5':
1104             include_dirs.append('/usr/openwin/include')
1105             added_lib_dirs.append('/usr/openwin/lib')
1106         elif os.path.exists('/usr/X11R6/include'):
1107             include_dirs.append('/usr/X11R6/include')
1108             added_lib_dirs.append('/usr/X11R6/lib64')
1109             added_lib_dirs.append('/usr/X11R6/lib')
1110         elif os.path.exists('/usr/X11R5/include'):
1111             include_dirs.append('/usr/X11R5/include')
1112             added_lib_dirs.append('/usr/X11R5/lib')
1113         else:
1114             # Assume default location for X11
1115             include_dirs.append('/usr/X11/include')
1116             added_lib_dirs.append('/usr/X11/lib')
1117
1118         # If Cygwin, then verify that X is installed before proceeding
1119         if platform == 'cygwin':
1120             x11_inc = find_file('X11/Xlib.h', [], include_dirs)
1121             if x11_inc is None:
1122                 return
1123
1124         # Check for BLT extension
1125         if self.compiler.find_library_file(lib_dirs + added_lib_dirs,
1126                                            'BLT8.0'):
1127             defs.append( ('WITH_BLT', 1) )
1128             libs.append('BLT8.0')
1129         elif self.compiler.find_library_file(lib_dirs + added_lib_dirs,
1130                                            'BLT'):
1131             defs.append( ('WITH_BLT', 1) )
1132             libs.append('BLT')
1133
1134         # Add the Tcl/Tk libraries
1135         libs.append('tk'+ version)
1136         libs.append('tcl'+ version)
1137
1138         if platform in ['aix3', 'aix4']:
1139             libs.append('ld')
1140
1141         # Finally, link with the X11 libraries (not appropriate on cygwin)
1142         if platform != "cygwin":
1143             libs.append('X11')
1144
1145         ext = Extension('_tkinter', ['_tkinter.c', 'tkappinit.c'],
1146                         define_macros=[('WITH_APPINIT', 1)] + defs,
1147                         include_dirs = include_dirs,
1148                         libraries = libs,
1149                         library_dirs = added_lib_dirs,
1150                         )
1151         self.extensions.append(ext)
1152
1153 ##         # Uncomment these lines if you want to play with xxmodule.c
1154 ##         ext = Extension('xx', ['xxmodule.c'])
1155 ##         self.extensions.append(ext)
1156
1157         # XXX handle these, but how to detect?
1158         # *** Uncomment and edit for PIL (TkImaging) extension only:
1159         #       -DWITH_PIL -I../Extensions/Imaging/libImaging  tkImaging.c \
1160         # *** Uncomment and edit for TOGL extension only:
1161         #       -DWITH_TOGL togl.c \
1162         # *** Uncomment these for TOGL extension only:
1163         #       -lGL -lGLU -lXext -lXmu \
1164
1165 class PyBuildInstall(install):
1166     # Suppress the warning about installation into the lib_dynload
1167     # directory, which is not in sys.path when running Python during
1168     # installation:
1169     def initialize_options (self):
1170         install.initialize_options(self)
1171         self.warn_dir=0
1172
1173 class PyBuildInstallLib(install_lib):
1174     # Do exactly what install_lib does but make sure correct access modes get
1175     # set on installed directories and files. All installed files with get
1176     # mode 644 unless they are a shared library in which case they will get
1177     # mode 755. All installed directories will get mode 755.
1178
1179     so_ext = sysconfig.get_config_var("SO")
1180
1181     def install(self):
1182         outfiles = install_lib.install(self)
1183         self.set_file_modes(outfiles, 0644, 0755)
1184         self.set_dir_modes(self.install_dir, 0755)
1185         return outfiles
1186
1187     def set_file_modes(self, files, defaultMode, sharedLibMode):
1188         if not self.is_chmod_supported(): return
1189         if not files: return
1190
1191         for filename in files:
1192             if os.path.islink(filename): continue
1193             mode = defaultMode
1194             if filename.endswith(self.so_ext): mode = sharedLibMode
1195             log.info("changing mode of %s to %o", filename, mode)
1196             if not self.dry_run: os.chmod(filename, mode)
1197
1198     def set_dir_modes(self, dirname, mode):
1199         if not self.is_chmod_supported(): return
1200         os.path.walk(dirname, self.set_dir_modes_visitor, mode)
1201
1202     def set_dir_modes_visitor(self, mode, dirname, names):
1203         if os.path.islink(dirname): return
1204         log.info("changing mode of %s to %o", dirname, mode)
1205         if not self.dry_run: os.chmod(dirname, mode)
1206
1207     def is_chmod_supported(self):
1208         return hasattr(os, 'chmod')
1209
1210 SUMMARY = """
1211 Python is an interpreted, interactive, object-oriented programming
1212 language. It is often compared to Tcl, Perl, Scheme or Java.
1213
1214 Python combines remarkable power with very clear syntax. It has
1215 modules, classes, exceptions, very high level dynamic data types, and
1216 dynamic typing. There are interfaces to many system calls and
1217 libraries, as well as to various windowing systems (X11, Motif, Tk,
1218 Mac, MFC). New built-in modules are easily written in C or C++. Python
1219 is also usable as an extension language for applications that need a
1220 programmable interface.
1221
1222 The Python implementation is portable: it runs on many brands of UNIX,
1223 on Windows, DOS, OS/2, Mac, Amiga... If your favorite system isn't
1224 listed here, it may still be supported, if there's a C compiler for
1225 it. Ask around on comp.lang.python -- or just try compiling Python
1226 yourself.
1227 """
1228
1229 CLASSIFIERS = """
1230 Development Status :: 3 - Alpha
1231 Development Status :: 6 - Mature
1232 License :: OSI Approved :: Python Software Foundation License
1233 Natural Language :: English
1234 Programming Language :: C
1235 Programming Language :: Python
1236 Topic :: Software Development
1237 """
1238
1239 def main():
1240     # turn off warnings when deprecated modules are imported
1241     import warnings
1242     warnings.filterwarnings("ignore",category=DeprecationWarning)
1243     setup(# PyPI Metadata (PEP 301)
1244           name = "Python",
1245           version = sys.version.split()[0],
1246           url = "http://www.python.org/%s" % sys.version[:3],
1247           maintainer = "Guido van Rossum and the Python community",
1248           maintainer_email = "python-dev@python.org",
1249           description = "A high-level object-oriented programming language",
1250           long_description = SUMMARY.strip(),
1251           license = "PSF license",
1252           classifiers = filter(None, CLASSIFIERS.split("\n")),
1253           platforms = ["Many"],
1254
1255           # Build info
1256           cmdclass = {'build_ext':PyBuildExt, 'install':PyBuildInstall,
1257                       'install_lib':PyBuildInstallLib},
1258           # The struct module is defined here, because build_ext won't be
1259           # called unless there's at least one extension module defined.
1260           ext_modules=[Extension('struct', ['structmodule.c'])],
1261
1262           # Scripts to install
1263           scripts = ['Tools/scripts/pydoc', 'Tools/scripts/idle',
1264                      'Lib/smtpd.py']
1265         )
1266
1267 # --install-platlib
1268 if __name__ == '__main__':
1269     main()