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