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 # profilers (_lsprof is for cProfile.py)
452 exts
.append( Extension('_hotshot', ['_hotshot.c']) )
453 exts
.append( Extension('_lsprof', ['_lsprof.c', 'rotatingtree.c']) )
454 # static Unicode character database
456 exts
.append( Extension('unicodedata', ['unicodedata.c']) )
458 missing
.append('unicodedata')
459 # access to ISO C locale support
460 data
= open('pyconfig.h').read()
461 m
= re
.search(r
"#s*define\s+WITH_LIBINTL\s+1\s*", data
)
463 locale_libs
= ['intl']
466 if platform
== 'darwin':
467 locale_extra_link_args
= ['-framework', 'CoreFoundation']
469 locale_extra_link_args
= []
472 exts
.append( Extension('_locale', ['_localemodule.c'],
473 libraries
=locale_libs
,
474 extra_link_args
=locale_extra_link_args
) )
476 # Modules with some UNIX dependencies -- on by default:
477 # (If you have a really backward UNIX, select and socket may not be
480 # fcntl(2) and ioctl(2)
481 exts
.append( Extension('fcntl', ['fcntlmodule.c']) )
482 if platform
not in ['mac']:
484 exts
.append( Extension('pwd', ['pwdmodule.c']) )
486 exts
.append( Extension('grp', ['grpmodule.c']) )
487 # spwd, shadow passwords
488 if (config_h_vars
.get('HAVE_GETSPNAM', False) or
489 config_h_vars
.get('HAVE_GETSPENT', False)):
490 exts
.append( Extension('spwd', ['spwdmodule.c']) )
492 missing
.append('spwd')
494 missing
.extend(['pwd', 'grp', 'spwd'])
496 # select(2); not on ancient System V
497 exts
.append( Extension('select', ['selectmodule.c']) )
499 # Fred Drake's interface to the Python parser
500 exts
.append( Extension('parser', ['parsermodule.c']) )
502 # cStringIO and cPickle
503 exts
.append( Extension('cStringIO', ['cStringIO.c']) )
504 exts
.append( Extension('cPickle', ['cPickle.c']) )
506 # Memory-mapped files (also works on Win32).
507 if platform
not in ['atheos', 'mac']:
508 exts
.append( Extension('mmap', ['mmapmodule.c']) )
510 missing
.append('mmap')
512 # Lance Ellinghaus's syslog module
513 if platform
not in ['mac']:
514 # syslog daemon interface
515 exts
.append( Extension('syslog', ['syslogmodule.c']) )
517 missing
.append('syslog')
519 # George Neville-Neil's timing module:
520 # Deprecated in PEP 4 http://www.python.org/peps/pep-0004.html
521 # http://mail.python.org/pipermail/python-dev/2006-January/060023.html
522 #exts.append( Extension('timing', ['timingmodule.c']) )
525 # Here ends the simple stuff. From here on, modules need certain
526 # libraries, are platform-specific, or present other surprises.
530 # These don't work for 64-bit platforms!!!
531 # These represent audio samples or images as strings:
533 # Operations on audio samples
534 # According to #993173, this one should actually work fine on
536 exts
.append( Extension('audioop', ['audioop.c']) )
538 # Disabled on 64-bit platforms
539 if sys
.maxint
!= 9223372036854775807L:
540 # Operations on images
541 exts
.append( Extension('imageop', ['imageop.c']) )
543 missing
.extend(['imageop'])
546 do_readline
= self
.compiler
.find_library_file(lib_dirs
, 'readline')
547 if platform
== 'darwin': # and os.uname()[2] < '9.':
548 # MacOSX 10.4 has a broken readline. Don't try to build
549 # the readline module unless the user has installed a fixed
551 # FIXME: The readline emulation on 10.5 is better, but the
552 # readline module doesn't compile out of the box.
553 if find_file('readline/rlconf.h', inc_dirs
, []) is None:
556 if sys
.platform
== 'darwin':
557 # In every directory on the search path search for a dynamic
558 # library and then a static library, instead of first looking
559 # for dynamic libraries on the entiry path.
560 # This way a staticly linked custom readline gets picked up
561 # before the (broken) dynamic library in /usr/lib.
562 readline_extra_link_args
= ('-Wl,-search_paths_first',)
564 readline_extra_link_args
= ()
566 readline_libs
= ['readline']
567 if self
.compiler
.find_library_file(lib_dirs
,
569 readline_libs
.append('ncursesw')
570 elif self
.compiler
.find_library_file(lib_dirs
,
572 readline_libs
.append('ncurses')
573 elif self
.compiler
.find_library_file(lib_dirs
, 'curses'):
574 readline_libs
.append('curses')
575 elif self
.compiler
.find_library_file(lib_dirs
+
576 ['/usr/lib/termcap'],
578 readline_libs
.append('termcap')
579 exts
.append( Extension('readline', ['readline.c'],
580 library_dirs
=['/usr/lib/termcap'],
581 extra_link_args
=readline_extra_link_args
,
582 libraries
=readline_libs
) )
584 missing
.append('readline')
586 if platform
not in ['mac']:
589 if self
.compiler
.find_library_file(lib_dirs
, 'crypt'):
593 exts
.append( Extension('crypt', ['cryptmodule.c'], libraries
=libs
) )
595 missing
.append('crypt')
598 exts
.append( Extension('_csv', ['_csv.c']) )
601 exts
.append( Extension('_socket', ['socketmodule.c'],
602 depends
= ['socketmodule.h']) )
603 # Detect SSL support for the socket module (via _ssl)
604 search_for_ssl_incs_in
= [
605 '/usr/local/ssl/include',
606 '/usr/contrib/ssl/include/'
608 ssl_incs
= find_file('openssl/ssl.h', inc_dirs
,
609 search_for_ssl_incs_in
611 if ssl_incs
is not None:
612 krb5_h
= find_file('krb5.h', inc_dirs
,
613 ['/usr/kerberos/include'])
616 ssl_libs
= find_library_file(self
.compiler
, 'ssl',lib_dirs
,
617 ['/usr/local/ssl/lib',
618 '/usr/contrib/ssl/lib/'
621 if (ssl_incs
is not None and
622 ssl_libs
is not None):
623 exts
.append( Extension('_ssl', ['_ssl.c'],
624 include_dirs
= ssl_incs
,
625 library_dirs
= ssl_libs
,
626 libraries
= ['ssl', 'crypto'],
627 depends
= ['socketmodule.h']), )
629 missing
.append('_ssl')
631 # find out which version of OpenSSL we have
633 openssl_ver_re
= re
.compile(
634 '^\s*#\s*define\s+OPENSSL_VERSION_NUMBER\s+(0x[0-9a-fA-F]+)' )
635 for ssl_inc_dir
in inc_dirs
+ search_for_ssl_incs_in
:
636 name
= os
.path
.join(ssl_inc_dir
, 'openssl', 'opensslv.h')
637 if os
.path
.isfile(name
):
639 incfile
= open(name
, 'r')
641 m
= openssl_ver_re
.match(line
)
643 openssl_ver
= eval(m
.group(1))
648 # first version found is what we'll use (as the compiler should)
652 #print 'openssl_ver = 0x%08x' % openssl_ver
654 if (ssl_incs
is not None and
655 ssl_libs
is not None and
656 openssl_ver
>= 0x00907000):
657 # The _hashlib module wraps optimized implementations
658 # of hash functions from the OpenSSL library.
659 exts
.append( Extension('_hashlib', ['_hashopenssl.c'],
660 include_dirs
= ssl_incs
,
661 library_dirs
= ssl_libs
,
662 libraries
= ['ssl', 'crypto']) )
663 # these aren't strictly missing since they are unneeded.
664 #missing.extend(['_sha', '_md5'])
666 # The _sha module implements the SHA1 hash algorithm.
667 exts
.append( Extension('_sha', ['shamodule.c']) )
668 # The _md5 module implements the RSA Data Security, Inc. MD5
669 # Message-Digest Algorithm, described in RFC 1321. The
670 # necessary files md5.c and md5.h are included here.
671 exts
.append( Extension('_md5',
672 sources
= ['md5module.c', 'md5.c'],
673 depends
= ['md5.h']) )
674 missing
.append('_hashlib')
676 if (openssl_ver
< 0x00908000):
677 # OpenSSL doesn't do these until 0.9.8 so we'll bring our own hash
678 exts
.append( Extension('_sha256', ['sha256module.c']) )
679 exts
.append( Extension('_sha512', ['sha512module.c']) )
681 # Modules that provide persistent dictionary-like semantics. You will
682 # probably want to arrange for at least one of them to be available on
683 # your machine, though none are defined by default because of library
684 # dependencies. The Python module anydbm.py provides an
685 # implementation independent wrapper for these; dumbdbm.py provides
686 # similar functionality (but slower of course) implemented in Python.
688 # Sleepycat^WOracle Berkeley DB interface.
689 # http://www.oracle.com/database/berkeley-db/db/index.html
691 # This requires the Sleepycat^WOracle DB code. The supported versions
692 # are set below. Visit the URL above to download
693 # a release. Most open source OSes come with one or more
694 # versions of BerkeleyDB already installed.
698 db_setup_debug
= False # verbose debug prints from this script?
700 def allow_db_ver(db_ver
):
701 """Returns a boolean if the given BerkeleyDB version is acceptable.
704 db_ver: A tuple of the version to verify.
706 if not (min_db_ver
<= db_ver
<= max_db_ver
):
708 # Use this function to filter out known bad configurations.
709 if (4, 6) == db_ver
[:2]:
710 # BerkeleyDB 4.6.x is not stable on many architectures.
711 arch
= platform_machine()
712 if arch
not in ('i386', 'i486', 'i586', 'i686',
717 def gen_db_minor_ver_nums(major
):
719 for x
in range(max_db_ver
[1]+1):
720 if allow_db_ver((4, x
)):
724 if allow_db_ver((3, x
)):
727 raise ValueError("unknown major BerkeleyDB version", major
)
729 # construct a list of paths to look for the header file in on
730 # top of the normal inc_dirs.
733 '/usr/local/include/db4',
734 '/opt/sfw/include/db4',
736 '/usr/local/include/db3',
737 '/opt/sfw/include/db3',
738 # Fink defaults (http://fink.sourceforge.net/)
742 # 4.x minor number specific paths
743 for x
in gen_db_minor_ver_nums(4):
744 db_inc_paths
.append('/usr/include/db4%d' % x
)
745 db_inc_paths
.append('/usr/include/db4.%d' % x
)
746 db_inc_paths
.append('/usr/local/BerkeleyDB.4.%d/include' % x
)
747 db_inc_paths
.append('/usr/local/include/db4%d' % x
)
748 db_inc_paths
.append('/pkg/db-4.%d/include' % x
)
749 db_inc_paths
.append('/opt/db-4.%d/include' % x
)
750 # MacPorts default (http://www.macports.org/)
751 db_inc_paths
.append('/opt/local/include/db4%d' % x
)
752 # 3.x minor number specific paths
753 for x
in gen_db_minor_ver_nums(3):
754 db_inc_paths
.append('/usr/include/db3%d' % x
)
755 db_inc_paths
.append('/usr/local/BerkeleyDB.3.%d/include' % x
)
756 db_inc_paths
.append('/usr/local/include/db3%d' % x
)
757 db_inc_paths
.append('/pkg/db-3.%d/include' % x
)
758 db_inc_paths
.append('/opt/db-3.%d/include' % x
)
760 # Add some common subdirectories for Sleepycat DB to the list,
761 # based on the standard include directories. This way DB3/4 gets
762 # picked up when it is installed in a non-standard prefix and
763 # the user has added that prefix into inc_dirs.
766 std_variants
.append(os
.path
.join(dn
, 'db3'))
767 std_variants
.append(os
.path
.join(dn
, 'db4'))
768 for x
in gen_db_minor_ver_nums(4):
769 std_variants
.append(os
.path
.join(dn
, "db4%d"%x))
770 std_variants
.append(os
.path
.join(dn
, "db4.%d"%x))
771 for x
in gen_db_minor_ver_nums(3):
772 std_variants
.append(os
.path
.join(dn
, "db3%d"%x))
773 std_variants
.append(os
.path
.join(dn
, "db3.%d"%x))
775 db_inc_paths
= std_variants
+ db_inc_paths
776 db_inc_paths
= [p
for p
in db_inc_paths
if os
.path
.exists(p
)]
780 class db_found(Exception): pass
782 # See whether there is a Sleepycat header in the standard
784 for d
in inc_dirs
+ db_inc_paths
:
785 f
= os
.path
.join(d
, "db.h")
786 if db_setup_debug
: print "db: looking for db.h in", f
787 if os
.path
.exists(f
):
789 m
= re
.search(r
"#define\WDB_VERSION_MAJOR\W(\d+)", f
)
791 db_major
= int(m
.group(1))
792 m
= re
.search(r
"#define\WDB_VERSION_MINOR\W(\d+)", f
)
793 db_minor
= int(m
.group(1))
794 db_ver
= (db_major
, db_minor
)
796 # Avoid 4.6 prior to 4.6.21 due to a BerkeleyDB bug
798 m
= re
.search(r
"#define\WDB_VERSION_PATCH\W(\d+)", f
)
799 db_patch
= int(m
.group(1))
801 print "db.h:", db_ver
, "patch", db_patch
,
802 print "being ignored (4.6.x must be >= 4.6.21)"
805 if ( (not db_ver_inc_map
.has_key(db_ver
)) and
806 allow_db_ver(db_ver
) ):
807 # save the include directory with the db.h version
808 # (first occurrence only)
809 db_ver_inc_map
[db_ver
] = d
811 print "db.h: found", db_ver
, "in", d
813 # we already found a header for this library version
814 if db_setup_debug
: print "db.h: ignoring", d
816 # ignore this header, it didn't contain a version number
818 print "db.h: no version number version in", d
820 db_found_vers
= db_ver_inc_map
.keys()
824 db_ver
= db_found_vers
.pop()
825 db_incdir
= db_ver_inc_map
[db_ver
]
827 # check lib directories parallel to the location of the header
829 db_incdir
.replace("include", 'lib64'),
830 db_incdir
.replace("include", 'lib'),
832 db_dirs_to_check
= filter(os
.path
.isdir
, db_dirs_to_check
)
834 # Look for a version specific db-X.Y before an ambiguoius dbX
835 # XXX should we -ever- look for a dbX name? Do any
836 # systems really not name their library by version and
837 # symlink to more general names?
838 for dblib
in (('db-%d.%d' % db_ver
),
840 ('db%d' % db_ver
[0])):
841 dblib_file
= self
.compiler
.find_library_file(
842 db_dirs_to_check
+ lib_dirs
, dblib
)
844 dblib_dir
= [ os
.path
.abspath(os
.path
.dirname(dblib_file
)) ]
847 if db_setup_debug
: print "db lib: ", dblib
, "not found"
851 print "bsddb using BerkeleyDB lib:", db_ver
, dblib
852 print "bsddb lib dir:", dblib_dir
, " inc dir:", db_incdir
853 db_incs
= [db_incdir
]
855 # We add the runtime_library_dirs argument because the
856 # BerkeleyDB lib we're linking against often isn't in the
857 # system dynamic library search path. This is usually
858 # correct and most trouble free, but may cause problems in
859 # some unusual system configurations (e.g. the directory
860 # is on an NFS server that goes away).
861 exts
.append(Extension('_bsddb', ['_bsddb.c'],
862 depends
= ['bsddb.h'],
863 library_dirs
=dblib_dir
,
864 runtime_library_dirs
=dblib_dir
,
865 include_dirs
=db_incs
,
868 if db_setup_debug
: print "db: no appropriate library found"
872 missing
.append('_bsddb')
874 # The sqlite interface
875 sqlite_setup_debug
= False # verbose debug prints from this script?
877 # We hunt for #define SQLITE_VERSION "n.n.n"
878 # We need to find >= sqlite version 3.0.8
879 sqlite_incdir
= sqlite_libdir
= None
880 sqlite_inc_paths
= [ '/usr/include',
881 '/usr/include/sqlite',
882 '/usr/include/sqlite3',
883 '/usr/local/include',
884 '/usr/local/include/sqlite',
885 '/usr/local/include/sqlite3',
887 MIN_SQLITE_VERSION_NUMBER
= (3, 0, 8)
888 MIN_SQLITE_VERSION
= ".".join([str(x
)
889 for x
in MIN_SQLITE_VERSION_NUMBER
])
891 # Scan the default include directories before the SQLite specific
892 # ones. This allows one to override the copy of sqlite on OSX,
893 # where /usr/include contains an old version of sqlite.
894 for d
in inc_dirs
+ sqlite_inc_paths
:
895 f
= os
.path
.join(d
, "sqlite3.h")
896 if os
.path
.exists(f
):
897 if sqlite_setup_debug
: print "sqlite: found %s"%f
898 incf
= open(f
).read()
900 r
'\s*.*#\s*.*define\s.*SQLITE_VERSION\W*"(.*)"', incf
)
902 sqlite_version
= m
.group(1)
903 sqlite_version_tuple
= tuple([int(x
)
904 for x
in sqlite_version
.split(".")])
905 if sqlite_version_tuple
>= MIN_SQLITE_VERSION_NUMBER
:
907 if sqlite_setup_debug
:
908 print "%s/sqlite3.h: version %s"%(d
, sqlite_version
)
912 if sqlite_setup_debug
:
913 print "%s: version %d is too old, need >= %s"%(d
,
914 sqlite_version
, MIN_SQLITE_VERSION
)
915 elif sqlite_setup_debug
:
916 print "sqlite: %s had no SQLITE_VERSION"%(f
,)
919 sqlite_dirs_to_check
= [
920 os
.path
.join(sqlite_incdir
, '..', 'lib64'),
921 os
.path
.join(sqlite_incdir
, '..', 'lib'),
922 os
.path
.join(sqlite_incdir
, '..', '..', 'lib64'),
923 os
.path
.join(sqlite_incdir
, '..', '..', 'lib'),
925 sqlite_libfile
= self
.compiler
.find_library_file(
926 sqlite_dirs_to_check
+ lib_dirs
, 'sqlite3')
928 sqlite_libdir
= [os
.path
.abspath(os
.path
.dirname(sqlite_libfile
))]
930 if sqlite_incdir
and sqlite_libdir
:
931 sqlite_srcs
= ['_sqlite/cache.c',
932 '_sqlite/connection.c',
934 '_sqlite/microprotocols.c',
936 '_sqlite/prepare_protocol.c',
938 '_sqlite/statement.c',
942 if sys
.platform
!= "win32":
943 sqlite_defines
.append(('MODULE_NAME', '"sqlite3"'))
945 sqlite_defines
.append(('MODULE_NAME', '\\"sqlite3\\"'))
948 if sys
.platform
== 'darwin':
949 # In every directory on the search path search for a dynamic
950 # library and then a static library, instead of first looking
951 # for dynamic libraries on the entiry path.
952 # This way a staticly linked custom sqlite gets picked up
953 # before the dynamic library in /usr/lib.
954 sqlite_extra_link_args
= ('-Wl,-search_paths_first',)
956 sqlite_extra_link_args
= ()
958 exts
.append(Extension('_sqlite3', sqlite_srcs
,
959 define_macros
=sqlite_defines
,
960 include_dirs
=["Modules/_sqlite",
962 library_dirs
=sqlite_libdir
,
963 runtime_library_dirs
=sqlite_libdir
,
964 extra_link_args
=sqlite_extra_link_args
,
965 libraries
=["sqlite3",]))
967 missing
.append('_sqlite3')
969 # Look for Berkeley db 1.85. Note that it is built as a different
970 # module name so it can be included even when later versions are
971 # available. A very restrictive search is performed to avoid
972 # accidentally building this module with a later version of the
973 # underlying db library. May BSD-ish Unixes incorporate db 1.85
974 # symbols into libc and place the include file in /usr/include.
976 # If the better bsddb library can be built (db_incs is defined)
977 # we do not build this one. Otherwise this build will pick up
978 # the more recent berkeleydb's db.h file first in the include path
979 # when attempting to compile and it will fail.
980 f
= "/usr/include/db.h"
981 if os
.path
.exists(f
) and not db_incs
:
982 data
= open(f
).read()
983 m
= re
.search(r
"#s*define\s+HASHVERSION\s+2\s*", data
)
985 # bingo - old version used hash file format version 2
986 ### XXX this should be fixed to not be platform-dependent
987 ### but I don't have direct access to an osf1 platform and
988 ### seemed to be muffing the search somehow
989 libraries
= platform
== "osf1" and ['db'] or None
990 if libraries
is not None:
991 exts
.append(Extension('bsddb185', ['bsddbmodule.c'],
992 libraries
=libraries
))
994 exts
.append(Extension('bsddb185', ['bsddbmodule.c']))
996 missing
.append('bsddb185')
998 missing
.append('bsddb185')
1000 # The standard Unix dbm module:
1001 if platform
not in ['cygwin']:
1002 if find_file("ndbm.h", inc_dirs
, []) is not None:
1003 # Some systems have -lndbm, others don't
1004 if self
.compiler
.find_library_file(lib_dirs
, 'ndbm'):
1005 ndbm_libs
= ['ndbm']
1008 exts
.append( Extension('dbm', ['dbmmodule.c'],
1009 define_macros
=[('HAVE_NDBM_H',None)],
1010 libraries
= ndbm_libs
) )
1011 elif self
.compiler
.find_library_file(lib_dirs
, 'gdbm'):
1012 gdbm_libs
= ['gdbm']
1013 if self
.compiler
.find_library_file(lib_dirs
, 'gdbm_compat'):
1014 gdbm_libs
.append('gdbm_compat')
1015 if find_file("gdbm/ndbm.h", inc_dirs
, []) is not None:
1016 exts
.append( Extension(
1017 'dbm', ['dbmmodule.c'],
1018 define_macros
=[('HAVE_GDBM_NDBM_H',None)],
1019 libraries
= gdbm_libs
) )
1020 elif find_file("gdbm-ndbm.h", inc_dirs
, []) is not None:
1021 exts
.append( Extension(
1022 'dbm', ['dbmmodule.c'],
1023 define_macros
=[('HAVE_GDBM_DASH_NDBM_H',None)],
1024 libraries
= gdbm_libs
) )
1026 missing
.append('dbm')
1027 elif db_incs
is not None:
1028 exts
.append( Extension('dbm', ['dbmmodule.c'],
1029 library_dirs
=dblib_dir
,
1030 runtime_library_dirs
=dblib_dir
,
1031 include_dirs
=db_incs
,
1032 define_macros
=[('HAVE_BERKDB_H',None),
1033 ('DB_DBM_HSEARCH',None)],
1036 missing
.append('dbm')
1038 # Anthony Baxter's gdbm module. GNU dbm(3) will require -lgdbm:
1039 if (self
.compiler
.find_library_file(lib_dirs
, 'gdbm')):
1040 exts
.append( Extension('gdbm', ['gdbmmodule.c'],
1041 libraries
= ['gdbm'] ) )
1043 missing
.append('gdbm')
1046 if platform
not in ['mac', 'win32']:
1047 # Steen Lumholt's termios module
1048 exts
.append( Extension('termios', ['termios.c']) )
1049 # Jeremy Hylton's rlimit interface
1050 if platform
not in ['atheos']:
1051 exts
.append( Extension('resource', ['resource.c']) )
1053 missing
.append('resource')
1055 # Sun yellow pages. Some systems have the functions in libc.
1056 if platform
not in ['cygwin', 'atheos', 'qnx6']:
1057 if (self
.compiler
.find_library_file(lib_dirs
, 'nsl')):
1061 exts
.append( Extension('nis', ['nismodule.c'],
1064 missing
.append('nis')
1066 missing
.extend(['nis', 'resource', 'termios'])
1068 # Curses support, requiring the System V version of curses, often
1069 # provided by the ncurses library.
1070 panel_library
= 'panel'
1071 if (self
.compiler
.find_library_file(lib_dirs
, 'ncursesw')):
1072 curses_libs
= ['ncursesw']
1073 # Bug 1464056: If _curses.so links with ncursesw,
1074 # _curses_panel.so must link with panelw.
1075 panel_library
= 'panelw'
1076 exts
.append( Extension('_curses', ['_cursesmodule.c'],
1077 libraries
= curses_libs
) )
1078 elif (self
.compiler
.find_library_file(lib_dirs
, 'ncurses')):
1079 curses_libs
= ['ncurses']
1080 exts
.append( Extension('_curses', ['_cursesmodule.c'],
1081 libraries
= curses_libs
) )
1082 elif (self
.compiler
.find_library_file(lib_dirs
, 'curses')
1083 and platform
!= 'darwin'):
1084 # OSX has an old Berkeley curses, not good enough for
1085 # the _curses module.
1086 if (self
.compiler
.find_library_file(lib_dirs
, 'terminfo')):
1087 curses_libs
= ['curses', 'terminfo']
1088 elif (self
.compiler
.find_library_file(lib_dirs
, 'termcap')):
1089 curses_libs
= ['curses', 'termcap']
1091 curses_libs
= ['curses']
1093 exts
.append( Extension('_curses', ['_cursesmodule.c'],
1094 libraries
= curses_libs
) )
1096 missing
.append('_curses')
1098 # If the curses module is enabled, check for the panel module
1099 if (module_enabled(exts
, '_curses') and
1100 self
.compiler
.find_library_file(lib_dirs
, panel_library
)):
1101 exts
.append( Extension('_curses_panel', ['_curses_panel.c'],
1102 libraries
= [panel_library
] + curses_libs
) )
1104 missing
.append('_curses_panel')
1106 # Andrew Kuchling's zlib module. Note that some versions of zlib
1107 # 1.1.3 have security problems. See CERT Advisory CA-2002-07:
1108 # http://www.cert.org/advisories/CA-2002-07.html
1110 # zlib 1.1.4 is fixed, but at least one vendor (RedHat) has decided to
1111 # patch its zlib 1.1.3 package instead of upgrading to 1.1.4. For
1112 # now, we still accept 1.1.3, because we think it's difficult to
1113 # exploit this in Python, and we'd rather make it RedHat's problem
1114 # than our problem <wink>.
1116 # You can upgrade zlib to version 1.1.4 yourself by going to
1117 # http://www.gzip.org/zlib/
1118 zlib_inc
= find_file('zlib.h', [], inc_dirs
)
1120 if zlib_inc
is not None:
1121 zlib_h
= zlib_inc
[0] + '/zlib.h'
1123 version_req
= '"1.1.3"'
1126 line
= fp
.readline()
1129 if line
.startswith('#define ZLIB_VERSION'):
1130 version
= line
.split()[2]
1132 if version
>= version_req
:
1133 if (self
.compiler
.find_library_file(lib_dirs
, 'z')):
1134 if sys
.platform
== "darwin":
1135 zlib_extra_link_args
= ('-Wl,-search_paths_first',)
1137 zlib_extra_link_args
= ()
1138 exts
.append( Extension('zlib', ['zlibmodule.c'],
1140 extra_link_args
= zlib_extra_link_args
))
1143 missing
.append('zlib')
1145 missing
.append('zlib')
1147 missing
.append('zlib')
1149 # Helper module for various ascii-encoders. Uses zlib for an optimized
1150 # crc32 if we have it. Otherwise binascii uses its own.
1152 extra_compile_args
= ['-DUSE_ZLIB_CRC32']
1154 extra_link_args
= zlib_extra_link_args
1156 extra_compile_args
= []
1158 extra_link_args
= []
1159 exts
.append( Extension('binascii', ['binascii.c'],
1160 extra_compile_args
= extra_compile_args
,
1161 libraries
= libraries
,
1162 extra_link_args
= extra_link_args
) )
1164 # Gustavo Niemeyer's bz2 module.
1165 if (self
.compiler
.find_library_file(lib_dirs
, 'bz2')):
1166 if sys
.platform
== "darwin":
1167 bz2_extra_link_args
= ('-Wl,-search_paths_first',)
1169 bz2_extra_link_args
= ()
1170 exts
.append( Extension('bz2', ['bz2module.c'],
1171 libraries
= ['bz2'],
1172 extra_link_args
= bz2_extra_link_args
) )
1174 missing
.append('bz2')
1176 # Interface to the Expat XML parser
1178 # Expat was written by James Clark and is now maintained by a
1179 # group of developers on SourceForge; see www.libexpat.org for
1180 # more information. The pyexpat module was written by Paul
1181 # Prescod after a prototype by Jack Jansen. The Expat source
1182 # is included in Modules/expat/. Usage of a system
1183 # shared libexpat.so/expat.dll is not advised.
1185 # More information on Expat can be found at www.libexpat.org.
1187 expatinc
= os
.path
.join(os
.getcwd(), srcdir
, 'Modules', 'expat')
1189 ('HAVE_EXPAT_CONFIG_H', '1'),
1192 exts
.append(Extension('pyexpat',
1193 define_macros
= define_macros
,
1194 include_dirs
= [expatinc
],
1195 sources
= ['pyexpat.c',
1202 # Fredrik Lundh's cElementTree module. Note that this also
1203 # uses expat (via the CAPI hook in pyexpat).
1205 if os
.path
.isfile(os
.path
.join(srcdir
, 'Modules', '_elementtree.c')):
1206 define_macros
.append(('USE_PYEXPAT_CAPI', None))
1207 exts
.append(Extension('_elementtree',
1208 define_macros
= define_macros
,
1209 include_dirs
= [expatinc
],
1210 sources
= ['_elementtree.c'],
1213 missing
.append('_elementtree')
1215 # Hye-Shik Chang's CJKCodecs modules.
1217 exts
.append(Extension('_multibytecodec',
1218 ['cjkcodecs/multibytecodec.c']))
1219 for loc
in ('kr', 'jp', 'cn', 'tw', 'hk', 'iso2022'):
1220 exts
.append(Extension('_codecs_%s' % loc
,
1221 ['cjkcodecs/_codecs_%s.c' % loc
]))
1223 missing
.append('_multibytecodec')
1224 for loc
in ('kr', 'jp', 'cn', 'tw', 'hk', 'iso2022'):
1225 missing
.append('_codecs_%s' % loc
)
1227 # Dynamic loading module
1228 if sys
.maxint
== 0x7fffffff:
1229 # This requires sizeof(int) == sizeof(long) == sizeof(char*)
1230 dl_inc
= find_file('dlfcn.h', [], inc_dirs
)
1231 if (dl_inc
is not None) and (platform
not in ['atheos']):
1232 exts
.append( Extension('dl', ['dlmodule.c']) )
1234 missing
.append('dl')
1236 missing
.append('dl')
1238 # Thomas Heller's _ctypes module
1239 self
.detect_ctypes(inc_dirs
, lib_dirs
)
1241 # Richard Oudkerk's multiprocessing module
1242 if platform
== 'win32': # Windows
1244 libraries
= ['ws2_32']
1246 elif platform
== 'darwin': # Mac OSX
1249 HAVE_SEM_TIMEDWAIT
=0,
1251 HAVE_BROKEN_SEM_GETVALUE
=1
1255 elif platform
== 'cygwin': # Cygwin
1258 HAVE_SEM_TIMEDWAIT
=1,
1260 HAVE_BROKEN_SEM_UNLINK
=1
1264 elif platform
in ('freebsd4', 'freebsd5', 'freebsd6', 'freebsd7', 'freebsd8'):
1265 # FreeBSD's P1003.1b semaphore support is very experimental
1266 # and has many known problems. (as of June 2008)
1267 macros
= dict( # FreeBSD
1269 HAVE_SEM_TIMEDWAIT
=0,
1274 elif platform
.startswith('openbsd'):
1275 macros
= dict( # OpenBSD
1276 HAVE_SEM_OPEN
=0, # Not implemented
1277 HAVE_SEM_TIMEDWAIT
=0,
1282 else: # Linux and other unices
1285 HAVE_SEM_TIMEDWAIT
=1,
1290 if platform
== 'win32':
1291 multiprocessing_srcs
= [ '_multiprocessing/multiprocessing.c',
1292 '_multiprocessing/semaphore.c',
1293 '_multiprocessing/pipe_connection.c',
1294 '_multiprocessing/socket_connection.c',
1295 '_multiprocessing/win32_functions.c'
1299 multiprocessing_srcs
= [ '_multiprocessing/multiprocessing.c',
1300 '_multiprocessing/socket_connection.c'
1303 if macros
.get('HAVE_SEM_OPEN', False):
1304 multiprocessing_srcs
.append('_multiprocessing/semaphore.c')
1306 if sysconfig
.get_config_var('WITH_THREAD'):
1307 exts
.append ( Extension('_multiprocessing', multiprocessing_srcs
,
1308 define_macros
=macros
.items(),
1309 include_dirs
=["Modules/_multiprocessing"]))
1311 missing
.append('_multiprocessing')
1313 # End multiprocessing
1316 # Platform-specific libraries
1317 if platform
== 'linux2':
1318 # Linux-specific modules
1319 exts
.append( Extension('linuxaudiodev', ['linuxaudiodev.c']) )
1321 missing
.append('linuxaudiodev')
1323 if platform
in ('linux2', 'freebsd4', 'freebsd5', 'freebsd6',
1324 'freebsd7', 'freebsd8'):
1325 exts
.append( Extension('ossaudiodev', ['ossaudiodev.c']) )
1327 missing
.append('ossaudiodev')
1329 if platform
== 'sunos5':
1330 # SunOS specific modules
1331 exts
.append( Extension('sunaudiodev', ['sunaudiodev.c']) )
1333 missing
.append('sunaudiodev')
1335 if platform
== 'darwin' and ("--disable-toolbox-glue" not in
1336 sysconfig
.get_config_var("CONFIG_ARGS")):
1338 if os
.uname()[2] > '8.':
1339 # We're on Mac OS X 10.4 or later, the compiler should
1340 # support '-Wno-deprecated-declarations'. This will
1341 # surpress deprecation warnings for the Carbon extensions,
1342 # these extensions wrap the Carbon APIs and even those
1343 # parts that are deprecated.
1344 carbon_extra_compile_args
= ['-Wno-deprecated-declarations']
1346 carbon_extra_compile_args
= []
1348 # Mac OS X specific modules.
1349 def macSrcExists(name1
, name2
=''):
1354 names
= (name1
, name2
)
1355 path
= os
.path
.join(srcdir
, 'Mac', 'Modules', *names
)
1356 return os
.path
.exists(path
)
1358 def addMacExtension(name
, kwds
, extra_srcs
=[]):
1361 dirname
= name
[1:].lower()
1363 cmodulename
= name
+ 'module.c'
1364 # Check for NNN.c, NNNmodule.c, _nnn/NNN.c, _nnn/NNNmodule.c
1365 if macSrcExists(cname
):
1367 elif macSrcExists(cmodulename
):
1368 srcs
= [cmodulename
]
1369 elif macSrcExists(dirname
, cname
):
1370 # XXX(nnorwitz): If all the names ended with module, we
1371 # wouldn't need this condition. ibcarbon is the only one.
1372 srcs
= [os
.path
.join(dirname
, cname
)]
1373 elif macSrcExists(dirname
, cmodulename
):
1374 srcs
= [os
.path
.join(dirname
, cmodulename
)]
1376 raise RuntimeError("%s not found" % name
)
1378 # Here's the whole point: add the extension with sources
1379 exts
.append(Extension(name
, srcs
+ extra_srcs
, **kwds
))
1382 core_kwds
= {'extra_compile_args': carbon_extra_compile_args
,
1383 'extra_link_args': ['-framework', 'CoreFoundation'],
1385 addMacExtension('_CF', core_kwds
, ['cf/pycfbridge.c'])
1386 addMacExtension('autoGIL', core_kwds
)
1389 carbon_kwds
= {'extra_compile_args': carbon_extra_compile_args
,
1390 'extra_link_args': ['-framework', 'Carbon'],
1392 CARBON_EXTS
= ['ColorPicker', 'gestalt', 'MacOS', 'Nav',
1393 'OSATerminology', 'icglue',
1394 # All these are in subdirs
1395 '_AE', '_AH', '_App', '_CarbonEvt', '_Cm', '_Ctl',
1396 '_Dlg', '_Drag', '_Evt', '_File', '_Folder', '_Fm',
1397 '_Help', '_Icn', '_IBCarbon', '_List',
1398 '_Menu', '_Mlte', '_OSA', '_Res', '_Qd', '_Qdoffs',
1399 '_Scrap', '_Snd', '_TE',
1401 for name
in CARBON_EXTS
:
1402 addMacExtension(name
, carbon_kwds
)
1404 # Workaround for a bug in the version of gcc shipped with Xcode 3.
1405 # The _Win extension should build just like the other Carbon extensions, but
1406 # this actually results in a hard crash of the linker.
1408 if '-arch ppc64' in cflags
and '-arch ppc' in cflags
:
1409 win_kwds
= {'extra_compile_args': carbon_extra_compile_args
+ ['-arch', 'i386', '-arch', 'ppc'],
1410 'extra_link_args': ['-framework', 'Carbon', '-arch', 'i386', '-arch', 'ppc'],
1412 addMacExtension('_Win', win_kwds
)
1414 addMacExtension('_Win', carbon_kwds
)
1417 # Application Services & QuickTime
1418 app_kwds
= {'extra_compile_args': carbon_extra_compile_args
,
1419 'extra_link_args': ['-framework','ApplicationServices'],
1421 addMacExtension('_Launch', app_kwds
)
1422 addMacExtension('_CG', app_kwds
)
1424 exts
.append( Extension('_Qt', ['qt/_Qtmodule.c'],
1425 extra_compile_args
=carbon_extra_compile_args
,
1426 extra_link_args
=['-framework', 'QuickTime',
1427 '-framework', 'Carbon']) )
1430 self
.extensions
.extend(exts
)
1432 # Call the method for detecting whether _tkinter can be compiled
1433 self
.detect_tkinter(inc_dirs
, lib_dirs
)
1435 if '_tkinter' not in [e
.name
for e
in self
.extensions
]:
1436 missing
.append('_tkinter')
1440 def detect_tkinter_darwin(self
, inc_dirs
, lib_dirs
):
1441 # The _tkinter module, using frameworks. Since frameworks are quite
1442 # different the UNIX search logic is not sharable.
1443 from os
.path
import join
, exists
1445 '/System/Library/Frameworks/',
1446 '/Library/Frameworks',
1447 join(os
.getenv('HOME'), '/Library/Frameworks')
1450 # Find the directory that contains the Tcl.framework and Tk.framework
1452 # XXX distutils should support -F!
1453 for F
in framework_dirs
:
1454 # both Tcl.framework and Tk.framework should be present
1455 for fw
in 'Tcl', 'Tk':
1456 if not exists(join(F
, fw
+ '.framework')):
1459 # ok, F is now directory with both frameworks. Continure
1463 # Tk and Tcl frameworks not found. Normal "unix" tkinter search
1467 # For 8.4a2, we must add -I options that point inside the Tcl and Tk
1468 # frameworks. In later release we should hopefully be able to pass
1469 # the -F option to gcc, which specifies a framework lookup path.
1472 join(F
, fw
+ '.framework', H
)
1473 for fw
in 'Tcl', 'Tk'
1474 for H
in 'Headers', 'Versions/Current/PrivateHeaders'
1477 # For 8.4a2, the X11 headers are not included. Rather than include a
1478 # complicated search, this is a hard-coded path. It could bail out
1479 # if X11 libs are not found...
1480 include_dirs
.append('/usr/X11R6/include')
1481 frameworks
= ['-framework', 'Tcl', '-framework', 'Tk']
1483 # All existing framework builds of Tcl/Tk don't support 64-bit
1485 cflags
= sysconfig
.get_config_vars('CFLAGS')[0]
1486 archs
= re
.findall('-arch\s+(\w+)', cflags
)
1487 if 'x86_64' in archs
or 'ppc64' in archs
:
1489 archs
.remove('x86_64')
1493 archs
.remove('ppc64')
1498 frameworks
.append('-arch')
1499 frameworks
.append(a
)
1501 ext
= Extension('_tkinter', ['_tkinter.c', 'tkappinit.c'],
1502 define_macros
=[('WITH_APPINIT', 1)],
1503 include_dirs
= include_dirs
,
1505 extra_compile_args
= frameworks
[2:],
1506 extra_link_args
= frameworks
,
1508 self
.extensions
.append(ext
)
1512 def detect_tkinter(self
, inc_dirs
, lib_dirs
):
1513 # The _tkinter module.
1515 # Rather than complicate the code below, detecting and building
1516 # AquaTk is a separate method. Only one Tkinter will be built on
1517 # Darwin - either AquaTk, if it is found, or X11 based Tk.
1518 platform
= self
.get_platform()
1519 if (platform
== 'darwin' and
1520 self
.detect_tkinter_darwin(inc_dirs
, lib_dirs
)):
1523 # Assume we haven't found any of the libraries or include files
1524 # The versions with dots are used on Unix, and the versions without
1525 # dots on Windows, for detection by cygwin.
1526 tcllib
= tklib
= tcl_includes
= tk_includes
= None
1527 for version
in ['8.5', '85', '8.4', '84', '8.3', '83', '8.2',
1528 '82', '8.1', '81', '8.0', '80']:
1529 tklib
= self
.compiler
.find_library_file(lib_dirs
, 'tk' + version
)
1530 tcllib
= self
.compiler
.find_library_file(lib_dirs
, 'tcl' + version
)
1531 if tklib
and tcllib
:
1532 # Exit the loop when we've found the Tcl/Tk libraries
1535 # Now check for the header files
1536 if tklib
and tcllib
:
1537 # Check for the include files on Debian and {Free,Open}BSD, where
1538 # they're put in /usr/include/{tcl,tk}X.Y
1539 dotversion
= version
1540 if '.' not in dotversion
and "bsd" in sys
.platform
.lower():
1541 # OpenBSD and FreeBSD use Tcl/Tk library names like libtcl83.a,
1542 # but the include subdirs are named like .../include/tcl8.3.
1543 dotversion
= dotversion
[:-1] + '.' + dotversion
[-1]
1544 tcl_include_sub
= []
1546 for dir in inc_dirs
:
1547 tcl_include_sub
+= [dir + os
.sep
+ "tcl" + dotversion
]
1548 tk_include_sub
+= [dir + os
.sep
+ "tk" + dotversion
]
1549 tk_include_sub
+= tcl_include_sub
1550 tcl_includes
= find_file('tcl.h', inc_dirs
, tcl_include_sub
)
1551 tk_includes
= find_file('tk.h', inc_dirs
, tk_include_sub
)
1553 if (tcllib
is None or tklib
is None or
1554 tcl_includes
is None or tk_includes
is None):
1555 self
.announce("INFO: Can't locate Tcl/Tk libs and/or headers", 2)
1558 # OK... everything seems to be present for Tcl/Tk.
1560 include_dirs
= [] ; libs
= [] ; defs
= [] ; added_lib_dirs
= []
1561 for dir in tcl_includes
+ tk_includes
:
1562 if dir not in include_dirs
:
1563 include_dirs
.append(dir)
1565 # Check for various platform-specific directories
1566 if platform
== 'sunos5':
1567 include_dirs
.append('/usr/openwin/include')
1568 added_lib_dirs
.append('/usr/openwin/lib')
1569 elif os
.path
.exists('/usr/X11R6/include'):
1570 include_dirs
.append('/usr/X11R6/include')
1571 added_lib_dirs
.append('/usr/X11R6/lib64')
1572 added_lib_dirs
.append('/usr/X11R6/lib')
1573 elif os
.path
.exists('/usr/X11R5/include'):
1574 include_dirs
.append('/usr/X11R5/include')
1575 added_lib_dirs
.append('/usr/X11R5/lib')
1577 # Assume default location for X11
1578 include_dirs
.append('/usr/X11/include')
1579 added_lib_dirs
.append('/usr/X11/lib')
1581 # If Cygwin, then verify that X is installed before proceeding
1582 if platform
== 'cygwin':
1583 x11_inc
= find_file('X11/Xlib.h', [], include_dirs
)
1587 # Check for BLT extension
1588 if self
.compiler
.find_library_file(lib_dirs
+ added_lib_dirs
,
1590 defs
.append( ('WITH_BLT', 1) )
1591 libs
.append('BLT8.0')
1592 elif self
.compiler
.find_library_file(lib_dirs
+ added_lib_dirs
,
1594 defs
.append( ('WITH_BLT', 1) )
1597 # Add the Tcl/Tk libraries
1598 libs
.append('tk'+ version
)
1599 libs
.append('tcl'+ version
)
1601 if platform
in ['aix3', 'aix4']:
1604 # Finally, link with the X11 libraries (not appropriate on cygwin)
1605 if platform
!= "cygwin":
1608 ext
= Extension('_tkinter', ['_tkinter.c', 'tkappinit.c'],
1609 define_macros
=[('WITH_APPINIT', 1)] + defs
,
1610 include_dirs
= include_dirs
,
1612 library_dirs
= added_lib_dirs
,
1614 self
.extensions
.append(ext
)
1616 ## # Uncomment these lines if you want to play with xxmodule.c
1617 ## ext = Extension('xx', ['xxmodule.c'])
1618 ## self.extensions.append(ext)
1620 # XXX handle these, but how to detect?
1621 # *** Uncomment and edit for PIL (TkImaging) extension only:
1622 # -DWITH_PIL -I../Extensions/Imaging/libImaging tkImaging.c \
1623 # *** Uncomment and edit for TOGL extension only:
1624 # -DWITH_TOGL togl.c \
1625 # *** Uncomment these for TOGL extension only:
1626 # -lGL -lGLU -lXext -lXmu \
1628 def configure_ctypes_darwin(self
, ext
):
1629 # Darwin (OS X) uses preconfigured files, in
1630 # the Modules/_ctypes/libffi_osx directory.
1631 srcdir
= sysconfig
.get_config_var('srcdir')
1632 ffi_srcdir
= os
.path
.abspath(os
.path
.join(srcdir
, 'Modules',
1633 '_ctypes', 'libffi_osx'))
1634 sources
= [os
.path
.join(ffi_srcdir
, p
)
1638 'x86/x86-ffi_darwin.c',
1640 'powerpc/ppc-darwin.S',
1641 'powerpc/ppc-darwin_closure.S',
1642 'powerpc/ppc-ffi_darwin.c',
1643 'powerpc/ppc64-darwin_closure.S',
1646 # Add .S (preprocessed assembly) to C compiler source extensions.
1647 self
.compiler
.src_extensions
.append('.S')
1649 include_dirs
= [os
.path
.join(ffi_srcdir
, 'include'),
1650 os
.path
.join(ffi_srcdir
, 'powerpc')]
1651 ext
.include_dirs
.extend(include_dirs
)
1652 ext
.sources
.extend(sources
)
1655 def configure_ctypes(self
, ext
):
1656 if not self
.use_system_libffi
:
1657 if sys
.platform
== 'darwin':
1658 return self
.configure_ctypes_darwin(ext
)
1660 srcdir
= sysconfig
.get_config_var('srcdir')
1661 ffi_builddir
= os
.path
.join(self
.build_temp
, 'libffi')
1662 ffi_srcdir
= os
.path
.abspath(os
.path
.join(srcdir
, 'Modules',
1663 '_ctypes', 'libffi'))
1664 ffi_configfile
= os
.path
.join(ffi_builddir
, 'fficonfig.py')
1666 from distutils
.dep_util
import newer_group
1668 config_sources
= [os
.path
.join(ffi_srcdir
, fname
)
1669 for fname
in os
.listdir(ffi_srcdir
)
1670 if os
.path
.isfile(os
.path
.join(ffi_srcdir
, fname
))]
1671 if self
.force
or newer_group(config_sources
,
1673 from distutils
.dir_util
import mkpath
1674 mkpath(ffi_builddir
)
1677 # Pass empty CFLAGS because we'll just append the resulting
1678 # CFLAGS to Python's; -g or -O2 is to be avoided.
1679 cmd
= "cd %s && env CFLAGS='' '%s/configure' %s" \
1680 % (ffi_builddir
, ffi_srcdir
, " ".join(config_args
))
1682 res
= os
.system(cmd
)
1683 if res
or not os
.path
.exists(ffi_configfile
):
1684 print "Failed to configure _ctypes module"
1688 execfile(ffi_configfile
, globals(), fficonfig
)
1689 ffi_srcdir
= os
.path
.join(fficonfig
['ffi_srcdir'], 'src')
1691 # Add .S (preprocessed assembly) to C compiler source extensions.
1692 self
.compiler
.src_extensions
.append('.S')
1694 include_dirs
= [os
.path
.join(ffi_builddir
, 'include'),
1695 ffi_builddir
, ffi_srcdir
]
1696 extra_compile_args
= fficonfig
['ffi_cflags'].split()
1698 ext
.sources
.extend(fficonfig
['ffi_sources'])
1699 ext
.include_dirs
.extend(include_dirs
)
1700 ext
.extra_compile_args
.extend(extra_compile_args
)
1703 def detect_ctypes(self
, inc_dirs
, lib_dirs
):
1704 self
.use_system_libffi
= False
1706 extra_compile_args
= []
1707 extra_link_args
= []
1708 sources
= ['_ctypes/_ctypes.c',
1709 '_ctypes/callbacks.c',
1710 '_ctypes/callproc.c',
1711 '_ctypes/stgdict.c',
1713 '_ctypes/malloc_closure.c']
1714 depends
= ['_ctypes/ctypes.h']
1716 if sys
.platform
== 'darwin':
1717 sources
.append('_ctypes/darwin/dlfcn_simple.c')
1718 extra_compile_args
.append('-DMACOSX')
1719 include_dirs
.append('_ctypes/darwin')
1720 # XXX Is this still needed?
1721 ## extra_link_args.extend(['-read_only_relocs', 'warning'])
1723 elif sys
.platform
== 'sunos5':
1724 # XXX This shouldn't be necessary; it appears that some
1725 # of the assembler code is non-PIC (i.e. it has relocations
1726 # when it shouldn't. The proper fix would be to rewrite
1727 # the assembler code to be PIC.
1728 # This only works with GCC; the Sun compiler likely refuses
1729 # this option. If you want to compile ctypes with the Sun
1730 # compiler, please research a proper solution, instead of
1731 # finding some -z option for the Sun compiler.
1732 extra_link_args
.append('-mimpure-text')
1734 elif sys
.platform
.startswith('hp-ux'):
1735 extra_link_args
.append('-fPIC')
1737 ext
= Extension('_ctypes',
1738 include_dirs
=include_dirs
,
1739 extra_compile_args
=extra_compile_args
,
1740 extra_link_args
=extra_link_args
,
1744 ext_test
= Extension('_ctypes_test',
1745 sources
=['_ctypes/_ctypes_test.c'])
1746 self
.extensions
.extend([ext
, ext_test
])
1748 if not '--with-system-ffi' in sysconfig
.get_config_var("CONFIG_ARGS"):
1751 if sys
.platform
== 'darwin':
1752 # OS X 10.5 comes with libffi.dylib; the include files are
1753 # in /usr/include/ffi
1754 inc_dirs
.append('/usr/include/ffi')
1756 ffi_inc
= find_file('ffi.h', [], inc_dirs
)
1757 if ffi_inc
is not None:
1758 ffi_h
= ffi_inc
[0] + '/ffi.h'
1761 line
= fp
.readline()
1765 if line
.startswith('#define LIBFFI_H'):
1768 if ffi_inc
is not None:
1769 for lib_name
in ('ffi_convenience', 'ffi_pic', 'ffi'):
1770 if (self
.compiler
.find_library_file(lib_dirs
, lib_name
)):
1774 if ffi_inc
and ffi_lib
:
1775 ext
.include_dirs
.extend(ffi_inc
)
1776 ext
.libraries
.append(ffi_lib
)
1777 self
.use_system_libffi
= True
1780 class PyBuildInstall(install
):
1781 # Suppress the warning about installation into the lib_dynload
1782 # directory, which is not in sys.path when running Python during
1784 def initialize_options (self
):
1785 install
.initialize_options(self
)
1788 class PyBuildInstallLib(install_lib
):
1789 # Do exactly what install_lib does but make sure correct access modes get
1790 # set on installed directories and files. All installed files with get
1791 # mode 644 unless they are a shared library in which case they will get
1792 # mode 755. All installed directories will get mode 755.
1794 so_ext
= sysconfig
.get_config_var("SO")
1797 outfiles
= install_lib
.install(self
)
1798 self
.set_file_modes(outfiles
, 0644, 0755)
1799 self
.set_dir_modes(self
.install_dir
, 0755)
1802 def set_file_modes(self
, files
, defaultMode
, sharedLibMode
):
1803 if not self
.is_chmod_supported(): return
1804 if not files
: return
1806 for filename
in files
:
1807 if os
.path
.islink(filename
): continue
1809 if filename
.endswith(self
.so_ext
): mode
= sharedLibMode
1810 log
.info("changing mode of %s to %o", filename
, mode
)
1811 if not self
.dry_run
: os
.chmod(filename
, mode
)
1813 def set_dir_modes(self
, dirname
, mode
):
1814 if not self
.is_chmod_supported(): return
1815 os
.path
.walk(dirname
, self
.set_dir_modes_visitor
, mode
)
1817 def set_dir_modes_visitor(self
, mode
, dirname
, names
):
1818 if os
.path
.islink(dirname
): return
1819 log
.info("changing mode of %s to %o", dirname
, mode
)
1820 if not self
.dry_run
: os
.chmod(dirname
, mode
)
1822 def is_chmod_supported(self
):
1823 return hasattr(os
, 'chmod')
1826 Python is an interpreted, interactive, object-oriented programming
1827 language. It is often compared to Tcl, Perl, Scheme or Java.
1829 Python combines remarkable power with very clear syntax. It has
1830 modules, classes, exceptions, very high level dynamic data types, and
1831 dynamic typing. There are interfaces to many system calls and
1832 libraries, as well as to various windowing systems (X11, Motif, Tk,
1833 Mac, MFC). New built-in modules are easily written in C or C++. Python
1834 is also usable as an extension language for applications that need a
1835 programmable interface.
1837 The Python implementation is portable: it runs on many brands of UNIX,
1838 on Windows, DOS, OS/2, Mac, Amiga... If your favorite system isn't
1839 listed here, it may still be supported, if there's a C compiler for
1840 it. Ask around on comp.lang.python -- or just try compiling Python
1845 Development Status :: 6 - Mature
1846 License :: OSI Approved :: Python Software Foundation License
1847 Natural Language :: English
1848 Programming Language :: C
1849 Programming Language :: Python
1850 Topic :: Software Development
1854 # turn off warnings when deprecated modules are imported
1856 warnings
.filterwarnings("ignore",category
=DeprecationWarning)
1857 setup(# PyPI Metadata (PEP 301)
1859 version
= sys
.version
.split()[0],
1860 url
= "http://www.python.org/%s" % sys
.version
[:3],
1861 maintainer
= "Guido van Rossum and the Python community",
1862 maintainer_email
= "python-dev@python.org",
1863 description
= "A high-level object-oriented programming language",
1864 long_description
= SUMMARY
.strip(),
1865 license
= "PSF license",
1866 classifiers
= filter(None, CLASSIFIERS
.split("\n")),
1867 platforms
= ["Many"],
1870 cmdclass
= {'build_ext':PyBuildExt
, 'install':PyBuildInstall
,
1871 'install_lib':PyBuildInstallLib
},
1872 # The struct module is defined here, because build_ext won't be
1873 # called unless there's at least one extension module defined.
1874 ext_modules
=[Extension('_struct', ['_struct.c'])],
1876 # Scripts to install
1877 scripts
= ['Tools/scripts/pydoc', 'Tools/scripts/idle',
1878 'Tools/scripts/2to3',
1883 if __name__
== '__main__':