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