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         # The standard Unix dbm module:
 897         if platform not in ['cygwin']:
 898             config_args = [arg.strip("'")
 899                            for arg in sysconfig.get_config_var("CONFIG_ARGS").split()]
 900             dbm_args = [arg.split('=')[-1] for arg in config_args
 901                         if arg.startswith('--with-dbmliborder=')]
 902             if dbm_args:
 903                 dbm_order = dbm_args[-1].split(":")
 904             else:
 905                 dbm_order = "ndbm:gdbm:bdb".split(":")
 906             dbmext = None
 907             for cand in dbm_order:
 908                 if cand == "ndbm":
 909                     if find_file("ndbm.h", inc_dirs, []) is not None:
 910                         # Some systems have -lndbm, others don't
 911                         if self.compiler.find_library_file(lib_dirs, 'ndbm'):
 912                             ndbm_libs = ['ndbm']
 913                         else:
 914                             ndbm_libs = []
 915                         print("building dbm using ndbm")
 916                         dbmext = Extension('_dbm', ['_dbmmodule.c'],
 917                                            define_macros=[
 918                                                ('HAVE_NDBM_H',None),
 919                                                ],
 920                                            libraries=ndbm_libs)
 921                         break
 922
 923                 elif cand == "gdbm":
 924                     if self.compiler.find_library_file(lib_dirs, 'gdbm'):
 925                         gdbm_libs = ['gdbm']
 926                         if self.compiler.find_library_file(lib_dirs, 'gdbm_compat'):
 927                             gdbm_libs.append('gdbm_compat')
 928                         if find_file("gdbm/ndbm.h", inc_dirs, []) is not None:
 929                             print("building dbm using gdbm")
 930                             dbmext = Extension(
 931                                 '_dbm', ['_dbmmodule.c'],
 932                                 define_macros=[
 933                                     ('HAVE_GDBM_NDBM_H', None),
 934                                     ],
 935                                 libraries = gdbm_libs)
 936                             break
 937                         if find_file("gdbm-ndbm.h", inc_dirs, []) is not None:
 938                             print("building dbm using gdbm")
 939                             dbmext = Extension(
 940                                 '_dbm', ['_dbmmodule.c'],
 941                                 define_macros=[
 942                                     ('HAVE_GDBM_DASH_NDBM_H', None),
 943                                     ],
 944                                 libraries = gdbm_libs)
 945                             break
 946                 elif cand == "bdb":
 947                     if db_incs is not None:
 948                         print("building dbm using bdb")
 949                         dbmext = Extension('_dbm', ['_dbmmodule.c'],
 950                                            library_dirs=dblib_dir,
 951                                            runtime_library_dirs=dblib_dir,
 952                                            include_dirs=db_incs,
 953                                            define_macros=[
 954                                                ('HAVE_BERKDB_H', None),
 955                                                ('DB_DBM_HSEARCH', None),
 956                                                ],
 957                                            libraries=dblibs)
 958                         break
 959             if dbmext is not None:
 960                 exts.append(dbmext)
 961             else:
 962                 missing.append('_dbm')
 963
 964         # Anthony Baxter's gdbm module.  GNU dbm(3) will require -lgdbm:
 965         if (self.compiler.find_library_file(lib_dirs, 'gdbm')):
 966             exts.append( Extension('_gdbm', ['_gdbmmodule.c'],
 967                                    libraries = ['gdbm'] ) )
 968         else:
 969             missing.append('_gdbm')
 970
 971         # Unix-only modules
 972         if platform not in ['mac', 'win32']:
 973             # Steen Lumholt's termios module
 974             exts.append( Extension('termios', ['termios.c']) )
 975             # Jeremy Hylton's rlimit interface
 976             if platform not in ['atheos']:
 977                 exts.append( Extension('resource', ['resource.c']) )
 978             else:
 979                 missing.append('resource')
 980
 981             # Sun yellow pages. Some systems have the functions in libc.
 982             if platform not in ['cygwin', 'atheos', 'qnx6']:
 983                 if (self.compiler.find_library_file(lib_dirs, 'nsl')):
 984                     libs = ['nsl']
 985                 else:
 986                     libs = []
 987                 exts.append( Extension('nis', ['nismodule.c'],
 988                                        libraries = libs) )
 989             else:
 990                 missing.append('nis')
 991         else:
 992             missing.extend(['nis', 'resource', 'termios'])
 993
 994         # Curses support, requiring the System V version of curses, often
 995         # provided by the ncurses library.
 996         panel_library = 'panel'
 997         if (self.compiler.find_library_file(lib_dirs, 'ncursesw')):
 998             curses_libs = ['ncursesw']
 999             # Bug 1464056: If _curses.so links with ncursesw,
1000             # _curses_panel.so must link with panelw.
1001             panel_library = 'panelw'
1002             exts.append( Extension('_curses', ['_cursesmodule.c'],
1003                                    libraries = curses_libs) )
1004         elif (self.compiler.find_library_file(lib_dirs, 'ncurses')):
1005             curses_libs = ['ncurses']
1006             exts.append( Extension('_curses', ['_cursesmodule.c'],
1007                                    libraries = curses_libs) )
1008         elif (self.compiler.find_library_file(lib_dirs, 'curses')
1009               and platform != 'darwin'):
1010                 # OSX has an old Berkeley curses, not good enough for
1011                 # the _curses module.
1012             if (self.compiler.find_library_file(lib_dirs, 'terminfo')):
1013                 curses_libs = ['curses', 'terminfo']
1014             elif (self.compiler.find_library_file(lib_dirs, 'termcap')):
1015                 curses_libs = ['curses', 'termcap']
1016             else:
1017                 curses_libs = ['curses']
1018
1019             exts.append( Extension('_curses', ['_cursesmodule.c'],
1020                                    libraries = curses_libs) )
1021         else:
1022             missing.append('_curses')
1023
1024         # If the curses module is enabled, check for the panel module
1025         if (module_enabled(exts, '_curses') and
1026             self.compiler.find_library_file(lib_dirs, panel_library)):
1027             exts.append( Extension('_curses_panel', ['_curses_panel.c'],
1028                                    libraries = [panel_library] + curses_libs) )
1029         else:
1030             missing.append('_curses_panel')
1031
1032         # Andrew Kuchling's zlib module.  Note that some versions of zlib
1033         # 1.1.3 have security problems.  See CERT Advisory CA-2002-07:
1034         # http://www.cert.org/advisories/CA-2002-07.html
1035         #
1036         # zlib 1.1.4 is fixed, but at least one vendor (RedHat) has decided to
1037         # patch its zlib 1.1.3 package instead of upgrading to 1.1.4.  For
1038         # now, we still accept 1.1.3, because we think it's difficult to
1039         # exploit this in Python, and we'd rather make it RedHat's problem
1040         # than our problem <wink>.
1041         #
1042         # You can upgrade zlib to version 1.1.4 yourself by going to
1043         # http://www.gzip.org/zlib/
1044         zlib_inc = find_file('zlib.h', [], inc_dirs)
1045         have_zlib = False
1046         if zlib_inc is not None:
1047             zlib_h = zlib_inc[0] + '/zlib.h'
1048             version = '"0.0.0"'
1049             version_req = '"1.1.3"'
1050             fp = open(zlib_h)
1051             while 1:
1052                 line = fp.readline()
1053                 if not line:
1054                     break
1055                 if line.startswith('#define ZLIB_VERSION'):
1056                     version = line.split()[2]
1057                     break
1058             if version >= version_req:
1059                 if (self.compiler.find_library_file(lib_dirs, 'z')):
1060                     if sys.platform == "darwin":
1061                         zlib_extra_link_args = ('-Wl,-search_paths_first',)
1062                     else:
1063                         zlib_extra_link_args = ()
1064                     exts.append( Extension('zlib', ['zlibmodule.c'],
1065                                            libraries = ['z'],
1066                                            extra_link_args = zlib_extra_link_args))
1067                     have_zlib = True
1068                 else:
1069                     missing.append('zlib')
1070             else:
1071                 missing.append('zlib')
1072         else:
1073             missing.append('zlib')
1074
1075         # Helper module for various ascii-encoders.  Uses zlib for an optimized
1076         # crc32 if we have it.  Otherwise binascii uses its own.
1077         if have_zlib:
1078             extra_compile_args = ['-DUSE_ZLIB_CRC32']
1079             libraries = ['z']
1080             extra_link_args = zlib_extra_link_args
1081         else:
1082             extra_compile_args = []
1083             libraries = []
1084             extra_link_args = []
1085         exts.append( Extension('binascii', ['binascii.c'],
1086                                extra_compile_args = extra_compile_args,
1087                                libraries = libraries,
1088                                extra_link_args = extra_link_args) )
1089
1090         # Gustavo Niemeyer's bz2 module.
1091         if (self.compiler.find_library_file(lib_dirs, 'bz2')):
1092             if sys.platform == "darwin":
1093                 bz2_extra_link_args = ('-Wl,-search_paths_first',)
1094             else:
1095                 bz2_extra_link_args = ()
1096             exts.append( Extension('bz2', ['bz2module.c'],
1097                                    libraries = ['bz2'],
1098                                    extra_link_args = bz2_extra_link_args) )
1099         else:
1100             missing.append('bz2')
1101
1102         # Interface to the Expat XML parser
1103         #
1104         # Expat was written by James Clark and is now maintained by a
1105         # group of developers on SourceForge; see www.libexpat.org for
1106         # more information.  The pyexpat module was written by Paul
1107         # Prescod after a prototype by Jack Jansen.  The Expat source
1108         # is included in Modules/expat/.  Usage of a system
1109         # shared libexpat.so/expat.dll is not advised.
1110         #
1111         # More information on Expat can be found at www.libexpat.org.
1112         #
1113         expatinc = os.path.join(os.getcwd(), srcdir, 'Modules', 'expat')
1114         define_macros = [
1115             ('HAVE_EXPAT_CONFIG_H', '1'),
1116         ]
1117
1118         exts.append(Extension('pyexpat',
1119                               define_macros = define_macros,
1120                               include_dirs = [expatinc],
1121                               sources = ['pyexpat.c',
1122                                          'expat/xmlparse.c',
1123                                          'expat/xmlrole.c',
1124                                          'expat/xmltok.c',
1125                                          ],
1126                               ))
1127
1128         # Fredrik Lundh's cElementTree module.  Note that this also
1129         # uses expat (via the CAPI hook in pyexpat).
1130
1131         if os.path.isfile(os.path.join(srcdir, 'Modules', '_elementtree.c')):
1132             define_macros.append(('USE_PYEXPAT_CAPI', None))
1133             exts.append(Extension('_elementtree',
1134                                   define_macros = define_macros,
1135                                   include_dirs = [expatinc],
1136                                   sources = ['_elementtree.c'],
1137                                   ))
1138         else:
1139             missing.append('_elementtree')
1140
1141         # Hye-Shik Chang's CJKCodecs modules.
1142         exts.append(Extension('_multibytecodec',
1143                               ['cjkcodecs/multibytecodec.c']))
1144         for loc in ('kr', 'jp', 'cn', 'tw', 'hk', 'iso2022'):
1145             exts.append(Extension('_codecs_%s' % loc,
1146                                   ['cjkcodecs/_codecs_%s.c' % loc]))
1147
1148         # Thomas Heller's _ctypes module
1149         self.detect_ctypes(inc_dirs, lib_dirs)
1150
1151         # Richard Oudkerk's multiprocessing module
1152         if platform == 'win32':             # Windows
1153             macros = dict()
1154             libraries = ['ws2_32']
1155
1156         elif platform == 'darwin':          # Mac OSX
1157             macros = dict()
1158             libraries = []
1159
1160         elif platform == 'cygwin':          # Cygwin
1161             macros = dict()
1162             libraries = []
1163
1164         elif platform in ('freebsd4', 'freebsd5', 'freebsd6', 'freebsd7', 'freebsd8'):
1165             # FreeBSD's P1003.1b semaphore support is very experimental
1166             # and has many known problems. (as of June 2008)
1167             macros = dict()
1168             libraries = []
1169
1170         elif platform.startswith('openbsd'):
1171             macros = dict()
1172             libraries = []
1173
1174         elif platform.startswith('netbsd'):
1175             macros = dict()
1176             libraries = []
1177
1178         else:                                   # Linux and other unices
1179             macros = dict()
1180             libraries = ['rt']
1181
1182         if platform == 'win32':
1183             multiprocessing_srcs = [ '_multiprocessing/multiprocessing.c',
1184                                      '_multiprocessing/semaphore.c',
1185                                      '_multiprocessing/pipe_connection.c',
1186                                      '_multiprocessing/socket_connection.c',
1187                                      '_multiprocessing/win32_functions.c'
1188                                    ]
1189
1190         else:
1191             multiprocessing_srcs = [ '_multiprocessing/multiprocessing.c',
1192                                      '_multiprocessing/socket_connection.c'
1193                                    ]
1194             if sysconfig.get_config_var('HAVE_SEM_OPEN'):
1195                 multiprocessing_srcs.append('_multiprocessing/semaphore.c')
1196
1197         if sysconfig.get_config_var('WITH_THREAD'):
1198             exts.append ( Extension('_multiprocessing', multiprocessing_srcs,
1199                                     define_macros=list(macros.items()),
1200                                     include_dirs=["Modules/_multiprocessing"]))
1201         else:
1202             missing.append('_multiprocessing')
1203         # End multiprocessing
1204
1205         # Platform-specific libraries
1206         if platform in ('linux2', 'freebsd4', 'freebsd5', 'freebsd6',
1207                         'freebsd7', 'freebsd8'):
1208             exts.append( Extension('ossaudiodev', ['ossaudiodev.c']) )
1209         else:
1210             missing.append('ossaudiodev')
1211
1212         if sys.platform == 'darwin':
1213             exts.append(
1214                        Extension('_gestalt', ['_gestalt.c'],
1215                        extra_link_args=['-framework', 'Carbon'])
1216                        )
1217
1218         self.extensions.extend(exts)
1219
1220         # Call the method for detecting whether _tkinter can be compiled
1221         self.detect_tkinter(inc_dirs, lib_dirs)
1222
1223         if '_tkinter' not in [e.name for e in self.extensions]:
1224             missing.append('_tkinter')
1225
1226         return missing
1227
1228     def detect_tkinter_darwin(self, inc_dirs, lib_dirs):
1229         # The _tkinter module, using frameworks. Since frameworks are quite
1230         # different the UNIX search logic is not sharable.
1231         from os.path import join, exists
1232         framework_dirs = [
1233             '/Library/Frameworks',
1234             '/System/Library/Frameworks/',
1235             join(os.getenv('HOME'), '/Library/Frameworks')
1236         ]
1237
1238         # Find the directory that contains the Tcl.framework and Tk.framework
1239         # bundles.
1240         # XXX distutils should support -F!
1241         for F in framework_dirs:
1242             # both Tcl.framework and Tk.framework should be present
1243             for fw in 'Tcl', 'Tk':
1244                 if not exists(join(F, fw + '.framework')):
1245                     break
1246             else:
1247                 # ok, F is now directory with both frameworks. Continure
1248                 # building
1249                 break
1250         else:
1251             # Tk and Tcl frameworks not found. Normal "unix" tkinter search
1252             # will now resume.
1253             return 0
1254
1255         # For 8.4a2, we must add -I options that point inside the Tcl and Tk
1256         # frameworks. In later release we should hopefully be able to pass
1257         # the -F option to gcc, which specifies a framework lookup path.
1258         #
1259         include_dirs = [
1260             join(F, fw + '.framework', H)
1261             for fw in ('Tcl', 'Tk')
1262             for H in ('Headers', 'Versions/Current/PrivateHeaders')
1263         ]
1264
1265         # For 8.4a2, the X11 headers are not included. Rather than include a
1266         # complicated search, this is a hard-coded path. It could bail out
1267         # if X11 libs are not found...
1268         include_dirs.append('/usr/X11R6/include')
1269         frameworks = ['-framework', 'Tcl', '-framework', 'Tk']
1270
1271         # All existing framework builds of Tcl/Tk don't support 64-bit
1272         # architectures.
1273         cflags = sysconfig.get_config_vars('CFLAGS')[0]
1274         archs = re.findall('-arch\s+(\w+)', cflags)
1275
1276         tmpfile = os.path.join(self.build_temp, 'tk.arch')
1277         if not os.path.exists(self.build_temp):
1278             os.makedirs(self.build_temp)
1279
1280         # Note: cannot use os.popen or subprocess here, that
1281         # requires extensions that are not available here.
1282         os.system("file %s/Tk.framework/Tk | grep 'for architecture' > %s"%(F, tmpfile))
1283         fp = open(tmpfile)
1284         detected_archs = []
1285         for ln in fp:
1286             a = ln.split()[-1]
1287             if a in archs:
1288                 detected_archs.append(ln.split()[-1])
1289         fp.close()
1290         os.unlink(tmpfile)
1291
1292         for a in detected_archs:
1293             frameworks.append('-arch')
1294             frameworks.append(a)
1295
1296         ext = Extension('_tkinter', ['_tkinter.c', 'tkappinit.c'],
1297                         define_macros=[('WITH_APPINIT', 1)],
1298                         include_dirs = include_dirs,
1299                         libraries = [],
1300                         extra_compile_args = frameworks[2:],
1301                         extra_link_args = frameworks,
1302                         )
1303         self.extensions.append(ext)
1304         return 1
1305
1306
1307     def detect_tkinter(self, inc_dirs, lib_dirs):
1308         # The _tkinter module.
1309
1310         # Rather than complicate the code below, detecting and building
1311         # AquaTk is a separate method. Only one Tkinter will be built on
1312         # Darwin - either AquaTk, if it is found, or X11 based Tk.
1313         platform = self.get_platform()
1314         if (platform == 'darwin' and
1315             self.detect_tkinter_darwin(inc_dirs, lib_dirs)):
1316             return
1317
1318         # Assume we haven't found any of the libraries or include files
1319         # The versions with dots are used on Unix, and the versions without
1320         # dots on Windows, for detection by cygwin.
1321         tcllib = tklib = tcl_includes = tk_includes = None
1322         for version in ['8.5', '85', '8.4', '84', '8.3', '83', '8.2',
1323                         '82', '8.1', '81', '8.0', '80']:
1324             tklib = self.compiler.find_library_file(lib_dirs, 'tk' + version)
1325             tcllib = self.compiler.find_library_file(lib_dirs, 'tcl' + version)
1326             if tklib and tcllib:
1327                 # Exit the loop when we've found the Tcl/Tk libraries
1328                 break
1329
1330         # Now check for the header files
1331         if tklib and tcllib:
1332             # Check for the include files on Debian and {Free,Open}BSD, where
1333             # they're put in /usr/include/{tcl,tk}X.Y
1334             dotversion = version
1335             if '.' not in dotversion and "bsd" in sys.platform.lower():
1336                 # OpenBSD and FreeBSD use Tcl/Tk library names like libtcl83.a,
1337                 # but the include subdirs are named like .../include/tcl8.3.
1338                 dotversion = dotversion[:-1] + '.' + dotversion[-1]
1339             tcl_include_sub = []
1340             tk_include_sub = []
1341             for dir in inc_dirs:
1342                 tcl_include_sub += [dir + os.sep + "tcl" + dotversion]
1343                 tk_include_sub += [dir + os.sep + "tk" + dotversion]
1344             tk_include_sub += tcl_include_sub
1345             tcl_includes = find_file('tcl.h', inc_dirs, tcl_include_sub)
1346             tk_includes = find_file('tk.h', inc_dirs, tk_include_sub)
1347
1348         if (tcllib is None or tklib is None or
1349             tcl_includes is None or tk_includes is None):
1350             self.announce("INFO: Can't locate Tcl/Tk libs and/or headers", 2)
1351             return
1352
1353         # OK... everything seems to be present for Tcl/Tk.
1354
1355         include_dirs = [] ; libs = [] ; defs = [] ; added_lib_dirs = []
1356         for dir in tcl_includes + tk_includes:
1357             if dir not in include_dirs:
1358                 include_dirs.append(dir)
1359
1360         # Check for various platform-specific directories
1361         if platform == 'sunos5':
1362             include_dirs.append('/usr/openwin/include')
1363             added_lib_dirs.append('/usr/openwin/lib')
1364         elif os.path.exists('/usr/X11R6/include'):
1365             include_dirs.append('/usr/X11R6/include')
1366             added_lib_dirs.append('/usr/X11R6/lib64')
1367             added_lib_dirs.append('/usr/X11R6/lib')
1368         elif os.path.exists('/usr/X11R5/include'):
1369             include_dirs.append('/usr/X11R5/include')
1370             added_lib_dirs.append('/usr/X11R5/lib')
1371         else:
1372             # Assume default location for X11
1373             include_dirs.append('/usr/X11/include')
1374             added_lib_dirs.append('/usr/X11/lib')
1375
1376         # If Cygwin, then verify that X is installed before proceeding
1377         if platform == 'cygwin':
1378             x11_inc = find_file('X11/Xlib.h', [], include_dirs)
1379             if x11_inc is None:
1380                 return
1381
1382         # Check for BLT extension
1383         if self.compiler.find_library_file(lib_dirs + added_lib_dirs,
1384                                            'BLT8.0'):
1385             defs.append( ('WITH_BLT', 1) )
1386             libs.append('BLT8.0')
1387         elif self.compiler.find_library_file(lib_dirs + added_lib_dirs,
1388                                            'BLT'):
1389             defs.append( ('WITH_BLT', 1) )
1390             libs.append('BLT')
1391
1392         # Add the Tcl/Tk libraries
1393         libs.append('tk'+ version)
1394         libs.append('tcl'+ version)
1395
1396         if platform in ['aix3', 'aix4']:
1397             libs.append('ld')
1398
1399         # Finally, link with the X11 libraries (not appropriate on cygwin)
1400         if platform != "cygwin":
1401             libs.append('X11')
1402
1403         ext = Extension('_tkinter', ['_tkinter.c', 'tkappinit.c'],
1404                         define_macros=[('WITH_APPINIT', 1)] + defs,
1405                         include_dirs = include_dirs,
1406                         libraries = libs,
1407                         library_dirs = added_lib_dirs,
1408                         )
1409         self.extensions.append(ext)
1410
1411 ##         # Uncomment these lines if you want to play with xxmodule.c
1412 ##         ext = Extension('xx', ['xxmodule.c'])
1413 ##         self.extensions.append(ext)
1414
1415         # XXX handle these, but how to detect?
1416         # *** Uncomment and edit for PIL (TkImaging) extension only:
1417         #       -DWITH_PIL -I../Extensions/Imaging/libImaging  tkImaging.c \
1418         # *** Uncomment and edit for TOGL extension only:
1419         #       -DWITH_TOGL togl.c \
1420         # *** Uncomment these for TOGL extension only:
1421         #       -lGL -lGLU -lXext -lXmu \
1422
1423     def configure_ctypes_darwin(self, ext):
1424         # Darwin (OS X) uses preconfigured files, in
1425         # the Modules/_ctypes/libffi_osx directory.
1426         srcdir = sysconfig.get_config_var('srcdir')
1427         ffi_srcdir = os.path.abspath(os.path.join(srcdir, 'Modules',
1428                                                   '_ctypes', 'libffi_osx'))
1429         sources = [os.path.join(ffi_srcdir, p)
1430                    for p in ['ffi.c',
1431                              'x86/darwin64.S',
1432                              'x86/x86-darwin.S',
1433                              'x86/x86-ffi_darwin.c',
1434                              'x86/x86-ffi64.c',
1435                              'powerpc/ppc-darwin.S',
1436                              'powerpc/ppc-darwin_closure.S',
1437                              'powerpc/ppc-ffi_darwin.c',
1438                              'powerpc/ppc64-darwin_closure.S',
1439                              ]]
1440
1441         # Add .S (preprocessed assembly) to C compiler source extensions.
1442         self.compiler.src_extensions.append('.S')
1443
1444         include_dirs = [os.path.join(ffi_srcdir, 'include'),
1445                         os.path.join(ffi_srcdir, 'powerpc')]
1446         ext.include_dirs.extend(include_dirs)
1447         ext.sources.extend(sources)
1448         return True
1449
1450     def configure_ctypes(self, ext):
1451         if not self.use_system_libffi:
1452             if sys.platform == 'darwin':
1453                 return self.configure_ctypes_darwin(ext)
1454
1455             srcdir = sysconfig.get_config_var('srcdir')
1456             ffi_builddir = os.path.join(self.build_temp, 'libffi')
1457             ffi_srcdir = os.path.abspath(os.path.join(srcdir, 'Modules',
1458                                          '_ctypes', 'libffi'))
1459             ffi_configfile = os.path.join(ffi_builddir, 'fficonfig.py')
1460
1461             from distutils.dep_util import newer_group
1462
1463             config_sources = [os.path.join(ffi_srcdir, fname)
1464                               for fname in os.listdir(ffi_srcdir)
1465                               if os.path.isfile(os.path.join(ffi_srcdir, fname))]
1466             if self.force or newer_group(config_sources,
1467                                          ffi_configfile):
1468                 from distutils.dir_util import mkpath
1469                 mkpath(ffi_builddir)
1470                 config_args = []
1471
1472                 # Pass empty CFLAGS because we'll just append the resulting
1473                 # CFLAGS to Python's; -g or -O2 is to be avoided.
1474                 cmd = "cd %s && env CFLAGS='' '%s/configure' %s" \
1475                       % (ffi_builddir, ffi_srcdir, " ".join(config_args))
1476
1477                 res = os.system(cmd)
1478                 if res or not os.path.exists(ffi_configfile):
1479                     print("Failed to configure _ctypes module")
1480                     return False
1481
1482             fficonfig = {}
1483             fp = open(ffi_configfile)
1484             try:
1485                 script = fp.read()
1486             finally:
1487                 fp.close()
1488             exec(script, globals(), fficonfig)
1489             ffi_srcdir = os.path.join(fficonfig['ffi_srcdir'], 'src')
1490
1491             # Add .S (preprocessed assembly) to C compiler source extensions.
1492             self.compiler.src_extensions.append('.S')
1493
1494             include_dirs = [os.path.join(ffi_builddir, 'include'),
1495                             ffi_builddir, ffi_srcdir]
1496             extra_compile_args = fficonfig['ffi_cflags'].split()
1497
1498             ext.sources.extend(fficonfig['ffi_sources'])
1499             ext.include_dirs.extend(include_dirs)
1500             ext.extra_compile_args.extend(extra_compile_args)
1501         return True
1502
1503     def detect_ctypes(self, inc_dirs, lib_dirs):
1504         self.use_system_libffi = False
1505         include_dirs = []
1506         extra_compile_args = []
1507         extra_link_args = []
1508         sources = ['_ctypes/_ctypes.c',
1509                    '_ctypes/callbacks.c',
1510                    '_ctypes/callproc.c',
1511                    '_ctypes/stgdict.c',
1512                    '_ctypes/cfield.c',
1513                    '_ctypes/malloc_closure.c']
1514         depends = ['_ctypes/ctypes.h']
1515
1516         if sys.platform == 'darwin':
1517             sources.append('_ctypes/darwin/dlfcn_simple.c')
1518             extra_compile_args.append('-DMACOSX')
1519             include_dirs.append('_ctypes/darwin')
1520 # XXX Is this still needed?
1521 ##            extra_link_args.extend(['-read_only_relocs', 'warning'])
1522
1523         elif sys.platform == 'sunos5':
1524             # XXX This shouldn't be necessary; it appears that some
1525             # of the assembler code is non-PIC (i.e. it has relocations
1526             # when it shouldn't. The proper fix would be to rewrite
1527             # the assembler code to be PIC.
1528             # This only works with GCC; the Sun compiler likely refuses
1529             # this option. If you want to compile ctypes with the Sun
1530             # compiler, please research a proper solution, instead of
1531             # finding some -z option for the Sun compiler.
1532             extra_link_args.append('-mimpure-text')
1533
1534         elif sys.platform.startswith('hp-ux'):
1535             extra_link_args.append('-fPIC')
1536
1537         ext = Extension('_ctypes',
1538                         include_dirs=include_dirs,
1539                         extra_compile_args=extra_compile_args,
1540                         extra_link_args=extra_link_args,
1541                         libraries=[],
1542                         sources=sources,
1543                         depends=depends)
1544         ext_test = Extension('_ctypes_test',
1545                              sources=['_ctypes/_ctypes_test.c'])
1546         self.extensions.extend([ext, ext_test])
1547
1548         if not '--with-system-ffi' in sysconfig.get_config_var("CONFIG_ARGS"):
1549             return
1550
1551         if sys.platform == 'darwin':
1552             # OS X 10.5 comes with libffi.dylib; the include files are
1553             # in /usr/include/ffi
1554             inc_dirs.append('/usr/include/ffi')
1555
1556         ffi_inc = find_file('ffi.h', [], inc_dirs)
1557         if ffi_inc is not None:
1558             ffi_h = ffi_inc[0] + '/ffi.h'
1559             fp = open(ffi_h)
1560             while 1:
1561                 line = fp.readline()
1562                 if not line:
1563                     ffi_inc = None
1564                     break
1565                 if line.startswith('#define LIBFFI_H'):
1566                     break
1567         ffi_lib = None
1568         if ffi_inc is not None:
1569             for lib_name in ('ffi_convenience', 'ffi_pic', 'ffi'):
1570                 if (self.compiler.find_library_file(lib_dirs, lib_name)):
1571                     ffi_lib = lib_name
1572                     break
1573
1574         if ffi_inc and ffi_lib:
1575             ext.include_dirs.extend(ffi_inc)
1576             ext.libraries.append(ffi_lib)
1577             self.use_system_libffi = True
1578
1579
1580 class PyBuildInstall(install):
1581     # Suppress the warning about installation into the lib_dynload
1582     # directory, which is not in sys.path when running Python during
1583     # installation:
1584     def initialize_options (self):
1585         install.initialize_options(self)
1586         self.warn_dir=0
1587
1588 class PyBuildInstallLib(install_lib):
1589     # Do exactly what install_lib does but make sure correct access modes get
1590     # set on installed directories and files. All installed files with get
1591     # mode 644 unless they are a shared library in which case they will get
1592     # mode 755. All installed directories will get mode 755.
1593
1594     so_ext = sysconfig.get_config_var("SO")
1595
1596     def install(self):
1597         outfiles = install_lib.install(self)
1598         self.set_file_modes(outfiles, 0o644, 0o755)
1599         self.set_dir_modes(self.install_dir, 0o755)
1600         return outfiles
1601
1602     def set_file_modes(self, files, defaultMode, sharedLibMode):
1603         if not self.is_chmod_supported(): return
1604         if not files: return
1605
1606         for filename in files:
1607             if os.path.islink(filename): continue
1608             mode = defaultMode
1609             if filename.endswith(self.so_ext): mode = sharedLibMode
1610             log.info("changing mode of %s to %o", filename, mode)
1611             if not self.dry_run: os.chmod(filename, mode)
1612
1613     def set_dir_modes(self, dirname, mode):
1614         if not self.is_chmod_supported(): return
1615         for dirpath, dirnames, fnames in os.walk(dirname):
1616             if os.path.islink(dirpath):
1617                 continue
1618             log.info("changing mode of %s to %o", dirpath, mode)
1619             if not self.dry_run: os.chmod(dirpath, mode)
1620
1621     def is_chmod_supported(self):
1622         return hasattr(os, 'chmod')
1623
1624 SUMMARY = """
1625 Python is an interpreted, interactive, object-oriented programming
1626 language. It is often compared to Tcl, Perl, Scheme or Java.
1627
1628 Python combines remarkable power with very clear syntax. It has
1629 modules, classes, exceptions, very high level dynamic data types, and
1630 dynamic typing. There are interfaces to many system calls and
1631 libraries, as well as to various windowing systems (X11, Motif, Tk,
1632 Mac, MFC). New built-in modules are easily written in C or C++. Python
1633 is also usable as an extension language for applications that need a
1634 programmable interface.
1635
1636 The Python implementation is portable: it runs on many brands of UNIX,
1637 on Windows, DOS, OS/2, Mac, Amiga... If your favorite system isn't
1638 listed here, it may still be supported, if there's a C compiler for
1639 it. Ask around on comp.lang.python -- or just try compiling Python
1640 yourself.
1641 """
1642
1643 CLASSIFIERS = """
1644 Development Status :: 6 - Mature
1645 License :: OSI Approved :: Python Software Foundation License
1646 Natural Language :: English
1647 Programming Language :: C
1648 Programming Language :: Python
1649 Topic :: Software Development
1650 """
1651
1652 def main():
1653     # turn off warnings when deprecated modules are imported
1654     import warnings
1655     warnings.filterwarnings("ignore",category=DeprecationWarning)
1656     setup(# PyPI Metadata (PEP 301)
1657           name = "Python",
1658           version = sys.version.split()[0],
1659           url = "http://www.python.org/%s" % sys.version[:3],
1660           maintainer = "Guido van Rossum and the Python community",
1661           maintainer_email = "python-dev@python.org",
1662           description = "A high-level object-oriented programming language",
1663           long_description = SUMMARY.strip(),
1664           license = "PSF license",
1665           classifiers = [x for x in CLASSIFIERS.split("\n") if x],
1666           platforms = ["Many"],
1667
1668           # Build info
1669           cmdclass = {'build_ext':PyBuildExt, 'install':PyBuildInstall,
1670                       'install_lib':PyBuildInstallLib},
1671           # The struct module is defined here, because build_ext won't be
1672           # called unless there's at least one extension module defined.
1673           ext_modules=[Extension('_struct', ['_struct.c'])],
1674
1675           scripts = ["Tools/scripts/pydoc3", "Tools/scripts/idle3",
1676                      "Tools/scripts/2to3"]
1677         )
1678
1679 # --install-platlib
1680 if __name__ == '__main__':
1681     main()