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/') 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             os.system("ldd %s > %s" % (do_readline, tmpfile))
 551             fp = open(tmpfile)
 552             for ln in fp:
 553                 if 'curses' in ln:
 554                     readline_termcap_library = re.sub(
 555                         r'.*lib(n?cursesw?)\.so.*', r'\1', ln
 556                     ).rstrip()
 557                     break
 558                 if 'tinfo' in ln: # termcap interface split out from ncurses
 559                     readline_termcap_library = 'tinfo'
 560                     break
 561             fp.close()
 562             os.unlink(tmpfile)
 563         # Issue 7384: If readline is already linked against curses,
 564         # use the same library for the readline and curses modules.
 565         # Disabled since applications relying on ncursesw might break.
 566         #
 567         # if 'curses' in readline_termcap_library:
 568         #    curses_library = readline_termcap_library
 569         # elif self.compiler.find_library_file(lib_dirs, 'ncursesw'):
 570         # (...)
 571         if self.compiler.find_library_file(lib_dirs, 'ncursesw'):
 572             curses_library = 'ncursesw'
 573         elif self.compiler.find_library_file(lib_dirs, 'ncurses'):
 574             curses_library = 'ncurses'
 575         elif self.compiler.find_library_file(lib_dirs, 'curses'):
 576             curses_library = 'curses'
 577
 578         if platform == 'darwin': # and os.uname()[2] < '9.':
 579             # MacOSX 10.4 has a broken readline. Don't try to build
 580             # the readline module unless the user has installed a fixed
 581             # readline package
 582             # FIXME: The readline emulation on 10.5 is better, but the
 583             # readline module doesn't compile out of the box.
 584             if find_file('readline/rlconf.h', inc_dirs, []) is None:
 585                 do_readline = False
 586         if do_readline:
 587             if sys.platform == 'darwin':
 588                 # In every directory on the search path search for a dynamic
 589                 # library and then a static library, instead of first looking
 590                 # for dynamic libraries on the entire path.
 591                 # This way a staticly linked custom readline gets picked up
 592                 # before the (possibly broken) dynamic library in /usr/lib.
 593                 readline_extra_link_args = ('-Wl,-search_paths_first',)
 594             else:
 595                 readline_extra_link_args = ()
 596
 597             readline_libs = ['readline']
 598             if readline_termcap_library:
 599                 pass # Issue 7384: Already linked against curses or tinfo.
 600             elif curses_library:
 601                 readline_libs.append(curses_library)
 602             elif self.compiler.find_library_file(lib_dirs +
 603                                                ['/usr/lib/termcap'],
 604                                                'termcap'):
 605                 readline_libs.append('termcap')
 606             exts.append( Extension('readline', ['readline.c'],
 607                                    library_dirs=['/usr/lib/termcap'],
 608                                    extra_link_args=readline_extra_link_args,
 609                                    libraries=readline_libs) )
 610         else:
 611             missing.append('readline')
 612
 613         if platform not in ['mac']:
 614             # crypt module.
 615
 616             if self.compiler.find_library_file(lib_dirs, 'crypt'):
 617                 libs = ['crypt']
 618             else:
 619                 libs = []
 620             exts.append( Extension('crypt', ['cryptmodule.c'], libraries=libs) )
 621         else:
 622             missing.append('crypt')
 623
 624         # CSV files
 625         exts.append( Extension('_csv', ['_csv.c']) )
 626
 627         # socket(2)
 628         exts.append( Extension('_socket', ['socketmodule.c'],
 629                                depends = ['socketmodule.h']) )
 630         # Detect SSL support for the socket module (via _ssl)
 631         search_for_ssl_incs_in = [
 632                               '/usr/local/ssl/include',
 633                               '/usr/contrib/ssl/include/'
 634                              ]
 635         ssl_incs = find_file('openssl/ssl.h', inc_dirs,
 636                              search_for_ssl_incs_in
 637                              )
 638         if ssl_incs is not None:
 639             krb5_h = find_file('krb5.h', inc_dirs,
 640                                ['/usr/kerberos/include'])
 641             if krb5_h:
 642                 ssl_incs += krb5_h
 643         ssl_libs = find_library_file(self.compiler, 'ssl',lib_dirs,
 644                                      ['/usr/local/ssl/lib',
 645                                       '/usr/contrib/ssl/lib/'
 646                                      ] )
 647
 648         if (ssl_incs is not None and
 649             ssl_libs is not None):
 650             exts.append( Extension('_ssl', ['_ssl.c'],
 651                                    include_dirs = ssl_incs,
 652                                    library_dirs = ssl_libs,
 653                                    libraries = ['ssl', 'crypto'],
 654                                    depends = ['socketmodule.h']), )
 655         else:
 656             missing.append('_ssl')
 657
 658         # find out which version of OpenSSL we have
 659         openssl_ver = 0
 660         openssl_ver_re = re.compile(
 661             '^\s*#\s*define\s+OPENSSL_VERSION_NUMBER\s+(0x[0-9a-fA-F]+)' )
 662
 663         # look for the openssl version header on the compiler search path.
 664         opensslv_h = find_file('openssl/opensslv.h', [],
 665                 inc_dirs + search_for_ssl_incs_in)
 666         if opensslv_h:
 667             name = os.path.join(opensslv_h[0], 'openssl/opensslv.h')
 668             if sys.platform == 'darwin' and is_macosx_sdk_path(name):
 669                 name = os.path.join(macosx_sdk_root(), name[1:])
 670             try:
 671                 incfile = open(name, 'r')
 672                 for line in incfile:
 673                     m = openssl_ver_re.match(line)
 674                     if m:
 675                         openssl_ver = eval(m.group(1))
 676             except IOError as msg:
 677                 print("IOError while reading opensshv.h:", msg)
 678                 pass
 679
 680         #print('openssl_ver = 0x%08x' % openssl_ver)
 681
 682         if ssl_incs is not None and ssl_libs is not None:
 683             if openssl_ver >= 0x00907000:
 684                 # The _hashlib module wraps optimized implementations
 685                 # of hash functions from the OpenSSL library.
 686                 exts.append( Extension('_hashlib', ['_hashopenssl.c'],
 687                                        include_dirs = ssl_incs,
 688                                        library_dirs = ssl_libs,
 689                                        libraries = ['ssl', 'crypto']) )
 690             else:
 691                 print("warning: openssl 0x%08x is too old for _hashlib" %
 692                       openssl_ver)
 693                 missing.append('_hashlib')
 694         else:
 695             missing.append('_hashlib')
 696
 697         if openssl_ver < 0x00908000:
 698             # OpenSSL doesn't do these until 0.9.8 so we'll bring our own hash
 699             exts.append( Extension('_sha256', ['sha256module.c']) )
 700             exts.append( Extension('_sha512', ['sha512module.c']) )
 701
 702         if openssl_ver < 0x00907000:
 703             # no openssl at all, use our own md5 and sha1
 704             exts.append( Extension('_md5', ['md5module.c']) )
 705             exts.append( Extension('_sha1', ['sha1module.c']) )
 706
 707         # Modules that provide persistent dictionary-like semantics.  You will
 708         # probably want to arrange for at least one of them to be available on
 709         # your machine, though none are defined by default because of library
 710         # dependencies.  The Python module dbm/__init__.py provides an
 711         # implementation independent wrapper for these; dbm/dumb.py provides
 712         # similar functionality (but slower of course) implemented in Python.
 713
 714         # Sleepycat^WOracle Berkeley DB interface.
 715         #  http://www.oracle.com/database/berkeley-db/db/index.html
 716         #
 717         # This requires the Sleepycat^WOracle DB code. The supported versions
 718         # are set below.  Visit the URL above to download
 719         # a release.  Most open source OSes come with one or more
 720         # versions of BerkeleyDB already installed.
 721
 722         max_db_ver = (4, 7)
 723         min_db_ver = (3, 3)
 724         db_setup_debug = False   # verbose debug prints from this script?
 725
 726         def allow_db_ver(db_ver):
 727             """Returns a boolean if the given BerkeleyDB version is acceptable.
 728
 729             Args:
 730               db_ver: A tuple of the version to verify.
 731             """
 732             if not (min_db_ver <= db_ver <= max_db_ver):
 733                 return False
 734             return True
 735
 736         def gen_db_minor_ver_nums(major):
 737             if major == 4:
 738                 for x in range(max_db_ver[1]+1):
 739                     if allow_db_ver((4, x)):
 740                         yield x
 741             elif major == 3:
 742                 for x in (3,):
 743                     if allow_db_ver((3, x)):
 744                         yield x
 745             else:
 746                 raise ValueError("unknown major BerkeleyDB version", major)
 747
 748         # construct a list of paths to look for the header file in on
 749         # top of the normal inc_dirs.
 750         db_inc_paths = [
 751             '/usr/include/db4',
 752             '/usr/local/include/db4',
 753             '/opt/sfw/include/db4',
 754             '/usr/include/db3',
 755             '/usr/local/include/db3',
 756             '/opt/sfw/include/db3',
 757             # Fink defaults (http://fink.sourceforge.net/)
 758             '/sw/include/db4',
 759             '/sw/include/db3',
 760         ]
 761         # 4.x minor number specific paths
 762         for x in gen_db_minor_ver_nums(4):
 763             db_inc_paths.append('/usr/include/db4%d' % x)
 764             db_inc_paths.append('/usr/include/db4.%d' % x)
 765             db_inc_paths.append('/usr/local/BerkeleyDB.4.%d/include' % x)
 766             db_inc_paths.append('/usr/local/include/db4%d' % x)
 767             db_inc_paths.append('/pkg/db-4.%d/include' % x)
 768             db_inc_paths.append('/opt/db-4.%d/include' % x)
 769             # MacPorts default (http://www.macports.org/)
 770             db_inc_paths.append('/opt/local/include/db4%d' % x)
 771         # 3.x minor number specific paths
 772         for x in gen_db_minor_ver_nums(3):
 773             db_inc_paths.append('/usr/include/db3%d' % x)
 774             db_inc_paths.append('/usr/local/BerkeleyDB.3.%d/include' % x)
 775             db_inc_paths.append('/usr/local/include/db3%d' % x)
 776             db_inc_paths.append('/pkg/db-3.%d/include' % x)
 777             db_inc_paths.append('/opt/db-3.%d/include' % x)
 778
 779         # Add some common subdirectories for Sleepycat DB to the list,
 780         # based on the standard include directories. This way DB3/4 gets
 781         # picked up when it is installed in a non-standard prefix and
 782         # the user has added that prefix into inc_dirs.
 783         std_variants = []
 784         for dn in inc_dirs:
 785             std_variants.append(os.path.join(dn, 'db3'))
 786             std_variants.append(os.path.join(dn, 'db4'))
 787             for x in gen_db_minor_ver_nums(4):
 788                 std_variants.append(os.path.join(dn, "db4%d"%x))
 789                 std_variants.append(os.path.join(dn, "db4.%d"%x))
 790             for x in gen_db_minor_ver_nums(3):
 791                 std_variants.append(os.path.join(dn, "db3%d"%x))
 792                 std_variants.append(os.path.join(dn, "db3.%d"%x))
 793
 794         db_inc_paths = std_variants + db_inc_paths
 795         db_inc_paths = [p for p in db_inc_paths if os.path.exists(p)]
 796
 797         db_ver_inc_map = {}
 798
 799         if sys.platform == 'darwin':
 800             sysroot = macosx_sdk_root()
 801
 802         class db_found(Exception): pass
 803         try:
 804             # See whether there is a Sleepycat header in the standard
 805             # search path.
 806             for d in inc_dirs + db_inc_paths:
 807                 f = os.path.join(d, "db.h")
 808                 if sys.platform == 'darwin' and is_macosx_sdk_path(d):
 809                     f = os.path.join(sysroot, d[1:], "db.h")
 810
 811                 if db_setup_debug: print("db: looking for db.h in", f)
 812                 if os.path.exists(f):
 813                     f = open(f, "rb").read()
 814                     m = re.search(br"#define\WDB_VERSION_MAJOR\W(\d+)", f)
 815                     if m:
 816                         db_major = int(m.group(1))
 817                         m = re.search(br"#define\WDB_VERSION_MINOR\W(\d+)", f)
 818                         db_minor = int(m.group(1))
 819                         db_ver = (db_major, db_minor)
 820
 821                         # Avoid 4.6 prior to 4.6.21 due to a BerkeleyDB bug
 822                         if db_ver == (4, 6):
 823                             m = re.search(br"#define\WDB_VERSION_PATCH\W(\d+)", f)
 824                             db_patch = int(m.group(1))
 825                             if db_patch < 21:
 826                                 print("db.h:", db_ver, "patch", db_patch,
 827                                       "being ignored (4.6.x must be >= 4.6.21)")
 828                                 continue
 829
 830                         if ( (db_ver not in db_ver_inc_map) and
 831                             allow_db_ver(db_ver) ):
 832                             # save the include directory with the db.h version
 833                             # (first occurrence only)
 834                             db_ver_inc_map[db_ver] = d
 835                             if db_setup_debug:
 836                                 print("db.h: found", db_ver, "in", d)
 837                         else:
 838                             # we already found a header for this library version
 839                             if db_setup_debug: print("db.h: ignoring", d)
 840                     else:
 841                         # ignore this header, it didn't contain a version number
 842                         if db_setup_debug:
 843                             print("db.h: no version number version in", d)
 844
 845             db_found_vers = list(db_ver_inc_map.keys())
 846             db_found_vers.sort()
 847
 848             while db_found_vers:
 849                 db_ver = db_found_vers.pop()
 850                 db_incdir = db_ver_inc_map[db_ver]
 851
 852                 # check lib directories parallel to the location of the header
 853                 db_dirs_to_check = [
 854                     db_incdir.replace("include", 'lib64'),
 855                     db_incdir.replace("include", 'lib'),
 856                 ]
 857
 858                 if sys.platform != 'darwin':
 859                     db_dirs_to_check = list(filter(os.path.isdir, db_dirs_to_check))
 860
 861                 else:
 862                     # Same as other branch, but takes OSX SDK into account
 863                     tmp = []
 864                     for dn in db_dirs_to_check:
 865                         if is_macosx_sdk_path(dn):
 866                             if os.path.isdir(os.path.join(sysroot, dn[1:])):
 867                                 tmp.append(dn)
 868                         else:
 869                             if os.path.isdir(dn):
 870                                 tmp.append(dn)
 871
 872                     db_dirs_to_check = tmp
 873
 874                 # Look for a version specific db-X.Y before an ambiguoius dbX
 875                 # XXX should we -ever- look for a dbX name?  Do any
 876                 # systems really not name their library by version and
 877                 # symlink to more general names?
 878                 for dblib in (('db-%d.%d' % db_ver),
 879                               ('db%d%d' % db_ver),
 880                               ('db%d' % db_ver[0])):
 881                     dblib_file = self.compiler.find_library_file(
 882                                     db_dirs_to_check + lib_dirs, dblib )
 883                     if dblib_file:
 884                         dblib_dir = [ os.path.abspath(os.path.dirname(dblib_file)) ]
 885                         raise db_found
 886                     else:
 887                         if db_setup_debug: print("db lib: ", dblib, "not found")
 888
 889         except db_found:
 890             if db_setup_debug:
 891                 print("bsddb using BerkeleyDB lib:", db_ver, dblib)
 892                 print("bsddb lib dir:", dblib_dir, " inc dir:", db_incdir)
 893             db_incs = [db_incdir]
 894             dblibs = [dblib]
 895         else:
 896             if db_setup_debug: print("db: no appropriate library found")
 897             db_incs = None
 898             dblibs = []
 899             dblib_dir = None
 900
 901         # The sqlite interface
 902         sqlite_setup_debug = False   # verbose debug prints from this script?
 903
 904         # We hunt for #define SQLITE_VERSION "n.n.n"
 905         # We need to find >= sqlite version 3.0.8
 906         sqlite_incdir = sqlite_libdir = None
 907         sqlite_inc_paths = [ '/usr/include',
 908                              '/usr/include/sqlite',
 909                              '/usr/include/sqlite3',
 910                              '/usr/local/include',
 911                              '/usr/local/include/sqlite',
 912                              '/usr/local/include/sqlite3',
 913                            ]
 914         MIN_SQLITE_VERSION_NUMBER = (3, 0, 8)
 915         MIN_SQLITE_VERSION = ".".join([str(x)
 916                                     for x in MIN_SQLITE_VERSION_NUMBER])
 917
 918         # Scan the default include directories before the SQLite specific
 919         # ones. This allows one to override the copy of sqlite on OSX,
 920         # where /usr/include contains an old version of sqlite.
 921         if sys.platform == 'darwin':
 922             sysroot = macosx_sdk_root()
 923
 924         for d in inc_dirs + sqlite_inc_paths:
 925             f = os.path.join(d, "sqlite3.h")
 926
 927             if sys.platform == 'darwin' and is_macosx_sdk_path(d):
 928                 f = os.path.join(sysroot, d[1:], "sqlite3.h")
 929
 930             if os.path.exists(f):
 931                 if sqlite_setup_debug: print("sqlite: found %s"%f)
 932                 incf = open(f).read()
 933                 m = re.search(
 934                     r'\s*.*#\s*.*define\s.*SQLITE_VERSION\W*"(.*)"', incf)
 935                 if m:
 936                     sqlite_version = m.group(1)
 937                     sqlite_version_tuple = tuple([int(x)
 938                                         for x in sqlite_version.split(".")])
 939                     if sqlite_version_tuple >= MIN_SQLITE_VERSION_NUMBER:
 940                         # we win!
 941                         if sqlite_setup_debug:
 942                             print("%s/sqlite3.h: version %s"%(d, sqlite_version))
 943                         sqlite_incdir = d
 944                         break
 945                     else:
 946                         if sqlite_setup_debug:
 947                             print("%s: version %d is too old, need >= %s"%(d,
 948                                         sqlite_version, MIN_SQLITE_VERSION))
 949                 elif sqlite_setup_debug:
 950                     print("sqlite: %s had no SQLITE_VERSION"%(f,))
 951
 952         if sqlite_incdir:
 953             sqlite_dirs_to_check = [
 954                 os.path.join(sqlite_incdir, '..', 'lib64'),
 955                 os.path.join(sqlite_incdir, '..', 'lib'),
 956                 os.path.join(sqlite_incdir, '..', '..', 'lib64'),
 957                 os.path.join(sqlite_incdir, '..', '..', 'lib'),
 958             ]
 959             sqlite_libfile = self.compiler.find_library_file(
 960                                 sqlite_dirs_to_check + lib_dirs, 'sqlite3')
 961             if sqlite_libfile:
 962                 sqlite_libdir = [os.path.abspath(os.path.dirname(sqlite_libfile))]
 963
 964         if sqlite_incdir and sqlite_libdir:
 965             sqlite_srcs = ['_sqlite/cache.c',
 966                 '_sqlite/connection.c',
 967                 '_sqlite/cursor.c',
 968                 '_sqlite/microprotocols.c',
 969                 '_sqlite/module.c',
 970                 '_sqlite/prepare_protocol.c',
 971                 '_sqlite/row.c',
 972                 '_sqlite/statement.c',
 973                 '_sqlite/util.c', ]
 974
 975             sqlite_defines = []
 976             if sys.platform != "win32":
 977                 sqlite_defines.append(('MODULE_NAME', '"sqlite3"'))
 978             else:
 979                 sqlite_defines.append(('MODULE_NAME', '\\"sqlite3\\"'))
 980
 981
 982             if sys.platform == 'darwin':
 983                 # In every directory on the search path search for a dynamic
 984                 # library and then a static library, instead of first looking
 985                 # for dynamic libraries on the entiry path.
 986                 # This way a staticly linked custom sqlite gets picked up
 987                 # before the dynamic library in /usr/lib.
 988                 sqlite_extra_link_args = ('-Wl,-search_paths_first',)
 989             else:
 990                 sqlite_extra_link_args = ()
 991
 992             exts.append(Extension('_sqlite3', sqlite_srcs,
 993                                   define_macros=sqlite_defines,
 994                                   include_dirs=["Modules/_sqlite",
 995                                                 sqlite_incdir],
 996                                   library_dirs=sqlite_libdir,
 997                                   runtime_library_dirs=sqlite_libdir,
 998                                   extra_link_args=sqlite_extra_link_args,
 999                                   libraries=["sqlite3",]))
1000         else:
1001             missing.append('_sqlite3')
1002
1003         dbm_order = ['gdbm']
1004         # The standard Unix dbm module:
1005         if platform not in ['cygwin']:
1006             config_args = [arg.strip("'")
1007                            for arg in sysconfig.get_config_var("CONFIG_ARGS").split()]
1008             dbm_args = [arg for arg in config_args
1009                         if arg.startswith('--with-dbmliborder=')]
1010             if dbm_args:
1011                 dbm_order = [arg.split('=')[-1] for arg in dbm_args][-1].split(":")
1012             else:
1013                 dbm_order = "ndbm:gdbm:bdb".split(":")
1014             dbmext = None
1015             for cand in dbm_order:
1016                 if cand == "ndbm":
1017                     if find_file("ndbm.h", inc_dirs, []) is not None:
1018                         # Some systems have -lndbm, others don't
1019                         if self.compiler.find_library_file(lib_dirs, 'ndbm'):
1020                             ndbm_libs = ['ndbm']
1021                         else:
1022                             ndbm_libs = []
1023                         print("building dbm using ndbm")
1024                         dbmext = Extension('_dbm', ['_dbmmodule.c'],
1025                                            define_macros=[
1026                                                ('HAVE_NDBM_H',None),
1027                                                ],
1028                                            libraries=ndbm_libs)
1029                         break
1030
1031                 elif cand == "gdbm":
1032                     if self.compiler.find_library_file(lib_dirs, 'gdbm'):
1033                         gdbm_libs = ['gdbm']
1034                         if self.compiler.find_library_file(lib_dirs, 'gdbm_compat'):
1035                             gdbm_libs.append('gdbm_compat')
1036                         if find_file("gdbm/ndbm.h", inc_dirs, []) is not None:
1037                             print("building dbm using gdbm")
1038                             dbmext = Extension(
1039                                 '_dbm', ['_dbmmodule.c'],
1040                                 define_macros=[
1041                                     ('HAVE_GDBM_NDBM_H', None),
1042                                     ],
1043                                 libraries = gdbm_libs)
1044                             break
1045                         if find_file("gdbm-ndbm.h", inc_dirs, []) is not None:
1046                             print("building dbm using gdbm")
1047                             dbmext = Extension(
1048                                 '_dbm', ['_dbmmodule.c'],
1049                                 define_macros=[
1050                                     ('HAVE_GDBM_DASH_NDBM_H', None),
1051                                     ],
1052                                 libraries = gdbm_libs)
1053                             break
1054                 elif cand == "bdb":
1055                     if db_incs is not None:
1056                         print("building dbm using bdb")
1057                         dbmext = Extension('_dbm', ['_dbmmodule.c'],
1058                                            library_dirs=dblib_dir,
1059                                            runtime_library_dirs=dblib_dir,
1060                                            include_dirs=db_incs,
1061                                            define_macros=[
1062                                                ('HAVE_BERKDB_H', None),
1063                                                ('DB_DBM_HSEARCH', None),
1064                                                ],
1065                                            libraries=dblibs)
1066                         break
1067             if dbmext is not None:
1068                 exts.append(dbmext)
1069             else:
1070                 missing.append('_dbm')
1071
1072         # Anthony Baxter's gdbm module.  GNU dbm(3) will require -lgdbm:
1073         if ('gdbm' in dbm_order and
1074             self.compiler.find_library_file(lib_dirs, 'gdbm')):
1075             exts.append( Extension('_gdbm', ['_gdbmmodule.c'],
1076                                    libraries = ['gdbm'] ) )
1077         else:
1078             missing.append('_gdbm')
1079
1080         # Unix-only modules
1081         if platform not in ['mac', 'win32']:
1082             # Steen Lumholt's termios module
1083             exts.append( Extension('termios', ['termios.c']) )
1084             # Jeremy Hylton's rlimit interface
1085             if platform not in ['atheos']:
1086                 exts.append( Extension('resource', ['resource.c']) )
1087             else:
1088                 missing.append('resource')
1089
1090             # Sun yellow pages. Some systems have the functions in libc.
1091             if (platform not in ['cygwin', 'qnx6'] and
1092                 find_file('rpcsvc/yp_prot.h', inc_dirs, []) is not None):
1093                 if (self.compiler.find_library_file(lib_dirs, 'nsl')):
1094                     libs = ['nsl']
1095                 else:
1096                     libs = []
1097                 exts.append( Extension('nis', ['nismodule.c'],
1098                                        libraries = libs) )
1099             else:
1100                 missing.append('nis')
1101         else:
1102             missing.extend(['nis', 'resource', 'termios'])
1103
1104         # Curses support, requiring the System V version of curses, often
1105         # provided by the ncurses library.
1106         panel_library = 'panel'
1107         if curses_library.startswith('ncurses'):
1108             if curses_library == 'ncursesw':
1109                 # Bug 1464056: If _curses.so links with ncursesw,
1110                 # _curses_panel.so must link with panelw.
1111                 panel_library = 'panelw'
1112             curses_libs = [curses_library]
1113             exts.append( Extension('_curses', ['_cursesmodule.c'],
1114                                    libraries = curses_libs) )
1115         elif curses_library == 'curses' and platform != 'darwin':
1116                 # OSX has an old Berkeley curses, not good enough for
1117                 # the _curses module.
1118             if (self.compiler.find_library_file(lib_dirs, 'terminfo')):
1119                 curses_libs = ['curses', 'terminfo']
1120             elif (self.compiler.find_library_file(lib_dirs, 'termcap')):
1121                 curses_libs = ['curses', 'termcap']
1122             else:
1123                 curses_libs = ['curses']
1124
1125             exts.append( Extension('_curses', ['_cursesmodule.c'],
1126                                    libraries = curses_libs) )
1127         else:
1128             missing.append('_curses')
1129
1130         # If the curses module is enabled, check for the panel module
1131         if (module_enabled(exts, '_curses') and
1132             self.compiler.find_library_file(lib_dirs, panel_library)):
1133             exts.append( Extension('_curses_panel', ['_curses_panel.c'],
1134                                    libraries = [panel_library] + curses_libs) )
1135         else:
1136             missing.append('_curses_panel')
1137
1138         # Andrew Kuchling's zlib module.  Note that some versions of zlib
1139         # 1.1.3 have security problems.  See CERT Advisory CA-2002-07:
1140         # http://www.cert.org/advisories/CA-2002-07.html
1141         #
1142         # zlib 1.1.4 is fixed, but at least one vendor (RedHat) has decided to
1143         # patch its zlib 1.1.3 package instead of upgrading to 1.1.4.  For
1144         # now, we still accept 1.1.3, because we think it's difficult to
1145         # exploit this in Python, and we'd rather make it RedHat's problem
1146         # than our problem <wink>.
1147         #
1148         # You can upgrade zlib to version 1.1.4 yourself by going to
1149         # http://www.gzip.org/zlib/
1150         zlib_inc = find_file('zlib.h', [], inc_dirs)
1151         have_zlib = False
1152         if zlib_inc is not None:
1153             zlib_h = zlib_inc[0] + '/zlib.h'
1154             version = '"0.0.0"'
1155             version_req = '"1.1.3"'
1156             fp = open(zlib_h)
1157             while 1:
1158                 line = fp.readline()
1159                 if not line:
1160                     break
1161                 if line.startswith('#define ZLIB_VERSION'):
1162                     version = line.split()[2]
1163                     break
1164             if version >= version_req:
1165                 if (self.compiler.find_library_file(lib_dirs, 'z')):
1166                     if sys.platform == "darwin":
1167                         zlib_extra_link_args = ('-Wl,-search_paths_first',)
1168                     else:
1169                         zlib_extra_link_args = ()
1170                     exts.append( Extension('zlib', ['zlibmodule.c'],
1171                                            libraries = ['z'],
1172                                            extra_link_args = zlib_extra_link_args))
1173                     have_zlib = True
1174                 else:
1175                     missing.append('zlib')
1176             else:
1177                 missing.append('zlib')
1178         else:
1179             missing.append('zlib')
1180
1181         # Helper module for various ascii-encoders.  Uses zlib for an optimized
1182         # crc32 if we have it.  Otherwise binascii uses its own.
1183         if have_zlib:
1184             extra_compile_args = ['-DUSE_ZLIB_CRC32']
1185             libraries = ['z']
1186             extra_link_args = zlib_extra_link_args
1187         else:
1188             extra_compile_args = []
1189             libraries = []
1190             extra_link_args = []
1191         exts.append( Extension('binascii', ['binascii.c'],
1192                                extra_compile_args = extra_compile_args,
1193                                libraries = libraries,
1194                                extra_link_args = extra_link_args) )
1195
1196         # Gustavo Niemeyer's bz2 module.
1197         if (self.compiler.find_library_file(lib_dirs, 'bz2')):
1198             if sys.platform == "darwin":
1199                 bz2_extra_link_args = ('-Wl,-search_paths_first',)
1200             else:
1201                 bz2_extra_link_args = ()
1202             exts.append( Extension('bz2', ['bz2module.c'],
1203                                    libraries = ['bz2'],
1204                                    extra_link_args = bz2_extra_link_args) )
1205         else:
1206             missing.append('bz2')
1207
1208         # Interface to the Expat XML parser
1209         #
1210         # Expat was written by James Clark and is now maintained by a
1211         # group of developers on SourceForge; see www.libexpat.org for
1212         # more information.  The pyexpat module was written by Paul
1213         # Prescod after a prototype by Jack Jansen.  The Expat source
1214         # is included in Modules/expat/.  Usage of a system
1215         # shared libexpat.so/expat.dll is not advised.
1216         #
1217         # More information on Expat can be found at www.libexpat.org.
1218         #
1219         expatinc = os.path.join(os.getcwd(), srcdir, 'Modules', 'expat')
1220         define_macros = [
1221             ('HAVE_EXPAT_CONFIG_H', '1'),
1222         ]
1223
1224         exts.append(Extension('pyexpat',
1225                               define_macros = define_macros,
1226                               include_dirs = [expatinc],
1227                               sources = ['pyexpat.c',
1228                                          'expat/xmlparse.c',
1229                                          'expat/xmlrole.c',
1230                                          'expat/xmltok.c',
1231                                          ],
1232                               ))
1233
1234         # Fredrik Lundh's cElementTree module.  Note that this also
1235         # uses expat (via the CAPI hook in pyexpat).
1236
1237         if os.path.isfile(os.path.join(srcdir, 'Modules', '_elementtree.c')):
1238             define_macros.append(('USE_PYEXPAT_CAPI', None))
1239             exts.append(Extension('_elementtree',
1240                                   define_macros = define_macros,
1241                                   include_dirs = [expatinc],
1242                                   sources = ['_elementtree.c'],
1243                                   ))
1244         else:
1245             missing.append('_elementtree')
1246
1247         # Hye-Shik Chang's CJKCodecs modules.
1248         exts.append(Extension('_multibytecodec',
1249                               ['cjkcodecs/multibytecodec.c']))
1250         for loc in ('kr', 'jp', 'cn', 'tw', 'hk', 'iso2022'):
1251             exts.append(Extension('_codecs_%s' % loc,
1252                                   ['cjkcodecs/_codecs_%s.c' % loc]))
1253
1254         # Thomas Heller's _ctypes module
1255         self.detect_ctypes(inc_dirs, lib_dirs)
1256
1257         # Richard Oudkerk's multiprocessing module
1258         if platform == 'win32':             # Windows
1259             macros = dict()
1260             libraries = ['ws2_32']
1261
1262         elif platform == 'darwin':          # Mac OSX
1263             macros = dict()
1264             libraries = []
1265
1266         elif platform == 'cygwin':          # Cygwin
1267             macros = dict()
1268             libraries = []
1269
1270         elif platform in ('freebsd4', 'freebsd5', 'freebsd6', 'freebsd7', 'freebsd8'):
1271             # FreeBSD's P1003.1b semaphore support is very experimental
1272             # and has many known problems. (as of June 2008)
1273             macros = dict()
1274             libraries = []
1275
1276         elif platform.startswith('openbsd'):
1277             macros = dict()
1278             libraries = []
1279
1280         elif platform.startswith('netbsd'):
1281             macros = dict()
1282             libraries = []
1283
1284         else:                                   # Linux and other unices
1285             macros = dict()
1286             libraries = ['rt']
1287
1288         if platform == 'win32':
1289             multiprocessing_srcs = [ '_multiprocessing/multiprocessing.c',
1290                                      '_multiprocessing/semaphore.c',
1291                                      '_multiprocessing/pipe_connection.c',
1292                                      '_multiprocessing/socket_connection.c',
1293                                      '_multiprocessing/win32_functions.c'
1294                                    ]
1295
1296         else:
1297             multiprocessing_srcs = [ '_multiprocessing/multiprocessing.c',
1298                                      '_multiprocessing/socket_connection.c'
1299                                    ]
1300             if (sysconfig.get_config_var('HAVE_SEM_OPEN') and not
1301                 sysconfig.get_config_var('POSIX_SEMAPHORES_NOT_ENABLED')):
1302                 multiprocessing_srcs.append('_multiprocessing/semaphore.c')
1303
1304         if sysconfig.get_config_var('WITH_THREAD'):
1305             exts.append ( Extension('_multiprocessing', multiprocessing_srcs,
1306                                     define_macros=list(macros.items()),
1307                                     include_dirs=["Modules/_multiprocessing"]))
1308         else:
1309             missing.append('_multiprocessing')
1310         # End multiprocessing
1311
1312         # Platform-specific libraries
1313         if platform in ('linux2', 'freebsd4', 'freebsd5', 'freebsd6',
1314                         'freebsd7', 'freebsd8'):
1315             exts.append( Extension('ossaudiodev', ['ossaudiodev.c']) )
1316         else:
1317             missing.append('ossaudiodev')
1318
1319         if sys.platform == 'darwin':
1320             exts.append(
1321                        Extension('_gestalt', ['_gestalt.c'],
1322                        extra_link_args=['-framework', 'Carbon'])
1323                        )
1324             exts.append(
1325                        Extension('_scproxy', ['_scproxy.c'],
1326                        extra_link_args=[
1327                            '-framework', 'SystemConfiguration',
1328                            '-framework', 'CoreFoundation',
1329                         ]))
1330
1331         self.extensions.extend(exts)
1332
1333         # Call the method for detecting whether _tkinter can be compiled
1334         self.detect_tkinter(inc_dirs, lib_dirs)
1335
1336         if '_tkinter' not in [e.name for e in self.extensions]:
1337             missing.append('_tkinter')
1338
1339         return missing
1340
1341     def detect_tkinter_darwin(self, inc_dirs, lib_dirs):
1342         # The _tkinter module, using frameworks. Since frameworks are quite
1343         # different the UNIX search logic is not sharable.
1344         from os.path import join, exists
1345         framework_dirs = [
1346             '/Library/Frameworks',
1347             '/System/Library/Frameworks/',
1348             join(os.getenv('HOME'), '/Library/Frameworks')
1349         ]
1350
1351         sysroot = macosx_sdk_root()
1352
1353         # Find the directory that contains the Tcl.framework and Tk.framework
1354         # bundles.
1355         # XXX distutils should support -F!
1356         for F in framework_dirs:
1357             # both Tcl.framework and Tk.framework should be present
1358
1359
1360             for fw in 'Tcl', 'Tk':
1361                 if is_macosx_sdk_path(F):
1362                     if not exists(join(sysroot, F[1:], fw + '.framework')):
1363                         break
1364                 else:
1365                     if not exists(join(F, fw + '.framework')):
1366                         break
1367             else:
1368                 # ok, F is now directory with both frameworks. Continure
1369                 # building
1370                 break
1371         else:
1372             # Tk and Tcl frameworks not found. Normal "unix" tkinter search
1373             # will now resume.
1374             return 0
1375
1376         # For 8.4a2, we must add -I options that point inside the Tcl and Tk
1377         # frameworks. In later release we should hopefully be able to pass
1378         # the -F option to gcc, which specifies a framework lookup path.
1379         #
1380         include_dirs = [
1381             join(F, fw + '.framework', H)
1382             for fw in ('Tcl', 'Tk')
1383             for H in ('Headers', 'Versions/Current/PrivateHeaders')
1384         ]
1385
1386         # For 8.4a2, the X11 headers are not included. Rather than include a
1387         # complicated search, this is a hard-coded path. It could bail out
1388         # if X11 libs are not found...
1389         include_dirs.append('/usr/X11R6/include')
1390         frameworks = ['-framework', 'Tcl', '-framework', 'Tk']
1391
1392         # All existing framework builds of Tcl/Tk don't support 64-bit
1393         # architectures.
1394         cflags = sysconfig.get_config_vars('CFLAGS')[0]
1395         archs = re.findall('-arch\s+(\w+)', cflags)
1396
1397         tmpfile = os.path.join(self.build_temp, 'tk.arch')
1398         if not os.path.exists(self.build_temp):
1399             os.makedirs(self.build_temp)
1400
1401         # Note: cannot use os.popen or subprocess here, that
1402         # requires extensions that are not available here.
1403         if is_macosx_sdk_path(F):
1404             os.system("file %s/Tk.framework/Tk | grep 'for architecture' > %s"%(os.path.join(sysroot, F[1:]), tmpfile))
1405         else:
1406             os.system("file %s/Tk.framework/Tk | grep 'for architecture' > %s"%(F, tmpfile))
1407         fp = open(tmpfile)
1408
1409         detected_archs = []
1410         for ln in fp:
1411             a = ln.split()[-1]
1412             if a in archs:
1413                 detected_archs.append(ln.split()[-1])
1414         fp.close()
1415         os.unlink(tmpfile)
1416
1417         for a in detected_archs:
1418             frameworks.append('-arch')
1419             frameworks.append(a)
1420
1421         ext = Extension('_tkinter', ['_tkinter.c', 'tkappinit.c'],
1422                         define_macros=[('WITH_APPINIT', 1)],
1423                         include_dirs = include_dirs,
1424                         libraries = [],
1425                         extra_compile_args = frameworks[2:],
1426                         extra_link_args = frameworks,
1427                         )
1428         self.extensions.append(ext)
1429         return 1
1430
1431
1432     def detect_tkinter(self, inc_dirs, lib_dirs):
1433         # The _tkinter module.
1434
1435         # Rather than complicate the code below, detecting and building
1436         # AquaTk is a separate method. Only one Tkinter will be built on
1437         # Darwin - either AquaTk, if it is found, or X11 based Tk.
1438         platform = self.get_platform()
1439         if (platform == 'darwin' and
1440             self.detect_tkinter_darwin(inc_dirs, lib_dirs)):
1441             return
1442
1443         # Assume we haven't found any of the libraries or include files
1444         # The versions with dots are used on Unix, and the versions without
1445         # dots on Windows, for detection by cygwin.
1446         tcllib = tklib = tcl_includes = tk_includes = None
1447         for version in ['8.5', '85', '8.4', '84', '8.3', '83', '8.2',
1448                         '82', '8.1', '81', '8.0', '80']:
1449             tklib = self.compiler.find_library_file(lib_dirs, 'tk' + version)
1450             tcllib = self.compiler.find_library_file(lib_dirs, 'tcl' + version)
1451             if tklib and tcllib:
1452                 # Exit the loop when we've found the Tcl/Tk libraries
1453                 break
1454
1455         # Now check for the header files
1456         if tklib and tcllib:
1457             # Check for the include files on Debian and {Free,Open}BSD, where
1458             # they're put in /usr/include/{tcl,tk}X.Y
1459             dotversion = version
1460             if '.' not in dotversion and "bsd" in sys.platform.lower():
1461                 # OpenBSD and FreeBSD use Tcl/Tk library names like libtcl83.a,
1462                 # but the include subdirs are named like .../include/tcl8.3.
1463                 dotversion = dotversion[:-1] + '.' + dotversion[-1]
1464             tcl_include_sub = []
1465             tk_include_sub = []
1466             for dir in inc_dirs:
1467                 tcl_include_sub += [dir + os.sep + "tcl" + dotversion]
1468                 tk_include_sub += [dir + os.sep + "tk" + dotversion]
1469             tk_include_sub += tcl_include_sub
1470             tcl_includes = find_file('tcl.h', inc_dirs, tcl_include_sub)
1471             tk_includes = find_file('tk.h', inc_dirs, tk_include_sub)
1472
1473         if (tcllib is None or tklib is None or
1474             tcl_includes is None or tk_includes is None):
1475             self.announce("INFO: Can't locate Tcl/Tk libs and/or headers", 2)
1476             return
1477
1478         # OK... everything seems to be present for Tcl/Tk.
1479
1480         include_dirs = [] ; libs = [] ; defs = [] ; added_lib_dirs = []
1481         for dir in tcl_includes + tk_includes:
1482             if dir not in include_dirs:
1483                 include_dirs.append(dir)
1484
1485         # Check for various platform-specific directories
1486         if platform == 'sunos5':
1487             include_dirs.append('/usr/openwin/include')
1488             added_lib_dirs.append('/usr/openwin/lib')
1489         elif os.path.exists('/usr/X11R6/include'):
1490             include_dirs.append('/usr/X11R6/include')
1491             added_lib_dirs.append('/usr/X11R6/lib64')
1492             added_lib_dirs.append('/usr/X11R6/lib')
1493         elif os.path.exists('/usr/X11R5/include'):
1494             include_dirs.append('/usr/X11R5/include')
1495             added_lib_dirs.append('/usr/X11R5/lib')
1496         else:
1497             # Assume default location for X11
1498             include_dirs.append('/usr/X11/include')
1499             added_lib_dirs.append('/usr/X11/lib')
1500
1501         # If Cygwin, then verify that X is installed before proceeding
1502         if platform == 'cygwin':
1503             x11_inc = find_file('X11/Xlib.h', [], include_dirs)
1504             if x11_inc is None:
1505                 return
1506
1507         # Check for BLT extension
1508         if self.compiler.find_library_file(lib_dirs + added_lib_dirs,
1509                                            'BLT8.0'):
1510             defs.append( ('WITH_BLT', 1) )
1511             libs.append('BLT8.0')
1512         elif self.compiler.find_library_file(lib_dirs + added_lib_dirs,
1513                                            'BLT'):
1514             defs.append( ('WITH_BLT', 1) )
1515             libs.append('BLT')
1516
1517         # Add the Tcl/Tk libraries
1518         libs.append('tk'+ version)
1519         libs.append('tcl'+ version)
1520
1521         if platform in ['aix3', 'aix4']:
1522             libs.append('ld')
1523
1524         # Finally, link with the X11 libraries (not appropriate on cygwin)
1525         if platform != "cygwin":
1526             libs.append('X11')
1527
1528         ext = Extension('_tkinter', ['_tkinter.c', 'tkappinit.c'],
1529                         define_macros=[('WITH_APPINIT', 1)] + defs,
1530                         include_dirs = include_dirs,
1531                         libraries = libs,
1532                         library_dirs = added_lib_dirs,
1533                         )
1534         self.extensions.append(ext)
1535
1536 ##         # Uncomment these lines if you want to play with xxmodule.c
1537 ##         ext = Extension('xx', ['xxmodule.c'])
1538 ##         self.extensions.append(ext)
1539
1540         # XXX handle these, but how to detect?
1541         # *** Uncomment and edit for PIL (TkImaging) extension only:
1542         #       -DWITH_PIL -I../Extensions/Imaging/libImaging  tkImaging.c \
1543         # *** Uncomment and edit for TOGL extension only:
1544         #       -DWITH_TOGL togl.c \
1545         # *** Uncomment these for TOGL extension only:
1546         #       -lGL -lGLU -lXext -lXmu \
1547
1548     def configure_ctypes_darwin(self, ext):
1549         # Darwin (OS X) uses preconfigured files, in
1550         # the Modules/_ctypes/libffi_osx directory.
1551         srcdir = sysconfig.get_config_var('srcdir')
1552         ffi_srcdir = os.path.abspath(os.path.join(srcdir, 'Modules',
1553                                                   '_ctypes', 'libffi_osx'))
1554         sources = [os.path.join(ffi_srcdir, p)
1555                    for p in ['ffi.c',
1556                              'x86/darwin64.S',
1557                              'x86/x86-darwin.S',
1558                              'x86/x86-ffi_darwin.c',
1559                              'x86/x86-ffi64.c',
1560                              'powerpc/ppc-darwin.S',
1561                              'powerpc/ppc-darwin_closure.S',
1562                              'powerpc/ppc-ffi_darwin.c',
1563                              'powerpc/ppc64-darwin_closure.S',
1564                              ]]
1565
1566         # Add .S (preprocessed assembly) to C compiler source extensions.
1567         self.compiler.src_extensions.append('.S')
1568
1569         include_dirs = [os.path.join(ffi_srcdir, 'include'),
1570                         os.path.join(ffi_srcdir, 'powerpc')]
1571         ext.include_dirs.extend(include_dirs)
1572         ext.sources.extend(sources)
1573         return True
1574
1575     def configure_ctypes(self, ext):
1576         if not self.use_system_libffi:
1577             if sys.platform == 'darwin':
1578                 return self.configure_ctypes_darwin(ext)
1579
1580             srcdir = sysconfig.get_config_var('srcdir')
1581             ffi_builddir = os.path.join(self.build_temp, 'libffi')
1582             ffi_srcdir = os.path.abspath(os.path.join(srcdir, 'Modules',
1583                                          '_ctypes', 'libffi'))
1584             ffi_configfile = os.path.join(ffi_builddir, 'fficonfig.py')
1585
1586             from distutils.dep_util import newer_group
1587
1588             config_sources = [os.path.join(ffi_srcdir, fname)
1589                               for fname in os.listdir(ffi_srcdir)
1590                               if os.path.isfile(os.path.join(ffi_srcdir, fname))]
1591             if self.force or newer_group(config_sources,
1592                                          ffi_configfile):
1593                 from distutils.dir_util import mkpath
1594                 mkpath(ffi_builddir)
1595                 config_args = []
1596
1597                 # Pass empty CFLAGS because we'll just append the resulting
1598                 # CFLAGS to Python's; -g or -O2 is to be avoided.
1599                 cmd = "cd %s && env CFLAGS='' '%s/configure' %s" \
1600                       % (ffi_builddir, ffi_srcdir, " ".join(config_args))
1601
1602                 res = os.system(cmd)
1603                 if res or not os.path.exists(ffi_configfile):
1604                     print("Failed to configure _ctypes module")
1605                     return False
1606
1607             fficonfig = {}
1608             fp = open(ffi_configfile)
1609             try:
1610                 script = fp.read()
1611             finally:
1612                 fp.close()
1613             exec(script, globals(), fficonfig)
1614             ffi_srcdir = os.path.join(fficonfig['ffi_srcdir'], 'src')
1615
1616             # Add .S (preprocessed assembly) to C compiler source extensions.
1617             self.compiler.src_extensions.append('.S')
1618
1619             include_dirs = [os.path.join(ffi_builddir, 'include'),
1620                             ffi_builddir, ffi_srcdir]
1621             extra_compile_args = fficonfig['ffi_cflags'].split()
1622
1623             ext.sources.extend(fficonfig['ffi_sources'])
1624             ext.include_dirs.extend(include_dirs)
1625             ext.extra_compile_args.extend(extra_compile_args)
1626         return True
1627
1628     def detect_ctypes(self, inc_dirs, lib_dirs):
1629         self.use_system_libffi = False
1630         include_dirs = []
1631         extra_compile_args = []
1632         extra_link_args = []
1633         sources = ['_ctypes/_ctypes.c',
1634                    '_ctypes/callbacks.c',
1635                    '_ctypes/callproc.c',
1636                    '_ctypes/stgdict.c',
1637                    '_ctypes/cfield.c',
1638                    '_ctypes/malloc_closure.c']
1639         depends = ['_ctypes/ctypes.h']
1640
1641         if sys.platform == 'darwin':
1642             sources.append('_ctypes/darwin/dlfcn_simple.c')
1643             extra_compile_args.append('-DMACOSX')
1644             include_dirs.append('_ctypes/darwin')
1645 # XXX Is this still needed?
1646 ##            extra_link_args.extend(['-read_only_relocs', 'warning'])
1647
1648         elif sys.platform == 'sunos5':
1649             # XXX This shouldn't be necessary; it appears that some
1650             # of the assembler code is non-PIC (i.e. it has relocations
1651             # when it shouldn't. The proper fix would be to rewrite
1652             # the assembler code to be PIC.
1653             # This only works with GCC; the Sun compiler likely refuses
1654             # this option. If you want to compile ctypes with the Sun
1655             # compiler, please research a proper solution, instead of
1656             # finding some -z option for the Sun compiler.
1657             extra_link_args.append('-mimpure-text')
1658
1659         elif sys.platform.startswith('hp-ux'):
1660             extra_link_args.append('-fPIC')
1661
1662         ext = Extension('_ctypes',
1663                         include_dirs=include_dirs,
1664                         extra_compile_args=extra_compile_args,
1665                         extra_link_args=extra_link_args,
1666                         libraries=[],
1667                         sources=sources,
1668                         depends=depends)
1669         ext_test = Extension('_ctypes_test',
1670                              sources=['_ctypes/_ctypes_test.c'])
1671         self.extensions.extend([ext, ext_test])
1672
1673         if not '--with-system-ffi' in sysconfig.get_config_var("CONFIG_ARGS"):
1674             return
1675
1676         if sys.platform == 'darwin':
1677             # OS X 10.5 comes with libffi.dylib; the include files are
1678             # in /usr/include/ffi
1679             inc_dirs.append('/usr/include/ffi')
1680
1681         ffi_inc = find_file('ffi.h', [], inc_dirs)
1682         if ffi_inc is not None:
1683             ffi_h = ffi_inc[0] + '/ffi.h'
1684             fp = open(ffi_h)
1685             while 1:
1686                 line = fp.readline()
1687                 if not line:
1688                     ffi_inc = None
1689                     break
1690                 if line.startswith('#define LIBFFI_H'):
1691                     break
1692         ffi_lib = None
1693         if ffi_inc is not None:
1694             for lib_name in ('ffi_convenience', 'ffi_pic', 'ffi'):
1695                 if (self.compiler.find_library_file(lib_dirs, lib_name)):
1696                     ffi_lib = lib_name
1697                     break
1698
1699         if ffi_inc and ffi_lib:
1700             ext.include_dirs.extend(ffi_inc)
1701             ext.libraries.append(ffi_lib)
1702             self.use_system_libffi = True
1703
1704
1705 class PyBuildInstall(install):
1706     # Suppress the warning about installation into the lib_dynload
1707     # directory, which is not in sys.path when running Python during
1708     # installation:
1709     def initialize_options (self):
1710         install.initialize_options(self)
1711         self.warn_dir=0
1712
1713 class PyBuildInstallLib(install_lib):
1714     # Do exactly what install_lib does but make sure correct access modes get
1715     # set on installed directories and files. All installed files with get
1716     # mode 644 unless they are a shared library in which case they will get
1717     # mode 755. All installed directories will get mode 755.
1718
1719     so_ext = sysconfig.get_config_var("SO")
1720
1721     def install(self):
1722         outfiles = install_lib.install(self)
1723         self.set_file_modes(outfiles, 0o644, 0o755)
1724         self.set_dir_modes(self.install_dir, 0o755)
1725         return outfiles
1726
1727     def set_file_modes(self, files, defaultMode, sharedLibMode):
1728         if not self.is_chmod_supported(): return
1729         if not files: return
1730
1731         for filename in files:
1732             if os.path.islink(filename): continue
1733             mode = defaultMode
1734             if filename.endswith(self.so_ext): mode = sharedLibMode
1735             log.info("changing mode of %s to %o", filename, mode)
1736             if not self.dry_run: os.chmod(filename, mode)
1737
1738     def set_dir_modes(self, dirname, mode):
1739         if not self.is_chmod_supported(): return
1740         for dirpath, dirnames, fnames in os.walk(dirname):
1741             if os.path.islink(dirpath):
1742                 continue
1743             log.info("changing mode of %s to %o", dirpath, mode)
1744             if not self.dry_run: os.chmod(dirpath, mode)
1745
1746     def is_chmod_supported(self):
1747         return hasattr(os, 'chmod')
1748
1749 SUMMARY = """
1750 Python is an interpreted, interactive, object-oriented programming
1751 language. It is often compared to Tcl, Perl, Scheme or Java.
1752
1753 Python combines remarkable power with very clear syntax. It has
1754 modules, classes, exceptions, very high level dynamic data types, and
1755 dynamic typing. There are interfaces to many system calls and
1756 libraries, as well as to various windowing systems (X11, Motif, Tk,
1757 Mac, MFC). New built-in modules are easily written in C or C++. Python
1758 is also usable as an extension language for applications that need a
1759 programmable interface.
1760
1761 The Python implementation is portable: it runs on many brands of UNIX,
1762 on Windows, DOS, OS/2, Mac, Amiga... If your favorite system isn't
1763 listed here, it may still be supported, if there's a C compiler for
1764 it. Ask around on comp.lang.python -- or just try compiling Python
1765 yourself.
1766 """
1767
1768 CLASSIFIERS = """
1769 Development Status :: 6 - Mature
1770 License :: OSI Approved :: Python Software Foundation License
1771 Natural Language :: English
1772 Programming Language :: C
1773 Programming Language :: Python
1774 Topic :: Software Development
1775 """
1776
1777 def main():
1778     # turn off warnings when deprecated modules are imported
1779     import warnings
1780     warnings.filterwarnings("ignore",category=DeprecationWarning)
1781     setup(# PyPI Metadata (PEP 301)
1782           name = "Python",
1783           version = sys.version.split()[0],
1784           url = "http://www.python.org/%s" % sys.version[:3],
1785           maintainer = "Guido van Rossum and the Python community",
1786           maintainer_email = "python-dev@python.org",
1787           description = "A high-level object-oriented programming language",
1788           long_description = SUMMARY.strip(),
1789           license = "PSF license",
1790           classifiers = [x for x in CLASSIFIERS.split("\n") if x],
1791           platforms = ["Many"],
1792
1793           # Build info
1794           cmdclass = {'build_ext':PyBuildExt, 'install':PyBuildInstall,
1795                       'install_lib':PyBuildInstallLib},
1796           # The struct module is defined here, because build_ext won't be
1797           # called unless there's at least one extension module defined.
1798           ext_modules=[Extension('_struct', ['_struct.c'])],
1799
1800           scripts = ["Tools/scripts/pydoc3", "Tools/scripts/idle3",
1801                      "Tools/scripts/2to3"]
1802         )
1803
1804 # --install-platlib
1805 if __name__ == '__main__':
1806     main()