setup.py

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