setup.py

   1 # Autodetecting setup.py script for building the Python extensions
   2 #
   3
   4 __version__ = "$Revision$"
   5
   6 import sys, os, imp, re, optparse
   7
   8 from distutils import log
   9 from distutils import sysconfig
  10 from distutils import text_file
  11 from distutils.errors import *
  12 from distutils.core import Extension, setup
  13 from distutils.command.build_ext import build_ext
  14 from distutils.command.install import install
  15 from distutils.command.install_lib import install_lib
  16
  17 # This global variable is used to hold the list of modules to be disabled.
  18 disabled_module_list = []
  19
  20 def add_dir_to_list(dirlist, dir):
  21     """Add the directory 'dir' to the list 'dirlist' (at the front) if
  22     1) 'dir' is not already in 'dirlist'
  23     2) 'dir' actually exists, and is a directory."""
  24     if dir is not None and os.path.isdir(dir) and dir not in dirlist:
  25         dirlist.insert(0, dir)
  26
  27 def find_file(filename, std_dirs, paths):
  28     """Searches for the directory where a given file is located,
  29     and returns a possibly-empty list of additional directories, or None
  30     if the file couldn't be found at all.
  31
  32     'filename' is the name of a file, such as readline.h or libcrypto.a.
  33     'std_dirs' is the list of standard system directories; if the
  34         file is found in one of them, no additional directives are needed.
  35     'paths' is a list of additional locations to check; if the file is
  36         found in one of them, the resulting list will contain the directory.
  37     """
  38
  39     # Check the standard locations
  40     for dir in std_dirs:
  41         f = os.path.join(dir, filename)
  42         if os.path.exists(f): return []
  43
  44     # Check the additional directories
  45     for dir in paths:
  46         f = os.path.join(dir, filename)
  47         if os.path.exists(f):
  48             return [dir]
  49
  50     # Not found anywhere
  51     return None
  52
  53 def find_library_file(compiler, libname, std_dirs, paths):
  54     result = compiler.find_library_file(std_dirs + paths, libname)
  55     if result is None:
  56         return None
  57
  58     # Check whether the found file is in one of the standard directories
  59     dirname = os.path.dirname(result)
  60     for p in std_dirs:
  61         # Ensure path doesn't end with path separator
  62         p = p.rstrip(os.sep)
  63         if p == dirname:
  64             return [ ]
  65
  66     # Otherwise, it must have been in one of the additional directories,
  67     # so we have to figure out which one.
  68     for p in paths:
  69         # Ensure path doesn't end with path separator
  70         p = p.rstrip(os.sep)
  71         if p == dirname:
  72             return [p]
  73     else:
  74         assert False, "Internal error: Path not found in std_dirs or paths"
  75
  76 def module_enabled(extlist, modname):
  77     """Returns whether the module 'modname' is present in the list
  78     of extensions 'extlist'."""
  79     extlist = [ext for ext in extlist if ext.name == modname]
  80     return len(extlist)
  81
  82 def find_module_file(module, dirlist):
  83     """Find a module in a set of possible folders. If it is not found
  84     return the unadorned filename"""
  85     list = find_file(module, [], dirlist)
  86     if not list:
  87         return module
  88     if len(list) > 1:
  89         log.info("WARNING: multiple copies of %s found"%module)
  90     return os.path.join(list[0], module)
  91
  92 class PyBuildExt(build_ext):
  93
  94     def build_extensions(self):
  95
  96         # Detect which modules should be compiled
  97         self.detect_modules()
  98
  99         # Remove modules that are present on the disabled list
 100         self.extensions = [ext for ext in self.extensions
 101                            if ext.name not in disabled_module_list]
 102
 103         # Fix up the autodetected modules, prefixing all the source files
 104         # with Modules/ and adding Python's include directory to the path.
 105         (srcdir,) = sysconfig.get_config_vars('srcdir')
 106         if not srcdir:
 107             # Maybe running on Windows but not using CYGWIN?
 108             raise ValueError("No source directory; cannot proceed.")
 109
 110         # Figure out the location of the source code for extension modules
 111         moddir = os.path.join(os.getcwd(), srcdir, 'Modules')
 112         moddir = os.path.normpath(moddir)
 113         srcdir, tail = os.path.split(moddir)
 114         srcdir = os.path.normpath(srcdir)
 115         moddir = os.path.normpath(moddir)
 116
 117         moddirlist = [moddir]
 118         incdirlist = ['./Include']
 119
 120         # Platform-dependent module source and include directories
 121         platform = self.get_platform()
 122         if platform in ('darwin', 'mac') and ("--disable-toolbox-glue" not in
 123             sysconfig.get_config_var("CONFIG_ARGS")):
 124             # Mac OS X also includes some mac-specific modules
 125             macmoddir = os.path.join(os.getcwd(), srcdir, 'Mac/Modules')
 126             moddirlist.append(macmoddir)
 127             incdirlist.append('./Mac/Include')
 128
 129         alldirlist = moddirlist + incdirlist
 130
 131         # Fix up the paths for scripts, too
 132         self.distribution.scripts = [os.path.join(srcdir, filename)
 133                                      for filename in self.distribution.scripts]
 134
 135         for ext in self.extensions[:]:
 136             ext.sources = [ find_module_file(filename, moddirlist)
 137                             for filename in ext.sources ]
 138             if ext.depends is not None:
 139                 ext.depends = [find_module_file(filename, alldirlist)
 140                                for filename in ext.depends]
 141             ext.include_dirs.append( '.' ) # to get config.h
 142             for incdir in incdirlist:
 143                 ext.include_dirs.append( os.path.join(srcdir, incdir) )
 144
 145             # If a module has already been built statically,
 146             # don't build it here
 147             if ext.name in sys.builtin_module_names:
 148                 self.extensions.remove(ext)
 149
 150         if platform != 'mac':
 151             # Parse Modules/Setup and Modules/Setup.local to figure out which
 152             # modules are turned on in the file.
 153             remove_modules = []
 154             for filename in ('Modules/Setup', 'Modules/Setup.local'):
 155                 input = text_file.TextFile(filename, join_lines=1)
 156                 while 1:
 157                     line = input.readline()
 158                     if not line: break
 159                     line = line.split()
 160                     remove_modules.append(line[0])
 161                 input.close()
 162
 163             for ext in self.extensions[:]:
 164                 if ext.name in remove_modules:
 165                     self.extensions.remove(ext)
 166
 167         # When you run "make CC=altcc" or something similar, you really want
 168         # those environment variables passed into the setup.py phase.  Here's
 169         # a small set of useful ones.
 170         compiler = os.environ.get('CC')
 171         args = {}
 172         # unfortunately, distutils doesn't let us provide separate C and C++
 173         # compilers
 174         if compiler is not None:
 175             (ccshared,cflags) = sysconfig.get_config_vars('CCSHARED','CFLAGS')
 176             args['compiler_so'] = compiler + ' ' + ccshared + ' ' + cflags
 177         self.compiler.set_executables(**args)
 178
 179         build_ext.build_extensions(self)
 180
 181     def build_extension(self, ext):
 182
 183         if ext.name == '_ctypes':
 184             if not self.configure_ctypes(ext):
 185                 return
 186
 187         try:
 188             build_ext.build_extension(self, ext)
 189         except (CCompilerError, DistutilsError), why:
 190             self.announce('WARNING: building of extension "%s" failed: %s' %
 191                           (ext.name, sys.exc_info()[1]))
 192             return
 193         # Workaround for Mac OS X: The Carbon-based modules cannot be
 194         # reliably imported into a command-line Python
 195         if 'Carbon' in ext.extra_link_args:
 196             self.announce(
 197                 'WARNING: skipping import check for Carbon-based "%s"' %
 198                 ext.name)
 199             return
 200         # Workaround for Cygwin: Cygwin currently has fork issues when many
 201         # modules have been imported
 202         if self.get_platform() == 'cygwin':
 203             self.announce('WARNING: skipping import check for Cygwin-based "%s"'
 204                 % ext.name)
 205             return
 206         ext_filename = os.path.join(
 207             self.build_lib,
 208             self.get_ext_filename(self.get_ext_fullname(ext.name)))
 209         try:
 210             imp.load_dynamic(ext.name, ext_filename)
 211         except ImportError, why:
 212             self.announce('*** WARNING: renaming "%s" since importing it'
 213                           ' failed: %s' % (ext.name, why), level=3)
 214             assert not self.inplace
 215             basename, tail = os.path.splitext(ext_filename)
 216             newname = basename + "_failed" + tail
 217             if os.path.exists(newname):
 218                 os.remove(newname)
 219             os.rename(ext_filename, newname)
 220
 221             # XXX -- This relies on a Vile HACK in
 222             # distutils.command.build_ext.build_extension().  The
 223             # _built_objects attribute is stored there strictly for
 224             # use here.
 225             # If there is a failure, _built_objects may not be there,
 226             # so catch the AttributeError and move on.
 227             try:
 228                 for filename in self._built_objects:
 229                     os.remove(filename)
 230             except AttributeError:
 231                 self.announce('unable to remove files (ignored)')
 232         except:
 233             exc_type, why, tb = sys.exc_info()
 234             self.announce('*** WARNING: importing extension "%s" '
 235                           'failed with %s: %s' % (ext.name, exc_type, why),
 236                           level=3)
 237
 238     def get_platform(self):
 239         # Get value of sys.platform
 240         for platform in ['cygwin', 'beos', 'darwin', 'atheos', 'osf1']:
 241             if sys.platform.startswith(platform):
 242                 return platform
 243         return sys.platform
 244
 245     def detect_modules(self):
 246         # Ensure that /usr/local is always used
 247         add_dir_to_list(self.compiler.library_dirs, '/usr/local/lib')
 248         add_dir_to_list(self.compiler.include_dirs, '/usr/local/include')
 249
 250         # Add paths specified in the environment variables LDFLAGS and
 251         # CPPFLAGS for header and library files.
 252         # We must get the values from the Makefile and not the environment
 253         # directly since an inconsistently reproducible issue comes up where
 254         # the environment variable is not set even though the value were passed
 255         # into configure and stored in the Makefile (issue found on OS X 10.3).
 256         for env_var, arg_name, dir_list in (
 257                 ('LDFLAGS', '-L', self.compiler.library_dirs),
 258                 ('CPPFLAGS', '-I', self.compiler.include_dirs)):
 259             env_val = sysconfig.get_config_var(env_var)
 260             if env_val:
 261                 # To prevent optparse from raising an exception about any
 262                 # options in env_val that is doesn't know about we strip out
 263                 # all double dashes and any dashes followed by a character
 264                 # that is not for the option we are dealing with.
 265                 #
 266                 # Please note that order of the regex is important!  We must
 267                 # strip out double-dashes first so that we don't end up with
 268                 # substituting "--Long" to "-Long" and thus lead to "ong" being
 269                 # used for a library directory.
 270                 env_val = re.sub(r'(^|\s+)-(-|(?!%s))' % arg_name[1], '', env_val)
 271                 parser = optparse.OptionParser()
 272                 # Make sure that allowing args interspersed with options is
 273                 # allowed
 274                 parser.allow_interspersed_args = True
 275                 parser.error = lambda msg: None
 276                 parser.add_option(arg_name, dest="dirs", action="append")
 277                 options = parser.parse_args(env_val.split())[0]
 278                 if options.dirs:
 279                     for directory in options.dirs:
 280                         add_dir_to_list(dir_list, directory)
 281
 282         if os.path.normpath(sys.prefix) != '/usr':
 283             add_dir_to_list(self.compiler.library_dirs,
 284                             sysconfig.get_config_var("LIBDIR"))
 285             add_dir_to_list(self.compiler.include_dirs,
 286                             sysconfig.get_config_var("INCLUDEDIR"))
 287
 288         try:
 289             have_unicode = unicode
 290         except NameError:
 291             have_unicode = 0
 292
 293         # lib_dirs and inc_dirs are used to search for files;
 294         # if a file is found in one of those directories, it can
 295         # be assumed that no additional -I,-L directives are needed.
 296         lib_dirs = self.compiler.library_dirs + [
 297             '/lib64', '/usr/lib64',
 298             '/lib', '/usr/lib',
 299             ]
 300         inc_dirs = self.compiler.include_dirs + ['/usr/include']
 301         exts = []
 302
 303         config_h = sysconfig.get_config_h_filename()
 304         config_h_vars = sysconfig.parse_config_h(open(config_h))
 305
 306         platform = self.get_platform()
 307         (srcdir,) = sysconfig.get_config_vars('srcdir')
 308
 309         # Check for AtheOS which has libraries in non-standard locations
 310         if platform == 'atheos':
 311             lib_dirs += ['/system/libs', '/atheos/autolnk/lib']
 312             lib_dirs += os.getenv('LIBRARY_PATH', '').split(os.pathsep)
 313             inc_dirs += ['/system/include', '/atheos/autolnk/include']
 314             inc_dirs += os.getenv('C_INCLUDE_PATH', '').split(os.pathsep)
 315
 316         # OSF/1 and Unixware have some stuff in /usr/ccs/lib (like -ldb)
 317         if platform in ['osf1', 'unixware7', 'openunix8']:
 318             lib_dirs += ['/usr/ccs/lib']
 319
 320         if platform == 'darwin':
 321             # This should work on any unixy platform ;-)
 322             # If the user has bothered specifying additional -I and -L flags
 323             # in OPT and LDFLAGS we might as well use them here.
 324             #   NOTE: using shlex.split would technically be more correct, but
 325             # also gives a bootstrap problem. Let's hope nobody uses directories
 326             # with whitespace in the name to store libraries.
 327             cflags, ldflags = sysconfig.get_config_vars(
 328                     'CFLAGS', 'LDFLAGS')
 329             for item in cflags.split():
 330                 if item.startswith('-I'):
 331                     inc_dirs.append(item[2:])
 332
 333             for item in ldflags.split():
 334                 if item.startswith('-L'):
 335                     lib_dirs.append(item[2:])
 336
 337         # Check for MacOS X, which doesn't need libm.a at all
 338         math_libs = ['m']
 339         if platform in ['darwin', 'beos', 'mac']:
 340             math_libs = []
 341
 342         # XXX Omitted modules: gl, pure, dl, SGI-specific modules
 343
 344         #
 345         # The following modules are all pretty straightforward, and compile
 346         # on pretty much any POSIXish platform.
 347         #
 348
 349         # Some modules that are normally always on:
 350         exts.append( Extension('_weakref', ['_weakref.c']) )
 351
 352         # array objects
 353         exts.append( Extension('array', ['arraymodule.c']) )
 354         # complex math library functions
 355         exts.append( Extension('cmath', ['cmathmodule.c'],
 356                                libraries=math_libs) )
 357
 358         # math library functions, e.g. sin()
 359         exts.append( Extension('math',  ['mathmodule.c'],
 360                                libraries=math_libs) )
 361         # fast string operations implemented in C
 362         exts.append( Extension('strop', ['stropmodule.c']) )
 363         # time operations and variables
 364         exts.append( Extension('time', ['timemodule.c'],
 365                                libraries=math_libs) )
 366         exts.append( Extension('datetime', ['datetimemodule.c', 'timemodule.c'],
 367                                libraries=math_libs) )
 368         # random number generator implemented in C
 369         exts.append( Extension("_random", ["_randommodule.c"]) )
 370         # fast iterator tools implemented in C
 371         exts.append( Extension("itertools", ["itertoolsmodule.c"]) )
 372         # high-performance collections
 373         exts.append( Extension("collections", ["collectionsmodule.c"]) )
 374         # bisect
 375         exts.append( Extension("_bisect", ["_bisectmodule.c"]) )
 376         # heapq
 377         exts.append( Extension("_heapq", ["_heapqmodule.c"]) )
 378         # operator.add() and similar goodies
 379         exts.append( Extension('operator', ['operator.c']) )
 380         # _functools
 381         exts.append( Extension("_functools", ["_functoolsmodule.c"]) )
 382         # Python C API test module
 383         exts.append( Extension('_testcapi', ['_testcapimodule.c']) )
 384         # profilers (_lsprof is for cProfile.py)
 385         exts.append( Extension('_hotshot', ['_hotshot.c']) )
 386         exts.append( Extension('_lsprof', ['_lsprof.c', 'rotatingtree.c']) )
 387         # static Unicode character database
 388         if have_unicode:
 389             exts.append( Extension('unicodedata', ['unicodedata.c']) )
 390         # access to ISO C locale support
 391         data = open('pyconfig.h').read()
 392         m = re.search(r"#s*define\s+WITH_LIBINTL\s+1\s*", data)
 393         if m is not None:
 394             locale_libs = ['intl']
 395         else:
 396             locale_libs = []
 397         if platform == 'darwin':
 398             locale_extra_link_args = ['-framework', 'CoreFoundation']
 399         else:
 400             locale_extra_link_args = []
 401
 402
 403         exts.append( Extension('_locale', ['_localemodule.c'],
 404                                libraries=locale_libs,
 405                                extra_link_args=locale_extra_link_args) )
 406
 407         # Modules with some UNIX dependencies -- on by default:
 408         # (If you have a really backward UNIX, select and socket may not be
 409         # supported...)
 410
 411         # fcntl(2) and ioctl(2)
 412         exts.append( Extension('fcntl', ['fcntlmodule.c']) )
 413         if platform not in ['mac']:
 414             # pwd(3)
 415             exts.append( Extension('pwd', ['pwdmodule.c']) )
 416             # grp(3)
 417             exts.append( Extension('grp', ['grpmodule.c']) )
 418             # spwd, shadow passwords
 419             if (config_h_vars.get('HAVE_GETSPNAM', False) or
 420                     config_h_vars.get('HAVE_GETSPENT', False)):
 421                 exts.append( Extension('spwd', ['spwdmodule.c']) )
 422         # select(2); not on ancient System V
 423         exts.append( Extension('select', ['selectmodule.c']) )
 424
 425         # Helper module for various ascii-encoders
 426         exts.append( Extension('binascii', ['binascii.c']) )
 427
 428         # Fred Drake's interface to the Python parser
 429         exts.append( Extension('parser', ['parsermodule.c']) )
 430
 431         # cStringIO and cPickle
 432         exts.append( Extension('cStringIO', ['cStringIO.c']) )
 433         exts.append( Extension('cPickle', ['cPickle.c']) )
 434
 435         # Memory-mapped files (also works on Win32).
 436         if platform not in ['atheos', 'mac']:
 437             exts.append( Extension('mmap', ['mmapmodule.c']) )
 438
 439         # Lance Ellinghaus's syslog module
 440         if platform not in ['mac']:
 441             # syslog daemon interface
 442             exts.append( Extension('syslog', ['syslogmodule.c']) )
 443
 444         # George Neville-Neil's timing module:
 445         # Deprecated in PEP 4 http://www.python.org/peps/pep-0004.html
 446         # http://mail.python.org/pipermail/python-dev/2006-January/060023.html
 447         #exts.append( Extension('timing', ['timingmodule.c']) )
 448
 449         #
 450         # Here ends the simple stuff.  From here on, modules need certain
 451         # libraries, are platform-specific, or present other surprises.
 452         #
 453
 454         # Multimedia modules
 455         # These don't work for 64-bit platforms!!!
 456         # These represent audio samples or images as strings:
 457
 458         # Operations on audio samples
 459         # According to #993173, this one should actually work fine on
 460         # 64-bit platforms.
 461         exts.append( Extension('audioop', ['audioop.c']) )
 462
 463         # Disabled on 64-bit platforms
 464         if sys.maxint != 9223372036854775807L:
 465             # Operations on images
 466             exts.append( Extension('imageop', ['imageop.c']) )
 467             # Read SGI RGB image files (but coded portably)
 468             exts.append( Extension('rgbimg', ['rgbimgmodule.c']) )
 469
 470         # readline
 471         do_readline = self.compiler.find_library_file(lib_dirs, 'readline')
 472         if platform == 'darwin':
 473             # MacOSX 10.4 has a broken readline. Don't try to build
 474             # the readline module unless the user has installed a fixed
 475             # readline package
 476             if find_file('readline/rlconf.h', inc_dirs, []) is None:
 477                 do_readline = False
 478         if do_readline:
 479             if sys.platform == 'darwin':
 480                 # In every directory on the search path search for a dynamic
 481                 # library and then a static library, instead of first looking
 482                 # for dynamic libraries on the entiry path.
 483                 # This way a staticly linked custom readline gets picked up
 484                 # before the (broken) dynamic library in /usr/lib.
 485                 readline_extra_link_args = ('-Wl,-search_paths_first',)
 486             else:
 487                 readline_extra_link_args = ()
 488
 489             readline_libs = ['readline']
 490             if self.compiler.find_library_file(lib_dirs,
 491                                                  'ncursesw'):
 492                 readline_libs.append('ncursesw')
 493             elif self.compiler.find_library_file(lib_dirs,
 494                                                  'ncurses'):
 495                 readline_libs.append('ncurses')
 496             elif self.compiler.find_library_file(lib_dirs, 'curses'):
 497                 readline_libs.append('curses')
 498             elif self.compiler.find_library_file(lib_dirs +
 499                                                ['/usr/lib/termcap'],
 500                                                'termcap'):
 501                 readline_libs.append('termcap')
 502             exts.append( Extension('readline', ['readline.c'],
 503                                    library_dirs=['/usr/lib/termcap'],
 504                                    extra_link_args=readline_extra_link_args,
 505                                    libraries=readline_libs) )
 506         if platform not in ['mac']:
 507             # crypt module.
 508
 509             if self.compiler.find_library_file(lib_dirs, 'crypt'):
 510                 libs = ['crypt']
 511             else:
 512                 libs = []
 513             exts.append( Extension('crypt', ['cryptmodule.c'], libraries=libs) )
 514
 515         # CSV files
 516         exts.append( Extension('_csv', ['_csv.c']) )
 517
 518         # socket(2)
 519         exts.append( Extension('_socket', ['socketmodule.c'],
 520                                depends = ['socketmodule.h']) )
 521         # Detect SSL support for the socket module (via _ssl)
 522         search_for_ssl_incs_in = [
 523                               '/usr/local/ssl/include',
 524                               '/usr/contrib/ssl/include/'
 525                              ]
 526         ssl_incs = find_file('openssl/ssl.h', inc_dirs,
 527                              search_for_ssl_incs_in
 528                              )
 529         if ssl_incs is not None:
 530             krb5_h = find_file('krb5.h', inc_dirs,
 531                                ['/usr/kerberos/include'])
 532             if krb5_h:
 533                 ssl_incs += krb5_h
 534         ssl_libs = find_library_file(self.compiler, 'ssl',lib_dirs,
 535                                      ['/usr/local/ssl/lib',
 536                                       '/usr/contrib/ssl/lib/'
 537                                      ] )
 538
 539         if (ssl_incs is not None and
 540             ssl_libs is not None):
 541             exts.append( Extension('_ssl', ['_ssl.c'],
 542                                    include_dirs = ssl_incs,
 543                                    library_dirs = ssl_libs,
 544                                    libraries = ['ssl', 'crypto'],
 545                                    depends = ['socketmodule.h']), )
 546
 547         # find out which version of OpenSSL we have
 548         openssl_ver = 0
 549         openssl_ver_re = re.compile(
 550             '^\s*#\s*define\s+OPENSSL_VERSION_NUMBER\s+(0x[0-9a-fA-F]+)' )
 551         for ssl_inc_dir in inc_dirs + search_for_ssl_incs_in:
 552             name = os.path.join(ssl_inc_dir, 'openssl', 'opensslv.h')
 553             if os.path.isfile(name):
 554                 try:
 555                     incfile = open(name, 'r')
 556                     for line in incfile:
 557                         m = openssl_ver_re.match(line)
 558                         if m:
 559                             openssl_ver = eval(m.group(1))
 560                             break
 561                 except IOError:
 562                     pass
 563
 564             # first version found is what we'll use (as the compiler should)
 565             if openssl_ver:
 566                 break
 567
 568         #print 'openssl_ver = 0x%08x' % openssl_ver
 569
 570         if (ssl_incs is not None and
 571             ssl_libs is not None and
 572             openssl_ver >= 0x00907000):
 573             # The _hashlib module wraps optimized implementations
 574             # of hash functions from the OpenSSL library.
 575             exts.append( Extension('_hashlib', ['_hashopenssl.c'],
 576                                    include_dirs = ssl_incs,
 577                                    library_dirs = ssl_libs,
 578                                    libraries = ['ssl', 'crypto']) )
 579         else:
 580             # The _sha module implements the SHA1 hash algorithm.
 581             exts.append( Extension('_sha', ['shamodule.c']) )
 582             # The _md5 module implements the RSA Data Security, Inc. MD5
 583             # Message-Digest Algorithm, described in RFC 1321.  The
 584             # necessary files md5.c and md5.h are included here.
 585             exts.append( Extension('_md5', ['md5module.c', 'md5.c']) )
 586
 587         if (openssl_ver < 0x00908000):
 588             # OpenSSL doesn't do these until 0.9.8 so we'll bring our own hash
 589             exts.append( Extension('_sha256', ['sha256module.c']) )
 590             exts.append( Extension('_sha512', ['sha512module.c']) )
 591
 592
 593         # Modules that provide persistent dictionary-like semantics.  You will
 594         # probably want to arrange for at least one of them to be available on
 595         # your machine, though none are defined by default because of library
 596         # dependencies.  The Python module anydbm.py provides an
 597         # implementation independent wrapper for these; dumbdbm.py provides
 598         # similar functionality (but slower of course) implemented in Python.
 599
 600         # Sleepycat Berkeley DB interface.  http://www.sleepycat.com
 601         #
 602         # This requires the Sleepycat DB code. The supported versions
 603         # are set below.  Visit http://www.sleepycat.com/ to download
 604         # a release.  Most open source OSes come with one or more
 605         # versions of BerkeleyDB already installed.
 606
 607         max_db_ver = (4, 4)
 608         min_db_ver = (3, 3)
 609         db_setup_debug = False   # verbose debug prints from this script?
 610
 611         # construct a list of paths to look for the header file in on
 612         # top of the normal inc_dirs.
 613         db_inc_paths = [
 614             '/usr/include/db4',
 615             '/usr/local/include/db4',
 616             '/opt/sfw/include/db4',
 617             '/sw/include/db4',
 618             '/usr/include/db3',
 619             '/usr/local/include/db3',
 620             '/opt/sfw/include/db3',
 621             '/sw/include/db3',
 622         ]
 623         # 4.x minor number specific paths
 624         for x in (0,1,2,3,4):
 625             db_inc_paths.append('/usr/include/db4%d' % x)
 626             db_inc_paths.append('/usr/include/db4.%d' % x)
 627             db_inc_paths.append('/usr/local/BerkeleyDB.4.%d/include' % x)
 628             db_inc_paths.append('/usr/local/include/db4%d' % x)
 629             db_inc_paths.append('/pkg/db-4.%d/include' % x)
 630             db_inc_paths.append('/opt/db-4.%d/include' % x)
 631         # 3.x minor number specific paths
 632         for x in (2,3):
 633             db_inc_paths.append('/usr/include/db3%d' % x)
 634             db_inc_paths.append('/usr/local/BerkeleyDB.3.%d/include' % x)
 635             db_inc_paths.append('/usr/local/include/db3%d' % x)
 636             db_inc_paths.append('/pkg/db-3.%d/include' % x)
 637             db_inc_paths.append('/opt/db-3.%d/include' % x)
 638
 639         db_ver_inc_map = {}
 640
 641         class db_found(Exception): pass
 642         try:
 643             # See whether there is a Sleepycat header in the standard
 644             # search path.
 645             for d in inc_dirs + db_inc_paths:
 646                 f = os.path.join(d, "db.h")
 647                 if db_setup_debug: print "db: looking for db.h in", f
 648                 if os.path.exists(f):
 649                     f = open(f).read()
 650                     m = re.search(r"#define\WDB_VERSION_MAJOR\W(\d+)", f)
 651                     if m:
 652                         db_major = int(m.group(1))
 653                         m = re.search(r"#define\WDB_VERSION_MINOR\W(\d+)", f)
 654                         db_minor = int(m.group(1))
 655                         db_ver = (db_major, db_minor)
 656
 657                         if ( (not db_ver_inc_map.has_key(db_ver)) and
 658                            (db_ver <= max_db_ver and db_ver >= min_db_ver) ):
 659                             # save the include directory with the db.h version
 660                             # (first occurrance only)
 661                             db_ver_inc_map[db_ver] = d
 662                             print "db.h: found", db_ver, "in", d
 663                         else:
 664                             # we already found a header for this library version
 665                             if db_setup_debug: print "db.h: ignoring", d
 666                     else:
 667                         # ignore this header, it didn't contain a version number
 668                         if db_setup_debug: print "db.h: unsupported version", db_ver, "in", d
 669
 670             db_found_vers = db_ver_inc_map.keys()
 671             db_found_vers.sort()
 672
 673             while db_found_vers:
 674                 db_ver = db_found_vers.pop()
 675                 db_incdir = db_ver_inc_map[db_ver]
 676
 677                 # check lib directories parallel to the location of the header
 678                 db_dirs_to_check = [
 679                     os.path.join(db_incdir, '..', 'lib64'),
 680                     os.path.join(db_incdir, '..', 'lib'),
 681                     os.path.join(db_incdir, '..', '..', 'lib64'),
 682                     os.path.join(db_incdir, '..', '..', 'lib'),
 683                 ]
 684                 db_dirs_to_check = filter(os.path.isdir, db_dirs_to_check)
 685
 686                 # Look for a version specific db-X.Y before an ambiguoius dbX
 687                 # XXX should we -ever- look for a dbX name?  Do any
 688                 # systems really not name their library by version and
 689                 # symlink to more general names?
 690                 for dblib in (('db-%d.%d' % db_ver),
 691                               ('db%d%d' % db_ver),
 692                               ('db%d' % db_ver[0])):
 693                     dblib_file = self.compiler.find_library_file(
 694                                     db_dirs_to_check + lib_dirs, dblib )
 695                     if dblib_file:
 696                         dblib_dir = [ os.path.abspath(os.path.dirname(dblib_file)) ]
 697                         raise db_found
 698                     else:
 699                         if db_setup_debug: print "db lib: ", dblib, "not found"
 700
 701         except db_found:
 702             print "db lib: using", db_ver, dblib
 703             if db_setup_debug: print "db: lib dir", dblib_dir, "inc dir", db_incdir
 704             db_incs = [db_incdir]
 705             dblibs = [dblib]
 706             # We add the runtime_library_dirs argument because the
 707             # BerkeleyDB lib we're linking against often isn't in the
 708             # system dynamic library search path.  This is usually
 709             # correct and most trouble free, but may cause problems in
 710             # some unusual system configurations (e.g. the directory
 711             # is on an NFS server that goes away).
 712             exts.append(Extension('_bsddb', ['_bsddb.c'],
 713                                   library_dirs=dblib_dir,
 714                                   runtime_library_dirs=dblib_dir,
 715                                   include_dirs=db_incs,
 716                                   libraries=dblibs))
 717         else:
 718             if db_setup_debug: print "db: no appropriate library found"
 719             db_incs = None
 720             dblibs = []
 721             dblib_dir = None
 722
 723         # The sqlite interface
 724         sqlite_setup_debug = True   # verbose debug prints from this script?
 725
 726         # We hunt for #define SQLITE_VERSION "n.n.n"
 727         # We need to find >= sqlite version 3.0.8
 728         sqlite_incdir = sqlite_libdir = None
 729         sqlite_inc_paths = [ '/usr/include',
 730                              '/usr/include/sqlite',
 731                              '/usr/include/sqlite3',
 732                              '/usr/local/include',
 733                              '/usr/local/include/sqlite',
 734                              '/usr/local/include/sqlite3',
 735                            ]
 736         MIN_SQLITE_VERSION_NUMBER = (3, 0, 8)
 737         MIN_SQLITE_VERSION = ".".join([str(x)
 738                                     for x in MIN_SQLITE_VERSION_NUMBER])
 739
 740         # Scan the default include directories before the SQLite specific
 741         # ones. This allows one to override the copy of sqlite on OSX,
 742         # where /usr/include contains an old version of sqlite.
 743         for d in inc_dirs + sqlite_inc_paths:
 744             f = os.path.join(d, "sqlite3.h")
 745             if os.path.exists(f):
 746                 if sqlite_setup_debug: print "sqlite: found %s"%f
 747                 incf = open(f).read()
 748                 m = re.search(
 749                     r'\s*.*#\s*.*define\s.*SQLITE_VERSION\W*"(.*)"', incf)
 750                 if m:
 751                     sqlite_version = m.group(1)
 752                     sqlite_version_tuple = tuple([int(x)
 753                                         for x in sqlite_version.split(".")])
 754                     if sqlite_version_tuple >= MIN_SQLITE_VERSION_NUMBER:
 755                         # we win!
 756                         print "%s/sqlite3.h: version %s"%(d, sqlite_version)
 757                         sqlite_incdir = d
 758                         break
 759                     else:
 760                         if sqlite_setup_debug:
 761                             print "%s: version %d is too old, need >= %s"%(d,
 762                                         sqlite_version, MIN_SQLITE_VERSION)
 763                 elif sqlite_setup_debug:
 764                     print "sqlite: %s had no SQLITE_VERSION"%(f,)
 765
 766         if sqlite_incdir:
 767             sqlite_dirs_to_check = [
 768                 os.path.join(sqlite_incdir, '..', 'lib64'),
 769                 os.path.join(sqlite_incdir, '..', 'lib'),
 770                 os.path.join(sqlite_incdir, '..', '..', 'lib64'),
 771                 os.path.join(sqlite_incdir, '..', '..', 'lib'),
 772             ]
 773             sqlite_libfile = self.compiler.find_library_file(
 774                                 sqlite_dirs_to_check + lib_dirs, 'sqlite3')
 775             sqlite_libdir = [os.path.abspath(os.path.dirname(sqlite_libfile))]
 776
 777         if sqlite_incdir and sqlite_libdir:
 778             sqlite_srcs = ['_sqlite/cache.c',
 779                 '_sqlite/connection.c',
 780                 '_sqlite/cursor.c',
 781                 '_sqlite/microprotocols.c',
 782                 '_sqlite/module.c',
 783                 '_sqlite/prepare_protocol.c',
 784                 '_sqlite/row.c',
 785                 '_sqlite/statement.c',
 786                 '_sqlite/util.c', ]
 787
 788             sqlite_defines = []
 789             if sys.platform != "win32":
 790                 sqlite_defines.append(('MODULE_NAME', '"sqlite3"'))
 791             else:
 792                 sqlite_defines.append(('MODULE_NAME', '\\"sqlite3\\"'))
 793
 794
 795             if sys.platform == 'darwin':
 796                 # In every directory on the search path search for a dynamic
 797                 # library and then a static library, instead of first looking
 798                 # for dynamic libraries on the entiry path.
 799                 # This way a staticly linked custom sqlite gets picked up
 800                 # before the dynamic library in /usr/lib.
 801                 sqlite_extra_link_args = ('-Wl,-search_paths_first',)
 802             else:
 803                 sqlite_extra_link_args = ()
 804
 805             exts.append(Extension('_sqlite3', sqlite_srcs,
 806                                   define_macros=sqlite_defines,
 807                                   include_dirs=["Modules/_sqlite",
 808                                                 sqlite_incdir],
 809                                   library_dirs=sqlite_libdir,
 810                                   runtime_library_dirs=sqlite_libdir,
 811                                   extra_link_args=sqlite_extra_link_args,
 812                                   libraries=["sqlite3",]))
 813
 814         # Look for Berkeley db 1.85.   Note that it is built as a different
 815         # module name so it can be included even when later versions are
 816         # available.  A very restrictive search is performed to avoid
 817         # accidentally building this module with a later version of the
 818         # underlying db library.  May BSD-ish Unixes incorporate db 1.85
 819         # symbols into libc and place the include file in /usr/include.
 820         f = "/usr/include/db.h"
 821         if os.path.exists(f):
 822             data = open(f).read()
 823             m = re.search(r"#s*define\s+HASHVERSION\s+2\s*", data)
 824             if m is not None:
 825                 # bingo - old version used hash file format version 2
 826                 ### XXX this should be fixed to not be platform-dependent
 827                 ### but I don't have direct access to an osf1 platform and
 828                 ### seemed to be muffing the search somehow
 829                 libraries = platform == "osf1" and ['db'] or None
 830                 if libraries is not None:
 831                     exts.append(Extension('bsddb185', ['bsddbmodule.c'],
 832                                           libraries=libraries))
 833                 else:
 834                     exts.append(Extension('bsddb185', ['bsddbmodule.c']))
 835
 836         # The standard Unix dbm module:
 837         if platform not in ['cygwin']:
 838             if find_file("ndbm.h", inc_dirs, []) is not None:
 839                 # Some systems have -lndbm, others don't
 840                 if self.compiler.find_library_file(lib_dirs, 'ndbm'):
 841                     ndbm_libs = ['ndbm']
 842                 else:
 843                     ndbm_libs = []
 844                 exts.append( Extension('dbm', ['dbmmodule.c'],
 845                                        define_macros=[('HAVE_NDBM_H',None)],
 846                                        libraries = ndbm_libs ) )
 847             elif (self.compiler.find_library_file(lib_dirs, 'gdbm')
 848                   and find_file("gdbm/ndbm.h", inc_dirs, []) is not None):
 849                 exts.append( Extension('dbm', ['dbmmodule.c'],
 850                                        define_macros=[('HAVE_GDBM_NDBM_H',None)],
 851                                        libraries = ['gdbm'] ) )
 852             elif db_incs is not None:
 853                 exts.append( Extension('dbm', ['dbmmodule.c'],
 854                                        library_dirs=dblib_dir,
 855                                        runtime_library_dirs=dblib_dir,
 856                                        include_dirs=db_incs,
 857                                        define_macros=[('HAVE_BERKDB_H',None),
 858                                                       ('DB_DBM_HSEARCH',None)],
 859                                        libraries=dblibs))
 860
 861         # Anthony Baxter's gdbm module.  GNU dbm(3) will require -lgdbm:
 862         if (self.compiler.find_library_file(lib_dirs, 'gdbm')):
 863             exts.append( Extension('gdbm', ['gdbmmodule.c'],
 864                                    libraries = ['gdbm'] ) )
 865
 866         # Unix-only modules
 867         if platform not in ['mac', 'win32']:
 868             # Steen Lumholt's termios module
 869             exts.append( Extension('termios', ['termios.c']) )
 870             # Jeremy Hylton's rlimit interface
 871             if platform not in ['atheos']:
 872                 exts.append( Extension('resource', ['resource.c']) )
 873
 874             # Sun yellow pages. Some systems have the functions in libc.
 875             if platform not in ['cygwin', 'atheos']:
 876                 if (self.compiler.find_library_file(lib_dirs, 'nsl')):
 877                     libs = ['nsl']
 878                 else:
 879                     libs = []
 880                 exts.append( Extension('nis', ['nismodule.c'],
 881                                        libraries = libs) )
 882
 883         # Curses support, requiring the System V version of curses, often
 884         # provided by the ncurses library.
 885         if (self.compiler.find_library_file(lib_dirs, 'ncursesw')):
 886             curses_libs = ['ncursesw']
 887             exts.append( Extension('_curses', ['_cursesmodule.c'],
 888                                    libraries = curses_libs) )
 889         elif (self.compiler.find_library_file(lib_dirs, 'ncurses')):
 890             curses_libs = ['ncurses']
 891             exts.append( Extension('_curses', ['_cursesmodule.c'],
 892                                    libraries = curses_libs) )
 893         elif (self.compiler.find_library_file(lib_dirs, 'curses')
 894               and platform != 'darwin'):
 895                 # OSX has an old Berkeley curses, not good enough for
 896                 # the _curses module.
 897             if (self.compiler.find_library_file(lib_dirs, 'terminfo')):
 898                 curses_libs = ['curses', 'terminfo']
 899             elif (self.compiler.find_library_file(lib_dirs, 'termcap')):
 900                 curses_libs = ['curses', 'termcap']
 901             else:
 902                 curses_libs = ['curses']
 903
 904             exts.append( Extension('_curses', ['_cursesmodule.c'],
 905                                    libraries = curses_libs) )
 906
 907         # If the curses module is enabled, check for the panel module
 908         if (module_enabled(exts, '_curses') and
 909             self.compiler.find_library_file(lib_dirs, 'panel')):
 910             exts.append( Extension('_curses_panel', ['_curses_panel.c'],
 911                                    libraries = ['panel'] + curses_libs) )
 912
 913
 914         # Andrew Kuchling's zlib module.  Note that some versions of zlib
 915         # 1.1.3 have security problems.  See CERT Advisory CA-2002-07:
 916         # http://www.cert.org/advisories/CA-2002-07.html
 917         #
 918         # zlib 1.1.4 is fixed, but at least one vendor (RedHat) has decided to
 919         # patch its zlib 1.1.3 package instead of upgrading to 1.1.4.  For
 920         # now, we still accept 1.1.3, because we think it's difficult to
 921         # exploit this in Python, and we'd rather make it RedHat's problem
 922         # than our problem <wink>.
 923         #
 924         # You can upgrade zlib to version 1.1.4 yourself by going to
 925         # http://www.gzip.org/zlib/
 926         zlib_inc = find_file('zlib.h', [], inc_dirs)
 927         if zlib_inc is not None:
 928             zlib_h = zlib_inc[0] + '/zlib.h'
 929             version = '"0.0.0"'
 930             version_req = '"1.1.3"'
 931             fp = open(zlib_h)
 932             while 1:
 933                 line = fp.readline()
 934                 if not line:
 935                     break
 936                 if line.startswith('#define ZLIB_VERSION'):
 937                     version = line.split()[2]
 938                     break
 939             if version >= version_req:
 940                 if (self.compiler.find_library_file(lib_dirs, 'z')):
 941                     exts.append( Extension('zlib', ['zlibmodule.c'],
 942                                            libraries = ['z']) )
 943
 944         # Gustavo Niemeyer's bz2 module.
 945         if (self.compiler.find_library_file(lib_dirs, 'bz2')):
 946             exts.append( Extension('bz2', ['bz2module.c'],
 947                                    libraries = ['bz2']) )
 948
 949         # Interface to the Expat XML parser
 950         #
 951         # Expat was written by James Clark and is now maintained by a
 952         # group of developers on SourceForge; see www.libexpat.org for
 953         # more information.  The pyexpat module was written by Paul
 954         # Prescod after a prototype by Jack Jansen.  The Expat source
 955         # is included in Modules/expat/.  Usage of a system
 956         # shared libexpat.so/expat.dll is not advised.
 957         #
 958         # More information on Expat can be found at www.libexpat.org.
 959         #
 960         expatinc = os.path.join(os.getcwd(), srcdir, 'Modules', 'expat')
 961         define_macros = [
 962             ('HAVE_EXPAT_CONFIG_H', '1'),
 963         ]
 964
 965         exts.append(Extension('pyexpat',
 966                               define_macros = define_macros,
 967                               include_dirs = [expatinc],
 968                               sources = ['pyexpat.c',
 969                                          'expat/xmlparse.c',
 970                                          'expat/xmlrole.c',
 971                                          'expat/xmltok.c',
 972                                          ],
 973                               ))
 974
 975         # Fredrik Lundh's cElementTree module.  Note that this also
 976         # uses expat (via the CAPI hook in pyexpat).
 977
 978         if os.path.isfile(os.path.join(srcdir, 'Modules', '_elementtree.c')):
 979             define_macros.append(('USE_PYEXPAT_CAPI', None))
 980             exts.append(Extension('_elementtree',
 981                                   define_macros = define_macros,
 982                                   include_dirs = [expatinc],
 983                                   sources = ['_elementtree.c'],
 984                                   ))
 985
 986         # Hye-Shik Chang's CJKCodecs modules.
 987         if have_unicode:
 988             exts.append(Extension('_multibytecodec',
 989                                   ['cjkcodecs/multibytecodec.c']))
 990             for loc in ('kr', 'jp', 'cn', 'tw', 'hk', 'iso2022'):
 991                 exts.append(Extension('_codecs_' + loc,
 992                                       ['cjkcodecs/_codecs_%s.c' % loc]))
 993
 994         # Dynamic loading module
 995         if sys.maxint == 0x7fffffff:
 996             # This requires sizeof(int) == sizeof(long) == sizeof(char*)
 997             dl_inc = find_file('dlfcn.h', [], inc_dirs)
 998             if (dl_inc is not None) and (platform not in ['atheos']):
 999                 exts.append( Extension('dl', ['dlmodule.c']) )
1000
1001         # Thomas Heller's _ctypes module
1002         self.detect_ctypes(inc_dirs, lib_dirs)
1003
1004         # Platform-specific libraries
1005         if platform == 'linux2':
1006             # Linux-specific modules
1007             exts.append( Extension('linuxaudiodev', ['linuxaudiodev.c']) )
1008
1009         if platform in ('linux2', 'freebsd4', 'freebsd5', 'freebsd6',
1010                         'freebsd7'):
1011             exts.append( Extension('ossaudiodev', ['ossaudiodev.c']) )
1012
1013         if platform == 'sunos5':
1014             # SunOS specific modules
1015             exts.append( Extension('sunaudiodev', ['sunaudiodev.c']) )
1016
1017         if platform == 'darwin' and ("--disable-toolbox-glue" not in
1018                 sysconfig.get_config_var("CONFIG_ARGS")):
1019
1020             if os.uname()[2] > '8.':
1021                 # We're on Mac OS X 10.4 or later, the compiler should
1022                 # support '-Wno-deprecated-declarations'. This will
1023                 # surpress deprecation warnings for the Carbon extensions,
1024                 # these extensions wrap the Carbon APIs and even those
1025                 # parts that are deprecated.
1026                 carbon_extra_compile_args = ['-Wno-deprecated-declarations']
1027             else:
1028                 carbon_extra_compile_args = []
1029
1030             # Mac OS X specific modules.
1031             def macSrcExists(name1, name2=''):
1032                 if not name1:
1033                     return None
1034                 names = (name1,)
1035                 if name2:
1036                     names = (name1, name2)
1037                 path = os.path.join(srcdir, 'Mac', 'Modules', *names)
1038                 return os.path.exists(path)
1039
1040             def addMacExtension(name, kwds, extra_srcs=[]):
1041                 dirname = ''
1042                 if name[0] == '_':
1043                     dirname = name[1:].lower()
1044                 cname = name + '.c'
1045                 cmodulename = name + 'module.c'
1046                 # Check for NNN.c, NNNmodule.c, _nnn/NNN.c, _nnn/NNNmodule.c
1047                 if macSrcExists(cname):
1048                     srcs = [cname]
1049                 elif macSrcExists(cmodulename):
1050                     srcs = [cmodulename]
1051                 elif macSrcExists(dirname, cname):
1052                     # XXX(nnorwitz): If all the names ended with module, we
1053                     # wouldn't need this condition.  ibcarbon is the only one.
1054                     srcs = [os.path.join(dirname, cname)]
1055                 elif macSrcExists(dirname, cmodulename):
1056                     srcs = [os.path.join(dirname, cmodulename)]
1057                 else:
1058                     raise RuntimeError("%s not found" % name)
1059
1060                 # Here's the whole point:  add the extension with sources
1061                 exts.append(Extension(name, srcs + extra_srcs, **kwds))
1062
1063             # Core Foundation
1064             core_kwds = {'extra_compile_args': carbon_extra_compile_args,
1065                          'extra_link_args': ['-framework', 'CoreFoundation'],
1066                         }
1067             addMacExtension('_CF', core_kwds, ['cf/pycfbridge.c'])
1068             addMacExtension('autoGIL', core_kwds)
1069
1070             # Carbon
1071             carbon_kwds = {'extra_compile_args': carbon_extra_compile_args,
1072                            'extra_link_args': ['-framework', 'Carbon'],
1073                           }
1074             CARBON_EXTS = ['ColorPicker', 'gestalt', 'MacOS', 'Nav',
1075                            'OSATerminology', 'icglue',
1076                            # All these are in subdirs
1077                            '_AE', '_AH', '_App', '_CarbonEvt', '_Cm', '_Ctl',
1078                            '_Dlg', '_Drag', '_Evt', '_File', '_Folder', '_Fm',
1079                            '_Help', '_Icn', '_IBCarbon', '_List',
1080                            '_Menu', '_Mlte', '_OSA', '_Res', '_Qd', '_Qdoffs',
1081                            '_Scrap', '_Snd', '_TE', '_Win',
1082                           ]
1083             for name in CARBON_EXTS:
1084                 addMacExtension(name, carbon_kwds)
1085
1086             # Application Services & QuickTime
1087             app_kwds = {'extra_compile_args': carbon_extra_compile_args,
1088                         'extra_link_args': ['-framework','ApplicationServices'],
1089                        }
1090             addMacExtension('_Launch', app_kwds)
1091             addMacExtension('_CG', app_kwds)
1092
1093             exts.append( Extension('_Qt', ['qt/_Qtmodule.c'],
1094                         extra_compile_args=carbon_extra_compile_args,
1095                         extra_link_args=['-framework', 'QuickTime',
1096                                      '-framework', 'Carbon']) )
1097
1098             # As there is no standardized place (yet) to put
1099             # user-installed Mac libraries on OSX, we search for "waste"
1100             # in parent directories of the Python source tree. You
1101             # should put a symlink to your Waste installation in the
1102             # same folder as your python source tree.  Or modify the
1103             # next few lines:-)
1104             waste_incs = find_file("WASTE.h", [],
1105                     ['../'*n + 'waste/C_C++ Headers' for n in (0,1,2,3,4)])
1106             waste_libs = find_library_file(self.compiler, "WASTE", [],
1107                     ["../"*n + "waste/Static Libraries" for n in (0,1,2,3,4)])
1108             if waste_incs != None and waste_libs != None:
1109                 exts.append( Extension('waste',
1110                                ['waste/wastemodule.c'] + [
1111                                 os.path.join(srcdir, d) for d in
1112                                 'Mac/Wastemods/WEObjectHandlers.c',
1113                                 'Mac/Wastemods/WETabHooks.c',
1114                                 'Mac/Wastemods/WETabs.c'
1115                                ],
1116                                include_dirs = waste_incs + [os.path.join(srcdir, 'Mac/Wastemods')],
1117                                library_dirs = waste_libs,
1118                                libraries = ['WASTE'],
1119                                extra_link_args = ['-framework', 'Carbon'],
1120                 ) )
1121
1122         self.extensions.extend(exts)
1123
1124         # Call the method for detecting whether _tkinter can be compiled
1125         self.detect_tkinter(inc_dirs, lib_dirs)
1126
1127     def detect_tkinter_darwin(self, inc_dirs, lib_dirs):
1128         # The _tkinter module, using frameworks. Since frameworks are quite
1129         # different the UNIX search logic is not sharable.
1130         from os.path import join, exists
1131         framework_dirs = [
1132             '/System/Library/Frameworks/',
1133             '/Library/Frameworks',
1134             join(os.getenv('HOME'), '/Library/Frameworks')
1135         ]
1136
1137         # Find the directory that contains the Tcl.framework and Tk.framework
1138         # bundles.
1139         # XXX distutils should support -F!
1140         for F in framework_dirs:
1141             # both Tcl.framework and Tk.framework should be present
1142             for fw in 'Tcl', 'Tk':
1143                 if not exists(join(F, fw + '.framework')):
1144                     break
1145             else:
1146                 # ok, F is now directory with both frameworks. Continure
1147                 # building
1148                 break
1149         else:
1150             # Tk and Tcl frameworks not found. Normal "unix" tkinter search
1151             # will now resume.
1152             return 0
1153
1154         # For 8.4a2, we must add -I options that point inside the Tcl and Tk
1155         # frameworks. In later release we should hopefully be able to pass
1156         # the -F option to gcc, which specifies a framework lookup path.
1157         #
1158         include_dirs = [
1159             join(F, fw + '.framework', H)
1160             for fw in 'Tcl', 'Tk'
1161             for H in 'Headers', 'Versions/Current/PrivateHeaders'
1162         ]
1163
1164         # For 8.4a2, the X11 headers are not included. Rather than include a
1165         # complicated search, this is a hard-coded path. It could bail out
1166         # if X11 libs are not found...
1167         include_dirs.append('/usr/X11R6/include')
1168         frameworks = ['-framework', 'Tcl', '-framework', 'Tk']
1169
1170         ext = Extension('_tkinter', ['_tkinter.c', 'tkappinit.c'],
1171                         define_macros=[('WITH_APPINIT', 1)],
1172                         include_dirs = include_dirs,
1173                         libraries = [],
1174                         extra_compile_args = frameworks,
1175                         extra_link_args = frameworks,
1176                         )
1177         self.extensions.append(ext)
1178         return 1
1179
1180
1181     def detect_tkinter(self, inc_dirs, lib_dirs):
1182         # The _tkinter module.
1183
1184         # Rather than complicate the code below, detecting and building
1185         # AquaTk is a separate method. Only one Tkinter will be built on
1186         # Darwin - either AquaTk, if it is found, or X11 based Tk.
1187         platform = self.get_platform()
1188         if (platform == 'darwin' and
1189             self.detect_tkinter_darwin(inc_dirs, lib_dirs)):
1190             return
1191
1192         # Assume we haven't found any of the libraries or include files
1193         # The versions with dots are used on Unix, and the versions without
1194         # dots on Windows, for detection by cygwin.
1195         tcllib = tklib = tcl_includes = tk_includes = None
1196         for version in ['8.5', '85', '8.4', '84', '8.3', '83', '8.2',
1197                         '82', '8.1', '81', '8.0', '80']:
1198             tklib = self.compiler.find_library_file(lib_dirs, 'tk' + version)
1199             tcllib = self.compiler.find_library_file(lib_dirs, 'tcl' + version)
1200             if tklib and tcllib:
1201                 # Exit the loop when we've found the Tcl/Tk libraries
1202                 break
1203
1204         # Now check for the header files
1205         if tklib and tcllib:
1206             # Check for the include files on Debian and {Free,Open}BSD, where
1207             # they're put in /usr/include/{tcl,tk}X.Y
1208             dotversion = version
1209             if '.' not in dotversion and "bsd" in sys.platform.lower():
1210                 # OpenBSD and FreeBSD use Tcl/Tk library names like libtcl83.a,
1211                 # but the include subdirs are named like .../include/tcl8.3.
1212                 dotversion = dotversion[:-1] + '.' + dotversion[-1]
1213             tcl_include_sub = []
1214             tk_include_sub = []
1215             for dir in inc_dirs:
1216                 tcl_include_sub += [dir + os.sep + "tcl" + dotversion]
1217                 tk_include_sub += [dir + os.sep + "tk" + dotversion]
1218             tk_include_sub += tcl_include_sub
1219             tcl_includes = find_file('tcl.h', inc_dirs, tcl_include_sub)
1220             tk_includes = find_file('tk.h', inc_dirs, tk_include_sub)
1221
1222         if (tcllib is None or tklib is None or
1223             tcl_includes is None or tk_includes is None):
1224             self.announce("INFO: Can't locate Tcl/Tk libs and/or headers", 2)
1225             return
1226
1227         # OK... everything seems to be present for Tcl/Tk.
1228
1229         include_dirs = [] ; libs = [] ; defs = [] ; added_lib_dirs = []
1230         for dir in tcl_includes + tk_includes:
1231             if dir not in include_dirs:
1232                 include_dirs.append(dir)
1233
1234         # Check for various platform-specific directories
1235         if platform == 'sunos5':
1236             include_dirs.append('/usr/openwin/include')
1237             added_lib_dirs.append('/usr/openwin/lib')
1238         elif os.path.exists('/usr/X11R6/include'):
1239             include_dirs.append('/usr/X11R6/include')
1240             added_lib_dirs.append('/usr/X11R6/lib64')
1241             added_lib_dirs.append('/usr/X11R6/lib')
1242         elif os.path.exists('/usr/X11R5/include'):
1243             include_dirs.append('/usr/X11R5/include')
1244             added_lib_dirs.append('/usr/X11R5/lib')
1245         else:
1246             # Assume default location for X11
1247             include_dirs.append('/usr/X11/include')
1248             added_lib_dirs.append('/usr/X11/lib')
1249
1250         # If Cygwin, then verify that X is installed before proceeding
1251         if platform == 'cygwin':
1252             x11_inc = find_file('X11/Xlib.h', [], include_dirs)
1253             if x11_inc is None:
1254                 return
1255
1256         # Check for BLT extension
1257         if self.compiler.find_library_file(lib_dirs + added_lib_dirs,
1258                                            'BLT8.0'):
1259             defs.append( ('WITH_BLT', 1) )
1260             libs.append('BLT8.0')
1261         elif self.compiler.find_library_file(lib_dirs + added_lib_dirs,
1262                                            'BLT'):
1263             defs.append( ('WITH_BLT', 1) )
1264             libs.append('BLT')
1265
1266         # Add the Tcl/Tk libraries
1267         libs.append('tk'+ version)
1268         libs.append('tcl'+ version)
1269
1270         if platform in ['aix3', 'aix4']:
1271             libs.append('ld')
1272
1273         # Finally, link with the X11 libraries (not appropriate on cygwin)
1274         if platform != "cygwin":
1275             libs.append('X11')
1276
1277         ext = Extension('_tkinter', ['_tkinter.c', 'tkappinit.c'],
1278                         define_macros=[('WITH_APPINIT', 1)] + defs,
1279                         include_dirs = include_dirs,
1280                         libraries = libs,
1281                         library_dirs = added_lib_dirs,
1282                         )
1283         self.extensions.append(ext)
1284
1285 ##         # Uncomment these lines if you want to play with xxmodule.c
1286 ##         ext = Extension('xx', ['xxmodule.c'])
1287 ##         self.extensions.append(ext)
1288
1289         # XXX handle these, but how to detect?
1290         # *** Uncomment and edit for PIL (TkImaging) extension only:
1291         #       -DWITH_PIL -I../Extensions/Imaging/libImaging  tkImaging.c \
1292         # *** Uncomment and edit for TOGL extension only:
1293         #       -DWITH_TOGL togl.c \
1294         # *** Uncomment these for TOGL extension only:
1295         #       -lGL -lGLU -lXext -lXmu \
1296
1297     def configure_ctypes(self, ext):
1298         if not self.use_system_libffi:
1299             (srcdir,) = sysconfig.get_config_vars('srcdir')
1300             ffi_builddir = os.path.join(self.build_temp, 'libffi')
1301             ffi_srcdir = os.path.abspath(os.path.join(srcdir, 'Modules',
1302                                          '_ctypes', 'libffi'))
1303             ffi_configfile = os.path.join(ffi_builddir, 'fficonfig.py')
1304
1305             from distutils.dep_util import newer_group
1306
1307             config_sources = [os.path.join(ffi_srcdir, fname)
1308                               for fname in os.listdir(ffi_srcdir)]
1309             if self.force or newer_group(config_sources,
1310                                          ffi_configfile):
1311                 from distutils.dir_util import mkpath
1312                 mkpath(ffi_builddir)
1313                 config_args = []
1314
1315                 # Pass empty CFLAGS because we'll just append the resulting
1316                 # CFLAGS to Python's; -g or -O2 is to be avoided.
1317                 cmd = "cd %s && env CFLAGS='' '%s/configure' %s" \
1318                       % (ffi_builddir, ffi_srcdir, " ".join(config_args))
1319
1320                 res = os.system(cmd)
1321                 if res or not os.path.exists(ffi_configfile):
1322                     print "Failed to configure _ctypes module"
1323                     return False
1324
1325             fficonfig = {}
1326             execfile(ffi_configfile, globals(), fficonfig)
1327             ffi_srcdir = os.path.join(fficonfig['ffi_srcdir'], 'src')
1328
1329             # Add .S (preprocessed assembly) to C compiler source extensions.
1330             self.compiler.src_extensions.append('.S')
1331
1332             include_dirs = [os.path.join(ffi_builddir, 'include'),
1333                             ffi_builddir, ffi_srcdir]
1334             extra_compile_args = fficonfig['ffi_cflags'].split()
1335
1336             ext.sources.extend(fficonfig['ffi_sources'])
1337             ext.include_dirs.extend(include_dirs)
1338             ext.extra_compile_args.extend(extra_compile_args)
1339         return True
1340
1341     def detect_ctypes(self, inc_dirs, lib_dirs):
1342         self.use_system_libffi = False
1343         include_dirs = []
1344         extra_compile_args = []
1345         sources = ['_ctypes/_ctypes.c',
1346                    '_ctypes/callbacks.c',
1347                    '_ctypes/callproc.c',
1348                    '_ctypes/stgdict.c',
1349                    '_ctypes/cfield.c',
1350                    '_ctypes/malloc_closure.c']
1351         depends = ['_ctypes/ctypes.h']
1352
1353         if sys.platform == 'darwin':
1354             sources.append('_ctypes/darwin/dlfcn_simple.c')
1355             include_dirs.append('_ctypes/darwin')
1356 # XXX Is this still needed?
1357 ##            extra_link_args.extend(['-read_only_relocs', 'warning'])
1358
1359         ext = Extension('_ctypes',
1360                         include_dirs=include_dirs,
1361                         extra_compile_args=extra_compile_args,
1362                         libraries=[],
1363                         sources=sources,
1364                         depends=depends)
1365         ext_test = Extension('_ctypes_test',
1366                              sources=['_ctypes/_ctypes_test.c'])
1367         self.extensions.extend([ext, ext_test])
1368
1369         if not '--with-system-ffi' in sysconfig.get_config_var("CONFIG_ARGS"):
1370             return
1371
1372         ffi_inc = find_file('ffi.h', [], inc_dirs)
1373         if ffi_inc is not None:
1374             ffi_h = ffi_inc[0] + '/ffi.h'
1375             fp = open(ffi_h)
1376             while 1:
1377                 line = fp.readline()
1378                 if not line:
1379                     ffi_inc = None
1380                     break
1381                 if line.startswith('#define LIBFFI_H'):
1382                     break
1383         ffi_lib = None
1384         if ffi_inc is not None:
1385             for lib_name in ('ffi_convenience', 'ffi_pic', 'ffi'):
1386                 if (self.compiler.find_library_file(lib_dirs, lib_name)):
1387                     ffi_lib = lib_name
1388                     break
1389
1390         if ffi_inc and ffi_lib:
1391             ext.include_dirs.extend(ffi_inc)
1392             ext.libraries.append(ffi_lib)
1393             self.use_system_libffi = True
1394
1395
1396 class PyBuildInstall(install):
1397     # Suppress the warning about installation into the lib_dynload
1398     # directory, which is not in sys.path when running Python during
1399     # installation:
1400     def initialize_options (self):
1401         install.initialize_options(self)
1402         self.warn_dir=0
1403
1404 class PyBuildInstallLib(install_lib):
1405     # Do exactly what install_lib does but make sure correct access modes get
1406     # set on installed directories and files. All installed files with get
1407     # mode 644 unless they are a shared library in which case they will get
1408     # mode 755. All installed directories will get mode 755.
1409
1410     so_ext = sysconfig.get_config_var("SO")
1411
1412     def install(self):
1413         outfiles = install_lib.install(self)
1414         self.set_file_modes(outfiles, 0644, 0755)
1415         self.set_dir_modes(self.install_dir, 0755)
1416         return outfiles
1417
1418     def set_file_modes(self, files, defaultMode, sharedLibMode):
1419         if not self.is_chmod_supported(): return
1420         if not files: return
1421
1422         for filename in files:
1423             if os.path.islink(filename): continue
1424             mode = defaultMode
1425             if filename.endswith(self.so_ext): mode = sharedLibMode
1426             log.info("changing mode of %s to %o", filename, mode)
1427             if not self.dry_run: os.chmod(filename, mode)
1428
1429     def set_dir_modes(self, dirname, mode):
1430         if not self.is_chmod_supported(): return
1431         os.path.walk(dirname, self.set_dir_modes_visitor, mode)
1432
1433     def set_dir_modes_visitor(self, mode, dirname, names):
1434         if os.path.islink(dirname): return
1435         log.info("changing mode of %s to %o", dirname, mode)
1436         if not self.dry_run: os.chmod(dirname, mode)
1437
1438     def is_chmod_supported(self):
1439         return hasattr(os, 'chmod')
1440
1441 SUMMARY = """
1442 Python is an interpreted, interactive, object-oriented programming
1443 language. It is often compared to Tcl, Perl, Scheme or Java.
1444
1445 Python combines remarkable power with very clear syntax. It has
1446 modules, classes, exceptions, very high level dynamic data types, and
1447 dynamic typing. There are interfaces to many system calls and
1448 libraries, as well as to various windowing systems (X11, Motif, Tk,
1449 Mac, MFC). New built-in modules are easily written in C or C++. Python
1450 is also usable as an extension language for applications that need a
1451 programmable interface.
1452
1453 The Python implementation is portable: it runs on many brands of UNIX,
1454 on Windows, DOS, OS/2, Mac, Amiga... If your favorite system isn't
1455 listed here, it may still be supported, if there's a C compiler for
1456 it. Ask around on comp.lang.python -- or just try compiling Python
1457 yourself.
1458 """
1459
1460 CLASSIFIERS = """
1461 Development Status :: 3 - Alpha
1462 Development Status :: 6 - Mature
1463 License :: OSI Approved :: Python Software Foundation License
1464 Natural Language :: English
1465 Programming Language :: C
1466 Programming Language :: Python
1467 Topic :: Software Development
1468 """
1469
1470 def main():
1471     # turn off warnings when deprecated modules are imported
1472     import warnings
1473     warnings.filterwarnings("ignore",category=DeprecationWarning)
1474     setup(# PyPI Metadata (PEP 301)
1475           name = "Python",
1476           version = sys.version.split()[0],
1477           url = "http://www.python.org/%s" % sys.version[:3],
1478           maintainer = "Guido van Rossum and the Python community",
1479           maintainer_email = "python-dev@python.org",
1480           description = "A high-level object-oriented programming language",
1481           long_description = SUMMARY.strip(),
1482           license = "PSF license",
1483           classifiers = filter(None, CLASSIFIERS.split("\n")),
1484           platforms = ["Many"],
1485
1486           # Build info
1487           cmdclass = {'build_ext':PyBuildExt, 'install':PyBuildInstall,
1488                       'install_lib':PyBuildInstallLib},
1489           # The struct module is defined here, because build_ext won't be
1490           # called unless there's at least one extension module defined.
1491           ext_modules=[Extension('_struct', ['_struct.c'])],
1492
1493           # Scripts to install
1494           scripts = ['Tools/scripts/pydoc', 'Tools/scripts/idle',
1495                      'Lib/smtpd.py']
1496         )
1497
1498 # --install-platlib
1499 if __name__ == '__main__':
1500     main()