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