1 # Autodetecting setup.py script for building the Python extensions
4 __version__
= "$Revision$"
6 import sys
, os
, imp
, re
, optparse
8 from platform
import machine
as platform_machine
10 from distutils
import log
11 from distutils
import sysconfig
12 from distutils
import text_file
13 from distutils
.errors
import *
14 from distutils
.core
import Extension
, setup
15 from distutils
.command
.build_ext
import build_ext
16 from distutils
.command
.install
import install
17 from distutils
.command
.install_lib
import install_lib
19 # This global variable is used to hold the list of modules to be disabled.
20 disabled_module_list
= []
22 def add_dir_to_list(dirlist
, dir):
23 """Add the directory 'dir' to the list 'dirlist' (at the front) if
24 1) 'dir' is not already in 'dirlist'
25 2) 'dir' actually exists, and is a directory."""
26 if dir is not None and os
.path
.isdir(dir) and dir not in dirlist
:
27 dirlist
.insert(0, dir)
29 def find_file(filename
, std_dirs
, paths
):
30 """Searches for the directory where a given file is located,
31 and returns a possibly-empty list of additional directories, or None
32 if the file couldn't be found at all.
34 'filename' is the name of a file, such as readline.h or libcrypto.a.
35 'std_dirs' is the list of standard system directories; if the
36 file is found in one of them, no additional directives are needed.
37 'paths' is a list of additional locations to check; if the file is
38 found in one of them, the resulting list will contain the directory.
41 # Check the standard locations
43 f
= os
.path
.join(dir, filename
)
44 if os
.path
.exists(f
): return []
46 # Check the additional directories
48 f
= os
.path
.join(dir, filename
)
55 def find_library_file(compiler
, libname
, std_dirs
, paths
):
56 result
= compiler
.find_library_file(std_dirs
+ paths
, libname
)
60 # Check whether the found file is in one of the standard directories
61 dirname
= os
.path
.dirname(result
)
63 # Ensure path doesn't end with path separator
68 # Otherwise, it must have been in one of the additional directories,
69 # so we have to figure out which one.
71 # Ensure path doesn't end with path separator
76 assert False, "Internal error: Path not found in std_dirs or paths"
78 def module_enabled(extlist
, modname
):
79 """Returns whether the module 'modname' is present in the list
80 of extensions 'extlist'."""
81 extlist
= [ext
for ext
in extlist
if ext
.name
== modname
]
84 def find_module_file(module
, dirlist
):
85 """Find a module in a set of possible folders. If it is not found
86 return the unadorned filename"""
87 list = find_file(module
, [], dirlist
)
91 log
.info("WARNING: multiple copies of %s found"%module
)
92 return os
.path
.join(list[0], module
)
94 class PyBuildExt(build_ext
):
96 def __init__(self
, dist
):
97 build_ext
.__init
__(self
, dist
)
100 def build_extensions(self
):
102 # Detect which modules should be compiled
103 missing
= self
.detect_modules()
105 # Remove modules that are present on the disabled list
106 extensions
= [ext
for ext
in self
.extensions
107 if ext
.name
not in disabled_module_list
]
108 # move ctypes to the end, it depends on other modules
109 ext_map
= dict((ext
.name
, i
) for i
, ext
in enumerate(extensions
))
110 if "_ctypes" in ext_map
:
111 ctypes
= extensions
.pop(ext_map
["_ctypes"])
112 extensions
.append(ctypes
)
113 self
.extensions
= extensions
115 # Fix up the autodetected modules, prefixing all the source files
116 # with Modules/ and adding Python's include directory to the path.
117 (srcdir
,) = sysconfig
.get_config_vars('srcdir')
119 # Maybe running on Windows but not using CYGWIN?
120 raise ValueError("No source directory; cannot proceed.")
121 srcdir
= os
.path
.abspath(srcdir
)
122 moddirlist
= [os
.path
.join(srcdir
, 'Modules')]
124 # Platform-dependent module source and include directories
126 platform
= self
.get_platform()
127 if platform
in ('darwin', 'mac') and ("--disable-toolbox-glue" not in
128 sysconfig
.get_config_var("CONFIG_ARGS")):
129 # Mac OS X also includes some mac-specific modules
130 macmoddir
= os
.path
.join(srcdir
, 'Mac/Modules')
131 moddirlist
.append(macmoddir
)
132 incdirlist
.append(os
.path
.join(srcdir
, 'Mac/Include'))
134 # Fix up the paths for scripts, too
135 self
.distribution
.scripts
= [os
.path
.join(srcdir
, filename
)
136 for filename
in self
.distribution
.scripts
]
138 # Python header files
139 headers
= [sysconfig
.get_config_h_filename()]
140 headers
+= glob(os
.path
.join(sysconfig
.get_python_inc(), "*.h"))
141 for ext
in self
.extensions
[:]:
142 ext
.sources
= [ find_module_file(filename
, moddirlist
)
143 for filename
in ext
.sources
]
144 if ext
.depends
is not None:
145 ext
.depends
= [find_module_file(filename
, moddirlist
)
146 for filename
in ext
.depends
]
149 # re-compile extensions if a header file has been changed
150 ext
.depends
.extend(headers
)
152 # platform specific include directories
153 ext
.include_dirs
.extend(incdirlist
)
155 # If a module has already been built statically,
156 # don't build it here
157 if ext
.name
in sys
.builtin_module_names
:
158 self
.extensions
.remove(ext
)
160 if platform
!= 'mac':
161 # Parse Modules/Setup and Modules/Setup.local to figure out which
162 # modules are turned on in the file.
164 for filename
in ('Modules/Setup', 'Modules/Setup.local'):
165 input = text_file
.TextFile(filename
, join_lines
=1)
167 line
= input.readline()
170 remove_modules
.append(line
[0])
173 for ext
in self
.extensions
[:]:
174 if ext
.name
in remove_modules
:
175 self
.extensions
.remove(ext
)
177 # When you run "make CC=altcc" or something similar, you really want
178 # those environment variables passed into the setup.py phase. Here's
179 # a small set of useful ones.
180 compiler
= os
.environ
.get('CC')
182 # unfortunately, distutils doesn't let us provide separate C and C++
184 if compiler
is not None:
185 (ccshared
,cflags
) = sysconfig
.get_config_vars('CCSHARED','CFLAGS')
186 args
['compiler_so'] = compiler
+ ' ' + ccshared
+ ' ' + cflags
187 self
.compiler
.set_executables(**args
)
189 build_ext
.build_extensions(self
)
191 longest
= max([len(e
.name
) for e
in self
.extensions
])
193 longest
= max(longest
, max([len(name
) for name
in self
.failed
]))
195 def print_three_column(lst
):
196 lst
.sort(key
=str.lower
)
197 # guarantee zip() doesn't drop anything
200 for e
, f
, g
in zip(lst
[::3], lst
[1::3], lst
[2::3]):
201 print "%-*s %-*s %-*s" % (longest
, e
, longest
, f
,
206 print ("Python build finished, but the necessary bits to build "
207 "these modules were not found:")
208 print_three_column(missing
)
209 print ("To find the necessary bits, look in setup.py in"
210 " detect_modules() for the module's name.")
214 failed
= self
.failed
[:]
216 print "Failed to build these modules:"
217 print_three_column(failed
)
220 def build_extension(self
, ext
):
222 if ext
.name
== '_ctypes':
223 if not self
.configure_ctypes(ext
):
227 build_ext
.build_extension(self
, ext
)
228 except (CCompilerError
, DistutilsError
), why
:
229 self
.announce('WARNING: building of extension "%s" failed: %s' %
230 (ext
.name
, sys
.exc_info()[1]))
231 self
.failed
.append(ext
.name
)
233 # Workaround for Mac OS X: The Carbon-based modules cannot be
234 # reliably imported into a command-line Python
235 if 'Carbon' in ext
.extra_link_args
:
237 'WARNING: skipping import check for Carbon-based "%s"' %
241 if self
.get_platform() == 'darwin' and (
242 sys
.maxint
> 2**32 and '-arch' in ext
.extra_link_args
):
243 # Don't bother doing an import check when an extension was
244 # build with an explicit '-arch' flag on OSX. That's currently
245 # only used to build 32-bit only extensions in a 4-way
246 # universal build and loading 32-bit code into a 64-bit
249 'WARNING: skipping import check for "%s"' %
253 # Workaround for Cygwin: Cygwin currently has fork issues when many
254 # modules have been imported
255 if self
.get_platform() == 'cygwin':
256 self
.announce('WARNING: skipping import check for Cygwin-based "%s"'
259 ext_filename
= os
.path
.join(
261 self
.get_ext_filename(self
.get_ext_fullname(ext
.name
)))
263 imp
.load_dynamic(ext
.name
, ext_filename
)
264 except ImportError, why
:
265 self
.failed
.append(ext
.name
)
266 self
.announce('*** WARNING: renaming "%s" since importing it'
267 ' failed: %s' % (ext
.name
, why
), level
=3)
268 assert not self
.inplace
269 basename
, tail
= os
.path
.splitext(ext_filename
)
270 newname
= basename
+ "_failed" + tail
271 if os
.path
.exists(newname
):
273 os
.rename(ext_filename
, newname
)
275 # XXX -- This relies on a Vile HACK in
276 # distutils.command.build_ext.build_extension(). The
277 # _built_objects attribute is stored there strictly for
279 # If there is a failure, _built_objects may not be there,
280 # so catch the AttributeError and move on.
282 for filename
in self
._built
_objects
:
284 except AttributeError:
285 self
.announce('unable to remove files (ignored)')
287 exc_type
, why
, tb
= sys
.exc_info()
288 self
.announce('*** WARNING: importing extension "%s" '
289 'failed with %s: %s' % (ext
.name
, exc_type
, why
),
291 self
.failed
.append(ext
.name
)
293 def get_platform(self
):
294 # Get value of sys.platform
295 for platform
in ['cygwin', 'beos', 'darwin', 'atheos', 'osf1']:
296 if sys
.platform
.startswith(platform
):
300 def detect_modules(self
):
301 # Ensure that /usr/local is always used
302 add_dir_to_list(self
.compiler
.library_dirs
, '/usr/local/lib')
303 add_dir_to_list(self
.compiler
.include_dirs
, '/usr/local/include')
305 # Add paths specified in the environment variables LDFLAGS and
306 # CPPFLAGS for header and library files.
307 # We must get the values from the Makefile and not the environment
308 # directly since an inconsistently reproducible issue comes up where
309 # the environment variable is not set even though the value were passed
310 # into configure and stored in the Makefile (issue found on OS X 10.3).
311 for env_var
, arg_name
, dir_list
in (
312 ('LDFLAGS', '-R', self
.compiler
.runtime_library_dirs
),
313 ('LDFLAGS', '-L', self
.compiler
.library_dirs
),
314 ('CPPFLAGS', '-I', self
.compiler
.include_dirs
)):
315 env_val
= sysconfig
.get_config_var(env_var
)
317 # To prevent optparse from raising an exception about any
318 # options in env_val that it doesn't know about we strip out
319 # all double dashes and any dashes followed by a character
320 # that is not for the option we are dealing with.
322 # Please note that order of the regex is important! We must
323 # strip out double-dashes first so that we don't end up with
324 # substituting "--Long" to "-Long" and thus lead to "ong" being
325 # used for a library directory.
326 env_val
= re
.sub(r
'(^|\s+)-(-|(?!%s))' % arg_name
[1],
328 parser
= optparse
.OptionParser()
329 # Make sure that allowing args interspersed with options is
331 parser
.allow_interspersed_args
= True
332 parser
.error
= lambda msg
: None
333 parser
.add_option(arg_name
, dest
="dirs", action
="append")
334 options
= parser
.parse_args(env_val
.split())[0]
336 for directory
in reversed(options
.dirs
):
337 add_dir_to_list(dir_list
, directory
)
339 if os
.path
.normpath(sys
.prefix
) != '/usr':
340 add_dir_to_list(self
.compiler
.library_dirs
,
341 sysconfig
.get_config_var("LIBDIR"))
342 add_dir_to_list(self
.compiler
.include_dirs
,
343 sysconfig
.get_config_var("INCLUDEDIR"))
346 have_unicode
= unicode
350 # lib_dirs and inc_dirs are used to search for files;
351 # if a file is found in one of those directories, it can
352 # be assumed that no additional -I,-L directives are needed.
353 lib_dirs
= self
.compiler
.library_dirs
+ [
354 '/lib64', '/usr/lib64',
357 inc_dirs
= self
.compiler
.include_dirs
+ ['/usr/include']
361 config_h
= sysconfig
.get_config_h_filename()
362 config_h_vars
= sysconfig
.parse_config_h(open(config_h
))
364 platform
= self
.get_platform()
365 srcdir
= sysconfig
.get_config_var('srcdir')
367 # Check for AtheOS which has libraries in non-standard locations
368 if platform
== 'atheos':
369 lib_dirs
+= ['/system/libs', '/atheos/autolnk/lib']
370 lib_dirs
+= os
.getenv('LIBRARY_PATH', '').split(os
.pathsep
)
371 inc_dirs
+= ['/system/include', '/atheos/autolnk/include']
372 inc_dirs
+= os
.getenv('C_INCLUDE_PATH', '').split(os
.pathsep
)
374 # OSF/1 and Unixware have some stuff in /usr/ccs/lib (like -ldb)
375 if platform
in ['osf1', 'unixware7', 'openunix8']:
376 lib_dirs
+= ['/usr/ccs/lib']
378 if platform
== 'darwin':
379 # This should work on any unixy platform ;-)
380 # If the user has bothered specifying additional -I and -L flags
381 # in OPT and LDFLAGS we might as well use them here.
382 # NOTE: using shlex.split would technically be more correct, but
383 # also gives a bootstrap problem. Let's hope nobody uses directories
384 # with whitespace in the name to store libraries.
385 cflags
, ldflags
= sysconfig
.get_config_vars(
387 for item
in cflags
.split():
388 if item
.startswith('-I'):
389 inc_dirs
.append(item
[2:])
391 for item
in ldflags
.split():
392 if item
.startswith('-L'):
393 lib_dirs
.append(item
[2:])
395 # Check for MacOS X, which doesn't need libm.a at all
397 if platform
in ['darwin', 'beos', 'mac']:
400 # XXX Omitted modules: gl, pure, dl, SGI-specific modules
403 # The following modules are all pretty straightforward, and compile
404 # on pretty much any POSIXish platform.
407 # Some modules that are normally always on:
408 exts
.append( Extension('_weakref', ['_weakref.c']) )
411 exts
.append( Extension('array', ['arraymodule.c']) )
412 # complex math library functions
413 exts
.append( Extension('cmath', ['cmathmodule.c'],
414 libraries
=math_libs
) )
416 # math library functions, e.g. sin()
417 exts
.append( Extension('math', ['mathmodule.c'],
418 libraries
=math_libs
) )
419 # fast string operations implemented in C
420 exts
.append( Extension('strop', ['stropmodule.c']) )
421 # time operations and variables
422 exts
.append( Extension('time', ['timemodule.c'],
423 libraries
=math_libs
) )
424 exts
.append( Extension('datetime', ['datetimemodule.c', 'timemodule.c'],
425 libraries
=math_libs
) )
426 # fast iterator tools implemented in C
427 exts
.append( Extension("itertools", ["itertoolsmodule.c"]) )
428 # code that will be builtins in the future, but conflict with the
430 exts
.append( Extension('future_builtins', ['future_builtins.c']) )
431 # random number generator implemented in C
432 exts
.append( Extension("_random", ["_randommodule.c"]) )
433 # high-performance collections
434 exts
.append( Extension("_collections", ["_collectionsmodule.c"]) )
436 exts
.append( Extension("_bisect", ["_bisectmodule.c"]) )
438 exts
.append( Extension("_heapq", ["_heapqmodule.c"]) )
439 # operator.add() and similar goodies
440 exts
.append( Extension('operator', ['operator.c']) )
441 # Python 3.0 _fileio module
442 exts
.append( Extension("_fileio", ["_fileio.c"]) )
443 # Python 3.0 _bytesio module
444 exts
.append( Extension("_bytesio", ["_bytesio.c"]) )
446 exts
.append( Extension("_functools", ["_functoolsmodule.c"]) )
448 exts
.append( Extension("_json", ["_json.c"]) )
449 # Python C API test module
450 exts
.append( Extension('_testcapi', ['_testcapimodule.c'],
451 depends
=['testcapi_long.h']) )
452 # profilers (_lsprof is for cProfile.py)
453 exts
.append( Extension('_hotshot', ['_hotshot.c']) )
454 exts
.append( Extension('_lsprof', ['_lsprof.c', 'rotatingtree.c']) )
455 # static Unicode character database
457 exts
.append( Extension('unicodedata', ['unicodedata.c']) )
459 missing
.append('unicodedata')
460 # access to ISO C locale support
461 data
= open('pyconfig.h').read()
462 m
= re
.search(r
"#s*define\s+WITH_LIBINTL\s+1\s*", data
)
464 locale_libs
= ['intl']
467 if platform
== 'darwin':
468 locale_extra_link_args
= ['-framework', 'CoreFoundation']
470 locale_extra_link_args
= []
473 exts
.append( Extension('_locale', ['_localemodule.c'],
474 libraries
=locale_libs
,
475 extra_link_args
=locale_extra_link_args
) )
477 # Modules with some UNIX dependencies -- on by default:
478 # (If you have a really backward UNIX, select and socket may not be
481 # fcntl(2) and ioctl(2)
482 exts
.append( Extension('fcntl', ['fcntlmodule.c']) )
483 if platform
not in ['mac']:
485 exts
.append( Extension('pwd', ['pwdmodule.c']) )
487 exts
.append( Extension('grp', ['grpmodule.c']) )
488 # spwd, shadow passwords
489 if (config_h_vars
.get('HAVE_GETSPNAM', False) or
490 config_h_vars
.get('HAVE_GETSPENT', False)):
491 exts
.append( Extension('spwd', ['spwdmodule.c']) )
493 missing
.append('spwd')
495 missing
.extend(['pwd', 'grp', 'spwd'])
497 # select(2); not on ancient System V
498 exts
.append( Extension('select', ['selectmodule.c']) )
500 # Fred Drake's interface to the Python parser
501 exts
.append( Extension('parser', ['parsermodule.c']) )
503 # cStringIO and cPickle
504 exts
.append( Extension('cStringIO', ['cStringIO.c']) )
505 exts
.append( Extension('cPickle', ['cPickle.c']) )
507 # Memory-mapped files (also works on Win32).
508 if platform
not in ['atheos', 'mac']:
509 exts
.append( Extension('mmap', ['mmapmodule.c']) )
511 missing
.append('mmap')
513 # Lance Ellinghaus's syslog module
514 if platform
not in ['mac']:
515 # syslog daemon interface
516 exts
.append( Extension('syslog', ['syslogmodule.c']) )
518 missing
.append('syslog')
520 # George Neville-Neil's timing module:
521 # Deprecated in PEP 4 http://www.python.org/peps/pep-0004.html
522 # http://mail.python.org/pipermail/python-dev/2006-January/060023.html
523 #exts.append( Extension('timing', ['timingmodule.c']) )
526 # Here ends the simple stuff. From here on, modules need certain
527 # libraries, are platform-specific, or present other surprises.
531 # These don't work for 64-bit platforms!!!
532 # These represent audio samples or images as strings:
534 # Operations on audio samples
535 # According to #993173, this one should actually work fine on
537 exts
.append( Extension('audioop', ['audioop.c']) )
539 # Disabled on 64-bit platforms
540 if sys
.maxint
!= 9223372036854775807L:
541 # Operations on images
542 exts
.append( Extension('imageop', ['imageop.c']) )
544 missing
.extend(['imageop'])
547 do_readline
= self
.compiler
.find_library_file(lib_dirs
, 'readline')
548 if platform
== 'darwin': # and os.uname()[2] < '9.':
549 # MacOSX 10.4 has a broken readline. Don't try to build
550 # the readline module unless the user has installed a fixed
552 # FIXME: The readline emulation on 10.5 is better, but the
553 # readline module doesn't compile out of the box.
554 if find_file('readline/rlconf.h', inc_dirs
, []) is None:
557 if sys
.platform
== 'darwin':
558 # In every directory on the search path search for a dynamic
559 # library and then a static library, instead of first looking
560 # for dynamic libraries on the entiry path.
561 # This way a staticly linked custom readline gets picked up
562 # before the (broken) dynamic library in /usr/lib.
563 readline_extra_link_args
= ('-Wl,-search_paths_first',)
565 readline_extra_link_args
= ()
567 readline_libs
= ['readline']
568 if self
.compiler
.find_library_file(lib_dirs
,
570 readline_libs
.append('ncursesw')
571 elif self
.compiler
.find_library_file(lib_dirs
,
573 readline_libs
.append('ncurses')
574 elif self
.compiler
.find_library_file(lib_dirs
, 'curses'):
575 readline_libs
.append('curses')
576 elif self
.compiler
.find_library_file(lib_dirs
+
577 ['/usr/lib/termcap'],
579 readline_libs
.append('termcap')
580 exts
.append( Extension('readline', ['readline.c'],
581 library_dirs
=['/usr/lib/termcap'],
582 extra_link_args
=readline_extra_link_args
,
583 libraries
=readline_libs
) )
585 missing
.append('readline')
587 if platform
not in ['mac']:
590 if self
.compiler
.find_library_file(lib_dirs
, 'crypt'):
594 exts
.append( Extension('crypt', ['cryptmodule.c'], libraries
=libs
) )
596 missing
.append('crypt')
599 exts
.append( Extension('_csv', ['_csv.c']) )
602 exts
.append( Extension('_socket', ['socketmodule.c'],
603 depends
= ['socketmodule.h']) )
604 # Detect SSL support for the socket module (via _ssl)
605 search_for_ssl_incs_in
= [
606 '/usr/local/ssl/include',
607 '/usr/contrib/ssl/include/'
609 ssl_incs
= find_file('openssl/ssl.h', inc_dirs
,
610 search_for_ssl_incs_in
612 if ssl_incs
is not None:
613 krb5_h
= find_file('krb5.h', inc_dirs
,
614 ['/usr/kerberos/include'])
617 ssl_libs
= find_library_file(self
.compiler
, 'ssl',lib_dirs
,
618 ['/usr/local/ssl/lib',
619 '/usr/contrib/ssl/lib/'
622 if (ssl_incs
is not None and
623 ssl_libs
is not None):
624 exts
.append( Extension('_ssl', ['_ssl.c'],
625 include_dirs
= ssl_incs
,
626 library_dirs
= ssl_libs
,
627 libraries
= ['ssl', 'crypto'],
628 depends
= ['socketmodule.h']), )
630 missing
.append('_ssl')
632 # find out which version of OpenSSL we have
634 openssl_ver_re
= re
.compile(
635 '^\s*#\s*define\s+OPENSSL_VERSION_NUMBER\s+(0x[0-9a-fA-F]+)' )
636 for ssl_inc_dir
in inc_dirs
+ search_for_ssl_incs_in
:
637 name
= os
.path
.join(ssl_inc_dir
, 'openssl', 'opensslv.h')
638 if os
.path
.isfile(name
):
640 incfile
= open(name
, 'r')
642 m
= openssl_ver_re
.match(line
)
644 openssl_ver
= eval(m
.group(1))
649 # first version found is what we'll use (as the compiler should)
653 #print 'openssl_ver = 0x%08x' % openssl_ver
655 if (ssl_incs
is not None and
656 ssl_libs
is not None and
657 openssl_ver
>= 0x00907000):
658 # The _hashlib module wraps optimized implementations
659 # of hash functions from the OpenSSL library.
660 exts
.append( Extension('_hashlib', ['_hashopenssl.c'],
661 include_dirs
= ssl_incs
,
662 library_dirs
= ssl_libs
,
663 libraries
= ['ssl', 'crypto']) )
664 # these aren't strictly missing since they are unneeded.
665 #missing.extend(['_sha', '_md5'])
667 # The _sha module implements the SHA1 hash algorithm.
668 exts
.append( Extension('_sha', ['shamodule.c']) )
669 # The _md5 module implements the RSA Data Security, Inc. MD5
670 # Message-Digest Algorithm, described in RFC 1321. The
671 # necessary files md5.c and md5.h are included here.
672 exts
.append( Extension('_md5',
673 sources
= ['md5module.c', 'md5.c'],
674 depends
= ['md5.h']) )
675 missing
.append('_hashlib')
677 if (openssl_ver
< 0x00908000):
678 # OpenSSL doesn't do these until 0.9.8 so we'll bring our own hash
679 exts
.append( Extension('_sha256', ['sha256module.c']) )
680 exts
.append( Extension('_sha512', ['sha512module.c']) )
682 # Modules that provide persistent dictionary-like semantics. You will
683 # probably want to arrange for at least one of them to be available on
684 # your machine, though none are defined by default because of library
685 # dependencies. The Python module anydbm.py provides an
686 # implementation independent wrapper for these; dumbdbm.py provides
687 # similar functionality (but slower of course) implemented in Python.
689 # Sleepycat^WOracle Berkeley DB interface.
690 # http://www.oracle.com/database/berkeley-db/db/index.html
692 # This requires the Sleepycat^WOracle DB code. The supported versions
693 # are set below. Visit the URL above to download
694 # a release. Most open source OSes come with one or more
695 # versions of BerkeleyDB already installed.
699 db_setup_debug
= False # verbose debug prints from this script?
701 def allow_db_ver(db_ver
):
702 """Returns a boolean if the given BerkeleyDB version is acceptable.
705 db_ver: A tuple of the version to verify.
707 if not (min_db_ver
<= db_ver
<= max_db_ver
):
709 # Use this function to filter out known bad configurations.
710 if (4, 6) == db_ver
[:2]:
711 # BerkeleyDB 4.6.x is not stable on many architectures.
712 arch
= platform_machine()
713 if arch
not in ('i386', 'i486', 'i586', 'i686',
718 def gen_db_minor_ver_nums(major
):
720 for x
in range(max_db_ver
[1]+1):
721 if allow_db_ver((4, x
)):
725 if allow_db_ver((3, x
)):
728 raise ValueError("unknown major BerkeleyDB version", major
)
730 # construct a list of paths to look for the header file in on
731 # top of the normal inc_dirs.
734 '/usr/local/include/db4',
735 '/opt/sfw/include/db4',
737 '/usr/local/include/db3',
738 '/opt/sfw/include/db3',
739 # Fink defaults (http://fink.sourceforge.net/)
743 # 4.x minor number specific paths
744 for x
in gen_db_minor_ver_nums(4):
745 db_inc_paths
.append('/usr/include/db4%d' % x
)
746 db_inc_paths
.append('/usr/include/db4.%d' % x
)
747 db_inc_paths
.append('/usr/local/BerkeleyDB.4.%d/include' % x
)
748 db_inc_paths
.append('/usr/local/include/db4%d' % x
)
749 db_inc_paths
.append('/pkg/db-4.%d/include' % x
)
750 db_inc_paths
.append('/opt/db-4.%d/include' % x
)
751 # MacPorts default (http://www.macports.org/)
752 db_inc_paths
.append('/opt/local/include/db4%d' % x
)
753 # 3.x minor number specific paths
754 for x
in gen_db_minor_ver_nums(3):
755 db_inc_paths
.append('/usr/include/db3%d' % x
)
756 db_inc_paths
.append('/usr/local/BerkeleyDB.3.%d/include' % x
)
757 db_inc_paths
.append('/usr/local/include/db3%d' % x
)
758 db_inc_paths
.append('/pkg/db-3.%d/include' % x
)
759 db_inc_paths
.append('/opt/db-3.%d/include' % x
)
761 # Add some common subdirectories for Sleepycat DB to the list,
762 # based on the standard include directories. This way DB3/4 gets
763 # picked up when it is installed in a non-standard prefix and
764 # the user has added that prefix into inc_dirs.
767 std_variants
.append(os
.path
.join(dn
, 'db3'))
768 std_variants
.append(os
.path
.join(dn
, 'db4'))
769 for x
in gen_db_minor_ver_nums(4):
770 std_variants
.append(os
.path
.join(dn
, "db4%d"%x))
771 std_variants
.append(os
.path
.join(dn
, "db4.%d"%x))
772 for x
in gen_db_minor_ver_nums(3):
773 std_variants
.append(os
.path
.join(dn
, "db3%d"%x))
774 std_variants
.append(os
.path
.join(dn
, "db3.%d"%x))
776 db_inc_paths
= std_variants
+ db_inc_paths
777 db_inc_paths
= [p
for p
in db_inc_paths
if os
.path
.exists(p
)]
781 class db_found(Exception): pass
783 # See whether there is a Sleepycat header in the standard
785 for d
in inc_dirs
+ db_inc_paths
:
786 f
= os
.path
.join(d
, "db.h")
787 if db_setup_debug
: print "db: looking for db.h in", f
788 if os
.path
.exists(f
):
790 m
= re
.search(r
"#define\WDB_VERSION_MAJOR\W(\d+)", f
)
792 db_major
= int(m
.group(1))
793 m
= re
.search(r
"#define\WDB_VERSION_MINOR\W(\d+)", f
)
794 db_minor
= int(m
.group(1))
795 db_ver
= (db_major
, db_minor
)
797 # Avoid 4.6 prior to 4.6.21 due to a BerkeleyDB bug
799 m
= re
.search(r
"#define\WDB_VERSION_PATCH\W(\d+)", f
)
800 db_patch
= int(m
.group(1))
802 print "db.h:", db_ver
, "patch", db_patch
,
803 print "being ignored (4.6.x must be >= 4.6.21)"
806 if ( (not db_ver_inc_map
.has_key(db_ver
)) and
807 allow_db_ver(db_ver
) ):
808 # save the include directory with the db.h version
809 # (first occurrence only)
810 db_ver_inc_map
[db_ver
] = d
812 print "db.h: found", db_ver
, "in", d
814 # we already found a header for this library version
815 if db_setup_debug
: print "db.h: ignoring", d
817 # ignore this header, it didn't contain a version number
819 print "db.h: no version number version in", d
821 db_found_vers
= db_ver_inc_map
.keys()
825 db_ver
= db_found_vers
.pop()
826 db_incdir
= db_ver_inc_map
[db_ver
]
828 # check lib directories parallel to the location of the header
830 db_incdir
.replace("include", 'lib64'),
831 db_incdir
.replace("include", 'lib'),
833 db_dirs_to_check
= filter(os
.path
.isdir
, db_dirs_to_check
)
835 # Look for a version specific db-X.Y before an ambiguoius dbX
836 # XXX should we -ever- look for a dbX name? Do any
837 # systems really not name their library by version and
838 # symlink to more general names?
839 for dblib
in (('db-%d.%d' % db_ver
),
841 ('db%d' % db_ver
[0])):
842 dblib_file
= self
.compiler
.find_library_file(
843 db_dirs_to_check
+ lib_dirs
, dblib
)
845 dblib_dir
= [ os
.path
.abspath(os
.path
.dirname(dblib_file
)) ]
848 if db_setup_debug
: print "db lib: ", dblib
, "not found"
852 print "bsddb using BerkeleyDB lib:", db_ver
, dblib
853 print "bsddb lib dir:", dblib_dir
, " inc dir:", db_incdir
854 db_incs
= [db_incdir
]
856 # We add the runtime_library_dirs argument because the
857 # BerkeleyDB lib we're linking against often isn't in the
858 # system dynamic library search path. This is usually
859 # correct and most trouble free, but may cause problems in
860 # some unusual system configurations (e.g. the directory
861 # is on an NFS server that goes away).
862 exts
.append(Extension('_bsddb', ['_bsddb.c'],
863 depends
= ['bsddb.h'],
864 library_dirs
=dblib_dir
,
865 runtime_library_dirs
=dblib_dir
,
866 include_dirs
=db_incs
,
869 if db_setup_debug
: print "db: no appropriate library found"
873 missing
.append('_bsddb')
875 # The sqlite interface
876 sqlite_setup_debug
= False # verbose debug prints from this script?
878 # We hunt for #define SQLITE_VERSION "n.n.n"
879 # We need to find >= sqlite version 3.0.8
880 sqlite_incdir
= sqlite_libdir
= None
881 sqlite_inc_paths
= [ '/usr/include',
882 '/usr/include/sqlite',
883 '/usr/include/sqlite3',
884 '/usr/local/include',
885 '/usr/local/include/sqlite',
886 '/usr/local/include/sqlite3',
888 MIN_SQLITE_VERSION_NUMBER
= (3, 0, 8)
889 MIN_SQLITE_VERSION
= ".".join([str(x
)
890 for x
in MIN_SQLITE_VERSION_NUMBER
])
892 # Scan the default include directories before the SQLite specific
893 # ones. This allows one to override the copy of sqlite on OSX,
894 # where /usr/include contains an old version of sqlite.
895 for d
in inc_dirs
+ sqlite_inc_paths
:
896 f
= os
.path
.join(d
, "sqlite3.h")
897 if os
.path
.exists(f
):
898 if sqlite_setup_debug
: print "sqlite: found %s"%f
899 incf
= open(f
).read()
901 r
'\s*.*#\s*.*define\s.*SQLITE_VERSION\W*"(.*)"', incf
)
903 sqlite_version
= m
.group(1)
904 sqlite_version_tuple
= tuple([int(x
)
905 for x
in sqlite_version
.split(".")])
906 if sqlite_version_tuple
>= MIN_SQLITE_VERSION_NUMBER
:
908 if sqlite_setup_debug
:
909 print "%s/sqlite3.h: version %s"%(d
, sqlite_version
)
913 if sqlite_setup_debug
:
914 print "%s: version %d is too old, need >= %s"%(d
,
915 sqlite_version
, MIN_SQLITE_VERSION
)
916 elif sqlite_setup_debug
:
917 print "sqlite: %s had no SQLITE_VERSION"%(f
,)
920 sqlite_dirs_to_check
= [
921 os
.path
.join(sqlite_incdir
, '..', 'lib64'),
922 os
.path
.join(sqlite_incdir
, '..', 'lib'),
923 os
.path
.join(sqlite_incdir
, '..', '..', 'lib64'),
924 os
.path
.join(sqlite_incdir
, '..', '..', 'lib'),
926 sqlite_libfile
= self
.compiler
.find_library_file(
927 sqlite_dirs_to_check
+ lib_dirs
, 'sqlite3')
929 sqlite_libdir
= [os
.path
.abspath(os
.path
.dirname(sqlite_libfile
))]
931 if sqlite_incdir
and sqlite_libdir
:
932 sqlite_srcs
= ['_sqlite/cache.c',
933 '_sqlite/connection.c',
935 '_sqlite/microprotocols.c',
937 '_sqlite/prepare_protocol.c',
939 '_sqlite/statement.c',
943 if sys
.platform
!= "win32":
944 sqlite_defines
.append(('MODULE_NAME', '"sqlite3"'))
946 sqlite_defines
.append(('MODULE_NAME', '\\"sqlite3\\"'))
949 if sys
.platform
== 'darwin':
950 # In every directory on the search path search for a dynamic
951 # library and then a static library, instead of first looking
952 # for dynamic libraries on the entiry path.
953 # This way a staticly linked custom sqlite gets picked up
954 # before the dynamic library in /usr/lib.
955 sqlite_extra_link_args
= ('-Wl,-search_paths_first',)
957 sqlite_extra_link_args
= ()
959 exts
.append(Extension('_sqlite3', sqlite_srcs
,
960 define_macros
=sqlite_defines
,
961 include_dirs
=["Modules/_sqlite",
963 library_dirs
=sqlite_libdir
,
964 runtime_library_dirs
=sqlite_libdir
,
965 extra_link_args
=sqlite_extra_link_args
,
966 libraries
=["sqlite3",]))
968 missing
.append('_sqlite3')
970 # Look for Berkeley db 1.85. Note that it is built as a different
971 # module name so it can be included even when later versions are
972 # available. A very restrictive search is performed to avoid
973 # accidentally building this module with a later version of the
974 # underlying db library. May BSD-ish Unixes incorporate db 1.85
975 # symbols into libc and place the include file in /usr/include.
977 # If the better bsddb library can be built (db_incs is defined)
978 # we do not build this one. Otherwise this build will pick up
979 # the more recent berkeleydb's db.h file first in the include path
980 # when attempting to compile and it will fail.
981 f
= "/usr/include/db.h"
982 if os
.path
.exists(f
) and not db_incs
:
983 data
= open(f
).read()
984 m
= re
.search(r
"#s*define\s+HASHVERSION\s+2\s*", data
)
986 # bingo - old version used hash file format version 2
987 ### XXX this should be fixed to not be platform-dependent
988 ### but I don't have direct access to an osf1 platform and
989 ### seemed to be muffing the search somehow
990 libraries
= platform
== "osf1" and ['db'] or None
991 if libraries
is not None:
992 exts
.append(Extension('bsddb185', ['bsddbmodule.c'],
993 libraries
=libraries
))
995 exts
.append(Extension('bsddb185', ['bsddbmodule.c']))
997 missing
.append('bsddb185')
999 missing
.append('bsddb185')
1001 # The standard Unix dbm module:
1002 if platform
not in ['cygwin']:
1003 if find_file("ndbm.h", inc_dirs
, []) is not None:
1004 # Some systems have -lndbm, others don't
1005 if self
.compiler
.find_library_file(lib_dirs
, 'ndbm'):
1006 ndbm_libs
= ['ndbm']
1009 exts
.append( Extension('dbm', ['dbmmodule.c'],
1010 define_macros
=[('HAVE_NDBM_H',None)],
1011 libraries
= ndbm_libs
) )
1012 elif self
.compiler
.find_library_file(lib_dirs
, 'gdbm'):
1013 gdbm_libs
= ['gdbm']
1014 if self
.compiler
.find_library_file(lib_dirs
, 'gdbm_compat'):
1015 gdbm_libs
.append('gdbm_compat')
1016 if find_file("gdbm/ndbm.h", inc_dirs
, []) is not None:
1017 exts
.append( Extension(
1018 'dbm', ['dbmmodule.c'],
1019 define_macros
=[('HAVE_GDBM_NDBM_H',None)],
1020 libraries
= gdbm_libs
) )
1021 elif find_file("gdbm-ndbm.h", inc_dirs
, []) is not None:
1022 exts
.append( Extension(
1023 'dbm', ['dbmmodule.c'],
1024 define_macros
=[('HAVE_GDBM_DASH_NDBM_H',None)],
1025 libraries
= gdbm_libs
) )
1027 missing
.append('dbm')
1028 elif db_incs
is not None:
1029 exts
.append( Extension('dbm', ['dbmmodule.c'],
1030 library_dirs
=dblib_dir
,
1031 runtime_library_dirs
=dblib_dir
,
1032 include_dirs
=db_incs
,
1033 define_macros
=[('HAVE_BERKDB_H',None),
1034 ('DB_DBM_HSEARCH',None)],
1037 missing
.append('dbm')
1039 # Anthony Baxter's gdbm module. GNU dbm(3) will require -lgdbm:
1040 if (self
.compiler
.find_library_file(lib_dirs
, 'gdbm')):
1041 exts
.append( Extension('gdbm', ['gdbmmodule.c'],
1042 libraries
= ['gdbm'] ) )
1044 missing
.append('gdbm')
1047 if platform
not in ['mac', 'win32']:
1048 # Steen Lumholt's termios module
1049 exts
.append( Extension('termios', ['termios.c']) )
1050 # Jeremy Hylton's rlimit interface
1051 if platform
not in ['atheos']:
1052 exts
.append( Extension('resource', ['resource.c']) )
1054 missing
.append('resource')
1056 # Sun yellow pages. Some systems have the functions in libc.
1057 if platform
not in ['cygwin', 'atheos', 'qnx6']:
1058 if (self
.compiler
.find_library_file(lib_dirs
, 'nsl')):
1062 exts
.append( Extension('nis', ['nismodule.c'],
1065 missing
.append('nis')
1067 missing
.extend(['nis', 'resource', 'termios'])
1069 # Curses support, requiring the System V version of curses, often
1070 # provided by the ncurses library.
1071 panel_library
= 'panel'
1072 if (self
.compiler
.find_library_file(lib_dirs
, 'ncursesw')):
1073 curses_libs
= ['ncursesw']
1074 # Bug 1464056: If _curses.so links with ncursesw,
1075 # _curses_panel.so must link with panelw.
1076 panel_library
= 'panelw'
1077 exts
.append( Extension('_curses', ['_cursesmodule.c'],
1078 libraries
= curses_libs
) )
1079 elif (self
.compiler
.find_library_file(lib_dirs
, 'ncurses')):
1080 curses_libs
= ['ncurses']
1081 exts
.append( Extension('_curses', ['_cursesmodule.c'],
1082 libraries
= curses_libs
) )
1083 elif (self
.compiler
.find_library_file(lib_dirs
, 'curses')
1084 and platform
!= 'darwin'):
1085 # OSX has an old Berkeley curses, not good enough for
1086 # the _curses module.
1087 if (self
.compiler
.find_library_file(lib_dirs
, 'terminfo')):
1088 curses_libs
= ['curses', 'terminfo']
1089 elif (self
.compiler
.find_library_file(lib_dirs
, 'termcap')):
1090 curses_libs
= ['curses', 'termcap']
1092 curses_libs
= ['curses']
1094 exts
.append( Extension('_curses', ['_cursesmodule.c'],
1095 libraries
= curses_libs
) )
1097 missing
.append('_curses')
1099 # If the curses module is enabled, check for the panel module
1100 if (module_enabled(exts
, '_curses') and
1101 self
.compiler
.find_library_file(lib_dirs
, panel_library
)):
1102 exts
.append( Extension('_curses_panel', ['_curses_panel.c'],
1103 libraries
= [panel_library
] + curses_libs
) )
1105 missing
.append('_curses_panel')
1107 # Andrew Kuchling's zlib module. Note that some versions of zlib
1108 # 1.1.3 have security problems. See CERT Advisory CA-2002-07:
1109 # http://www.cert.org/advisories/CA-2002-07.html
1111 # zlib 1.1.4 is fixed, but at least one vendor (RedHat) has decided to
1112 # patch its zlib 1.1.3 package instead of upgrading to 1.1.4. For
1113 # now, we still accept 1.1.3, because we think it's difficult to
1114 # exploit this in Python, and we'd rather make it RedHat's problem
1115 # than our problem <wink>.
1117 # You can upgrade zlib to version 1.1.4 yourself by going to
1118 # http://www.gzip.org/zlib/
1119 zlib_inc
= find_file('zlib.h', [], inc_dirs
)
1121 if zlib_inc
is not None:
1122 zlib_h
= zlib_inc
[0] + '/zlib.h'
1124 version_req
= '"1.1.3"'
1127 line
= fp
.readline()
1130 if line
.startswith('#define ZLIB_VERSION'):
1131 version
= line
.split()[2]
1133 if version
>= version_req
:
1134 if (self
.compiler
.find_library_file(lib_dirs
, 'z')):
1135 if sys
.platform
== "darwin":
1136 zlib_extra_link_args
= ('-Wl,-search_paths_first',)
1138 zlib_extra_link_args
= ()
1139 exts
.append( Extension('zlib', ['zlibmodule.c'],
1141 extra_link_args
= zlib_extra_link_args
))
1144 missing
.append('zlib')
1146 missing
.append('zlib')
1148 missing
.append('zlib')
1150 # Helper module for various ascii-encoders. Uses zlib for an optimized
1151 # crc32 if we have it. Otherwise binascii uses its own.
1153 extra_compile_args
= ['-DUSE_ZLIB_CRC32']
1155 extra_link_args
= zlib_extra_link_args
1157 extra_compile_args
= []
1159 extra_link_args
= []
1160 exts
.append( Extension('binascii', ['binascii.c'],
1161 extra_compile_args
= extra_compile_args
,
1162 libraries
= libraries
,
1163 extra_link_args
= extra_link_args
) )
1165 # Gustavo Niemeyer's bz2 module.
1166 if (self
.compiler
.find_library_file(lib_dirs
, 'bz2')):
1167 if sys
.platform
== "darwin":
1168 bz2_extra_link_args
= ('-Wl,-search_paths_first',)
1170 bz2_extra_link_args
= ()
1171 exts
.append( Extension('bz2', ['bz2module.c'],
1172 libraries
= ['bz2'],
1173 extra_link_args
= bz2_extra_link_args
) )
1175 missing
.append('bz2')
1177 # Interface to the Expat XML parser
1179 # Expat was written by James Clark and is now maintained by a
1180 # group of developers on SourceForge; see www.libexpat.org for
1181 # more information. The pyexpat module was written by Paul
1182 # Prescod after a prototype by Jack Jansen. The Expat source
1183 # is included in Modules/expat/. Usage of a system
1184 # shared libexpat.so/expat.dll is not advised.
1186 # More information on Expat can be found at www.libexpat.org.
1188 expatinc
= os
.path
.join(os
.getcwd(), srcdir
, 'Modules', 'expat')
1190 ('HAVE_EXPAT_CONFIG_H', '1'),
1193 exts
.append(Extension('pyexpat',
1194 define_macros
= define_macros
,
1195 include_dirs
= [expatinc
],
1196 sources
= ['pyexpat.c',
1203 # Fredrik Lundh's cElementTree module. Note that this also
1204 # uses expat (via the CAPI hook in pyexpat).
1206 if os
.path
.isfile(os
.path
.join(srcdir
, 'Modules', '_elementtree.c')):
1207 define_macros
.append(('USE_PYEXPAT_CAPI', None))
1208 exts
.append(Extension('_elementtree',
1209 define_macros
= define_macros
,
1210 include_dirs
= [expatinc
],
1211 sources
= ['_elementtree.c'],
1214 missing
.append('_elementtree')
1216 # Hye-Shik Chang's CJKCodecs modules.
1218 exts
.append(Extension('_multibytecodec',
1219 ['cjkcodecs/multibytecodec.c']))
1220 for loc
in ('kr', 'jp', 'cn', 'tw', 'hk', 'iso2022'):
1221 exts
.append(Extension('_codecs_%s' % loc
,
1222 ['cjkcodecs/_codecs_%s.c' % loc
]))
1224 missing
.append('_multibytecodec')
1225 for loc
in ('kr', 'jp', 'cn', 'tw', 'hk', 'iso2022'):
1226 missing
.append('_codecs_%s' % loc
)
1228 # Dynamic loading module
1229 if sys
.maxint
== 0x7fffffff:
1230 # This requires sizeof(int) == sizeof(long) == sizeof(char*)
1231 dl_inc
= find_file('dlfcn.h', [], inc_dirs
)
1232 if (dl_inc
is not None) and (platform
not in ['atheos']):
1233 exts
.append( Extension('dl', ['dlmodule.c']) )
1235 missing
.append('dl')
1237 missing
.append('dl')
1239 # Thomas Heller's _ctypes module
1240 self
.detect_ctypes(inc_dirs
, lib_dirs
)
1242 # Richard Oudkerk's multiprocessing module
1243 if platform
== 'win32': # Windows
1245 libraries
= ['ws2_32']
1247 elif platform
== 'darwin': # Mac OSX
1250 HAVE_SEM_TIMEDWAIT
=0,
1252 HAVE_BROKEN_SEM_GETVALUE
=1
1256 elif platform
== 'cygwin': # Cygwin
1259 HAVE_SEM_TIMEDWAIT
=1,
1261 HAVE_BROKEN_SEM_UNLINK
=1
1265 elif platform
in ('freebsd4', 'freebsd5', 'freebsd6', 'freebsd7', 'freebsd8'):
1266 # FreeBSD's P1003.1b semaphore support is very experimental
1267 # and has many known problems. (as of June 2008)
1268 macros
= dict( # FreeBSD
1270 HAVE_SEM_TIMEDWAIT
=0,
1275 elif platform
.startswith('openbsd'):
1276 macros
= dict( # OpenBSD
1277 HAVE_SEM_OPEN
=0, # Not implemented
1278 HAVE_SEM_TIMEDWAIT
=0,
1283 else: # Linux and other unices
1286 HAVE_SEM_TIMEDWAIT
=1,
1291 if platform
== 'win32':
1292 multiprocessing_srcs
= [ '_multiprocessing/multiprocessing.c',
1293 '_multiprocessing/semaphore.c',
1294 '_multiprocessing/pipe_connection.c',
1295 '_multiprocessing/socket_connection.c',
1296 '_multiprocessing/win32_functions.c'
1300 multiprocessing_srcs
= [ '_multiprocessing/multiprocessing.c',
1301 '_multiprocessing/socket_connection.c'
1304 if macros
.get('HAVE_SEM_OPEN', False):
1305 multiprocessing_srcs
.append('_multiprocessing/semaphore.c')
1307 if sysconfig
.get_config_var('WITH_THREAD'):
1308 exts
.append ( Extension('_multiprocessing', multiprocessing_srcs
,
1309 define_macros
=macros
.items(),
1310 include_dirs
=["Modules/_multiprocessing"]))
1312 missing
.append('_multiprocessing')
1314 # End multiprocessing
1317 # Platform-specific libraries
1318 if platform
== 'linux2':
1319 # Linux-specific modules
1320 exts
.append( Extension('linuxaudiodev', ['linuxaudiodev.c']) )
1322 missing
.append('linuxaudiodev')
1324 if platform
in ('linux2', 'freebsd4', 'freebsd5', 'freebsd6',
1325 'freebsd7', 'freebsd8'):
1326 exts
.append( Extension('ossaudiodev', ['ossaudiodev.c']) )
1328 missing
.append('ossaudiodev')
1330 if platform
== 'sunos5':
1331 # SunOS specific modules
1332 exts
.append( Extension('sunaudiodev', ['sunaudiodev.c']) )
1334 missing
.append('sunaudiodev')
1336 if platform
== 'darwin' and ("--disable-toolbox-glue" not in
1337 sysconfig
.get_config_var("CONFIG_ARGS")):
1339 if os
.uname()[2] > '8.':
1340 # We're on Mac OS X 10.4 or later, the compiler should
1341 # support '-Wno-deprecated-declarations'. This will
1342 # surpress deprecation warnings for the Carbon extensions,
1343 # these extensions wrap the Carbon APIs and even those
1344 # parts that are deprecated.
1345 carbon_extra_compile_args
= ['-Wno-deprecated-declarations']
1347 carbon_extra_compile_args
= []
1349 # Mac OS X specific modules.
1350 def macSrcExists(name1
, name2
=''):
1355 names
= (name1
, name2
)
1356 path
= os
.path
.join(srcdir
, 'Mac', 'Modules', *names
)
1357 return os
.path
.exists(path
)
1359 def addMacExtension(name
, kwds
, extra_srcs
=[]):
1362 dirname
= name
[1:].lower()
1364 cmodulename
= name
+ 'module.c'
1365 # Check for NNN.c, NNNmodule.c, _nnn/NNN.c, _nnn/NNNmodule.c
1366 if macSrcExists(cname
):
1368 elif macSrcExists(cmodulename
):
1369 srcs
= [cmodulename
]
1370 elif macSrcExists(dirname
, cname
):
1371 # XXX(nnorwitz): If all the names ended with module, we
1372 # wouldn't need this condition. ibcarbon is the only one.
1373 srcs
= [os
.path
.join(dirname
, cname
)]
1374 elif macSrcExists(dirname
, cmodulename
):
1375 srcs
= [os
.path
.join(dirname
, cmodulename
)]
1377 raise RuntimeError("%s not found" % name
)
1379 # Here's the whole point: add the extension with sources
1380 exts
.append(Extension(name
, srcs
+ extra_srcs
, **kwds
))
1383 core_kwds
= {'extra_compile_args': carbon_extra_compile_args
,
1384 'extra_link_args': ['-framework', 'CoreFoundation'],
1386 addMacExtension('_CF', core_kwds
, ['cf/pycfbridge.c'])
1387 addMacExtension('autoGIL', core_kwds
)
1390 carbon_kwds
= {'extra_compile_args': carbon_extra_compile_args
,
1391 'extra_link_args': ['-framework', 'Carbon'],
1393 CARBON_EXTS
= ['ColorPicker', 'gestalt', 'MacOS', 'Nav',
1394 'OSATerminology', 'icglue',
1395 # All these are in subdirs
1396 '_AE', '_AH', '_App', '_CarbonEvt', '_Cm', '_Ctl',
1397 '_Dlg', '_Drag', '_Evt', '_File', '_Folder', '_Fm',
1398 '_Help', '_Icn', '_IBCarbon', '_List',
1399 '_Menu', '_Mlte', '_OSA', '_Res', '_Qd', '_Qdoffs',
1400 '_Scrap', '_Snd', '_TE',
1402 for name
in CARBON_EXTS
:
1403 addMacExtension(name
, carbon_kwds
)
1405 # Workaround for a bug in the version of gcc shipped with Xcode 3.
1406 # The _Win extension should build just like the other Carbon extensions, but
1407 # this actually results in a hard crash of the linker.
1409 if '-arch ppc64' in cflags
and '-arch ppc' in cflags
:
1410 win_kwds
= {'extra_compile_args': carbon_extra_compile_args
+ ['-arch', 'i386', '-arch', 'ppc'],
1411 'extra_link_args': ['-framework', 'Carbon', '-arch', 'i386', '-arch', 'ppc'],
1413 addMacExtension('_Win', win_kwds
)
1415 addMacExtension('_Win', carbon_kwds
)
1418 # Application Services & QuickTime
1419 app_kwds
= {'extra_compile_args': carbon_extra_compile_args
,
1420 'extra_link_args': ['-framework','ApplicationServices'],
1422 addMacExtension('_Launch', app_kwds
)
1423 addMacExtension('_CG', app_kwds
)
1425 exts
.append( Extension('_Qt', ['qt/_Qtmodule.c'],
1426 extra_compile_args
=carbon_extra_compile_args
,
1427 extra_link_args
=['-framework', 'QuickTime',
1428 '-framework', 'Carbon']) )
1431 self
.extensions
.extend(exts
)
1433 # Call the method for detecting whether _tkinter can be compiled
1434 self
.detect_tkinter(inc_dirs
, lib_dirs
)
1436 if '_tkinter' not in [e
.name
for e
in self
.extensions
]:
1437 missing
.append('_tkinter')
1441 def detect_tkinter_darwin(self
, inc_dirs
, lib_dirs
):
1442 # The _tkinter module, using frameworks. Since frameworks are quite
1443 # different the UNIX search logic is not sharable.
1444 from os
.path
import join
, exists
1446 '/Library/Frameworks',
1447 '/System/Library/Frameworks/',
1448 join(os
.getenv('HOME'), '/Library/Frameworks')
1451 # Find the directory that contains the Tcl.framework and Tk.framework
1453 # XXX distutils should support -F!
1454 for F
in framework_dirs
:
1455 # both Tcl.framework and Tk.framework should be present
1456 for fw
in 'Tcl', 'Tk':
1457 if not exists(join(F
, fw
+ '.framework')):
1460 # ok, F is now directory with both frameworks. Continure
1464 # Tk and Tcl frameworks not found. Normal "unix" tkinter search
1468 # For 8.4a2, we must add -I options that point inside the Tcl and Tk
1469 # frameworks. In later release we should hopefully be able to pass
1470 # the -F option to gcc, which specifies a framework lookup path.
1473 join(F
, fw
+ '.framework', H
)
1474 for fw
in 'Tcl', 'Tk'
1475 for H
in 'Headers', 'Versions/Current/PrivateHeaders'
1478 # For 8.4a2, the X11 headers are not included. Rather than include a
1479 # complicated search, this is a hard-coded path. It could bail out
1480 # if X11 libs are not found...
1481 include_dirs
.append('/usr/X11R6/include')
1482 frameworks
= ['-framework', 'Tcl', '-framework', 'Tk']
1484 # All existing framework builds of Tcl/Tk don't support 64-bit
1486 cflags
= sysconfig
.get_config_vars('CFLAGS')[0]
1487 archs
= re
.findall('-arch\s+(\w+)', cflags
)
1488 if 'x86_64' in archs
or 'ppc64' in archs
:
1490 archs
.remove('x86_64')
1494 archs
.remove('ppc64')
1499 frameworks
.append('-arch')
1500 frameworks
.append(a
)
1502 ext
= Extension('_tkinter', ['_tkinter.c', 'tkappinit.c'],
1503 define_macros
=[('WITH_APPINIT', 1)],
1504 include_dirs
= include_dirs
,
1506 extra_compile_args
= frameworks
[2:],
1507 extra_link_args
= frameworks
,
1509 self
.extensions
.append(ext
)
1513 def detect_tkinter(self
, inc_dirs
, lib_dirs
):
1514 # The _tkinter module.
1516 # Rather than complicate the code below, detecting and building
1517 # AquaTk is a separate method. Only one Tkinter will be built on
1518 # Darwin - either AquaTk, if it is found, or X11 based Tk.
1519 platform
= self
.get_platform()
1520 if (platform
== 'darwin' and
1521 self
.detect_tkinter_darwin(inc_dirs
, lib_dirs
)):
1524 # Assume we haven't found any of the libraries or include files
1525 # The versions with dots are used on Unix, and the versions without
1526 # dots on Windows, for detection by cygwin.
1527 tcllib
= tklib
= tcl_includes
= tk_includes
= None
1528 for version
in ['8.5', '85', '8.4', '84', '8.3', '83', '8.2',
1529 '82', '8.1', '81', '8.0', '80']:
1530 tklib
= self
.compiler
.find_library_file(lib_dirs
, 'tk' + version
)
1531 tcllib
= self
.compiler
.find_library_file(lib_dirs
, 'tcl' + version
)
1532 if tklib
and tcllib
:
1533 # Exit the loop when we've found the Tcl/Tk libraries
1536 # Now check for the header files
1537 if tklib
and tcllib
:
1538 # Check for the include files on Debian and {Free,Open}BSD, where
1539 # they're put in /usr/include/{tcl,tk}X.Y
1540 dotversion
= version
1541 if '.' not in dotversion
and "bsd" in sys
.platform
.lower():
1542 # OpenBSD and FreeBSD use Tcl/Tk library names like libtcl83.a,
1543 # but the include subdirs are named like .../include/tcl8.3.
1544 dotversion
= dotversion
[:-1] + '.' + dotversion
[-1]
1545 tcl_include_sub
= []
1547 for dir in inc_dirs
:
1548 tcl_include_sub
+= [dir + os
.sep
+ "tcl" + dotversion
]
1549 tk_include_sub
+= [dir + os
.sep
+ "tk" + dotversion
]
1550 tk_include_sub
+= tcl_include_sub
1551 tcl_includes
= find_file('tcl.h', inc_dirs
, tcl_include_sub
)
1552 tk_includes
= find_file('tk.h', inc_dirs
, tk_include_sub
)
1554 if (tcllib
is None or tklib
is None or
1555 tcl_includes
is None or tk_includes
is None):
1556 self
.announce("INFO: Can't locate Tcl/Tk libs and/or headers", 2)
1559 # OK... everything seems to be present for Tcl/Tk.
1561 include_dirs
= [] ; libs
= [] ; defs
= [] ; added_lib_dirs
= []
1562 for dir in tcl_includes
+ tk_includes
:
1563 if dir not in include_dirs
:
1564 include_dirs
.append(dir)
1566 # Check for various platform-specific directories
1567 if platform
== 'sunos5':
1568 include_dirs
.append('/usr/openwin/include')
1569 added_lib_dirs
.append('/usr/openwin/lib')
1570 elif os
.path
.exists('/usr/X11R6/include'):
1571 include_dirs
.append('/usr/X11R6/include')
1572 added_lib_dirs
.append('/usr/X11R6/lib64')
1573 added_lib_dirs
.append('/usr/X11R6/lib')
1574 elif os
.path
.exists('/usr/X11R5/include'):
1575 include_dirs
.append('/usr/X11R5/include')
1576 added_lib_dirs
.append('/usr/X11R5/lib')
1578 # Assume default location for X11
1579 include_dirs
.append('/usr/X11/include')
1580 added_lib_dirs
.append('/usr/X11/lib')
1582 # If Cygwin, then verify that X is installed before proceeding
1583 if platform
== 'cygwin':
1584 x11_inc
= find_file('X11/Xlib.h', [], include_dirs
)
1588 # Check for BLT extension
1589 if self
.compiler
.find_library_file(lib_dirs
+ added_lib_dirs
,
1591 defs
.append( ('WITH_BLT', 1) )
1592 libs
.append('BLT8.0')
1593 elif self
.compiler
.find_library_file(lib_dirs
+ added_lib_dirs
,
1595 defs
.append( ('WITH_BLT', 1) )
1598 # Add the Tcl/Tk libraries
1599 libs
.append('tk'+ version
)
1600 libs
.append('tcl'+ version
)
1602 if platform
in ['aix3', 'aix4']:
1605 # Finally, link with the X11 libraries (not appropriate on cygwin)
1606 if platform
!= "cygwin":
1609 ext
= Extension('_tkinter', ['_tkinter.c', 'tkappinit.c'],
1610 define_macros
=[('WITH_APPINIT', 1)] + defs
,
1611 include_dirs
= include_dirs
,
1613 library_dirs
= added_lib_dirs
,
1615 self
.extensions
.append(ext
)
1617 ## # Uncomment these lines if you want to play with xxmodule.c
1618 ## ext = Extension('xx', ['xxmodule.c'])
1619 ## self.extensions.append(ext)
1621 # XXX handle these, but how to detect?
1622 # *** Uncomment and edit for PIL (TkImaging) extension only:
1623 # -DWITH_PIL -I../Extensions/Imaging/libImaging tkImaging.c \
1624 # *** Uncomment and edit for TOGL extension only:
1625 # -DWITH_TOGL togl.c \
1626 # *** Uncomment these for TOGL extension only:
1627 # -lGL -lGLU -lXext -lXmu \
1629 def configure_ctypes_darwin(self
, ext
):
1630 # Darwin (OS X) uses preconfigured files, in
1631 # the Modules/_ctypes/libffi_osx directory.
1632 srcdir
= sysconfig
.get_config_var('srcdir')
1633 ffi_srcdir
= os
.path
.abspath(os
.path
.join(srcdir
, 'Modules',
1634 '_ctypes', 'libffi_osx'))
1635 sources
= [os
.path
.join(ffi_srcdir
, p
)
1639 'x86/x86-ffi_darwin.c',
1641 'powerpc/ppc-darwin.S',
1642 'powerpc/ppc-darwin_closure.S',
1643 'powerpc/ppc-ffi_darwin.c',
1644 'powerpc/ppc64-darwin_closure.S',
1647 # Add .S (preprocessed assembly) to C compiler source extensions.
1648 self
.compiler
.src_extensions
.append('.S')
1650 include_dirs
= [os
.path
.join(ffi_srcdir
, 'include'),
1651 os
.path
.join(ffi_srcdir
, 'powerpc')]
1652 ext
.include_dirs
.extend(include_dirs
)
1653 ext
.sources
.extend(sources
)
1656 def configure_ctypes(self
, ext
):
1657 if not self
.use_system_libffi
:
1658 if sys
.platform
== 'darwin':
1659 return self
.configure_ctypes_darwin(ext
)
1661 srcdir
= sysconfig
.get_config_var('srcdir')
1662 ffi_builddir
= os
.path
.join(self
.build_temp
, 'libffi')
1663 ffi_srcdir
= os
.path
.abspath(os
.path
.join(srcdir
, 'Modules',
1664 '_ctypes', 'libffi'))
1665 ffi_configfile
= os
.path
.join(ffi_builddir
, 'fficonfig.py')
1667 from distutils
.dep_util
import newer_group
1669 config_sources
= [os
.path
.join(ffi_srcdir
, fname
)
1670 for fname
in os
.listdir(ffi_srcdir
)
1671 if os
.path
.isfile(os
.path
.join(ffi_srcdir
, fname
))]
1672 if self
.force
or newer_group(config_sources
,
1674 from distutils
.dir_util
import mkpath
1675 mkpath(ffi_builddir
)
1678 # Pass empty CFLAGS because we'll just append the resulting
1679 # CFLAGS to Python's; -g or -O2 is to be avoided.
1680 cmd
= "cd %s && env CFLAGS='' '%s/configure' %s" \
1681 % (ffi_builddir
, ffi_srcdir
, " ".join(config_args
))
1683 res
= os
.system(cmd
)
1684 if res
or not os
.path
.exists(ffi_configfile
):
1685 print "Failed to configure _ctypes module"
1689 execfile(ffi_configfile
, globals(), fficonfig
)
1690 ffi_srcdir
= os
.path
.join(fficonfig
['ffi_srcdir'], 'src')
1692 # Add .S (preprocessed assembly) to C compiler source extensions.
1693 self
.compiler
.src_extensions
.append('.S')
1695 include_dirs
= [os
.path
.join(ffi_builddir
, 'include'),
1696 ffi_builddir
, ffi_srcdir
]
1697 extra_compile_args
= fficonfig
['ffi_cflags'].split()
1699 ext
.sources
.extend(fficonfig
['ffi_sources'])
1700 ext
.include_dirs
.extend(include_dirs
)
1701 ext
.extra_compile_args
.extend(extra_compile_args
)
1704 def detect_ctypes(self
, inc_dirs
, lib_dirs
):
1705 self
.use_system_libffi
= False
1707 extra_compile_args
= []
1708 extra_link_args
= []
1709 sources
= ['_ctypes/_ctypes.c',
1710 '_ctypes/callbacks.c',
1711 '_ctypes/callproc.c',
1712 '_ctypes/stgdict.c',
1714 '_ctypes/malloc_closure.c']
1715 depends
= ['_ctypes/ctypes.h']
1717 if sys
.platform
== 'darwin':
1718 sources
.append('_ctypes/darwin/dlfcn_simple.c')
1719 extra_compile_args
.append('-DMACOSX')
1720 include_dirs
.append('_ctypes/darwin')
1721 # XXX Is this still needed?
1722 ## extra_link_args.extend(['-read_only_relocs', 'warning'])
1724 elif sys
.platform
== 'sunos5':
1725 # XXX This shouldn't be necessary; it appears that some
1726 # of the assembler code is non-PIC (i.e. it has relocations
1727 # when it shouldn't. The proper fix would be to rewrite
1728 # the assembler code to be PIC.
1729 # This only works with GCC; the Sun compiler likely refuses
1730 # this option. If you want to compile ctypes with the Sun
1731 # compiler, please research a proper solution, instead of
1732 # finding some -z option for the Sun compiler.
1733 extra_link_args
.append('-mimpure-text')
1735 elif sys
.platform
.startswith('hp-ux'):
1736 extra_link_args
.append('-fPIC')
1738 ext
= Extension('_ctypes',
1739 include_dirs
=include_dirs
,
1740 extra_compile_args
=extra_compile_args
,
1741 extra_link_args
=extra_link_args
,
1745 ext_test
= Extension('_ctypes_test',
1746 sources
=['_ctypes/_ctypes_test.c'])
1747 self
.extensions
.extend([ext
, ext_test
])
1749 if not '--with-system-ffi' in sysconfig
.get_config_var("CONFIG_ARGS"):
1752 if sys
.platform
== 'darwin':
1753 # OS X 10.5 comes with libffi.dylib; the include files are
1754 # in /usr/include/ffi
1755 inc_dirs
.append('/usr/include/ffi')
1757 ffi_inc
= find_file('ffi.h', [], inc_dirs
)
1758 if ffi_inc
is not None:
1759 ffi_h
= ffi_inc
[0] + '/ffi.h'
1762 line
= fp
.readline()
1766 if line
.startswith('#define LIBFFI_H'):
1769 if ffi_inc
is not None:
1770 for lib_name
in ('ffi_convenience', 'ffi_pic', 'ffi'):
1771 if (self
.compiler
.find_library_file(lib_dirs
, lib_name
)):
1775 if ffi_inc
and ffi_lib
:
1776 ext
.include_dirs
.extend(ffi_inc
)
1777 ext
.libraries
.append(ffi_lib
)
1778 self
.use_system_libffi
= True
1781 class PyBuildInstall(install
):
1782 # Suppress the warning about installation into the lib_dynload
1783 # directory, which is not in sys.path when running Python during
1785 def initialize_options (self
):
1786 install
.initialize_options(self
)
1789 class PyBuildInstallLib(install_lib
):
1790 # Do exactly what install_lib does but make sure correct access modes get
1791 # set on installed directories and files. All installed files with get
1792 # mode 644 unless they are a shared library in which case they will get
1793 # mode 755. All installed directories will get mode 755.
1795 so_ext
= sysconfig
.get_config_var("SO")
1798 outfiles
= install_lib
.install(self
)
1799 self
.set_file_modes(outfiles
, 0644, 0755)
1800 self
.set_dir_modes(self
.install_dir
, 0755)
1803 def set_file_modes(self
, files
, defaultMode
, sharedLibMode
):
1804 if not self
.is_chmod_supported(): return
1805 if not files
: return
1807 for filename
in files
:
1808 if os
.path
.islink(filename
): continue
1810 if filename
.endswith(self
.so_ext
): mode
= sharedLibMode
1811 log
.info("changing mode of %s to %o", filename
, mode
)
1812 if not self
.dry_run
: os
.chmod(filename
, mode
)
1814 def set_dir_modes(self
, dirname
, mode
):
1815 if not self
.is_chmod_supported(): return
1816 os
.path
.walk(dirname
, self
.set_dir_modes_visitor
, mode
)
1818 def set_dir_modes_visitor(self
, mode
, dirname
, names
):
1819 if os
.path
.islink(dirname
): return
1820 log
.info("changing mode of %s to %o", dirname
, mode
)
1821 if not self
.dry_run
: os
.chmod(dirname
, mode
)
1823 def is_chmod_supported(self
):
1824 return hasattr(os
, 'chmod')
1827 Python is an interpreted, interactive, object-oriented programming
1828 language. It is often compared to Tcl, Perl, Scheme or Java.
1830 Python combines remarkable power with very clear syntax. It has
1831 modules, classes, exceptions, very high level dynamic data types, and
1832 dynamic typing. There are interfaces to many system calls and
1833 libraries, as well as to various windowing systems (X11, Motif, Tk,
1834 Mac, MFC). New built-in modules are easily written in C or C++. Python
1835 is also usable as an extension language for applications that need a
1836 programmable interface.
1838 The Python implementation is portable: it runs on many brands of UNIX,
1839 on Windows, DOS, OS/2, Mac, Amiga... If your favorite system isn't
1840 listed here, it may still be supported, if there's a C compiler for
1841 it. Ask around on comp.lang.python -- or just try compiling Python
1846 Development Status :: 6 - Mature
1847 License :: OSI Approved :: Python Software Foundation License
1848 Natural Language :: English
1849 Programming Language :: C
1850 Programming Language :: Python
1851 Topic :: Software Development
1855 # turn off warnings when deprecated modules are imported
1857 warnings
.filterwarnings("ignore",category
=DeprecationWarning)
1858 setup(# PyPI Metadata (PEP 301)
1860 version
= sys
.version
.split()[0],
1861 url
= "http://www.python.org/%s" % sys
.version
[:3],
1862 maintainer
= "Guido van Rossum and the Python community",
1863 maintainer_email
= "python-dev@python.org",
1864 description
= "A high-level object-oriented programming language",
1865 long_description
= SUMMARY
.strip(),
1866 license
= "PSF license",
1867 classifiers
= filter(None, CLASSIFIERS
.split("\n")),
1868 platforms
= ["Many"],
1871 cmdclass
= {'build_ext':PyBuildExt
, 'install':PyBuildInstall
,
1872 'install_lib':PyBuildInstallLib
},
1873 # The struct module is defined here, because build_ext won't be
1874 # called unless there's at least one extension module defined.
1875 ext_modules
=[Extension('_struct', ['_struct.c'])],
1877 # Scripts to install
1878 scripts
= ['Tools/scripts/pydoc', 'Tools/scripts/idle',
1879 'Tools/scripts/2to3',
1884 if __name__
== '__main__':