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