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.")
122 # Figure out the location of the source code for extension modules
123 # (This logic is copied in distutils.test.test_sysconfig,
124 # so building in a separate directory does not break test_distutils.)
125 moddir
= os
.path
.join(os
.getcwd(), srcdir
, 'Modules')
126 moddir
= os
.path
.normpath(moddir
)
127 srcdir
, tail
= os
.path
.split(moddir
)
128 srcdir
= os
.path
.normpath(srcdir
)
129 moddir
= os
.path
.normpath(moddir
)
131 moddirlist
= [moddir
]
132 incdirlist
= ['./Include']
134 # Platform-dependent module source and include directories
135 platform
= self
.get_platform()
136 if platform
in ('darwin', 'mac') and ("--disable-toolbox-glue" not in
137 sysconfig
.get_config_var("CONFIG_ARGS")):
138 # Mac OS X also includes some mac-specific modules
139 macmoddir
= os
.path
.join(os
.getcwd(), srcdir
, 'Mac/Modules')
140 moddirlist
.append(macmoddir
)
141 incdirlist
.append('./Mac/Include')
143 alldirlist
= moddirlist
+ incdirlist
145 # Fix up the paths for scripts, too
146 self
.distribution
.scripts
= [os
.path
.join(srcdir
, filename
)
147 for filename
in self
.distribution
.scripts
]
149 # Python header files
150 headers
= glob("Include/*.h") + ["pyconfig.h"]
152 for ext
in self
.extensions
[:]:
153 ext
.sources
= [ find_module_file(filename
, moddirlist
)
154 for filename
in ext
.sources
]
155 if ext
.depends
is not None:
156 ext
.depends
= [find_module_file(filename
, alldirlist
)
157 for filename
in ext
.depends
]
160 # re-compile extensions if a header file has been changed
161 ext
.depends
.extend(headers
)
163 ext
.include_dirs
.append( '.' ) # to get config.h
164 for incdir
in incdirlist
:
165 ext
.include_dirs
.append( os
.path
.join(srcdir
, incdir
) )
167 # If a module has already been built statically,
168 # don't build it here
169 if ext
.name
in sys
.builtin_module_names
:
170 self
.extensions
.remove(ext
)
172 if platform
!= 'mac':
173 # Parse Modules/Setup and Modules/Setup.local to figure out which
174 # modules are turned on in the file.
176 for filename
in ('Modules/Setup', 'Modules/Setup.local'):
177 input = text_file
.TextFile(filename
, join_lines
=1)
179 line
= input.readline()
182 remove_modules
.append(line
[0])
185 for ext
in self
.extensions
[:]:
186 if ext
.name
in remove_modules
:
187 self
.extensions
.remove(ext
)
189 # When you run "make CC=altcc" or something similar, you really want
190 # those environment variables passed into the setup.py phase. Here's
191 # a small set of useful ones.
192 compiler
= os
.environ
.get('CC')
194 # unfortunately, distutils doesn't let us provide separate C and C++
196 if compiler
is not None:
197 (ccshared
,cflags
) = sysconfig
.get_config_vars('CCSHARED','CFLAGS')
198 args
['compiler_so'] = compiler
+ ' ' + ccshared
+ ' ' + cflags
199 self
.compiler
.set_executables(**args
)
201 build_ext
.build_extensions(self
)
203 longest
= max([len(e
.name
) for e
in self
.extensions
])
205 longest
= max(longest
, max([len(name
) for name
in self
.failed
]))
207 def print_three_column(lst
):
208 lst
.sort(key
=str.lower
)
209 # guarantee zip() doesn't drop anything
212 for e
, f
, g
in zip(lst
[::3], lst
[1::3], lst
[2::3]):
213 print "%-*s %-*s %-*s" % (longest
, e
, longest
, f
,
218 print "Failed to find the necessary bits to build these modules:"
219 print_three_column(missing
)
220 print ("To find the necessary bits, look in setup.py in"
221 " detect_modules() for the module's name.")
225 failed
= self
.failed
[:]
227 print "Failed to build these modules:"
228 print_three_column(failed
)
231 def build_extension(self
, ext
):
233 if ext
.name
== '_ctypes':
234 if not self
.configure_ctypes(ext
):
238 build_ext
.build_extension(self
, ext
)
239 except (CCompilerError
, DistutilsError
), why
:
240 self
.announce('WARNING: building of extension "%s" failed: %s' %
241 (ext
.name
, sys
.exc_info()[1]))
242 self
.failed
.append(ext
.name
)
244 # Workaround for Mac OS X: The Carbon-based modules cannot be
245 # reliably imported into a command-line Python
246 if 'Carbon' in ext
.extra_link_args
:
248 'WARNING: skipping import check for Carbon-based "%s"' %
252 if self
.get_platform() == 'darwin' and (
253 sys
.maxint
> 2**32 and '-arch' in ext
.extra_link_args
):
254 # Don't bother doing an import check when an extension was
255 # build with an explicit '-arch' flag on OSX. That's currently
256 # only used to build 32-bit only extensions in a 4-way
257 # universal build and loading 32-bit code into a 64-bit
260 'WARNING: skipping import check for "%s"' %
264 # Workaround for Cygwin: Cygwin currently has fork issues when many
265 # modules have been imported
266 if self
.get_platform() == 'cygwin':
267 self
.announce('WARNING: skipping import check for Cygwin-based "%s"'
270 ext_filename
= os
.path
.join(
272 self
.get_ext_filename(self
.get_ext_fullname(ext
.name
)))
274 imp
.load_dynamic(ext
.name
, ext_filename
)
275 except ImportError, why
:
276 self
.failed
.append(ext
.name
)
277 self
.announce('*** WARNING: renaming "%s" since importing it'
278 ' failed: %s' % (ext
.name
, why
), level
=3)
279 assert not self
.inplace
280 basename
, tail
= os
.path
.splitext(ext_filename
)
281 newname
= basename
+ "_failed" + tail
282 if os
.path
.exists(newname
):
284 os
.rename(ext_filename
, newname
)
286 # XXX -- This relies on a Vile HACK in
287 # distutils.command.build_ext.build_extension(). The
288 # _built_objects attribute is stored there strictly for
290 # If there is a failure, _built_objects may not be there,
291 # so catch the AttributeError and move on.
293 for filename
in self
._built
_objects
:
295 except AttributeError:
296 self
.announce('unable to remove files (ignored)')
298 exc_type
, why
, tb
= sys
.exc_info()
299 self
.announce('*** WARNING: importing extension "%s" '
300 'failed with %s: %s' % (ext
.name
, exc_type
, why
),
302 self
.failed
.append(ext
.name
)
304 def get_platform(self
):
305 # Get value of sys.platform
306 for platform
in ['cygwin', 'beos', 'darwin', 'atheos', 'osf1']:
307 if sys
.platform
.startswith(platform
):
311 def detect_modules(self
):
312 # Ensure that /usr/local is always used
313 add_dir_to_list(self
.compiler
.library_dirs
, '/usr/local/lib')
314 add_dir_to_list(self
.compiler
.include_dirs
, '/usr/local/include')
316 # Add paths specified in the environment variables LDFLAGS and
317 # CPPFLAGS for header and library files.
318 # We must get the values from the Makefile and not the environment
319 # directly since an inconsistently reproducible issue comes up where
320 # the environment variable is not set even though the value were passed
321 # into configure and stored in the Makefile (issue found on OS X 10.3).
322 for env_var
, arg_name
, dir_list
in (
323 ('LDFLAGS', '-L', self
.compiler
.library_dirs
),
324 ('CPPFLAGS', '-I', self
.compiler
.include_dirs
)):
325 env_val
= sysconfig
.get_config_var(env_var
)
327 # To prevent optparse from raising an exception about any
328 # options in env_val that is doesn't know about we strip out
329 # all double dashes and any dashes followed by a character
330 # that is not for the option we are dealing with.
332 # Please note that order of the regex is important! We must
333 # strip out double-dashes first so that we don't end up with
334 # substituting "--Long" to "-Long" and thus lead to "ong" being
335 # used for a library directory.
336 env_val
= re
.sub(r
'(^|\s+)-(-|(?!%s))' % arg_name
[1],
338 parser
= optparse
.OptionParser()
339 # Make sure that allowing args interspersed with options is
341 parser
.allow_interspersed_args
= True
342 parser
.error
= lambda msg
: None
343 parser
.add_option(arg_name
, dest
="dirs", action
="append")
344 options
= parser
.parse_args(env_val
.split())[0]
346 for directory
in reversed(options
.dirs
):
347 add_dir_to_list(dir_list
, directory
)
349 if os
.path
.normpath(sys
.prefix
) != '/usr':
350 add_dir_to_list(self
.compiler
.library_dirs
,
351 sysconfig
.get_config_var("LIBDIR"))
352 add_dir_to_list(self
.compiler
.include_dirs
,
353 sysconfig
.get_config_var("INCLUDEDIR"))
356 have_unicode
= unicode
360 # lib_dirs and inc_dirs are used to search for files;
361 # if a file is found in one of those directories, it can
362 # be assumed that no additional -I,-L directives are needed.
363 lib_dirs
= self
.compiler
.library_dirs
+ [
364 '/lib64', '/usr/lib64',
367 inc_dirs
= self
.compiler
.include_dirs
+ ['/usr/include']
371 config_h
= sysconfig
.get_config_h_filename()
372 config_h_vars
= sysconfig
.parse_config_h(open(config_h
))
374 platform
= self
.get_platform()
375 (srcdir
,) = sysconfig
.get_config_vars('srcdir')
377 # Check for AtheOS which has libraries in non-standard locations
378 if platform
== 'atheos':
379 lib_dirs
+= ['/system/libs', '/atheos/autolnk/lib']
380 lib_dirs
+= os
.getenv('LIBRARY_PATH', '').split(os
.pathsep
)
381 inc_dirs
+= ['/system/include', '/atheos/autolnk/include']
382 inc_dirs
+= os
.getenv('C_INCLUDE_PATH', '').split(os
.pathsep
)
384 # OSF/1 and Unixware have some stuff in /usr/ccs/lib (like -ldb)
385 if platform
in ['osf1', 'unixware7', 'openunix8']:
386 lib_dirs
+= ['/usr/ccs/lib']
388 if platform
== 'darwin':
389 # This should work on any unixy platform ;-)
390 # If the user has bothered specifying additional -I and -L flags
391 # in OPT and LDFLAGS we might as well use them here.
392 # NOTE: using shlex.split would technically be more correct, but
393 # also gives a bootstrap problem. Let's hope nobody uses directories
394 # with whitespace in the name to store libraries.
395 cflags
, ldflags
= sysconfig
.get_config_vars(
397 for item
in cflags
.split():
398 if item
.startswith('-I'):
399 inc_dirs
.append(item
[2:])
401 for item
in ldflags
.split():
402 if item
.startswith('-L'):
403 lib_dirs
.append(item
[2:])
405 # Check for MacOS X, which doesn't need libm.a at all
407 if platform
in ['darwin', 'beos', 'mac']:
410 # XXX Omitted modules: gl, pure, dl, SGI-specific modules
413 # The following modules are all pretty straightforward, and compile
414 # on pretty much any POSIXish platform.
417 # Some modules that are normally always on:
418 exts
.append( Extension('_weakref', ['_weakref.c']) )
421 exts
.append( Extension('array', ['arraymodule.c']) )
422 # complex math library functions
423 exts
.append( Extension('cmath', ['cmathmodule.c'],
424 libraries
=math_libs
) )
426 # math library functions, e.g. sin()
427 exts
.append( Extension('math', ['mathmodule.c'],
428 libraries
=math_libs
) )
429 # fast string operations implemented in C
430 exts
.append( Extension('strop', ['stropmodule.c']) )
431 # time operations and variables
432 exts
.append( Extension('time', ['timemodule.c'],
433 libraries
=math_libs
) )
434 exts
.append( Extension('datetime', ['datetimemodule.c', 'timemodule.c'],
435 libraries
=math_libs
) )
436 # fast iterator tools implemented in C
437 exts
.append( Extension("itertools", ["itertoolsmodule.c"]) )
438 # code that will be builtins in the future, but conflict with the
440 exts
.append( Extension('future_builtins', ['future_builtins.c']) )
441 # random number generator implemented in C
442 exts
.append( Extension("_random", ["_randommodule.c"]) )
443 # high-performance collections
444 exts
.append( Extension("_collections", ["_collectionsmodule.c"]) )
446 exts
.append( Extension("_bisect", ["_bisectmodule.c"]) )
448 exts
.append( Extension("_heapq", ["_heapqmodule.c"]) )
449 # operator.add() and similar goodies
450 exts
.append( Extension('operator', ['operator.c']) )
451 # Python 3.0 _fileio module
452 exts
.append( Extension("_fileio", ["_fileio.c"]) )
453 # Python 3.0 _bytesio module
454 exts
.append( Extension("_bytesio", ["_bytesio.c"]) )
456 exts
.append( Extension("_functools", ["_functoolsmodule.c"]) )
458 exts
.append( Extension("_json", ["_json.c"]) )
459 # Python C API test module
460 exts
.append( Extension('_testcapi', ['_testcapimodule.c']) )
461 # profilers (_lsprof is for cProfile.py)
462 exts
.append( Extension('_hotshot', ['_hotshot.c']) )
463 exts
.append( Extension('_lsprof', ['_lsprof.c', 'rotatingtree.c']) )
464 # static Unicode character database
466 exts
.append( Extension('unicodedata', ['unicodedata.c']) )
468 missing
.append('unicodedata')
469 # access to ISO C locale support
470 data
= open('pyconfig.h').read()
471 m
= re
.search(r
"#s*define\s+WITH_LIBINTL\s+1\s*", data
)
473 locale_libs
= ['intl']
476 if platform
== 'darwin':
477 locale_extra_link_args
= ['-framework', 'CoreFoundation']
479 locale_extra_link_args
= []
482 exts
.append( Extension('_locale', ['_localemodule.c'],
483 libraries
=locale_libs
,
484 extra_link_args
=locale_extra_link_args
) )
486 # Modules with some UNIX dependencies -- on by default:
487 # (If you have a really backward UNIX, select and socket may not be
490 # fcntl(2) and ioctl(2)
491 exts
.append( Extension('fcntl', ['fcntlmodule.c']) )
492 if platform
not in ['mac']:
494 exts
.append( Extension('pwd', ['pwdmodule.c']) )
496 exts
.append( Extension('grp', ['grpmodule.c']) )
497 # spwd, shadow passwords
498 if (config_h_vars
.get('HAVE_GETSPNAM', False) or
499 config_h_vars
.get('HAVE_GETSPENT', False)):
500 exts
.append( Extension('spwd', ['spwdmodule.c']) )
502 missing
.append('spwd')
504 missing
.extend(['pwd', 'grp', 'spwd'])
506 # select(2); not on ancient System V
507 exts
.append( Extension('select', ['selectmodule.c']) )
509 # Fred Drake's interface to the Python parser
510 exts
.append( Extension('parser', ['parsermodule.c']) )
512 # cStringIO and cPickle
513 exts
.append( Extension('cStringIO', ['cStringIO.c']) )
514 exts
.append( Extension('cPickle', ['cPickle.c']) )
516 # Memory-mapped files (also works on Win32).
517 if platform
not in ['atheos', 'mac']:
518 exts
.append( Extension('mmap', ['mmapmodule.c']) )
520 missing
.append('mmap')
522 # Lance Ellinghaus's syslog module
523 if platform
not in ['mac']:
524 # syslog daemon interface
525 exts
.append( Extension('syslog', ['syslogmodule.c']) )
527 missing
.append('syslog')
529 # George Neville-Neil's timing module:
530 # Deprecated in PEP 4 http://www.python.org/peps/pep-0004.html
531 # http://mail.python.org/pipermail/python-dev/2006-January/060023.html
532 #exts.append( Extension('timing', ['timingmodule.c']) )
535 # Here ends the simple stuff. From here on, modules need certain
536 # libraries, are platform-specific, or present other surprises.
540 # These don't work for 64-bit platforms!!!
541 # These represent audio samples or images as strings:
543 # Operations on audio samples
544 # According to #993173, this one should actually work fine on
546 exts
.append( Extension('audioop', ['audioop.c']) )
548 # Disabled on 64-bit platforms
549 if sys
.maxint
!= 9223372036854775807L:
550 # Operations on images
551 exts
.append( Extension('imageop', ['imageop.c']) )
553 missing
.extend(['imageop'])
556 do_readline
= self
.compiler
.find_library_file(lib_dirs
, 'readline')
557 if platform
== 'darwin': # and os.uname()[2] < '9.':
558 # MacOSX 10.4 has a broken readline. Don't try to build
559 # the readline module unless the user has installed a fixed
561 # FIXME: The readline emulation on 10.5 is better, but the
562 # readline module doesn't compile out of the box.
563 if find_file('readline/rlconf.h', inc_dirs
, []) is None:
566 if sys
.platform
== 'darwin':
567 # In every directory on the search path search for a dynamic
568 # library and then a static library, instead of first looking
569 # for dynamic libraries on the entiry path.
570 # This way a staticly linked custom readline gets picked up
571 # before the (broken) dynamic library in /usr/lib.
572 readline_extra_link_args
= ('-Wl,-search_paths_first',)
574 readline_extra_link_args
= ()
576 readline_libs
= ['readline']
577 if self
.compiler
.find_library_file(lib_dirs
,
579 readline_libs
.append('ncursesw')
580 elif self
.compiler
.find_library_file(lib_dirs
,
582 readline_libs
.append('ncurses')
583 elif self
.compiler
.find_library_file(lib_dirs
, 'curses'):
584 readline_libs
.append('curses')
585 elif self
.compiler
.find_library_file(lib_dirs
+
586 ['/usr/lib/termcap'],
588 readline_libs
.append('termcap')
589 exts
.append( Extension('readline', ['readline.c'],
590 library_dirs
=['/usr/lib/termcap'],
591 extra_link_args
=readline_extra_link_args
,
592 libraries
=readline_libs
) )
594 missing
.append('readline')
596 if platform
not in ['mac']:
599 if self
.compiler
.find_library_file(lib_dirs
, 'crypt'):
603 exts
.append( Extension('crypt', ['cryptmodule.c'], libraries
=libs
) )
605 missing
.append('crypt')
608 exts
.append( Extension('_csv', ['_csv.c']) )
611 exts
.append( Extension('_socket', ['socketmodule.c'],
612 depends
= ['socketmodule.h']) )
613 # Detect SSL support for the socket module (via _ssl)
614 search_for_ssl_incs_in
= [
615 '/usr/local/ssl/include',
616 '/usr/contrib/ssl/include/'
618 ssl_incs
= find_file('openssl/ssl.h', inc_dirs
,
619 search_for_ssl_incs_in
621 if ssl_incs
is not None:
622 krb5_h
= find_file('krb5.h', inc_dirs
,
623 ['/usr/kerberos/include'])
626 ssl_libs
= find_library_file(self
.compiler
, 'ssl',lib_dirs
,
627 ['/usr/local/ssl/lib',
628 '/usr/contrib/ssl/lib/'
631 if (ssl_incs
is not None and
632 ssl_libs
is not None):
633 exts
.append( Extension('_ssl', ['_ssl.c'],
634 include_dirs
= ssl_incs
,
635 library_dirs
= ssl_libs
,
636 libraries
= ['ssl', 'crypto'],
637 depends
= ['socketmodule.h']), )
639 missing
.append('_ssl')
641 # find out which version of OpenSSL we have
643 openssl_ver_re
= re
.compile(
644 '^\s*#\s*define\s+OPENSSL_VERSION_NUMBER\s+(0x[0-9a-fA-F]+)' )
645 for ssl_inc_dir
in inc_dirs
+ search_for_ssl_incs_in
:
646 name
= os
.path
.join(ssl_inc_dir
, 'openssl', 'opensslv.h')
647 if os
.path
.isfile(name
):
649 incfile
= open(name
, 'r')
651 m
= openssl_ver_re
.match(line
)
653 openssl_ver
= eval(m
.group(1))
658 # first version found is what we'll use (as the compiler should)
662 #print 'openssl_ver = 0x%08x' % openssl_ver
664 if (ssl_incs
is not None and
665 ssl_libs
is not None and
666 openssl_ver
>= 0x00907000):
667 # The _hashlib module wraps optimized implementations
668 # of hash functions from the OpenSSL library.
669 exts
.append( Extension('_hashlib', ['_hashopenssl.c'],
670 include_dirs
= ssl_incs
,
671 library_dirs
= ssl_libs
,
672 libraries
= ['ssl', 'crypto']) )
673 # these aren't strictly missing since they are unneeded.
674 #missing.extend(['_sha', '_md5'])
676 # The _sha module implements the SHA1 hash algorithm.
677 exts
.append( Extension('_sha', ['shamodule.c']) )
678 # The _md5 module implements the RSA Data Security, Inc. MD5
679 # Message-Digest Algorithm, described in RFC 1321. The
680 # necessary files md5.c and md5.h are included here.
681 exts
.append( Extension('_md5',
682 sources
= ['md5module.c', 'md5.c'],
683 depends
= ['md5.h']) )
684 missing
.append('_hashlib')
686 if (openssl_ver
< 0x00908000):
687 # OpenSSL doesn't do these until 0.9.8 so we'll bring our own hash
688 exts
.append( Extension('_sha256', ['sha256module.c']) )
689 exts
.append( Extension('_sha512', ['sha512module.c']) )
691 # Modules that provide persistent dictionary-like semantics. You will
692 # probably want to arrange for at least one of them to be available on
693 # your machine, though none are defined by default because of library
694 # dependencies. The Python module anydbm.py provides an
695 # implementation independent wrapper for these; dumbdbm.py provides
696 # similar functionality (but slower of course) implemented in Python.
698 # Sleepycat^WOracle Berkeley DB interface.
699 # http://www.oracle.com/database/berkeley-db/db/index.html
701 # This requires the Sleepycat^WOracle DB code. The supported versions
702 # are set below. Visit the URL above to download
703 # a release. Most open source OSes come with one or more
704 # versions of BerkeleyDB already installed.
708 db_setup_debug
= False # verbose debug prints from this script?
710 def allow_db_ver(db_ver
):
711 """Returns a boolean if the given BerkeleyDB version is acceptable.
714 db_ver: A tuple of the version to verify.
716 if not (min_db_ver
<= db_ver
<= max_db_ver
):
718 # Use this function to filter out known bad configurations.
719 if (4, 6) == db_ver
[:2]:
720 # BerkeleyDB 4.6.x is not stable on many architectures.
721 arch
= platform_machine()
722 if arch
not in ('i386', 'i486', 'i586', 'i686',
727 def gen_db_minor_ver_nums(major
):
729 for x
in range(max_db_ver
[1]+1):
730 if allow_db_ver((4, x
)):
734 if allow_db_ver((3, x
)):
737 raise ValueError("unknown major BerkeleyDB version", major
)
739 # construct a list of paths to look for the header file in on
740 # top of the normal inc_dirs.
743 '/usr/local/include/db4',
744 '/opt/sfw/include/db4',
746 '/usr/local/include/db3',
747 '/opt/sfw/include/db3',
748 # Fink defaults (http://fink.sourceforge.net/)
752 # 4.x minor number specific paths
753 for x
in gen_db_minor_ver_nums(4):
754 db_inc_paths
.append('/usr/include/db4%d' % x
)
755 db_inc_paths
.append('/usr/include/db4.%d' % x
)
756 db_inc_paths
.append('/usr/local/BerkeleyDB.4.%d/include' % x
)
757 db_inc_paths
.append('/usr/local/include/db4%d' % x
)
758 db_inc_paths
.append('/pkg/db-4.%d/include' % x
)
759 db_inc_paths
.append('/opt/db-4.%d/include' % x
)
760 # MacPorts default (http://www.macports.org/)
761 db_inc_paths
.append('/opt/local/include/db4%d' % x
)
762 # 3.x minor number specific paths
763 for x
in gen_db_minor_ver_nums(3):
764 db_inc_paths
.append('/usr/include/db3%d' % x
)
765 db_inc_paths
.append('/usr/local/BerkeleyDB.3.%d/include' % x
)
766 db_inc_paths
.append('/usr/local/include/db3%d' % x
)
767 db_inc_paths
.append('/pkg/db-3.%d/include' % x
)
768 db_inc_paths
.append('/opt/db-3.%d/include' % x
)
770 # Add some common subdirectories for Sleepycat DB to the list,
771 # based on the standard include directories. This way DB3/4 gets
772 # picked up when it is installed in a non-standard prefix and
773 # the user has added that prefix into inc_dirs.
776 std_variants
.append(os
.path
.join(dn
, 'db3'))
777 std_variants
.append(os
.path
.join(dn
, 'db4'))
778 for x
in gen_db_minor_ver_nums(4):
779 std_variants
.append(os
.path
.join(dn
, "db4%d"%x))
780 std_variants
.append(os
.path
.join(dn
, "db4.%d"%x))
781 for x
in gen_db_minor_ver_nums(3):
782 std_variants
.append(os
.path
.join(dn
, "db3%d"%x))
783 std_variants
.append(os
.path
.join(dn
, "db3.%d"%x))
785 db_inc_paths
= std_variants
+ db_inc_paths
786 db_inc_paths
= [p
for p
in db_inc_paths
if os
.path
.exists(p
)]
790 class db_found(Exception): pass
792 # See whether there is a Sleepycat header in the standard
794 for d
in inc_dirs
+ db_inc_paths
:
795 f
= os
.path
.join(d
, "db.h")
796 if db_setup_debug
: print "db: looking for db.h in", f
797 if os
.path
.exists(f
):
799 m
= re
.search(r
"#define\WDB_VERSION_MAJOR\W(\d+)", f
)
801 db_major
= int(m
.group(1))
802 m
= re
.search(r
"#define\WDB_VERSION_MINOR\W(\d+)", f
)
803 db_minor
= int(m
.group(1))
804 db_ver
= (db_major
, db_minor
)
806 # Avoid 4.6 prior to 4.6.21 due to a BerkeleyDB bug
808 m
= re
.search(r
"#define\WDB_VERSION_PATCH\W(\d+)", f
)
809 db_patch
= int(m
.group(1))
811 print "db.h:", db_ver
, "patch", db_patch
,
812 print "being ignored (4.6.x must be >= 4.6.21)"
815 if ( (not db_ver_inc_map
.has_key(db_ver
)) and
816 allow_db_ver(db_ver
) ):
817 # save the include directory with the db.h version
818 # (first occurrence only)
819 db_ver_inc_map
[db_ver
] = d
821 print "db.h: found", db_ver
, "in", d
823 # we already found a header for this library version
824 if db_setup_debug
: print "db.h: ignoring", d
826 # ignore this header, it didn't contain a version number
828 print "db.h: no version number version in", d
830 db_found_vers
= db_ver_inc_map
.keys()
834 db_ver
= db_found_vers
.pop()
835 db_incdir
= db_ver_inc_map
[db_ver
]
837 # check lib directories parallel to the location of the header
839 db_incdir
.replace("include", 'lib64'),
840 db_incdir
.replace("include", 'lib'),
842 db_dirs_to_check
= filter(os
.path
.isdir
, db_dirs_to_check
)
844 # Look for a version specific db-X.Y before an ambiguoius dbX
845 # XXX should we -ever- look for a dbX name? Do any
846 # systems really not name their library by version and
847 # symlink to more general names?
848 for dblib
in (('db-%d.%d' % db_ver
),
850 ('db%d' % db_ver
[0])):
851 dblib_file
= self
.compiler
.find_library_file(
852 db_dirs_to_check
+ lib_dirs
, dblib
)
854 dblib_dir
= [ os
.path
.abspath(os
.path
.dirname(dblib_file
)) ]
857 if db_setup_debug
: print "db lib: ", dblib
, "not found"
861 print "bsddb using BerkeleyDB lib:", db_ver
, dblib
862 print "bsddb lib dir:", dblib_dir
, " inc dir:", db_incdir
863 db_incs
= [db_incdir
]
865 # We add the runtime_library_dirs argument because the
866 # BerkeleyDB lib we're linking against often isn't in the
867 # system dynamic library search path. This is usually
868 # correct and most trouble free, but may cause problems in
869 # some unusual system configurations (e.g. the directory
870 # is on an NFS server that goes away).
871 exts
.append(Extension('_bsddb', ['_bsddb.c'],
872 depends
= ['bsddb.h'],
873 library_dirs
=dblib_dir
,
874 runtime_library_dirs
=dblib_dir
,
875 include_dirs
=db_incs
,
878 if db_setup_debug
: print "db: no appropriate library found"
882 missing
.append('_bsddb')
884 # The sqlite interface
885 sqlite_setup_debug
= False # verbose debug prints from this script?
887 # We hunt for #define SQLITE_VERSION "n.n.n"
888 # We need to find >= sqlite version 3.0.8
889 sqlite_incdir
= sqlite_libdir
= None
890 sqlite_inc_paths
= [ '/usr/include',
891 '/usr/include/sqlite',
892 '/usr/include/sqlite3',
893 '/usr/local/include',
894 '/usr/local/include/sqlite',
895 '/usr/local/include/sqlite3',
897 MIN_SQLITE_VERSION_NUMBER
= (3, 0, 8)
898 MIN_SQLITE_VERSION
= ".".join([str(x
)
899 for x
in MIN_SQLITE_VERSION_NUMBER
])
901 # Scan the default include directories before the SQLite specific
902 # ones. This allows one to override the copy of sqlite on OSX,
903 # where /usr/include contains an old version of sqlite.
904 for d
in inc_dirs
+ sqlite_inc_paths
:
905 f
= os
.path
.join(d
, "sqlite3.h")
906 if os
.path
.exists(f
):
907 if sqlite_setup_debug
: print "sqlite: found %s"%f
908 incf
= open(f
).read()
910 r
'\s*.*#\s*.*define\s.*SQLITE_VERSION\W*"(.*)"', incf
)
912 sqlite_version
= m
.group(1)
913 sqlite_version_tuple
= tuple([int(x
)
914 for x
in sqlite_version
.split(".")])
915 if sqlite_version_tuple
>= MIN_SQLITE_VERSION_NUMBER
:
917 if sqlite_setup_debug
:
918 print "%s/sqlite3.h: version %s"%(d
, sqlite_version
)
922 if sqlite_setup_debug
:
923 print "%s: version %d is too old, need >= %s"%(d
,
924 sqlite_version
, MIN_SQLITE_VERSION
)
925 elif sqlite_setup_debug
:
926 print "sqlite: %s had no SQLITE_VERSION"%(f
,)
929 sqlite_dirs_to_check
= [
930 os
.path
.join(sqlite_incdir
, '..', 'lib64'),
931 os
.path
.join(sqlite_incdir
, '..', 'lib'),
932 os
.path
.join(sqlite_incdir
, '..', '..', 'lib64'),
933 os
.path
.join(sqlite_incdir
, '..', '..', 'lib'),
935 sqlite_libfile
= self
.compiler
.find_library_file(
936 sqlite_dirs_to_check
+ lib_dirs
, 'sqlite3')
937 sqlite_libdir
= [os
.path
.abspath(os
.path
.dirname(sqlite_libfile
))]
939 if sqlite_incdir
and sqlite_libdir
:
940 sqlite_srcs
= ['_sqlite/cache.c',
941 '_sqlite/connection.c',
943 '_sqlite/microprotocols.c',
945 '_sqlite/prepare_protocol.c',
947 '_sqlite/statement.c',
951 if sys
.platform
!= "win32":
952 sqlite_defines
.append(('MODULE_NAME', '"sqlite3"'))
954 sqlite_defines
.append(('MODULE_NAME', '\\"sqlite3\\"'))
957 if sys
.platform
== 'darwin':
958 # In every directory on the search path search for a dynamic
959 # library and then a static library, instead of first looking
960 # for dynamic libraries on the entiry path.
961 # This way a staticly linked custom sqlite gets picked up
962 # before the dynamic library in /usr/lib.
963 sqlite_extra_link_args
= ('-Wl,-search_paths_first',)
965 sqlite_extra_link_args
= ()
967 exts
.append(Extension('_sqlite3', sqlite_srcs
,
968 define_macros
=sqlite_defines
,
969 include_dirs
=["Modules/_sqlite",
971 library_dirs
=sqlite_libdir
,
972 runtime_library_dirs
=sqlite_libdir
,
973 extra_link_args
=sqlite_extra_link_args
,
974 libraries
=["sqlite3",]))
976 missing
.append('_sqlite3')
978 # Look for Berkeley db 1.85. Note that it is built as a different
979 # module name so it can be included even when later versions are
980 # available. A very restrictive search is performed to avoid
981 # accidentally building this module with a later version of the
982 # underlying db library. May BSD-ish Unixes incorporate db 1.85
983 # symbols into libc and place the include file in /usr/include.
985 # If the better bsddb library can be built (db_incs is defined)
986 # we do not build this one. Otherwise this build will pick up
987 # the more recent berkeleydb's db.h file first in the include path
988 # when attempting to compile and it will fail.
989 f
= "/usr/include/db.h"
990 if os
.path
.exists(f
) and not db_incs
:
991 data
= open(f
).read()
992 m
= re
.search(r
"#s*define\s+HASHVERSION\s+2\s*", data
)
994 # bingo - old version used hash file format version 2
995 ### XXX this should be fixed to not be platform-dependent
996 ### but I don't have direct access to an osf1 platform and
997 ### seemed to be muffing the search somehow
998 libraries
= platform
== "osf1" and ['db'] or None
999 if libraries
is not None:
1000 exts
.append(Extension('bsddb185', ['bsddbmodule.c'],
1001 libraries
=libraries
))
1003 exts
.append(Extension('bsddb185', ['bsddbmodule.c']))
1005 missing
.append('bsddb185')
1007 missing
.append('bsddb185')
1009 # The standard Unix dbm module:
1010 if platform
not in ['cygwin']:
1011 if find_file("ndbm.h", inc_dirs
, []) is not None:
1012 # Some systems have -lndbm, others don't
1013 if self
.compiler
.find_library_file(lib_dirs
, 'ndbm'):
1014 ndbm_libs
= ['ndbm']
1017 exts
.append( Extension('dbm', ['dbmmodule.c'],
1018 define_macros
=[('HAVE_NDBM_H',None)],
1019 libraries
= ndbm_libs
) )
1020 elif (self
.compiler
.find_library_file(lib_dirs
, 'gdbm')
1021 and find_file("gdbm/ndbm.h", inc_dirs
, []) is not None):
1022 exts
.append( Extension('dbm', ['dbmmodule.c'],
1023 define_macros
=[('HAVE_GDBM_NDBM_H',None)],
1024 libraries
= ['gdbm'] ) )
1025 elif db_incs
is not None:
1026 exts
.append( Extension('dbm', ['dbmmodule.c'],
1027 library_dirs
=dblib_dir
,
1028 runtime_library_dirs
=dblib_dir
,
1029 include_dirs
=db_incs
,
1030 define_macros
=[('HAVE_BERKDB_H',None),
1031 ('DB_DBM_HSEARCH',None)],
1034 missing
.append('dbm')
1036 # Anthony Baxter's gdbm module. GNU dbm(3) will require -lgdbm:
1037 if (self
.compiler
.find_library_file(lib_dirs
, 'gdbm')):
1038 exts
.append( Extension('gdbm', ['gdbmmodule.c'],
1039 libraries
= ['gdbm'] ) )
1041 missing
.append('gdbm')
1044 if platform
not in ['mac', 'win32']:
1045 # Steen Lumholt's termios module
1046 exts
.append( Extension('termios', ['termios.c']) )
1047 # Jeremy Hylton's rlimit interface
1048 if platform
not in ['atheos']:
1049 exts
.append( Extension('resource', ['resource.c']) )
1051 missing
.append('resource')
1053 # Sun yellow pages. Some systems have the functions in libc.
1054 if platform
not in ['cygwin', 'atheos', 'qnx6']:
1055 if (self
.compiler
.find_library_file(lib_dirs
, 'nsl')):
1059 exts
.append( Extension('nis', ['nismodule.c'],
1062 missing
.append('nis')
1064 missing
.extend(['nis', 'resource', 'termios'])
1066 # Curses support, requiring the System V version of curses, often
1067 # provided by the ncurses library.
1068 panel_library
= 'panel'
1069 if (self
.compiler
.find_library_file(lib_dirs
, 'ncursesw')):
1070 curses_libs
= ['ncursesw']
1071 # Bug 1464056: If _curses.so links with ncursesw,
1072 # _curses_panel.so must link with panelw.
1073 panel_library
= 'panelw'
1074 exts
.append( Extension('_curses', ['_cursesmodule.c'],
1075 libraries
= curses_libs
) )
1076 elif (self
.compiler
.find_library_file(lib_dirs
, 'ncurses')):
1077 curses_libs
= ['ncurses']
1078 exts
.append( Extension('_curses', ['_cursesmodule.c'],
1079 libraries
= curses_libs
) )
1080 elif (self
.compiler
.find_library_file(lib_dirs
, 'curses')
1081 and platform
!= 'darwin'):
1082 # OSX has an old Berkeley curses, not good enough for
1083 # the _curses module.
1084 if (self
.compiler
.find_library_file(lib_dirs
, 'terminfo')):
1085 curses_libs
= ['curses', 'terminfo']
1086 elif (self
.compiler
.find_library_file(lib_dirs
, 'termcap')):
1087 curses_libs
= ['curses', 'termcap']
1089 curses_libs
= ['curses']
1091 exts
.append( Extension('_curses', ['_cursesmodule.c'],
1092 libraries
= curses_libs
) )
1094 missing
.append('_curses')
1096 # If the curses module is enabled, check for the panel module
1097 if (module_enabled(exts
, '_curses') and
1098 self
.compiler
.find_library_file(lib_dirs
, panel_library
)):
1099 exts
.append( Extension('_curses_panel', ['_curses_panel.c'],
1100 libraries
= [panel_library
] + curses_libs
) )
1102 missing
.append('_curses_panel')
1104 # Andrew Kuchling's zlib module. Note that some versions of zlib
1105 # 1.1.3 have security problems. See CERT Advisory CA-2002-07:
1106 # http://www.cert.org/advisories/CA-2002-07.html
1108 # zlib 1.1.4 is fixed, but at least one vendor (RedHat) has decided to
1109 # patch its zlib 1.1.3 package instead of upgrading to 1.1.4. For
1110 # now, we still accept 1.1.3, because we think it's difficult to
1111 # exploit this in Python, and we'd rather make it RedHat's problem
1112 # than our problem <wink>.
1114 # You can upgrade zlib to version 1.1.4 yourself by going to
1115 # http://www.gzip.org/zlib/
1116 zlib_inc
= find_file('zlib.h', [], inc_dirs
)
1118 if zlib_inc
is not None:
1119 zlib_h
= zlib_inc
[0] + '/zlib.h'
1121 version_req
= '"1.1.3"'
1124 line
= fp
.readline()
1127 if line
.startswith('#define ZLIB_VERSION'):
1128 version
= line
.split()[2]
1130 if version
>= version_req
:
1131 if (self
.compiler
.find_library_file(lib_dirs
, 'z')):
1132 if sys
.platform
== "darwin":
1133 zlib_extra_link_args
= ('-Wl,-search_paths_first',)
1135 zlib_extra_link_args
= ()
1136 exts
.append( Extension('zlib', ['zlibmodule.c'],
1138 extra_link_args
= zlib_extra_link_args
))
1141 missing
.append('zlib')
1143 missing
.append('zlib')
1145 missing
.append('zlib')
1147 # Helper module for various ascii-encoders. Uses zlib for an optimized
1148 # crc32 if we have it. Otherwise binascii uses its own.
1150 extra_compile_args
= ['-DUSE_ZLIB_CRC32']
1152 extra_link_args
= zlib_extra_link_args
1154 extra_compile_args
= []
1156 extra_link_args
= []
1157 exts
.append( Extension('binascii', ['binascii.c'],
1158 extra_compile_args
= extra_compile_args
,
1159 libraries
= libraries
,
1160 extra_link_args
= extra_link_args
) )
1162 # Gustavo Niemeyer's bz2 module.
1163 if (self
.compiler
.find_library_file(lib_dirs
, 'bz2')):
1164 if sys
.platform
== "darwin":
1165 bz2_extra_link_args
= ('-Wl,-search_paths_first',)
1167 bz2_extra_link_args
= ()
1168 exts
.append( Extension('bz2', ['bz2module.c'],
1169 libraries
= ['bz2'],
1170 extra_link_args
= bz2_extra_link_args
) )
1172 missing
.append('bz2')
1174 # Interface to the Expat XML parser
1176 # Expat was written by James Clark and is now maintained by a
1177 # group of developers on SourceForge; see www.libexpat.org for
1178 # more information. The pyexpat module was written by Paul
1179 # Prescod after a prototype by Jack Jansen. The Expat source
1180 # is included in Modules/expat/. Usage of a system
1181 # shared libexpat.so/expat.dll is not advised.
1183 # More information on Expat can be found at www.libexpat.org.
1185 expatinc
= os
.path
.join(os
.getcwd(), srcdir
, 'Modules', 'expat')
1187 ('HAVE_EXPAT_CONFIG_H', '1'),
1190 exts
.append(Extension('pyexpat',
1191 define_macros
= define_macros
,
1192 include_dirs
= [expatinc
],
1193 sources
= ['pyexpat.c',
1200 # Fredrik Lundh's cElementTree module. Note that this also
1201 # uses expat (via the CAPI hook in pyexpat).
1203 if os
.path
.isfile(os
.path
.join(srcdir
, 'Modules', '_elementtree.c')):
1204 define_macros
.append(('USE_PYEXPAT_CAPI', None))
1205 exts
.append(Extension('_elementtree',
1206 define_macros
= define_macros
,
1207 include_dirs
= [expatinc
],
1208 sources
= ['_elementtree.c'],
1211 missing
.append('_elementtree')
1213 # Hye-Shik Chang's CJKCodecs modules.
1215 exts
.append(Extension('_multibytecodec',
1216 ['cjkcodecs/multibytecodec.c']))
1217 for loc
in ('kr', 'jp', 'cn', 'tw', 'hk', 'iso2022'):
1218 exts
.append(Extension('_codecs_%s' % loc
,
1219 ['cjkcodecs/_codecs_%s.c' % loc
]))
1221 missing
.append('_multibytecodec')
1222 for loc
in ('kr', 'jp', 'cn', 'tw', 'hk', 'iso2022'):
1223 missing
.append('_codecs_%s' % loc
)
1225 # Dynamic loading module
1226 if sys
.maxint
== 0x7fffffff:
1227 # This requires sizeof(int) == sizeof(long) == sizeof(char*)
1228 dl_inc
= find_file('dlfcn.h', [], inc_dirs
)
1229 if (dl_inc
is not None) and (platform
not in ['atheos']):
1230 exts
.append( Extension('dl', ['dlmodule.c']) )
1232 missing
.append('dl')
1234 missing
.append('dl')
1236 # Thomas Heller's _ctypes module
1237 self
.detect_ctypes(inc_dirs
, lib_dirs
)
1239 # Richard Oudkerk's multiprocessing module
1240 if platform
== 'win32': # Windows
1242 libraries
= ['ws2_32']
1244 elif platform
== 'darwin': # Mac OSX
1247 HAVE_SEM_TIMEDWAIT
=0,
1249 HAVE_BROKEN_SEM_GETVALUE
=1
1253 elif platform
== 'cygwin': # Cygwin
1256 HAVE_SEM_TIMEDWAIT
=1,
1258 HAVE_BROKEN_SEM_UNLINK
=1
1262 elif platform
in ('freebsd5', 'freebsd6', 'freebsd7', 'freebsd8'):
1263 # FreeBSD's P1003.1b semaphore support is very experimental
1264 # and has many known problems. (as of June 2008)
1265 macros
= dict( # FreeBSD
1267 HAVE_SEM_TIMEDWAIT
=0,
1272 elif platform
.startswith('openbsd'):
1273 macros
= dict( # OpenBSD
1274 HAVE_SEM_OPEN
=0, # Not implemented
1275 HAVE_SEM_TIMEDWAIT
=0,
1280 else: # Linux and other unices
1283 HAVE_SEM_TIMEDWAIT
=1,
1288 if platform
== 'win32':
1289 multiprocessing_srcs
= [ '_multiprocessing/multiprocessing.c',
1290 '_multiprocessing/semaphore.c',
1291 '_multiprocessing/pipe_connection.c',
1292 '_multiprocessing/socket_connection.c',
1293 '_multiprocessing/win32_functions.c'
1297 multiprocessing_srcs
= [ '_multiprocessing/multiprocessing.c',
1298 '_multiprocessing/socket_connection.c'
1301 if macros
.get('HAVE_SEM_OPEN', False):
1302 multiprocessing_srcs
.append('_multiprocessing/semaphore.c')
1304 exts
.append ( Extension('_multiprocessing', multiprocessing_srcs
,
1305 define_macros
=macros
.items(),
1306 include_dirs
=["Modules/_multiprocessing"]))
1307 # End multiprocessing
1310 # Platform-specific libraries
1311 if platform
== 'linux2':
1312 # Linux-specific modules
1313 exts
.append( Extension('linuxaudiodev', ['linuxaudiodev.c']) )
1315 missing
.append('linuxaudiodev')
1317 if platform
in ('linux2', 'freebsd4', 'freebsd5', 'freebsd6',
1318 'freebsd7', 'freebsd8'):
1319 exts
.append( Extension('ossaudiodev', ['ossaudiodev.c']) )
1321 missing
.append('ossaudiodev')
1323 if platform
== 'sunos5':
1324 # SunOS specific modules
1325 exts
.append( Extension('sunaudiodev', ['sunaudiodev.c']) )
1327 missing
.append('sunaudiodev')
1329 if platform
== 'darwin' and ("--disable-toolbox-glue" not in
1330 sysconfig
.get_config_var("CONFIG_ARGS")):
1332 if os
.uname()[2] > '8.':
1333 # We're on Mac OS X 10.4 or later, the compiler should
1334 # support '-Wno-deprecated-declarations'. This will
1335 # surpress deprecation warnings for the Carbon extensions,
1336 # these extensions wrap the Carbon APIs and even those
1337 # parts that are deprecated.
1338 carbon_extra_compile_args
= ['-Wno-deprecated-declarations']
1340 carbon_extra_compile_args
= []
1342 # Mac OS X specific modules.
1343 def macSrcExists(name1
, name2
=''):
1348 names
= (name1
, name2
)
1349 path
= os
.path
.join(srcdir
, 'Mac', 'Modules', *names
)
1350 return os
.path
.exists(path
)
1352 def addMacExtension(name
, kwds
, extra_srcs
=[]):
1355 dirname
= name
[1:].lower()
1357 cmodulename
= name
+ 'module.c'
1358 # Check for NNN.c, NNNmodule.c, _nnn/NNN.c, _nnn/NNNmodule.c
1359 if macSrcExists(cname
):
1361 elif macSrcExists(cmodulename
):
1362 srcs
= [cmodulename
]
1363 elif macSrcExists(dirname
, cname
):
1364 # XXX(nnorwitz): If all the names ended with module, we
1365 # wouldn't need this condition. ibcarbon is the only one.
1366 srcs
= [os
.path
.join(dirname
, cname
)]
1367 elif macSrcExists(dirname
, cmodulename
):
1368 srcs
= [os
.path
.join(dirname
, cmodulename
)]
1370 raise RuntimeError("%s not found" % name
)
1372 # Here's the whole point: add the extension with sources
1373 exts
.append(Extension(name
, srcs
+ extra_srcs
, **kwds
))
1376 core_kwds
= {'extra_compile_args': carbon_extra_compile_args
,
1377 'extra_link_args': ['-framework', 'CoreFoundation'],
1379 addMacExtension('_CF', core_kwds
, ['cf/pycfbridge.c'])
1380 addMacExtension('autoGIL', core_kwds
)
1383 carbon_kwds
= {'extra_compile_args': carbon_extra_compile_args
,
1384 'extra_link_args': ['-framework', 'Carbon'],
1386 CARBON_EXTS
= ['ColorPicker', 'gestalt', 'MacOS', 'Nav',
1387 'OSATerminology', 'icglue',
1388 # All these are in subdirs
1389 '_AE', '_AH', '_App', '_CarbonEvt', '_Cm', '_Ctl',
1390 '_Dlg', '_Drag', '_Evt', '_File', '_Folder', '_Fm',
1391 '_Help', '_Icn', '_IBCarbon', '_List',
1392 '_Menu', '_Mlte', '_OSA', '_Res', '_Qd', '_Qdoffs',
1393 '_Scrap', '_Snd', '_TE',
1395 for name
in CARBON_EXTS
:
1396 addMacExtension(name
, carbon_kwds
)
1398 # Workaround for a bug in the version of gcc shipped with Xcode 3.
1399 # The _Win extension should build just like the other Carbon extensions, but
1400 # this actually results in a hard crash of the linker.
1402 if '-arch ppc64' in cflags
and '-arch ppc' in cflags
:
1403 win_kwds
= {'extra_compile_args': carbon_extra_compile_args
+ ['-arch', 'i386', '-arch', 'ppc'],
1404 'extra_link_args': ['-framework', 'Carbon', '-arch', 'i386', '-arch', 'ppc'],
1406 addMacExtension('_Win', win_kwds
)
1408 addMacExtension('_Win', carbon_kwds
)
1411 # Application Services & QuickTime
1412 app_kwds
= {'extra_compile_args': carbon_extra_compile_args
,
1413 'extra_link_args': ['-framework','ApplicationServices'],
1415 addMacExtension('_Launch', app_kwds
)
1416 addMacExtension('_CG', app_kwds
)
1418 exts
.append( Extension('_Qt', ['qt/_Qtmodule.c'],
1419 extra_compile_args
=carbon_extra_compile_args
,
1420 extra_link_args
=['-framework', 'QuickTime',
1421 '-framework', 'Carbon']) )
1424 self
.extensions
.extend(exts
)
1426 # Call the method for detecting whether _tkinter can be compiled
1427 self
.detect_tkinter(inc_dirs
, lib_dirs
)
1429 if '_tkinter' not in [e
.name
for e
in self
.extensions
]:
1430 missing
.append('_tkinter')
1434 def detect_tkinter_darwin(self
, inc_dirs
, lib_dirs
):
1435 # The _tkinter module, using frameworks. Since frameworks are quite
1436 # different the UNIX search logic is not sharable.
1437 from os
.path
import join
, exists
1439 '/System/Library/Frameworks/',
1440 '/Library/Frameworks',
1441 join(os
.getenv('HOME'), '/Library/Frameworks')
1444 # Find the directory that contains the Tcl.framework and Tk.framework
1446 # XXX distutils should support -F!
1447 for F
in framework_dirs
:
1448 # both Tcl.framework and Tk.framework should be present
1449 for fw
in 'Tcl', 'Tk':
1450 if not exists(join(F
, fw
+ '.framework')):
1453 # ok, F is now directory with both frameworks. Continure
1457 # Tk and Tcl frameworks not found. Normal "unix" tkinter search
1461 # For 8.4a2, we must add -I options that point inside the Tcl and Tk
1462 # frameworks. In later release we should hopefully be able to pass
1463 # the -F option to gcc, which specifies a framework lookup path.
1466 join(F
, fw
+ '.framework', H
)
1467 for fw
in 'Tcl', 'Tk'
1468 for H
in 'Headers', 'Versions/Current/PrivateHeaders'
1471 # For 8.4a2, the X11 headers are not included. Rather than include a
1472 # complicated search, this is a hard-coded path. It could bail out
1473 # if X11 libs are not found...
1474 include_dirs
.append('/usr/X11R6/include')
1475 frameworks
= ['-framework', 'Tcl', '-framework', 'Tk']
1477 # All existing framework builds of Tcl/Tk don't support 64-bit
1479 cflags
= sysconfig
.get_config_vars('CFLAGS')[0]
1480 archs
= re
.findall('-arch\s+(\w+)', cflags
)
1481 if 'x86_64' in archs
or 'ppc64' in archs
:
1483 archs
.remove('x86_64')
1487 archs
.remove('ppc64')
1492 frameworks
.append('-arch')
1493 frameworks
.append(a
)
1495 ext
= Extension('_tkinter', ['_tkinter.c', 'tkappinit.c'],
1496 define_macros
=[('WITH_APPINIT', 1)],
1497 include_dirs
= include_dirs
,
1499 extra_compile_args
= frameworks
[2:],
1500 extra_link_args
= frameworks
,
1502 self
.extensions
.append(ext
)
1506 def detect_tkinter(self
, inc_dirs
, lib_dirs
):
1507 # The _tkinter module.
1509 # Rather than complicate the code below, detecting and building
1510 # AquaTk is a separate method. Only one Tkinter will be built on
1511 # Darwin - either AquaTk, if it is found, or X11 based Tk.
1512 platform
= self
.get_platform()
1513 if (platform
== 'darwin' and
1514 self
.detect_tkinter_darwin(inc_dirs
, lib_dirs
)):
1517 # Assume we haven't found any of the libraries or include files
1518 # The versions with dots are used on Unix, and the versions without
1519 # dots on Windows, for detection by cygwin.
1520 tcllib
= tklib
= tcl_includes
= tk_includes
= None
1521 for version
in ['8.5', '85', '8.4', '84', '8.3', '83', '8.2',
1522 '82', '8.1', '81', '8.0', '80']:
1523 tklib
= self
.compiler
.find_library_file(lib_dirs
, 'tk' + version
)
1524 tcllib
= self
.compiler
.find_library_file(lib_dirs
, 'tcl' + version
)
1525 if tklib
and tcllib
:
1526 # Exit the loop when we've found the Tcl/Tk libraries
1529 # Now check for the header files
1530 if tklib
and tcllib
:
1531 # Check for the include files on Debian and {Free,Open}BSD, where
1532 # they're put in /usr/include/{tcl,tk}X.Y
1533 dotversion
= version
1534 if '.' not in dotversion
and "bsd" in sys
.platform
.lower():
1535 # OpenBSD and FreeBSD use Tcl/Tk library names like libtcl83.a,
1536 # but the include subdirs are named like .../include/tcl8.3.
1537 dotversion
= dotversion
[:-1] + '.' + dotversion
[-1]
1538 tcl_include_sub
= []
1540 for dir in inc_dirs
:
1541 tcl_include_sub
+= [dir + os
.sep
+ "tcl" + dotversion
]
1542 tk_include_sub
+= [dir + os
.sep
+ "tk" + dotversion
]
1543 tk_include_sub
+= tcl_include_sub
1544 tcl_includes
= find_file('tcl.h', inc_dirs
, tcl_include_sub
)
1545 tk_includes
= find_file('tk.h', inc_dirs
, tk_include_sub
)
1547 if (tcllib
is None or tklib
is None or
1548 tcl_includes
is None or tk_includes
is None):
1549 self
.announce("INFO: Can't locate Tcl/Tk libs and/or headers", 2)
1552 # OK... everything seems to be present for Tcl/Tk.
1554 include_dirs
= [] ; libs
= [] ; defs
= [] ; added_lib_dirs
= []
1555 for dir in tcl_includes
+ tk_includes
:
1556 if dir not in include_dirs
:
1557 include_dirs
.append(dir)
1559 # Check for various platform-specific directories
1560 if platform
== 'sunos5':
1561 include_dirs
.append('/usr/openwin/include')
1562 added_lib_dirs
.append('/usr/openwin/lib')
1563 elif os
.path
.exists('/usr/X11R6/include'):
1564 include_dirs
.append('/usr/X11R6/include')
1565 added_lib_dirs
.append('/usr/X11R6/lib64')
1566 added_lib_dirs
.append('/usr/X11R6/lib')
1567 elif os
.path
.exists('/usr/X11R5/include'):
1568 include_dirs
.append('/usr/X11R5/include')
1569 added_lib_dirs
.append('/usr/X11R5/lib')
1571 # Assume default location for X11
1572 include_dirs
.append('/usr/X11/include')
1573 added_lib_dirs
.append('/usr/X11/lib')
1575 # If Cygwin, then verify that X is installed before proceeding
1576 if platform
== 'cygwin':
1577 x11_inc
= find_file('X11/Xlib.h', [], include_dirs
)
1581 # Check for BLT extension
1582 if self
.compiler
.find_library_file(lib_dirs
+ added_lib_dirs
,
1584 defs
.append( ('WITH_BLT', 1) )
1585 libs
.append('BLT8.0')
1586 elif self
.compiler
.find_library_file(lib_dirs
+ added_lib_dirs
,
1588 defs
.append( ('WITH_BLT', 1) )
1591 # Add the Tcl/Tk libraries
1592 libs
.append('tk'+ version
)
1593 libs
.append('tcl'+ version
)
1595 if platform
in ['aix3', 'aix4']:
1598 # Finally, link with the X11 libraries (not appropriate on cygwin)
1599 if platform
!= "cygwin":
1602 ext
= Extension('_tkinter', ['_tkinter.c', 'tkappinit.c'],
1603 define_macros
=[('WITH_APPINIT', 1)] + defs
,
1604 include_dirs
= include_dirs
,
1606 library_dirs
= added_lib_dirs
,
1608 self
.extensions
.append(ext
)
1610 ## # Uncomment these lines if you want to play with xxmodule.c
1611 ## ext = Extension('xx', ['xxmodule.c'])
1612 ## self.extensions.append(ext)
1614 # XXX handle these, but how to detect?
1615 # *** Uncomment and edit for PIL (TkImaging) extension only:
1616 # -DWITH_PIL -I../Extensions/Imaging/libImaging tkImaging.c \
1617 # *** Uncomment and edit for TOGL extension only:
1618 # -DWITH_TOGL togl.c \
1619 # *** Uncomment these for TOGL extension only:
1620 # -lGL -lGLU -lXext -lXmu \
1622 def configure_ctypes_darwin(self
, ext
):
1623 # Darwin (OS X) uses preconfigured files, in
1624 # the Modules/_ctypes/libffi_osx directory.
1625 (srcdir
,) = sysconfig
.get_config_vars('srcdir')
1626 ffi_srcdir
= os
.path
.abspath(os
.path
.join(srcdir
, 'Modules',
1627 '_ctypes', 'libffi_osx'))
1628 sources
= [os
.path
.join(ffi_srcdir
, p
)
1632 'x86/x86-ffi_darwin.c',
1634 'powerpc/ppc-darwin.S',
1635 'powerpc/ppc-darwin_closure.S',
1636 'powerpc/ppc-ffi_darwin.c',
1637 'powerpc/ppc64-darwin_closure.S',
1640 # Add .S (preprocessed assembly) to C compiler source extensions.
1641 self
.compiler
.src_extensions
.append('.S')
1643 include_dirs
= [os
.path
.join(ffi_srcdir
, 'include'),
1644 os
.path
.join(ffi_srcdir
, 'powerpc')]
1645 ext
.include_dirs
.extend(include_dirs
)
1646 ext
.sources
.extend(sources
)
1649 def configure_ctypes(self
, ext
):
1650 if not self
.use_system_libffi
:
1651 if sys
.platform
== 'darwin':
1652 return self
.configure_ctypes_darwin(ext
)
1654 (srcdir
,) = sysconfig
.get_config_vars('srcdir')
1655 ffi_builddir
= os
.path
.join(self
.build_temp
, 'libffi')
1656 ffi_srcdir
= os
.path
.abspath(os
.path
.join(srcdir
, 'Modules',
1657 '_ctypes', 'libffi'))
1658 ffi_configfile
= os
.path
.join(ffi_builddir
, 'fficonfig.py')
1660 from distutils
.dep_util
import newer_group
1662 config_sources
= [os
.path
.join(ffi_srcdir
, fname
)
1663 for fname
in os
.listdir(ffi_srcdir
)
1664 if os
.path
.isfile(os
.path
.join(ffi_srcdir
, fname
))]
1665 if self
.force
or newer_group(config_sources
,
1667 from distutils
.dir_util
import mkpath
1668 mkpath(ffi_builddir
)
1671 # Pass empty CFLAGS because we'll just append the resulting
1672 # CFLAGS to Python's; -g or -O2 is to be avoided.
1673 cmd
= "cd %s && env CFLAGS='' '%s/configure' %s" \
1674 % (ffi_builddir
, ffi_srcdir
, " ".join(config_args
))
1676 res
= os
.system(cmd
)
1677 if res
or not os
.path
.exists(ffi_configfile
):
1678 print "Failed to configure _ctypes module"
1682 execfile(ffi_configfile
, globals(), fficonfig
)
1683 ffi_srcdir
= os
.path
.join(fficonfig
['ffi_srcdir'], 'src')
1685 # Add .S (preprocessed assembly) to C compiler source extensions.
1686 self
.compiler
.src_extensions
.append('.S')
1688 include_dirs
= [os
.path
.join(ffi_builddir
, 'include'),
1689 ffi_builddir
, ffi_srcdir
]
1690 extra_compile_args
= fficonfig
['ffi_cflags'].split()
1692 ext
.sources
.extend(fficonfig
['ffi_sources'])
1693 ext
.include_dirs
.extend(include_dirs
)
1694 ext
.extra_compile_args
.extend(extra_compile_args
)
1697 def detect_ctypes(self
, inc_dirs
, lib_dirs
):
1698 self
.use_system_libffi
= False
1700 extra_compile_args
= []
1701 extra_link_args
= []
1702 sources
= ['_ctypes/_ctypes.c',
1703 '_ctypes/callbacks.c',
1704 '_ctypes/callproc.c',
1705 '_ctypes/stgdict.c',
1707 '_ctypes/malloc_closure.c']
1708 depends
= ['_ctypes/ctypes.h']
1710 if sys
.platform
== 'darwin':
1711 sources
.append('_ctypes/darwin/dlfcn_simple.c')
1712 extra_compile_args
.append('-DMACOSX')
1713 include_dirs
.append('_ctypes/darwin')
1714 # XXX Is this still needed?
1715 ## extra_link_args.extend(['-read_only_relocs', 'warning'])
1717 elif sys
.platform
== 'sunos5':
1718 # XXX This shouldn't be necessary; it appears that some
1719 # of the assembler code is non-PIC (i.e. it has relocations
1720 # when it shouldn't. The proper fix would be to rewrite
1721 # the assembler code to be PIC.
1722 # This only works with GCC; the Sun compiler likely refuses
1723 # this option. If you want to compile ctypes with the Sun
1724 # compiler, please research a proper solution, instead of
1725 # finding some -z option for the Sun compiler.
1726 extra_link_args
.append('-mimpure-text')
1728 elif sys
.platform
.startswith('hp-ux'):
1729 extra_link_args
.append('-fPIC')
1731 ext
= Extension('_ctypes',
1732 include_dirs
=include_dirs
,
1733 extra_compile_args
=extra_compile_args
,
1734 extra_link_args
=extra_link_args
,
1738 ext_test
= Extension('_ctypes_test',
1739 sources
=['_ctypes/_ctypes_test.c'])
1740 self
.extensions
.extend([ext
, ext_test
])
1742 if not '--with-system-ffi' in sysconfig
.get_config_var("CONFIG_ARGS"):
1745 if sys
.platform
== 'darwin':
1746 # OS X 10.5 comes with libffi.dylib; the include files are
1747 # in /usr/include/ffi
1748 inc_dirs
.append('/usr/include/ffi')
1750 ffi_inc
= find_file('ffi.h', [], inc_dirs
)
1751 if ffi_inc
is not None:
1752 ffi_h
= ffi_inc
[0] + '/ffi.h'
1755 line
= fp
.readline()
1759 if line
.startswith('#define LIBFFI_H'):
1762 if ffi_inc
is not None:
1763 for lib_name
in ('ffi_convenience', 'ffi_pic', 'ffi'):
1764 if (self
.compiler
.find_library_file(lib_dirs
, lib_name
)):
1768 if ffi_inc
and ffi_lib
:
1769 ext
.include_dirs
.extend(ffi_inc
)
1770 ext
.libraries
.append(ffi_lib
)
1771 self
.use_system_libffi
= True
1774 class PyBuildInstall(install
):
1775 # Suppress the warning about installation into the lib_dynload
1776 # directory, which is not in sys.path when running Python during
1778 def initialize_options (self
):
1779 install
.initialize_options(self
)
1782 class PyBuildInstallLib(install_lib
):
1783 # Do exactly what install_lib does but make sure correct access modes get
1784 # set on installed directories and files. All installed files with get
1785 # mode 644 unless they are a shared library in which case they will get
1786 # mode 755. All installed directories will get mode 755.
1788 so_ext
= sysconfig
.get_config_var("SO")
1791 outfiles
= install_lib
.install(self
)
1792 self
.set_file_modes(outfiles
, 0644, 0755)
1793 self
.set_dir_modes(self
.install_dir
, 0755)
1796 def set_file_modes(self
, files
, defaultMode
, sharedLibMode
):
1797 if not self
.is_chmod_supported(): return
1798 if not files
: return
1800 for filename
in files
:
1801 if os
.path
.islink(filename
): continue
1803 if filename
.endswith(self
.so_ext
): mode
= sharedLibMode
1804 log
.info("changing mode of %s to %o", filename
, mode
)
1805 if not self
.dry_run
: os
.chmod(filename
, mode
)
1807 def set_dir_modes(self
, dirname
, mode
):
1808 if not self
.is_chmod_supported(): return
1809 os
.path
.walk(dirname
, self
.set_dir_modes_visitor
, mode
)
1811 def set_dir_modes_visitor(self
, mode
, dirname
, names
):
1812 if os
.path
.islink(dirname
): return
1813 log
.info("changing mode of %s to %o", dirname
, mode
)
1814 if not self
.dry_run
: os
.chmod(dirname
, mode
)
1816 def is_chmod_supported(self
):
1817 return hasattr(os
, 'chmod')
1820 Python is an interpreted, interactive, object-oriented programming
1821 language. It is often compared to Tcl, Perl, Scheme or Java.
1823 Python combines remarkable power with very clear syntax. It has
1824 modules, classes, exceptions, very high level dynamic data types, and
1825 dynamic typing. There are interfaces to many system calls and
1826 libraries, as well as to various windowing systems (X11, Motif, Tk,
1827 Mac, MFC). New built-in modules are easily written in C or C++. Python
1828 is also usable as an extension language for applications that need a
1829 programmable interface.
1831 The Python implementation is portable: it runs on many brands of UNIX,
1832 on Windows, DOS, OS/2, Mac, Amiga... If your favorite system isn't
1833 listed here, it may still be supported, if there's a C compiler for
1834 it. Ask around on comp.lang.python -- or just try compiling Python
1839 Development Status :: 3 - Alpha
1840 Development Status :: 6 - Mature
1841 License :: OSI Approved :: Python Software Foundation License
1842 Natural Language :: English
1843 Programming Language :: C
1844 Programming Language :: Python
1845 Topic :: Software Development
1849 # turn off warnings when deprecated modules are imported
1851 warnings
.filterwarnings("ignore",category
=DeprecationWarning)
1852 setup(# PyPI Metadata (PEP 301)
1854 version
= sys
.version
.split()[0],
1855 url
= "http://www.python.org/%s" % sys
.version
[:3],
1856 maintainer
= "Guido van Rossum and the Python community",
1857 maintainer_email
= "python-dev@python.org",
1858 description
= "A high-level object-oriented programming language",
1859 long_description
= SUMMARY
.strip(),
1860 license
= "PSF license",
1861 classifiers
= filter(None, CLASSIFIERS
.split("\n")),
1862 platforms
= ["Many"],
1865 cmdclass
= {'build_ext':PyBuildExt
, 'install':PyBuildInstall
,
1866 'install_lib':PyBuildInstallLib
},
1867 # The struct module is defined here, because build_ext won't be
1868 # called unless there's at least one extension module defined.
1869 ext_modules
=[Extension('_struct', ['_struct.c'])],
1871 # Scripts to install
1872 scripts
= ['Tools/scripts/pydoc', 'Tools/scripts/idle',
1873 'Tools/scripts/2to3',
1878 if __name__
== '__main__':