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