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