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