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