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.3.  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, 3)
 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):
 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         # 3.x minor number specific paths
 588         for x in (2,3):
 589             db_inc_paths.append('/usr/include/db3%d' % x)
 590             db_inc_paths.append('/usr/local/BerkeleyDB.3.%d/include' % x)
 591             db_inc_paths.append('/usr/local/include/db3%d' % x)
 592             db_inc_paths.append('/pkg/db-3.%d/include' % x)
 593
 594         db_ver_inc_map = {}
 595
 596         class db_found(Exception): pass
 597         try:
 598             # See whether there is a Sleepycat header in the standard
 599             # search path.
 600             for d in inc_dirs + db_inc_paths:
 601                 f = os.path.join(d, "db.h")
 602                 if db_setup_debug: print "db: looking for db.h in", f
 603                 if os.path.exists(f):
 604                     f = open(f).read()
 605                     m = re.search(r"#define\WDB_VERSION_MAJOR\W(\d+)", f)
 606                     if m:
 607                         db_major = int(m.group(1))
 608                         m = re.search(r"#define\WDB_VERSION_MINOR\W(\d+)", f)
 609                         db_minor = int(m.group(1))
 610                         db_ver = (db_major, db_minor)
 611
 612                         if ( (not db_ver_inc_map.has_key(db_ver)) and
 613                            (db_ver <= max_db_ver and db_ver >= min_db_ver) ):
 614                             # save the include directory with the db.h version
 615                             # (first occurrance only)
 616                             db_ver_inc_map[db_ver] = d
 617                             print "db.h: found", db_ver, "in", d
 618                         else:
 619                             # we already found a header for this library version
 620                             if db_setup_debug: print "db.h: ignoring", d
 621                     else:
 622                         # ignore this header, it didn't contain a version number
 623                         if db_setup_debug: print "db.h: unsupported version", db_ver, "in", d
 624
 625             db_found_vers = db_ver_inc_map.keys()
 626             db_found_vers.sort()
 627
 628             while db_found_vers:
 629                 db_ver = db_found_vers.pop()
 630                 db_incdir = db_ver_inc_map[db_ver]
 631
 632                 # check lib directories parallel to the location of the header
 633                 db_dirs_to_check = [
 634                     os.path.join(db_incdir, '..', 'lib64'),
 635                     os.path.join(db_incdir, '..', 'lib'),
 636                     os.path.join(db_incdir, '..', '..', 'lib64'),
 637                     os.path.join(db_incdir, '..', '..', 'lib'),
 638                 ]
 639                 db_dirs_to_check = filter(os.path.isdir, db_dirs_to_check)
 640
 641                 # Look for a version specific db-X.Y before an ambiguoius dbX
 642                 # XXX should we -ever- look for a dbX name?  Do any
 643                 # systems really not name their library by version and
 644                 # symlink to more general names?
 645                 for dblib in (('db-%d.%d' % db_ver),
 646                               ('db%d%d' % db_ver),
 647                               ('db%d' % db_ver[0])):
 648                     dblib_file = self.compiler.find_library_file(
 649                                     db_dirs_to_check + lib_dirs, dblib )
 650                     if dblib_file:
 651                         dblib_dir = [ os.path.abspath(os.path.dirname(dblib_file)) ]
 652                         raise db_found
 653                     else:
 654                         if db_setup_debug: print "db lib: ", dblib, "not found"
 655
 656         except db_found:
 657             print "db lib: using", db_ver, dblib
 658             if db_setup_debug: print "db: lib dir", dblib_dir, "inc dir", db_incdir
 659             db_incs = [db_incdir]
 660             dblibs = [dblib]
 661             # We add the runtime_library_dirs argument because the
 662             # BerkeleyDB lib we're linking against often isn't in the
 663             # system dynamic library search path.  This is usually
 664             # correct and most trouble free, but may cause problems in
 665             # some unusual system configurations (e.g. the directory
 666             # is on an NFS server that goes away).
 667             exts.append(Extension('_bsddb', ['_bsddb.c'],
 668                                   library_dirs=dblib_dir,
 669                                   runtime_library_dirs=dblib_dir,
 670                                   include_dirs=db_incs,
 671                                   libraries=dblibs))
 672         else:
 673             if db_setup_debug: print "db: no appropriate library found"
 674             db_incs = None
 675             dblibs = []
 676             dblib_dir = None
 677
 678
 679         # Look for Berkeley db 1.85.   Note that it is built as a different
 680         # module name so it can be included even when later versions are
 681         # available.  A very restrictive search is performed to avoid
 682         # accidentally building this module with a later version of the
 683         # underlying db library.  May BSD-ish Unixes incorporate db 1.85
 684         # symbols into libc and place the include file in /usr/include.
 685         f = "/usr/include/db.h"
 686         if os.path.exists(f):
 687             data = open(f).read()
 688             m = re.search(r"#s*define\s+HASHVERSION\s+2\s*", data)
 689             if m is not None:
 690                 # bingo - old version used hash file format version 2
 691                 ### XXX this should be fixed to not be platform-dependent
 692                 ### but I don't have direct access to an osf1 platform and
 693                 ### seemed to be muffing the search somehow
 694                 libraries = platform == "osf1" and ['db'] or None
 695                 if libraries is not None:
 696                     exts.append(Extension('bsddb185', ['bsddbmodule.c'],
 697                                           libraries=libraries))
 698                 else:
 699                     exts.append(Extension('bsddb185', ['bsddbmodule.c']))
 700
 701         # The standard Unix dbm module:
 702         if platform not in ['cygwin']:
 703             if find_file("ndbm.h", inc_dirs, []) is not None:
 704                 # Some systems have -lndbm, others don't
 705                 if self.compiler.find_library_file(lib_dirs, 'ndbm'):
 706                     ndbm_libs = ['ndbm']
 707                 else:
 708                     ndbm_libs = []
 709                 exts.append( Extension('dbm', ['dbmmodule.c'],
 710                                        define_macros=[('HAVE_NDBM_H',None)],
 711                                        libraries = ndbm_libs ) )
 712             elif (self.compiler.find_library_file(lib_dirs, 'gdbm')
 713                   and find_file("gdbm/ndbm.h", inc_dirs, []) is not None):
 714                 exts.append( Extension('dbm', ['dbmmodule.c'],
 715                                        define_macros=[('HAVE_GDBM_NDBM_H',None)],
 716                                        libraries = ['gdbm'] ) )
 717             elif db_incs is not None:
 718                 exts.append( Extension('dbm', ['dbmmodule.c'],
 719                                        library_dirs=dblib_dir,
 720                                        runtime_library_dirs=dblib_dir,
 721                                        include_dirs=db_incs,
 722                                        define_macros=[('HAVE_BERKDB_H',None),
 723                                                       ('DB_DBM_HSEARCH',None)],
 724                                        libraries=dblibs))
 725
 726         # Anthony Baxter's gdbm module.  GNU dbm(3) will require -lgdbm:
 727         if (self.compiler.find_library_file(lib_dirs, 'gdbm')):
 728             exts.append( Extension('gdbm', ['gdbmmodule.c'],
 729                                    libraries = ['gdbm'] ) )
 730
 731         # Unix-only modules
 732         if platform not in ['mac', 'win32']:
 733             # Steen Lumholt's termios module
 734             exts.append( Extension('termios', ['termios.c']) )
 735             # Jeremy Hylton's rlimit interface
 736             if platform not in ['atheos']:
 737                 exts.append( Extension('resource', ['resource.c']) )
 738
 739             # Sun yellow pages. Some systems have the functions in libc.
 740             if platform not in ['cygwin', 'atheos']:
 741                 if (self.compiler.find_library_file(lib_dirs, 'nsl')):
 742                     libs = ['nsl']
 743                 else:
 744                     libs = []
 745                 exts.append( Extension('nis', ['nismodule.c'],
 746                                        libraries = libs) )
 747
 748         # Curses support, requiring the System V version of curses, often
 749         # provided by the ncurses library.
 750         if (self.compiler.find_library_file(lib_dirs, 'ncurses')):
 751             curses_libs = ['ncurses']
 752             exts.append( Extension('_curses', ['_cursesmodule.c'],
 753                                    libraries = curses_libs) )
 754         elif (self.compiler.find_library_file(lib_dirs, 'curses')
 755               and platform != 'darwin'):
 756                 # OSX has an old Berkeley curses, not good enough for
 757                 # the _curses module.
 758             if (self.compiler.find_library_file(lib_dirs, 'terminfo')):
 759                 curses_libs = ['curses', 'terminfo']
 760             elif (self.compiler.find_library_file(lib_dirs, 'termcap')):
 761                 curses_libs = ['curses', 'termcap']
 762             else:
 763                 curses_libs = ['curses']
 764
 765             exts.append( Extension('_curses', ['_cursesmodule.c'],
 766                                    libraries = curses_libs) )
 767
 768         # If the curses module is enabled, check for the panel module
 769         if (module_enabled(exts, '_curses') and
 770             self.compiler.find_library_file(lib_dirs, 'panel')):
 771             exts.append( Extension('_curses_panel', ['_curses_panel.c'],
 772                                    libraries = ['panel'] + curses_libs) )
 773
 774
 775         # Andrew Kuchling's zlib module.  Note that some versions of zlib
 776         # 1.1.3 have security problems.  See CERT Advisory CA-2002-07:
 777         # http://www.cert.org/advisories/CA-2002-07.html
 778         #
 779         # zlib 1.1.4 is fixed, but at least one vendor (RedHat) has decided to
 780         # patch its zlib 1.1.3 package instead of upgrading to 1.1.4.  For
 781         # now, we still accept 1.1.3, because we think it's difficult to
 782         # exploit this in Python, and we'd rather make it RedHat's problem
 783         # than our problem <wink>.
 784         #
 785         # You can upgrade zlib to version 1.1.4 yourself by going to
 786         # http://www.gzip.org/zlib/
 787         zlib_inc = find_file('zlib.h', [], inc_dirs)
 788         if zlib_inc is not None:
 789             zlib_h = zlib_inc[0] + '/zlib.h'
 790             version = '"0.0.0"'
 791             version_req = '"1.1.3"'
 792             fp = open(zlib_h)
 793             while 1:
 794                 line = fp.readline()
 795                 if not line:
 796                     break
 797                 if line.startswith('#define ZLIB_VERSION'):
 798                     version = line.split()[2]
 799                     break
 800             if version >= version_req:
 801                 if (self.compiler.find_library_file(lib_dirs, 'z')):
 802                     exts.append( Extension('zlib', ['zlibmodule.c'],
 803                                            libraries = ['z']) )
 804
 805         # Gustavo Niemeyer's bz2 module.
 806         if (self.compiler.find_library_file(lib_dirs, 'bz2')):
 807             exts.append( Extension('bz2', ['bz2module.c'],
 808                                    libraries = ['bz2']) )
 809
 810         # Interface to the Expat XML parser
 811         #
 812         # Expat was written by James Clark and is now maintained by a
 813         # group of developers on SourceForge; see www.libexpat.org for
 814         # more information.  The pyexpat module was written by Paul
 815         # Prescod after a prototype by Jack Jansen.  The Expat source
 816         # is included in Modules/expat/.  Usage of a system
 817         # shared libexpat.so/expat.dll is not advised.
 818         #
 819         # More information on Expat can be found at www.libexpat.org.
 820         #
 821         if sys.byteorder == "little":
 822             xmlbo = "1234"
 823         else:
 824             xmlbo = "4321"
 825         expatinc = os.path.join(os.getcwd(), srcdir, 'Modules', 'expat')
 826         define_macros = [
 827             ('XML_NS', '1'),
 828             ('XML_DTD', '1'),
 829             ('BYTEORDER', xmlbo),
 830             ('XML_CONTEXT_BYTES','1024'),
 831             ]
 832         for feature_macro in ['HAVE_MEMMOVE', 'HAVE_BCOPY']:
 833             if config_h_vars.has_key(feature_macro):
 834                 define_macros.append((feature_macro, '1'))
 835         exts.append(Extension('pyexpat',
 836                               define_macros = define_macros,
 837                               include_dirs = [expatinc],
 838                               sources = ['pyexpat.c',
 839                                          'expat/xmlparse.c',
 840                                          'expat/xmlrole.c',
 841                                          'expat/xmltok.c',
 842                                          ],
 843                               ))
 844
 845         # Fredrik Lundh's cElementTree module.  Note that this also
 846         # uses expat (via the CAPI hook in pyexpat).
 847
 848         if os.path.isfile('Modules/_elementtree.c'):
 849             define_macros.append(('USE_PYEXPAT_CAPI', None))
 850             exts.append(Extension('_elementtree',
 851                                   define_macros = define_macros,
 852                                   include_dirs = [expatinc],
 853                                   sources = ['_elementtree.c'],
 854                                   ))
 855
 856         # Hye-Shik Chang's CJKCodecs modules.
 857         if have_unicode:
 858             exts.append(Extension('_multibytecodec',
 859                                   ['cjkcodecs/multibytecodec.c']))
 860             for loc in ('kr', 'jp', 'cn', 'tw', 'hk', 'iso2022'):
 861                 exts.append(Extension('_codecs_' + loc,
 862                                       ['cjkcodecs/_codecs_%s.c' % loc]))
 863
 864         # Dynamic loading module
 865         if sys.maxint == 0x7fffffff:
 866             # This requires sizeof(int) == sizeof(long) == sizeof(char*)
 867             dl_inc = find_file('dlfcn.h', [], inc_dirs)
 868             if (dl_inc is not None) and (platform not in ['atheos', 'darwin']):
 869                 exts.append( Extension('dl', ['dlmodule.c']) )
 870
 871         # Platform-specific libraries
 872         if platform == 'linux2':
 873             # Linux-specific modules
 874             exts.append( Extension('linuxaudiodev', ['linuxaudiodev.c']) )
 875
 876         if platform in ('linux2', 'freebsd4', 'freebsd5', 'freebsd6',
 877                         'freebsd7'):
 878             exts.append( Extension('ossaudiodev', ['ossaudiodev.c']) )
 879
 880         if platform == 'sunos5':
 881             # SunOS specific modules
 882             exts.append( Extension('sunaudiodev', ['sunaudiodev.c']) )
 883
 884         if platform == 'darwin' and ("--disable-toolbox-glue" not in
 885             sysconfig.get_config_var("CONFIG_ARGS")):
 886             # Mac OS X specific modules.
 887             exts.append( Extension('_CF', ['cf/_CFmodule.c', 'cf/pycfbridge.c'],
 888                         extra_link_args=['-framework', 'CoreFoundation']) )
 889
 890             exts.append( Extension('ColorPicker', ['ColorPickermodule.c'],
 891                         extra_link_args=['-framework', 'Carbon']) )
 892             exts.append( Extension('autoGIL', ['autoGIL.c'],
 893                         extra_link_args=['-framework', 'CoreFoundation']) )
 894             exts.append( Extension('gestalt', ['gestaltmodule.c'],
 895                         extra_link_args=['-framework', 'Carbon']) )
 896             exts.append( Extension('MacOS', ['macosmodule.c'],
 897                         extra_link_args=['-framework', 'Carbon']) )
 898             exts.append( Extension('OSATerminology', ['OSATerminology.c'],
 899                         extra_link_args=['-framework', 'Carbon']) )
 900             exts.append( Extension('icglue', ['icgluemodule.c'],
 901                         extra_link_args=['-framework', 'Carbon']) )
 902             exts.append( Extension('_Res', ['res/_Resmodule.c'],
 903                         extra_link_args=['-framework', 'Carbon']) )
 904             exts.append( Extension('_Snd', ['snd/_Sndmodule.c'],
 905                         extra_link_args=['-framework', 'Carbon']) )
 906             exts.append( Extension('Nav', ['Nav.c'],
 907                     extra_link_args=['-framework', 'Carbon']) )
 908             exts.append( Extension('_AE', ['ae/_AEmodule.c'],
 909                     extra_link_args=['-framework', 'Carbon']) )
 910             exts.append( Extension('_AH', ['ah/_AHmodule.c'],
 911                     extra_link_args=['-framework', 'Carbon']) )
 912             exts.append( Extension('_App', ['app/_Appmodule.c'],
 913                     extra_link_args=['-framework', 'Carbon']) )
 914             exts.append( Extension('_CarbonEvt', ['carbonevt/_CarbonEvtmodule.c'],
 915                     extra_link_args=['-framework', 'Carbon']) )
 916             exts.append( Extension('_CG', ['cg/_CGmodule.c'],
 917                     extra_link_args=['-framework', 'ApplicationServices']) )
 918             exts.append( Extension('_Cm', ['cm/_Cmmodule.c'],
 919                     extra_link_args=['-framework', 'Carbon']) )
 920             exts.append( Extension('_Ctl', ['ctl/_Ctlmodule.c'],
 921                     extra_link_args=['-framework', 'Carbon']) )
 922             exts.append( Extension('_Dlg', ['dlg/_Dlgmodule.c'],
 923                     extra_link_args=['-framework', 'Carbon']) )
 924             exts.append( Extension('_Drag', ['drag/_Dragmodule.c'],
 925                     extra_link_args=['-framework', 'Carbon']) )
 926             exts.append( Extension('_Evt', ['evt/_Evtmodule.c'],
 927                     extra_link_args=['-framework', 'Carbon']) )
 928             exts.append( Extension('_File', ['file/_Filemodule.c'],
 929                     extra_link_args=['-framework', 'Carbon']) )
 930             exts.append( Extension('_Folder', ['folder/_Foldermodule.c'],
 931                     extra_link_args=['-framework', 'Carbon']) )
 932             exts.append( Extension('_Fm', ['fm/_Fmmodule.c'],
 933                     extra_link_args=['-framework', 'Carbon']) )
 934             exts.append( Extension('_Help', ['help/_Helpmodule.c'],
 935                     extra_link_args=['-framework', 'Carbon']) )
 936             exts.append( Extension('_Icn', ['icn/_Icnmodule.c'],
 937                     extra_link_args=['-framework', 'Carbon']) )
 938             exts.append( Extension('_IBCarbon', ['ibcarbon/_IBCarbon.c'],
 939                     extra_link_args=['-framework', 'Carbon']) )
 940             exts.append( Extension('_Launch', ['launch/_Launchmodule.c'],
 941                     extra_link_args=['-framework', 'ApplicationServices']) )
 942             exts.append( Extension('_List', ['list/_Listmodule.c'],
 943                     extra_link_args=['-framework', 'Carbon']) )
 944             exts.append( Extension('_Menu', ['menu/_Menumodule.c'],
 945                     extra_link_args=['-framework', 'Carbon']) )
 946             exts.append( Extension('_Mlte', ['mlte/_Mltemodule.c'],
 947                     extra_link_args=['-framework', 'Carbon']) )
 948             exts.append( Extension('_OSA', ['osa/_OSAmodule.c'],
 949                     extra_link_args=['-framework', 'Carbon']) )
 950             exts.append( Extension('_Qd', ['qd/_Qdmodule.c'],
 951                     extra_link_args=['-framework', 'Carbon']) )
 952             exts.append( Extension('_Qdoffs', ['qdoffs/_Qdoffsmodule.c'],
 953                     extra_link_args=['-framework', 'Carbon']) )
 954             exts.append( Extension('_Qt', ['qt/_Qtmodule.c'],
 955                     extra_link_args=['-framework', 'QuickTime',
 956                                      '-framework', 'Carbon']) )
 957             exts.append( Extension('_Scrap', ['scrap/_Scrapmodule.c'],
 958                     extra_link_args=['-framework', 'Carbon']) )
 959             exts.append( Extension('_TE', ['te/_TEmodule.c'],
 960                     extra_link_args=['-framework', 'Carbon']) )
 961             # As there is no standardized place (yet) to put
 962             # user-installed Mac libraries on OSX, we search for "waste"
 963             # in parent directories of the Python source tree. You
 964             # should put a symlink to your Waste installation in the
 965             # same folder as your python source tree.  Or modify the
 966             # next few lines:-)
 967             waste_incs = find_file("WASTE.h", [],
 968                     ['../'*n + 'waste/C_C++ Headers' for n in (0,1,2,3,4)])
 969             waste_libs = find_library_file(self.compiler, "WASTE", [],
 970                     ["../"*n + "waste/Static Libraries" for n in (0,1,2,3,4)])
 971             if waste_incs != None and waste_libs != None:
 972                 (srcdir,) = sysconfig.get_config_vars('srcdir')
 973                 exts.append( Extension('waste',
 974                                ['waste/wastemodule.c'] + [
 975                                 os.path.join(srcdir, d) for d in
 976                                 'Mac/Wastemods/WEObjectHandlers.c',
 977                                 'Mac/Wastemods/WETabHooks.c',
 978                                 'Mac/Wastemods/WETabs.c'
 979                                ],
 980                                include_dirs = waste_incs + [os.path.join(srcdir, 'Mac/Wastemods')],
 981                                library_dirs = waste_libs,
 982                                libraries = ['WASTE'],
 983                                extra_link_args = ['-framework', 'Carbon'],
 984                 ) )
 985             exts.append( Extension('_Win', ['win/_Winmodule.c'],
 986                     extra_link_args=['-framework', 'Carbon']) )
 987
 988         self.extensions.extend(exts)
 989
 990         # Call the method for detecting whether _tkinter can be compiled
 991         self.detect_tkinter(inc_dirs, lib_dirs)
 992
 993     def detect_tkinter_darwin(self, inc_dirs, lib_dirs):
 994         # The _tkinter module, using frameworks. Since frameworks are quite
 995         # different the UNIX search logic is not sharable.
 996         from os.path import join, exists
 997         framework_dirs = [
 998             '/System/Library/Frameworks/',
 999             '/Library/Frameworks',
1000             join(os.getenv('HOME'), '/Library/Frameworks')
1001         ]
1002
1003         # Find the directory that contains the Tcl.framework and Tk.framework
1004         # bundles.
1005         # XXX distutils should support -F!
1006         for F in framework_dirs:
1007             # both Tcl.framework and Tk.framework should be present
1008             for fw in 'Tcl', 'Tk':
1009                 if not exists(join(F, fw + '.framework')):
1010                     break
1011             else:
1012                 # ok, F is now directory with both frameworks. Continure
1013                 # building
1014                 break
1015         else:
1016             # Tk and Tcl frameworks not found. Normal "unix" tkinter search
1017             # will now resume.
1018             return 0
1019
1020         # For 8.4a2, we must add -I options that point inside the Tcl and Tk
1021         # frameworks. In later release we should hopefully be able to pass
1022         # the -F option to gcc, which specifies a framework lookup path.
1023         #
1024         include_dirs = [
1025             join(F, fw + '.framework', H)
1026             for fw in 'Tcl', 'Tk'
1027             for H in 'Headers', 'Versions/Current/PrivateHeaders'
1028         ]
1029
1030         # For 8.4a2, the X11 headers are not included. Rather than include a
1031         # complicated search, this is a hard-coded path. It could bail out
1032         # if X11 libs are not found...
1033         include_dirs.append('/usr/X11R6/include')
1034         frameworks = ['-framework', 'Tcl', '-framework', 'Tk']
1035
1036         ext = Extension('_tkinter', ['_tkinter.c', 'tkappinit.c'],
1037                         define_macros=[('WITH_APPINIT', 1)],
1038                         include_dirs = include_dirs,
1039                         libraries = [],
1040                         extra_compile_args = frameworks,
1041                         extra_link_args = frameworks,
1042                         )
1043         self.extensions.append(ext)
1044         return 1
1045
1046
1047     def detect_tkinter(self, inc_dirs, lib_dirs):
1048         # The _tkinter module.
1049
1050         # Rather than complicate the code below, detecting and building
1051         # AquaTk is a separate method. Only one Tkinter will be built on
1052         # Darwin - either AquaTk, if it is found, or X11 based Tk.
1053         platform = self.get_platform()
1054         if (platform == 'darwin' and
1055             self.detect_tkinter_darwin(inc_dirs, lib_dirs)):
1056             return
1057
1058         # Assume we haven't found any of the libraries or include files
1059         # The versions with dots are used on Unix, and the versions without
1060         # dots on Windows, for detection by cygwin.
1061         tcllib = tklib = tcl_includes = tk_includes = None
1062         for version in ['8.5', '85', '8.4', '84', '8.3', '83', '8.2',
1063                         '82', '8.1', '81', '8.0', '80']:
1064             tklib = self.compiler.find_library_file(lib_dirs, 'tk' + version)
1065             tcllib = self.compiler.find_library_file(lib_dirs, 'tcl' + version)
1066             if tklib and tcllib:
1067                 # Exit the loop when we've found the Tcl/Tk libraries
1068                 break
1069
1070         # Now check for the header files
1071         if tklib and tcllib:
1072             # Check for the include files on Debian and {Free,Open}BSD, where
1073             # they're put in /usr/include/{tcl,tk}X.Y
1074             dotversion = version
1075             if '.' not in dotversion and "bsd" in sys.platform.lower():
1076                 # OpenBSD and FreeBSD use Tcl/Tk library names like libtcl83.a,
1077                 # but the include subdirs are named like .../include/tcl8.3.
1078                 dotversion = dotversion[:-1] + '.' + dotversion[-1]
1079             tcl_include_sub = []
1080             tk_include_sub = []
1081             for dir in inc_dirs:
1082                 tcl_include_sub += [dir + os.sep + "tcl" + dotversion]
1083                 tk_include_sub += [dir + os.sep + "tk" + dotversion]
1084             tk_include_sub += tcl_include_sub
1085             tcl_includes = find_file('tcl.h', inc_dirs, tcl_include_sub)
1086             tk_includes = find_file('tk.h', inc_dirs, tk_include_sub)
1087
1088         if (tcllib is None or tklib is None or
1089             tcl_includes is None or tk_includes is None):
1090             self.announce("INFO: Can't locate Tcl/Tk libs and/or headers", 2)
1091             return
1092
1093         # OK... everything seems to be present for Tcl/Tk.
1094
1095         include_dirs = [] ; libs = [] ; defs = [] ; added_lib_dirs = []
1096         for dir in tcl_includes + tk_includes:
1097             if dir not in include_dirs:
1098                 include_dirs.append(dir)
1099
1100         # Check for various platform-specific directories
1101         if platform == 'sunos5':
1102             include_dirs.append('/usr/openwin/include')
1103             added_lib_dirs.append('/usr/openwin/lib')
1104         elif os.path.exists('/usr/X11R6/include'):
1105             include_dirs.append('/usr/X11R6/include')
1106             added_lib_dirs.append('/usr/X11R6/lib64')
1107             added_lib_dirs.append('/usr/X11R6/lib')
1108         elif os.path.exists('/usr/X11R5/include'):
1109             include_dirs.append('/usr/X11R5/include')
1110             added_lib_dirs.append('/usr/X11R5/lib')
1111         else:
1112             # Assume default location for X11
1113             include_dirs.append('/usr/X11/include')
1114             added_lib_dirs.append('/usr/X11/lib')
1115
1116         # If Cygwin, then verify that X is installed before proceeding
1117         if platform == 'cygwin':
1118             x11_inc = find_file('X11/Xlib.h', [], include_dirs)
1119             if x11_inc is None:
1120                 return
1121
1122         # Check for BLT extension
1123         if self.compiler.find_library_file(lib_dirs + added_lib_dirs,
1124                                            'BLT8.0'):
1125             defs.append( ('WITH_BLT', 1) )
1126             libs.append('BLT8.0')
1127         elif self.compiler.find_library_file(lib_dirs + added_lib_dirs,
1128                                            'BLT'):
1129             defs.append( ('WITH_BLT', 1) )
1130             libs.append('BLT')
1131
1132         # Add the Tcl/Tk libraries
1133         libs.append('tk'+ version)
1134         libs.append('tcl'+ version)
1135
1136         if platform in ['aix3', 'aix4']:
1137             libs.append('ld')
1138
1139         # Finally, link with the X11 libraries (not appropriate on cygwin)
1140         if platform != "cygwin":
1141             libs.append('X11')
1142
1143         ext = Extension('_tkinter', ['_tkinter.c', 'tkappinit.c'],
1144                         define_macros=[('WITH_APPINIT', 1)] + defs,
1145                         include_dirs = include_dirs,
1146                         libraries = libs,
1147                         library_dirs = added_lib_dirs,
1148                         )
1149         self.extensions.append(ext)
1150
1151 ##         # Uncomment these lines if you want to play with xxmodule.c
1152 ##         ext = Extension('xx', ['xxmodule.c'])
1153 ##         self.extensions.append(ext)
1154
1155         # XXX handle these, but how to detect?
1156         # *** Uncomment and edit for PIL (TkImaging) extension only:
1157         #       -DWITH_PIL -I../Extensions/Imaging/libImaging  tkImaging.c \
1158         # *** Uncomment and edit for TOGL extension only:
1159         #       -DWITH_TOGL togl.c \
1160         # *** Uncomment these for TOGL extension only:
1161         #       -lGL -lGLU -lXext -lXmu \
1162
1163 class PyBuildInstall(install):
1164     # Suppress the warning about installation into the lib_dynload
1165     # directory, which is not in sys.path when running Python during
1166     # installation:
1167     def initialize_options (self):
1168         install.initialize_options(self)
1169         self.warn_dir=0
1170
1171 class PyBuildInstallLib(install_lib):
1172     # Do exactly what install_lib does but make sure correct access modes get
1173     # set on installed directories and files. All installed files with get
1174     # mode 644 unless they are a shared library in which case they will get
1175     # mode 755. All installed directories will get mode 755.
1176
1177     so_ext = sysconfig.get_config_var("SO")
1178
1179     def install(self):
1180         outfiles = install_lib.install(self)
1181         self.set_file_modes(outfiles, 0644, 0755)
1182         self.set_dir_modes(self.install_dir, 0755)
1183         return outfiles
1184
1185     def set_file_modes(self, files, defaultMode, sharedLibMode):
1186         if not self.is_chmod_supported(): return
1187         if not files: return
1188
1189         for filename in files:
1190             if os.path.islink(filename): continue
1191             mode = defaultMode
1192             if filename.endswith(self.so_ext): mode = sharedLibMode
1193             log.info("changing mode of %s to %o", filename, mode)
1194             if not self.dry_run: os.chmod(filename, mode)
1195
1196     def set_dir_modes(self, dirname, mode):
1197         if not self.is_chmod_supported(): return
1198         os.path.walk(dirname, self.set_dir_modes_visitor, mode)
1199
1200     def set_dir_modes_visitor(self, mode, dirname, names):
1201         if os.path.islink(dirname): return
1202         log.info("changing mode of %s to %o", dirname, mode)
1203         if not self.dry_run: os.chmod(dirname, mode)
1204
1205     def is_chmod_supported(self):
1206         return hasattr(os, 'chmod')
1207
1208 SUMMARY = """
1209 Python is an interpreted, interactive, object-oriented programming
1210 language. It is often compared to Tcl, Perl, Scheme or Java.
1211
1212 Python combines remarkable power with very clear syntax. It has
1213 modules, classes, exceptions, very high level dynamic data types, and
1214 dynamic typing. There are interfaces to many system calls and
1215 libraries, as well as to various windowing systems (X11, Motif, Tk,
1216 Mac, MFC). New built-in modules are easily written in C or C++. Python
1217 is also usable as an extension language for applications that need a
1218 programmable interface.
1219
1220 The Python implementation is portable: it runs on many brands of UNIX,
1221 on Windows, DOS, OS/2, Mac, Amiga... If your favorite system isn't
1222 listed here, it may still be supported, if there's a C compiler for
1223 it. Ask around on comp.lang.python -- or just try compiling Python
1224 yourself.
1225 """
1226
1227 CLASSIFIERS = """
1228 Development Status :: 3 - Alpha
1229 Development Status :: 6 - Mature
1230 License :: OSI Approved :: Python Software Foundation License
1231 Natural Language :: English
1232 Programming Language :: C
1233 Programming Language :: Python
1234 Topic :: Software Development
1235 """
1236
1237 def main():
1238     # turn off warnings when deprecated modules are imported
1239     import warnings
1240     warnings.filterwarnings("ignore",category=DeprecationWarning)
1241     setup(# PyPI Metadata (PEP 301)
1242           name = "Python",
1243           version = sys.version.split()[0],
1244           url = "http://www.python.org/%s" % sys.version[:3],
1245           maintainer = "Guido van Rossum and the Python community",
1246           maintainer_email = "python-dev@python.org",
1247           description = "A high-level object-oriented programming language",
1248           long_description = SUMMARY.strip(),
1249           license = "PSF license",
1250           classifiers = filter(None, CLASSIFIERS.split("\n")),
1251           platforms = ["Many"],
1252
1253           # Build info
1254           cmdclass = {'build_ext':PyBuildExt, 'install':PyBuildInstall,
1255                       'install_lib':PyBuildInstallLib},
1256           # The struct module is defined here, because build_ext won't be
1257           # called unless there's at least one extension module defined.
1258           ext_modules=[Extension('struct', ['structmodule.c'])],
1259
1260           # Scripts to install
1261           scripts = ['Tools/scripts/pydoc', 'Tools/scripts/idle',
1262                      'Lib/smtpd.py']
1263         )
1264
1265 # --install-platlib
1266 if __name__ == '__main__':
1267     main()