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             exts.append(
1222                        Extension('_scproxy', ['_scproxy.c'],
1223                        extra_link_args=[
1224                            '-framework', 'SystemConfiguration',
1225                            '-framework', 'CoreFoundation',
1226                         ]))
1227
1228         self.extensions.extend(exts)
1229
1230         # Call the method for detecting whether _tkinter can be compiled
1231         self.detect_tkinter(inc_dirs, lib_dirs)
1232
1233         if '_tkinter' not in [e.name for e in self.extensions]:
1234             missing.append('_tkinter')
1235
1236         return missing
1237
1238     def detect_tkinter_darwin(self, inc_dirs, lib_dirs):
1239         # The _tkinter module, using frameworks. Since frameworks are quite
1240         # different the UNIX search logic is not sharable.
1241         from os.path import join, exists
1242         framework_dirs = [
1243             '/Library/Frameworks',
1244             '/System/Library/Frameworks/',
1245             join(os.getenv('HOME'), '/Library/Frameworks')
1246         ]
1247
1248         # Find the directory that contains the Tcl.framework and Tk.framework
1249         # bundles.
1250         # XXX distutils should support -F!
1251         for F in framework_dirs:
1252             # both Tcl.framework and Tk.framework should be present
1253             for fw in 'Tcl', 'Tk':
1254                 if not exists(join(F, fw + '.framework')):
1255                     break
1256             else:
1257                 # ok, F is now directory with both frameworks. Continure
1258                 # building
1259                 break
1260         else:
1261             # Tk and Tcl frameworks not found. Normal "unix" tkinter search
1262             # will now resume.
1263             return 0
1264
1265         # For 8.4a2, we must add -I options that point inside the Tcl and Tk
1266         # frameworks. In later release we should hopefully be able to pass
1267         # the -F option to gcc, which specifies a framework lookup path.
1268         #
1269         include_dirs = [
1270             join(F, fw + '.framework', H)
1271             for fw in ('Tcl', 'Tk')
1272             for H in ('Headers', 'Versions/Current/PrivateHeaders')
1273         ]
1274
1275         # For 8.4a2, the X11 headers are not included. Rather than include a
1276         # complicated search, this is a hard-coded path. It could bail out
1277         # if X11 libs are not found...
1278         include_dirs.append('/usr/X11R6/include')
1279         frameworks = ['-framework', 'Tcl', '-framework', 'Tk']
1280
1281         # All existing framework builds of Tcl/Tk don't support 64-bit
1282         # architectures.
1283         cflags = sysconfig.get_config_vars('CFLAGS')[0]
1284         archs = re.findall('-arch\s+(\w+)', cflags)
1285
1286         tmpfile = os.path.join(self.build_temp, 'tk.arch')
1287         if not os.path.exists(self.build_temp):
1288             os.makedirs(self.build_temp)
1289
1290         # Note: cannot use os.popen or subprocess here, that
1291         # requires extensions that are not available here.
1292         os.system("file %s/Tk.framework/Tk | grep 'for architecture' > %s"%(F, tmpfile))
1293         fp = open(tmpfile)
1294         detected_archs = []
1295         for ln in fp:
1296             a = ln.split()[-1]
1297             if a in archs:
1298                 detected_archs.append(ln.split()[-1])
1299         fp.close()
1300         os.unlink(tmpfile)
1301
1302         for a in detected_archs:
1303             frameworks.append('-arch')
1304             frameworks.append(a)
1305
1306         ext = Extension('_tkinter', ['_tkinter.c', 'tkappinit.c'],
1307                         define_macros=[('WITH_APPINIT', 1)],
1308                         include_dirs = include_dirs,
1309                         libraries = [],
1310                         extra_compile_args = frameworks[2:],
1311                         extra_link_args = frameworks,
1312                         )
1313         self.extensions.append(ext)
1314         return 1
1315
1316
1317     def detect_tkinter(self, inc_dirs, lib_dirs):
1318         # The _tkinter module.
1319
1320         # Rather than complicate the code below, detecting and building
1321         # AquaTk is a separate method. Only one Tkinter will be built on
1322         # Darwin - either AquaTk, if it is found, or X11 based Tk.
1323         platform = self.get_platform()
1324         if (platform == 'darwin' and
1325             self.detect_tkinter_darwin(inc_dirs, lib_dirs)):
1326             return
1327
1328         # Assume we haven't found any of the libraries or include files
1329         # The versions with dots are used on Unix, and the versions without
1330         # dots on Windows, for detection by cygwin.
1331         tcllib = tklib = tcl_includes = tk_includes = None
1332         for version in ['8.5', '85', '8.4', '84', '8.3', '83', '8.2',
1333                         '82', '8.1', '81', '8.0', '80']:
1334             tklib = self.compiler.find_library_file(lib_dirs, 'tk' + version)
1335             tcllib = self.compiler.find_library_file(lib_dirs, 'tcl' + version)
1336             if tklib and tcllib:
1337                 # Exit the loop when we've found the Tcl/Tk libraries
1338                 break
1339
1340         # Now check for the header files
1341         if tklib and tcllib:
1342             # Check for the include files on Debian and {Free,Open}BSD, where
1343             # they're put in /usr/include/{tcl,tk}X.Y
1344             dotversion = version
1345             if '.' not in dotversion and "bsd" in sys.platform.lower():
1346                 # OpenBSD and FreeBSD use Tcl/Tk library names like libtcl83.a,
1347                 # but the include subdirs are named like .../include/tcl8.3.
1348                 dotversion = dotversion[:-1] + '.' + dotversion[-1]
1349             tcl_include_sub = []
1350             tk_include_sub = []
1351             for dir in inc_dirs:
1352                 tcl_include_sub += [dir + os.sep + "tcl" + dotversion]
1353                 tk_include_sub += [dir + os.sep + "tk" + dotversion]
1354             tk_include_sub += tcl_include_sub
1355             tcl_includes = find_file('tcl.h', inc_dirs, tcl_include_sub)
1356             tk_includes = find_file('tk.h', inc_dirs, tk_include_sub)
1357
1358         if (tcllib is None or tklib is None or
1359             tcl_includes is None or tk_includes is None):
1360             self.announce("INFO: Can't locate Tcl/Tk libs and/or headers", 2)
1361             return
1362
1363         # OK... everything seems to be present for Tcl/Tk.
1364
1365         include_dirs = [] ; libs = [] ; defs = [] ; added_lib_dirs = []
1366         for dir in tcl_includes + tk_includes:
1367             if dir not in include_dirs:
1368                 include_dirs.append(dir)
1369
1370         # Check for various platform-specific directories
1371         if platform == 'sunos5':
1372             include_dirs.append('/usr/openwin/include')
1373             added_lib_dirs.append('/usr/openwin/lib')
1374         elif os.path.exists('/usr/X11R6/include'):
1375             include_dirs.append('/usr/X11R6/include')
1376             added_lib_dirs.append('/usr/X11R6/lib64')
1377             added_lib_dirs.append('/usr/X11R6/lib')
1378         elif os.path.exists('/usr/X11R5/include'):
1379             include_dirs.append('/usr/X11R5/include')
1380             added_lib_dirs.append('/usr/X11R5/lib')
1381         else:
1382             # Assume default location for X11
1383             include_dirs.append('/usr/X11/include')
1384             added_lib_dirs.append('/usr/X11/lib')
1385
1386         # If Cygwin, then verify that X is installed before proceeding
1387         if platform == 'cygwin':
1388             x11_inc = find_file('X11/Xlib.h', [], include_dirs)
1389             if x11_inc is None:
1390                 return
1391
1392         # Check for BLT extension
1393         if self.compiler.find_library_file(lib_dirs + added_lib_dirs,
1394                                            'BLT8.0'):
1395             defs.append( ('WITH_BLT', 1) )
1396             libs.append('BLT8.0')
1397         elif self.compiler.find_library_file(lib_dirs + added_lib_dirs,
1398                                            'BLT'):
1399             defs.append( ('WITH_BLT', 1) )
1400             libs.append('BLT')
1401
1402         # Add the Tcl/Tk libraries
1403         libs.append('tk'+ version)
1404         libs.append('tcl'+ version)
1405
1406         if platform in ['aix3', 'aix4']:
1407             libs.append('ld')
1408
1409         # Finally, link with the X11 libraries (not appropriate on cygwin)
1410         if platform != "cygwin":
1411             libs.append('X11')
1412
1413         ext = Extension('_tkinter', ['_tkinter.c', 'tkappinit.c'],
1414                         define_macros=[('WITH_APPINIT', 1)] + defs,
1415                         include_dirs = include_dirs,
1416                         libraries = libs,
1417                         library_dirs = added_lib_dirs,
1418                         )
1419         self.extensions.append(ext)
1420
1421 ##         # Uncomment these lines if you want to play with xxmodule.c
1422 ##         ext = Extension('xx', ['xxmodule.c'])
1423 ##         self.extensions.append(ext)
1424
1425         # XXX handle these, but how to detect?
1426         # *** Uncomment and edit for PIL (TkImaging) extension only:
1427         #       -DWITH_PIL -I../Extensions/Imaging/libImaging  tkImaging.c \
1428         # *** Uncomment and edit for TOGL extension only:
1429         #       -DWITH_TOGL togl.c \
1430         # *** Uncomment these for TOGL extension only:
1431         #       -lGL -lGLU -lXext -lXmu \
1432
1433     def configure_ctypes_darwin(self, ext):
1434         # Darwin (OS X) uses preconfigured files, in
1435         # the Modules/_ctypes/libffi_osx directory.
1436         srcdir = sysconfig.get_config_var('srcdir')
1437         ffi_srcdir = os.path.abspath(os.path.join(srcdir, 'Modules',
1438                                                   '_ctypes', 'libffi_osx'))
1439         sources = [os.path.join(ffi_srcdir, p)
1440                    for p in ['ffi.c',
1441                              'x86/darwin64.S',
1442                              'x86/x86-darwin.S',
1443                              'x86/x86-ffi_darwin.c',
1444                              'x86/x86-ffi64.c',
1445                              'powerpc/ppc-darwin.S',
1446                              'powerpc/ppc-darwin_closure.S',
1447                              'powerpc/ppc-ffi_darwin.c',
1448                              'powerpc/ppc64-darwin_closure.S',
1449                              ]]
1450
1451         # Add .S (preprocessed assembly) to C compiler source extensions.
1452         self.compiler.src_extensions.append('.S')
1453
1454         include_dirs = [os.path.join(ffi_srcdir, 'include'),
1455                         os.path.join(ffi_srcdir, 'powerpc')]
1456         ext.include_dirs.extend(include_dirs)
1457         ext.sources.extend(sources)
1458         return True
1459
1460     def configure_ctypes(self, ext):
1461         if not self.use_system_libffi:
1462             if sys.platform == 'darwin':
1463                 return self.configure_ctypes_darwin(ext)
1464
1465             srcdir = sysconfig.get_config_var('srcdir')
1466             ffi_builddir = os.path.join(self.build_temp, 'libffi')
1467             ffi_srcdir = os.path.abspath(os.path.join(srcdir, 'Modules',
1468                                          '_ctypes', 'libffi'))
1469             ffi_configfile = os.path.join(ffi_builddir, 'fficonfig.py')
1470
1471             from distutils.dep_util import newer_group
1472
1473             config_sources = [os.path.join(ffi_srcdir, fname)
1474                               for fname in os.listdir(ffi_srcdir)
1475                               if os.path.isfile(os.path.join(ffi_srcdir, fname))]
1476             if self.force or newer_group(config_sources,
1477                                          ffi_configfile):
1478                 from distutils.dir_util import mkpath
1479                 mkpath(ffi_builddir)
1480                 config_args = []
1481
1482                 # Pass empty CFLAGS because we'll just append the resulting
1483                 # CFLAGS to Python's; -g or -O2 is to be avoided.
1484                 cmd = "cd %s && env CFLAGS='' '%s/configure' %s" \
1485                       % (ffi_builddir, ffi_srcdir, " ".join(config_args))
1486
1487                 res = os.system(cmd)
1488                 if res or not os.path.exists(ffi_configfile):
1489                     print("Failed to configure _ctypes module")
1490                     return False
1491
1492             fficonfig = {}
1493             fp = open(ffi_configfile)
1494             try:
1495                 script = fp.read()
1496             finally:
1497                 fp.close()
1498             exec(script, globals(), fficonfig)
1499             ffi_srcdir = os.path.join(fficonfig['ffi_srcdir'], 'src')
1500
1501             # Add .S (preprocessed assembly) to C compiler source extensions.
1502             self.compiler.src_extensions.append('.S')
1503
1504             include_dirs = [os.path.join(ffi_builddir, 'include'),
1505                             ffi_builddir, ffi_srcdir]
1506             extra_compile_args = fficonfig['ffi_cflags'].split()
1507
1508             ext.sources.extend(fficonfig['ffi_sources'])
1509             ext.include_dirs.extend(include_dirs)
1510             ext.extra_compile_args.extend(extra_compile_args)
1511         return True
1512
1513     def detect_ctypes(self, inc_dirs, lib_dirs):
1514         self.use_system_libffi = False
1515         include_dirs = []
1516         extra_compile_args = []
1517         extra_link_args = []
1518         sources = ['_ctypes/_ctypes.c',
1519                    '_ctypes/callbacks.c',
1520                    '_ctypes/callproc.c',
1521                    '_ctypes/stgdict.c',
1522                    '_ctypes/cfield.c',
1523                    '_ctypes/malloc_closure.c']
1524         depends = ['_ctypes/ctypes.h']
1525
1526         if sys.platform == 'darwin':
1527             sources.append('_ctypes/darwin/dlfcn_simple.c')
1528             extra_compile_args.append('-DMACOSX')
1529             include_dirs.append('_ctypes/darwin')
1530 # XXX Is this still needed?
1531 ##            extra_link_args.extend(['-read_only_relocs', 'warning'])
1532
1533         elif sys.platform == 'sunos5':
1534             # XXX This shouldn't be necessary; it appears that some
1535             # of the assembler code is non-PIC (i.e. it has relocations
1536             # when it shouldn't. The proper fix would be to rewrite
1537             # the assembler code to be PIC.
1538             # This only works with GCC; the Sun compiler likely refuses
1539             # this option. If you want to compile ctypes with the Sun
1540             # compiler, please research a proper solution, instead of
1541             # finding some -z option for the Sun compiler.
1542             extra_link_args.append('-mimpure-text')
1543
1544         elif sys.platform.startswith('hp-ux'):
1545             extra_link_args.append('-fPIC')
1546
1547         ext = Extension('_ctypes',
1548                         include_dirs=include_dirs,
1549                         extra_compile_args=extra_compile_args,
1550                         extra_link_args=extra_link_args,
1551                         libraries=[],
1552                         sources=sources,
1553                         depends=depends)
1554         ext_test = Extension('_ctypes_test',
1555                              sources=['_ctypes/_ctypes_test.c'])
1556         self.extensions.extend([ext, ext_test])
1557
1558         if not '--with-system-ffi' in sysconfig.get_config_var("CONFIG_ARGS"):
1559             return
1560
1561         if sys.platform == 'darwin':
1562             # OS X 10.5 comes with libffi.dylib; the include files are
1563             # in /usr/include/ffi
1564             inc_dirs.append('/usr/include/ffi')
1565
1566         ffi_inc = find_file('ffi.h', [], inc_dirs)
1567         if ffi_inc is not None:
1568             ffi_h = ffi_inc[0] + '/ffi.h'
1569             fp = open(ffi_h)
1570             while 1:
1571                 line = fp.readline()
1572                 if not line:
1573                     ffi_inc = None
1574                     break
1575                 if line.startswith('#define LIBFFI_H'):
1576                     break
1577         ffi_lib = None
1578         if ffi_inc is not None:
1579             for lib_name in ('ffi_convenience', 'ffi_pic', 'ffi'):
1580                 if (self.compiler.find_library_file(lib_dirs, lib_name)):
1581                     ffi_lib = lib_name
1582                     break
1583
1584         if ffi_inc and ffi_lib:
1585             ext.include_dirs.extend(ffi_inc)
1586             ext.libraries.append(ffi_lib)
1587             self.use_system_libffi = True
1588
1589
1590 class PyBuildInstall(install):
1591     # Suppress the warning about installation into the lib_dynload
1592     # directory, which is not in sys.path when running Python during
1593     # installation:
1594     def initialize_options (self):
1595         install.initialize_options(self)
1596         self.warn_dir=0
1597
1598 class PyBuildInstallLib(install_lib):
1599     # Do exactly what install_lib does but make sure correct access modes get
1600     # set on installed directories and files. All installed files with get
1601     # mode 644 unless they are a shared library in which case they will get
1602     # mode 755. All installed directories will get mode 755.
1603
1604     so_ext = sysconfig.get_config_var("SO")
1605
1606     def install(self):
1607         outfiles = install_lib.install(self)
1608         self.set_file_modes(outfiles, 0o644, 0o755)
1609         self.set_dir_modes(self.install_dir, 0o755)
1610         return outfiles
1611
1612     def set_file_modes(self, files, defaultMode, sharedLibMode):
1613         if not self.is_chmod_supported(): return
1614         if not files: return
1615
1616         for filename in files:
1617             if os.path.islink(filename): continue
1618             mode = defaultMode
1619             if filename.endswith(self.so_ext): mode = sharedLibMode
1620             log.info("changing mode of %s to %o", filename, mode)
1621             if not self.dry_run: os.chmod(filename, mode)
1622
1623     def set_dir_modes(self, dirname, mode):
1624         if not self.is_chmod_supported(): return
1625         for dirpath, dirnames, fnames in os.walk(dirname):
1626             if os.path.islink(dirpath):
1627                 continue
1628             log.info("changing mode of %s to %o", dirpath, mode)
1629             if not self.dry_run: os.chmod(dirpath, mode)
1630
1631     def is_chmod_supported(self):
1632         return hasattr(os, 'chmod')
1633
1634 SUMMARY = """
1635 Python is an interpreted, interactive, object-oriented programming
1636 language. It is often compared to Tcl, Perl, Scheme or Java.
1637
1638 Python combines remarkable power with very clear syntax. It has
1639 modules, classes, exceptions, very high level dynamic data types, and
1640 dynamic typing. There are interfaces to many system calls and
1641 libraries, as well as to various windowing systems (X11, Motif, Tk,
1642 Mac, MFC). New built-in modules are easily written in C or C++. Python
1643 is also usable as an extension language for applications that need a
1644 programmable interface.
1645
1646 The Python implementation is portable: it runs on many brands of UNIX,
1647 on Windows, DOS, OS/2, Mac, Amiga... If your favorite system isn't
1648 listed here, it may still be supported, if there's a C compiler for
1649 it. Ask around on comp.lang.python -- or just try compiling Python
1650 yourself.
1651 """
1652
1653 CLASSIFIERS = """
1654 Development Status :: 6 - Mature
1655 License :: OSI Approved :: Python Software Foundation License
1656 Natural Language :: English
1657 Programming Language :: C
1658 Programming Language :: Python
1659 Topic :: Software Development
1660 """
1661
1662 def main():
1663     # turn off warnings when deprecated modules are imported
1664     import warnings
1665     warnings.filterwarnings("ignore",category=DeprecationWarning)
1666     setup(# PyPI Metadata (PEP 301)
1667           name = "Python",
1668           version = sys.version.split()[0],
1669           url = "http://www.python.org/%s" % sys.version[:3],
1670           maintainer = "Guido van Rossum and the Python community",
1671           maintainer_email = "python-dev@python.org",
1672           description = "A high-level object-oriented programming language",
1673           long_description = SUMMARY.strip(),
1674           license = "PSF license",
1675           classifiers = [x for x in CLASSIFIERS.split("\n") if x],
1676           platforms = ["Many"],
1677
1678           # Build info
1679           cmdclass = {'build_ext':PyBuildExt, 'install':PyBuildInstall,
1680                       'install_lib':PyBuildInstallLib},
1681           # The struct module is defined here, because build_ext won't be
1682           # called unless there's at least one extension module defined.
1683           ext_modules=[Extension('_struct', ['_struct.c'])],
1684
1685           scripts = ["Tools/scripts/pydoc3", "Tools/scripts/idle3",
1686                      "Tools/scripts/2to3"]
1687         )
1688
1689 # --install-platlib
1690 if __name__ == '__main__':
1691     main()