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