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