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 else: # Linux and other unices
1275 HAVE_SEM_TIMEDWAIT
=1,
1280 if platform
== 'win32':
1281 multiprocessing_srcs
= [ '_multiprocessing/multiprocessing.c',
1282 '_multiprocessing/semaphore.c',
1283 '_multiprocessing/pipe_connection.c',
1284 '_multiprocessing/socket_connection.c',
1285 '_multiprocessing/win32_functions.c'
1289 multiprocessing_srcs
= [ '_multiprocessing/multiprocessing.c',
1290 '_multiprocessing/socket_connection.c'
1293 if macros
.get('HAVE_SEM_OPEN', False):
1294 multiprocessing_srcs
.append('_multiprocessing/semaphore.c')
1296 exts
.append ( Extension('_multiprocessing', multiprocessing_srcs
,
1297 define_macros
=macros
.items(),
1298 include_dirs
=["Modules/_multiprocessing"]))
1299 # End multiprocessing
1302 # Platform-specific libraries
1303 if platform
== 'linux2':
1304 # Linux-specific modules
1305 exts
.append( Extension('linuxaudiodev', ['linuxaudiodev.c']) )
1307 missing
.append('linuxaudiodev')
1309 if platform
in ('linux2', 'freebsd4', 'freebsd5', 'freebsd6',
1310 'freebsd7', 'freebsd8'):
1311 exts
.append( Extension('ossaudiodev', ['ossaudiodev.c']) )
1313 missing
.append('ossaudiodev')
1315 if platform
== 'sunos5':
1316 # SunOS specific modules
1317 exts
.append( Extension('sunaudiodev', ['sunaudiodev.c']) )
1319 missing
.append('sunaudiodev')
1321 if platform
== 'darwin' and ("--disable-toolbox-glue" not in
1322 sysconfig
.get_config_var("CONFIG_ARGS")):
1324 if os
.uname()[2] > '8.':
1325 # We're on Mac OS X 10.4 or later, the compiler should
1326 # support '-Wno-deprecated-declarations'. This will
1327 # surpress deprecation warnings for the Carbon extensions,
1328 # these extensions wrap the Carbon APIs and even those
1329 # parts that are deprecated.
1330 carbon_extra_compile_args
= ['-Wno-deprecated-declarations']
1332 carbon_extra_compile_args
= []
1334 # Mac OS X specific modules.
1335 def macSrcExists(name1
, name2
=''):
1340 names
= (name1
, name2
)
1341 path
= os
.path
.join(srcdir
, 'Mac', 'Modules', *names
)
1342 return os
.path
.exists(path
)
1344 def addMacExtension(name
, kwds
, extra_srcs
=[]):
1347 dirname
= name
[1:].lower()
1349 cmodulename
= name
+ 'module.c'
1350 # Check for NNN.c, NNNmodule.c, _nnn/NNN.c, _nnn/NNNmodule.c
1351 if macSrcExists(cname
):
1353 elif macSrcExists(cmodulename
):
1354 srcs
= [cmodulename
]
1355 elif macSrcExists(dirname
, cname
):
1356 # XXX(nnorwitz): If all the names ended with module, we
1357 # wouldn't need this condition. ibcarbon is the only one.
1358 srcs
= [os
.path
.join(dirname
, cname
)]
1359 elif macSrcExists(dirname
, cmodulename
):
1360 srcs
= [os
.path
.join(dirname
, cmodulename
)]
1362 raise RuntimeError("%s not found" % name
)
1364 # Here's the whole point: add the extension with sources
1365 exts
.append(Extension(name
, srcs
+ extra_srcs
, **kwds
))
1368 core_kwds
= {'extra_compile_args': carbon_extra_compile_args
,
1369 'extra_link_args': ['-framework', 'CoreFoundation'],
1371 addMacExtension('_CF', core_kwds
, ['cf/pycfbridge.c'])
1372 addMacExtension('autoGIL', core_kwds
)
1375 carbon_kwds
= {'extra_compile_args': carbon_extra_compile_args
,
1376 'extra_link_args': ['-framework', 'Carbon'],
1378 CARBON_EXTS
= ['ColorPicker', 'gestalt', 'MacOS', 'Nav',
1379 'OSATerminology', 'icglue',
1380 # All these are in subdirs
1381 '_AE', '_AH', '_App', '_CarbonEvt', '_Cm', '_Ctl',
1382 '_Dlg', '_Drag', '_Evt', '_File', '_Folder', '_Fm',
1383 '_Help', '_Icn', '_IBCarbon', '_List',
1384 '_Menu', '_Mlte', '_OSA', '_Res', '_Qd', '_Qdoffs',
1385 '_Scrap', '_Snd', '_TE',
1387 for name
in CARBON_EXTS
:
1388 addMacExtension(name
, carbon_kwds
)
1390 # Workaround for a bug in the version of gcc shipped with Xcode 3.
1391 # The _Win extension should build just like the other Carbon extensions, but
1392 # this actually results in a hard crash of the linker.
1394 if '-arch ppc64' in cflags
and '-arch ppc' in cflags
:
1395 win_kwds
= {'extra_compile_args': carbon_extra_compile_args
+ ['-arch', 'i386', '-arch', 'ppc'],
1396 'extra_link_args': ['-framework', 'Carbon', '-arch', 'i386', '-arch', 'ppc'],
1398 addMacExtension('_Win', win_kwds
)
1400 addMacExtension('_Win', carbon_kwds
)
1403 # Application Services & QuickTime
1404 app_kwds
= {'extra_compile_args': carbon_extra_compile_args
,
1405 'extra_link_args': ['-framework','ApplicationServices'],
1407 addMacExtension('_Launch', app_kwds
)
1408 addMacExtension('_CG', app_kwds
)
1410 exts
.append( Extension('_Qt', ['qt/_Qtmodule.c'],
1411 extra_compile_args
=carbon_extra_compile_args
,
1412 extra_link_args
=['-framework', 'QuickTime',
1413 '-framework', 'Carbon']) )
1416 self
.extensions
.extend(exts
)
1418 # Call the method for detecting whether _tkinter can be compiled
1419 self
.detect_tkinter(inc_dirs
, lib_dirs
)
1421 if '_tkinter' not in [e
.name
for e
in self
.extensions
]:
1422 missing
.append('_tkinter')
1426 def detect_tkinter_darwin(self
, inc_dirs
, lib_dirs
):
1427 # The _tkinter module, using frameworks. Since frameworks are quite
1428 # different the UNIX search logic is not sharable.
1429 from os
.path
import join
, exists
1431 '/System/Library/Frameworks/',
1432 '/Library/Frameworks',
1433 join(os
.getenv('HOME'), '/Library/Frameworks')
1436 # Find the directory that contains the Tcl.framework and Tk.framework
1438 # XXX distutils should support -F!
1439 for F
in framework_dirs
:
1440 # both Tcl.framework and Tk.framework should be present
1441 for fw
in 'Tcl', 'Tk':
1442 if not exists(join(F
, fw
+ '.framework')):
1445 # ok, F is now directory with both frameworks. Continure
1449 # Tk and Tcl frameworks not found. Normal "unix" tkinter search
1453 # For 8.4a2, we must add -I options that point inside the Tcl and Tk
1454 # frameworks. In later release we should hopefully be able to pass
1455 # the -F option to gcc, which specifies a framework lookup path.
1458 join(F
, fw
+ '.framework', H
)
1459 for fw
in 'Tcl', 'Tk'
1460 for H
in 'Headers', 'Versions/Current/PrivateHeaders'
1463 # For 8.4a2, the X11 headers are not included. Rather than include a
1464 # complicated search, this is a hard-coded path. It could bail out
1465 # if X11 libs are not found...
1466 include_dirs
.append('/usr/X11R6/include')
1467 frameworks
= ['-framework', 'Tcl', '-framework', 'Tk']
1469 # All existing framework builds of Tcl/Tk don't support 64-bit
1471 cflags
= sysconfig
.get_config_vars('CFLAGS')[0]
1472 archs
= re
.findall('-arch\s+(\w+)', cflags
)
1473 if 'x86_64' in archs
or 'ppc64' in archs
:
1475 archs
.remove('x86_64')
1479 archs
.remove('ppc64')
1484 frameworks
.append('-arch')
1485 frameworks
.append(a
)
1487 ext
= Extension('_tkinter', ['_tkinter.c', 'tkappinit.c'],
1488 define_macros
=[('WITH_APPINIT', 1)],
1489 include_dirs
= include_dirs
,
1491 extra_compile_args
= frameworks
[2:],
1492 extra_link_args
= frameworks
,
1494 self
.extensions
.append(ext
)
1498 def detect_tkinter(self
, inc_dirs
, lib_dirs
):
1499 # The _tkinter module.
1501 # Rather than complicate the code below, detecting and building
1502 # AquaTk is a separate method. Only one Tkinter will be built on
1503 # Darwin - either AquaTk, if it is found, or X11 based Tk.
1504 platform
= self
.get_platform()
1505 if (platform
== 'darwin' and
1506 self
.detect_tkinter_darwin(inc_dirs
, lib_dirs
)):
1509 # Assume we haven't found any of the libraries or include files
1510 # The versions with dots are used on Unix, and the versions without
1511 # dots on Windows, for detection by cygwin.
1512 tcllib
= tklib
= tcl_includes
= tk_includes
= None
1513 for version
in ['8.5', '85', '8.4', '84', '8.3', '83', '8.2',
1514 '82', '8.1', '81', '8.0', '80']:
1515 tklib
= self
.compiler
.find_library_file(lib_dirs
, 'tk' + version
)
1516 tcllib
= self
.compiler
.find_library_file(lib_dirs
, 'tcl' + version
)
1517 if tklib
and tcllib
:
1518 # Exit the loop when we've found the Tcl/Tk libraries
1521 # Now check for the header files
1522 if tklib
and tcllib
:
1523 # Check for the include files on Debian and {Free,Open}BSD, where
1524 # they're put in /usr/include/{tcl,tk}X.Y
1525 dotversion
= version
1526 if '.' not in dotversion
and "bsd" in sys
.platform
.lower():
1527 # OpenBSD and FreeBSD use Tcl/Tk library names like libtcl83.a,
1528 # but the include subdirs are named like .../include/tcl8.3.
1529 dotversion
= dotversion
[:-1] + '.' + dotversion
[-1]
1530 tcl_include_sub
= []
1532 for dir in inc_dirs
:
1533 tcl_include_sub
+= [dir + os
.sep
+ "tcl" + dotversion
]
1534 tk_include_sub
+= [dir + os
.sep
+ "tk" + dotversion
]
1535 tk_include_sub
+= tcl_include_sub
1536 tcl_includes
= find_file('tcl.h', inc_dirs
, tcl_include_sub
)
1537 tk_includes
= find_file('tk.h', inc_dirs
, tk_include_sub
)
1539 if (tcllib
is None or tklib
is None or
1540 tcl_includes
is None or tk_includes
is None):
1541 self
.announce("INFO: Can't locate Tcl/Tk libs and/or headers", 2)
1544 # OK... everything seems to be present for Tcl/Tk.
1546 include_dirs
= [] ; libs
= [] ; defs
= [] ; added_lib_dirs
= []
1547 for dir in tcl_includes
+ tk_includes
:
1548 if dir not in include_dirs
:
1549 include_dirs
.append(dir)
1551 # Check for various platform-specific directories
1552 if platform
== 'sunos5':
1553 include_dirs
.append('/usr/openwin/include')
1554 added_lib_dirs
.append('/usr/openwin/lib')
1555 elif os
.path
.exists('/usr/X11R6/include'):
1556 include_dirs
.append('/usr/X11R6/include')
1557 added_lib_dirs
.append('/usr/X11R6/lib64')
1558 added_lib_dirs
.append('/usr/X11R6/lib')
1559 elif os
.path
.exists('/usr/X11R5/include'):
1560 include_dirs
.append('/usr/X11R5/include')
1561 added_lib_dirs
.append('/usr/X11R5/lib')
1563 # Assume default location for X11
1564 include_dirs
.append('/usr/X11/include')
1565 added_lib_dirs
.append('/usr/X11/lib')
1567 # If Cygwin, then verify that X is installed before proceeding
1568 if platform
== 'cygwin':
1569 x11_inc
= find_file('X11/Xlib.h', [], include_dirs
)
1573 # Check for BLT extension
1574 if self
.compiler
.find_library_file(lib_dirs
+ added_lib_dirs
,
1576 defs
.append( ('WITH_BLT', 1) )
1577 libs
.append('BLT8.0')
1578 elif self
.compiler
.find_library_file(lib_dirs
+ added_lib_dirs
,
1580 defs
.append( ('WITH_BLT', 1) )
1583 # Add the Tcl/Tk libraries
1584 libs
.append('tk'+ version
)
1585 libs
.append('tcl'+ version
)
1587 if platform
in ['aix3', 'aix4']:
1590 # Finally, link with the X11 libraries (not appropriate on cygwin)
1591 if platform
!= "cygwin":
1594 ext
= Extension('_tkinter', ['_tkinter.c', 'tkappinit.c'],
1595 define_macros
=[('WITH_APPINIT', 1)] + defs
,
1596 include_dirs
= include_dirs
,
1598 library_dirs
= added_lib_dirs
,
1600 self
.extensions
.append(ext
)
1602 ## # Uncomment these lines if you want to play with xxmodule.c
1603 ## ext = Extension('xx', ['xxmodule.c'])
1604 ## self.extensions.append(ext)
1606 # XXX handle these, but how to detect?
1607 # *** Uncomment and edit for PIL (TkImaging) extension only:
1608 # -DWITH_PIL -I../Extensions/Imaging/libImaging tkImaging.c \
1609 # *** Uncomment and edit for TOGL extension only:
1610 # -DWITH_TOGL togl.c \
1611 # *** Uncomment these for TOGL extension only:
1612 # -lGL -lGLU -lXext -lXmu \
1614 def configure_ctypes_darwin(self
, ext
):
1615 # Darwin (OS X) uses preconfigured files, in
1616 # the Modules/_ctypes/libffi_osx directory.
1617 (srcdir
,) = sysconfig
.get_config_vars('srcdir')
1618 ffi_srcdir
= os
.path
.abspath(os
.path
.join(srcdir
, 'Modules',
1619 '_ctypes', 'libffi_osx'))
1620 sources
= [os
.path
.join(ffi_srcdir
, p
)
1624 'x86/x86-ffi_darwin.c',
1626 'powerpc/ppc-darwin.S',
1627 'powerpc/ppc-darwin_closure.S',
1628 'powerpc/ppc-ffi_darwin.c',
1629 'powerpc/ppc64-darwin_closure.S',
1632 # Add .S (preprocessed assembly) to C compiler source extensions.
1633 self
.compiler
.src_extensions
.append('.S')
1635 include_dirs
= [os
.path
.join(ffi_srcdir
, 'include'),
1636 os
.path
.join(ffi_srcdir
, 'powerpc')]
1637 ext
.include_dirs
.extend(include_dirs
)
1638 ext
.sources
.extend(sources
)
1641 def configure_ctypes(self
, ext
):
1642 if not self
.use_system_libffi
:
1643 if sys
.platform
== 'darwin':
1644 return self
.configure_ctypes_darwin(ext
)
1646 (srcdir
,) = sysconfig
.get_config_vars('srcdir')
1647 ffi_builddir
= os
.path
.join(self
.build_temp
, 'libffi')
1648 ffi_srcdir
= os
.path
.abspath(os
.path
.join(srcdir
, 'Modules',
1649 '_ctypes', 'libffi'))
1650 ffi_configfile
= os
.path
.join(ffi_builddir
, 'fficonfig.py')
1652 from distutils
.dep_util
import newer_group
1654 config_sources
= [os
.path
.join(ffi_srcdir
, fname
)
1655 for fname
in os
.listdir(ffi_srcdir
)
1656 if os
.path
.isfile(os
.path
.join(ffi_srcdir
, fname
))]
1657 if self
.force
or newer_group(config_sources
,
1659 from distutils
.dir_util
import mkpath
1660 mkpath(ffi_builddir
)
1663 # Pass empty CFLAGS because we'll just append the resulting
1664 # CFLAGS to Python's; -g or -O2 is to be avoided.
1665 cmd
= "cd %s && env CFLAGS='' '%s/configure' %s" \
1666 % (ffi_builddir
, ffi_srcdir
, " ".join(config_args
))
1668 res
= os
.system(cmd
)
1669 if res
or not os
.path
.exists(ffi_configfile
):
1670 print "Failed to configure _ctypes module"
1674 execfile(ffi_configfile
, globals(), fficonfig
)
1675 ffi_srcdir
= os
.path
.join(fficonfig
['ffi_srcdir'], 'src')
1677 # Add .S (preprocessed assembly) to C compiler source extensions.
1678 self
.compiler
.src_extensions
.append('.S')
1680 include_dirs
= [os
.path
.join(ffi_builddir
, 'include'),
1681 ffi_builddir
, ffi_srcdir
]
1682 extra_compile_args
= fficonfig
['ffi_cflags'].split()
1684 ext
.sources
.extend(fficonfig
['ffi_sources'])
1685 ext
.include_dirs
.extend(include_dirs
)
1686 ext
.extra_compile_args
.extend(extra_compile_args
)
1689 def detect_ctypes(self
, inc_dirs
, lib_dirs
):
1690 self
.use_system_libffi
= False
1692 extra_compile_args
= []
1693 extra_link_args
= []
1694 sources
= ['_ctypes/_ctypes.c',
1695 '_ctypes/callbacks.c',
1696 '_ctypes/callproc.c',
1697 '_ctypes/stgdict.c',
1699 '_ctypes/malloc_closure.c']
1700 depends
= ['_ctypes/ctypes.h']
1702 if sys
.platform
== 'darwin':
1703 sources
.append('_ctypes/darwin/dlfcn_simple.c')
1704 extra_compile_args
.append('-DMACOSX')
1705 include_dirs
.append('_ctypes/darwin')
1706 # XXX Is this still needed?
1707 ## extra_link_args.extend(['-read_only_relocs', 'warning'])
1709 elif sys
.platform
== 'sunos5':
1710 # XXX This shouldn't be necessary; it appears that some
1711 # of the assembler code is non-PIC (i.e. it has relocations
1712 # when it shouldn't. The proper fix would be to rewrite
1713 # the assembler code to be PIC.
1714 # This only works with GCC; the Sun compiler likely refuses
1715 # this option. If you want to compile ctypes with the Sun
1716 # compiler, please research a proper solution, instead of
1717 # finding some -z option for the Sun compiler.
1718 extra_link_args
.append('-mimpure-text')
1720 elif sys
.platform
.startswith('hp-ux'):
1721 extra_link_args
.append('-fPIC')
1723 ext
= Extension('_ctypes',
1724 include_dirs
=include_dirs
,
1725 extra_compile_args
=extra_compile_args
,
1726 extra_link_args
=extra_link_args
,
1730 ext_test
= Extension('_ctypes_test',
1731 sources
=['_ctypes/_ctypes_test.c'])
1732 self
.extensions
.extend([ext
, ext_test
])
1734 if not '--with-system-ffi' in sysconfig
.get_config_var("CONFIG_ARGS"):
1737 if sys
.platform
== 'darwin':
1738 # OS X 10.5 comes with libffi.dylib; the include files are
1739 # in /usr/include/ffi
1740 inc_dirs
.append('/usr/include/ffi')
1742 ffi_inc
= find_file('ffi.h', [], inc_dirs
)
1743 if ffi_inc
is not None:
1744 ffi_h
= ffi_inc
[0] + '/ffi.h'
1747 line
= fp
.readline()
1751 if line
.startswith('#define LIBFFI_H'):
1754 if ffi_inc
is not None:
1755 for lib_name
in ('ffi_convenience', 'ffi_pic', 'ffi'):
1756 if (self
.compiler
.find_library_file(lib_dirs
, lib_name
)):
1760 if ffi_inc
and ffi_lib
:
1761 ext
.include_dirs
.extend(ffi_inc
)
1762 ext
.libraries
.append(ffi_lib
)
1763 self
.use_system_libffi
= True
1766 class PyBuildInstall(install
):
1767 # Suppress the warning about installation into the lib_dynload
1768 # directory, which is not in sys.path when running Python during
1770 def initialize_options (self
):
1771 install
.initialize_options(self
)
1774 class PyBuildInstallLib(install_lib
):
1775 # Do exactly what install_lib does but make sure correct access modes get
1776 # set on installed directories and files. All installed files with get
1777 # mode 644 unless they are a shared library in which case they will get
1778 # mode 755. All installed directories will get mode 755.
1780 so_ext
= sysconfig
.get_config_var("SO")
1783 outfiles
= install_lib
.install(self
)
1784 self
.set_file_modes(outfiles
, 0644, 0755)
1785 self
.set_dir_modes(self
.install_dir
, 0755)
1788 def set_file_modes(self
, files
, defaultMode
, sharedLibMode
):
1789 if not self
.is_chmod_supported(): return
1790 if not files
: return
1792 for filename
in files
:
1793 if os
.path
.islink(filename
): continue
1795 if filename
.endswith(self
.so_ext
): mode
= sharedLibMode
1796 log
.info("changing mode of %s to %o", filename
, mode
)
1797 if not self
.dry_run
: os
.chmod(filename
, mode
)
1799 def set_dir_modes(self
, dirname
, mode
):
1800 if not self
.is_chmod_supported(): return
1801 os
.path
.walk(dirname
, self
.set_dir_modes_visitor
, mode
)
1803 def set_dir_modes_visitor(self
, mode
, dirname
, names
):
1804 if os
.path
.islink(dirname
): return
1805 log
.info("changing mode of %s to %o", dirname
, mode
)
1806 if not self
.dry_run
: os
.chmod(dirname
, mode
)
1808 def is_chmod_supported(self
):
1809 return hasattr(os
, 'chmod')
1812 Python is an interpreted, interactive, object-oriented programming
1813 language. It is often compared to Tcl, Perl, Scheme or Java.
1815 Python combines remarkable power with very clear syntax. It has
1816 modules, classes, exceptions, very high level dynamic data types, and
1817 dynamic typing. There are interfaces to many system calls and
1818 libraries, as well as to various windowing systems (X11, Motif, Tk,
1819 Mac, MFC). New built-in modules are easily written in C or C++. Python
1820 is also usable as an extension language for applications that need a
1821 programmable interface.
1823 The Python implementation is portable: it runs on many brands of UNIX,
1824 on Windows, DOS, OS/2, Mac, Amiga... If your favorite system isn't
1825 listed here, it may still be supported, if there's a C compiler for
1826 it. Ask around on comp.lang.python -- or just try compiling Python
1831 Development Status :: 3 - Alpha
1832 Development Status :: 6 - Mature
1833 License :: OSI Approved :: Python Software Foundation License
1834 Natural Language :: English
1835 Programming Language :: C
1836 Programming Language :: Python
1837 Topic :: Software Development
1841 # turn off warnings when deprecated modules are imported
1843 warnings
.filterwarnings("ignore",category
=DeprecationWarning)
1844 setup(# PyPI Metadata (PEP 301)
1846 version
= sys
.version
.split()[0],
1847 url
= "http://www.python.org/%s" % sys
.version
[:3],
1848 maintainer
= "Guido van Rossum and the Python community",
1849 maintainer_email
= "python-dev@python.org",
1850 description
= "A high-level object-oriented programming language",
1851 long_description
= SUMMARY
.strip(),
1852 license
= "PSF license",
1853 classifiers
= filter(None, CLASSIFIERS
.split("\n")),
1854 platforms
= ["Many"],
1857 cmdclass
= {'build_ext':PyBuildExt
, 'install':PyBuildInstall
,
1858 'install_lib':PyBuildInstallLib
},
1859 # The struct module is defined here, because build_ext won't be
1860 # called unless there's at least one extension module defined.
1861 ext_modules
=[Extension('_struct', ['_struct.c'])],
1863 # Scripts to install
1864 scripts
= ['Tools/scripts/pydoc', 'Tools/scripts/idle',
1865 'Tools/scripts/2to3',
1870 if __name__
== '__main__':