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 # Were we compiled --with-pydebug or with #define Py_DEBUG?
20 COMPILED_WITH_PYDEBUG
= hasattr(sys
, 'gettotalrefcount')
22 # This global variable is used to hold the list of modules to be disabled.
23 disabled_module_list
= []
25 def add_dir_to_list(dirlist
, dir):
26 """Add the directory 'dir' to the list 'dirlist' (at the front) if
27 1) 'dir' is not already in 'dirlist'
28 2) 'dir' actually exists, and is a directory."""
29 if dir is not None and os
.path
.isdir(dir) and dir not in dirlist
:
30 dirlist
.insert(0, dir)
32 def find_file(filename
, std_dirs
, paths
):
33 """Searches for the directory where a given file is located,
34 and returns a possibly-empty list of additional directories, or None
35 if the file couldn't be found at all.
37 'filename' is the name of a file, such as readline.h or libcrypto.a.
38 'std_dirs' is the list of standard system directories; if the
39 file is found in one of them, no additional directives are needed.
40 'paths' is a list of additional locations to check; if the file is
41 found in one of them, the resulting list will contain the directory.
44 # Check the standard locations
46 f
= os
.path
.join(dir, filename
)
47 if os
.path
.exists(f
): return []
49 # Check the additional directories
51 f
= os
.path
.join(dir, filename
)
58 def find_library_file(compiler
, libname
, std_dirs
, paths
):
59 result
= compiler
.find_library_file(std_dirs
+ paths
, libname
)
63 # Check whether the found file is in one of the standard directories
64 dirname
= os
.path
.dirname(result
)
66 # Ensure path doesn't end with path separator
71 # Otherwise, it must have been in one of the additional directories,
72 # so we have to figure out which one.
74 # Ensure path doesn't end with path separator
79 assert False, "Internal error: Path not found in std_dirs or paths"
81 def module_enabled(extlist
, modname
):
82 """Returns whether the module 'modname' is present in the list
83 of extensions 'extlist'."""
84 extlist
= [ext
for ext
in extlist
if ext
.name
== modname
]
87 def find_module_file(module
, dirlist
):
88 """Find a module in a set of possible folders. If it is not found
89 return the unadorned filename"""
90 list = find_file(module
, [], dirlist
)
94 log
.info("WARNING: multiple copies of %s found"%module
)
95 return os
.path
.join(list[0], module
)
97 class PyBuildExt(build_ext
):
99 def __init__(self
, dist
):
100 build_ext
.__init
__(self
, dist
)
103 def build_extensions(self
):
105 # Detect which modules should be compiled
106 missing
= self
.detect_modules()
108 # Remove modules that are present on the disabled list
109 extensions
= [ext
for ext
in self
.extensions
110 if ext
.name
not in disabled_module_list
]
111 # move ctypes to the end, it depends on other modules
112 ext_map
= dict((ext
.name
, i
) for i
, ext
in enumerate(extensions
))
113 if "_ctypes" in ext_map
:
114 ctypes
= extensions
.pop(ext_map
["_ctypes"])
115 extensions
.append(ctypes
)
116 self
.extensions
= extensions
118 # Fix up the autodetected modules, prefixing all the source files
119 # with Modules/ and adding Python's include directory to the path.
120 (srcdir
,) = sysconfig
.get_config_vars('srcdir')
122 # Maybe running on Windows but not using CYGWIN?
123 raise ValueError("No source directory; cannot proceed.")
124 srcdir
= os
.path
.abspath(srcdir
)
125 moddirlist
= [os
.path
.join(srcdir
, 'Modules')]
127 # Platform-dependent module source and include directories
129 platform
= self
.get_platform()
130 if platform
in ('darwin', 'mac') and ("--disable-toolbox-glue" not in
131 sysconfig
.get_config_var("CONFIG_ARGS")):
132 # Mac OS X also includes some mac-specific modules
133 macmoddir
= os
.path
.join(srcdir
, 'Mac/Modules')
134 moddirlist
.append(macmoddir
)
135 incdirlist
.append(os
.path
.join(srcdir
, 'Mac/Include'))
137 # Fix up the paths for scripts, too
138 self
.distribution
.scripts
= [os
.path
.join(srcdir
, filename
)
139 for filename
in self
.distribution
.scripts
]
141 # Python header files
142 headers
= [sysconfig
.get_config_h_filename()]
143 headers
+= glob(os
.path
.join(sysconfig
.get_python_inc(), "*.h"))
144 for ext
in self
.extensions
[:]:
145 ext
.sources
= [ find_module_file(filename
, moddirlist
)
146 for filename
in ext
.sources
]
147 if ext
.depends
is not None:
148 ext
.depends
= [find_module_file(filename
, moddirlist
)
149 for filename
in ext
.depends
]
152 # re-compile extensions if a header file has been changed
153 ext
.depends
.extend(headers
)
155 # platform specific include directories
156 ext
.include_dirs
.extend(incdirlist
)
158 # If a module has already been built statically,
159 # don't build it here
160 if ext
.name
in sys
.builtin_module_names
:
161 self
.extensions
.remove(ext
)
163 if platform
!= 'mac':
164 # Parse Modules/Setup and Modules/Setup.local to figure out which
165 # modules are turned on in the file.
167 for filename
in ('Modules/Setup', 'Modules/Setup.local'):
168 input = text_file
.TextFile(filename
, join_lines
=1)
170 line
= input.readline()
173 remove_modules
.append(line
[0])
176 for ext
in self
.extensions
[:]:
177 if ext
.name
in remove_modules
:
178 self
.extensions
.remove(ext
)
180 # When you run "make CC=altcc" or something similar, you really want
181 # those environment variables passed into the setup.py phase. Here's
182 # a small set of useful ones.
183 compiler
= os
.environ
.get('CC')
185 # unfortunately, distutils doesn't let us provide separate C and C++
187 if compiler
is not None:
188 (ccshared
,cflags
) = sysconfig
.get_config_vars('CCSHARED','CFLAGS')
189 args
['compiler_so'] = compiler
+ ' ' + ccshared
+ ' ' + cflags
190 self
.compiler_obj
.set_executables(**args
)
192 build_ext
.build_extensions(self
)
194 longest
= max([len(e
.name
) for e
in self
.extensions
])
196 longest
= max(longest
, max([len(name
) for name
in self
.failed
]))
198 def print_three_column(lst
):
199 lst
.sort(key
=str.lower
)
200 # guarantee zip() doesn't drop anything
203 for e
, f
, g
in zip(lst
[::3], lst
[1::3], lst
[2::3]):
204 print "%-*s %-*s %-*s" % (longest
, e
, longest
, f
,
209 print ("Python build finished, but the necessary bits to build "
210 "these modules were not found:")
211 print_three_column(missing
)
212 print ("To find the necessary bits, look in setup.py in"
213 " detect_modules() for the module's name.")
217 failed
= self
.failed
[:]
219 print "Failed to build these modules:"
220 print_three_column(failed
)
223 def build_extension(self
, ext
):
225 if ext
.name
== '_ctypes':
226 if not self
.configure_ctypes(ext
):
230 build_ext
.build_extension(self
, ext
)
231 except (CCompilerError
, DistutilsError
), why
:
232 self
.announce('WARNING: building of extension "%s" failed: %s' %
233 (ext
.name
, sys
.exc_info()[1]))
234 self
.failed
.append(ext
.name
)
236 # Workaround for Mac OS X: The Carbon-based modules cannot be
237 # reliably imported into a command-line Python
238 if 'Carbon' in ext
.extra_link_args
:
240 'WARNING: skipping import check for Carbon-based "%s"' %
244 if self
.get_platform() == 'darwin' and (
245 sys
.maxint
> 2**32 and '-arch' in ext
.extra_link_args
):
246 # Don't bother doing an import check when an extension was
247 # build with an explicit '-arch' flag on OSX. That's currently
248 # only used to build 32-bit only extensions in a 4-way
249 # universal build and loading 32-bit code into a 64-bit
252 'WARNING: skipping import check for "%s"' %
256 # Workaround for Cygwin: Cygwin currently has fork issues when many
257 # modules have been imported
258 if self
.get_platform() == 'cygwin':
259 self
.announce('WARNING: skipping import check for Cygwin-based "%s"'
262 ext_filename
= os
.path
.join(
264 self
.get_ext_filename(self
.get_ext_fullname(ext
.name
)))
266 imp
.load_dynamic(ext
.name
, ext_filename
)
267 except ImportError, why
:
268 self
.failed
.append(ext
.name
)
269 self
.announce('*** WARNING: renaming "%s" since importing it'
270 ' failed: %s' % (ext
.name
, why
), level
=3)
271 assert not self
.inplace
272 basename
, tail
= os
.path
.splitext(ext_filename
)
273 newname
= basename
+ "_failed" + tail
274 if os
.path
.exists(newname
):
276 os
.rename(ext_filename
, newname
)
278 # XXX -- This relies on a Vile HACK in
279 # distutils.command.build_ext.build_extension(). The
280 # _built_objects attribute is stored there strictly for
282 # If there is a failure, _built_objects may not be there,
283 # so catch the AttributeError and move on.
285 for filename
in self
._built
_objects
:
287 except AttributeError:
288 self
.announce('unable to remove files (ignored)')
290 exc_type
, why
, tb
= sys
.exc_info()
291 self
.announce('*** WARNING: importing extension "%s" '
292 'failed with %s: %s' % (ext
.name
, exc_type
, why
),
294 self
.failed
.append(ext
.name
)
296 def get_platform(self
):
297 # Get value of sys.platform
298 for platform
in ['cygwin', 'beos', 'darwin', 'atheos', 'osf1']:
299 if sys
.platform
.startswith(platform
):
303 def detect_modules(self
):
304 # Ensure that /usr/local is always used
305 add_dir_to_list(self
.compiler_obj
.library_dirs
, '/usr/local/lib')
306 add_dir_to_list(self
.compiler_obj
.include_dirs
, '/usr/local/include')
308 # Add paths specified in the environment variables LDFLAGS and
309 # CPPFLAGS for header and library files.
310 # We must get the values from the Makefile and not the environment
311 # directly since an inconsistently reproducible issue comes up where
312 # the environment variable is not set even though the value were passed
313 # into configure and stored in the Makefile (issue found on OS X 10.3).
314 for env_var
, arg_name
, dir_list
in (
315 ('LDFLAGS', '-R', self
.compiler_obj
.runtime_library_dirs
),
316 ('LDFLAGS', '-L', self
.compiler_obj
.library_dirs
),
317 ('CPPFLAGS', '-I', self
.compiler_obj
.include_dirs
)):
318 env_val
= sysconfig
.get_config_var(env_var
)
320 # To prevent optparse from raising an exception about any
321 # options in env_val that it doesn't know about we strip out
322 # all double dashes and any dashes followed by a character
323 # that is not for the option we are dealing with.
325 # Please note that order of the regex is important! We must
326 # strip out double-dashes first so that we don't end up with
327 # substituting "--Long" to "-Long" and thus lead to "ong" being
328 # used for a library directory.
329 env_val
= re
.sub(r
'(^|\s+)-(-|(?!%s))' % arg_name
[1],
331 parser
= optparse
.OptionParser()
332 # Make sure that allowing args interspersed with options is
334 parser
.allow_interspersed_args
= True
335 parser
.error
= lambda msg
: None
336 parser
.add_option(arg_name
, dest
="dirs", action
="append")
337 options
= parser
.parse_args(env_val
.split())[0]
339 for directory
in reversed(options
.dirs
):
340 add_dir_to_list(dir_list
, directory
)
342 if os
.path
.normpath(sys
.prefix
) != '/usr':
343 add_dir_to_list(self
.compiler_obj
.library_dirs
,
344 sysconfig
.get_config_var("LIBDIR"))
345 add_dir_to_list(self
.compiler_obj
.include_dirs
,
346 sysconfig
.get_config_var("INCLUDEDIR"))
349 have_unicode
= unicode
353 # lib_dirs and inc_dirs are used to search for files;
354 # if a file is found in one of those directories, it can
355 # be assumed that no additional -I,-L directives are needed.
356 lib_dirs
= self
.compiler_obj
.library_dirs
+ [
357 '/lib64', '/usr/lib64',
360 inc_dirs
= self
.compiler_obj
.include_dirs
+ ['/usr/include']
364 config_h
= sysconfig
.get_config_h_filename()
365 config_h_vars
= sysconfig
.parse_config_h(open(config_h
))
367 platform
= self
.get_platform()
368 srcdir
= sysconfig
.get_config_var('srcdir')
370 # Check for AtheOS which has libraries in non-standard locations
371 if platform
== 'atheos':
372 lib_dirs
+= ['/system/libs', '/atheos/autolnk/lib']
373 lib_dirs
+= os
.getenv('LIBRARY_PATH', '').split(os
.pathsep
)
374 inc_dirs
+= ['/system/include', '/atheos/autolnk/include']
375 inc_dirs
+= os
.getenv('C_INCLUDE_PATH', '').split(os
.pathsep
)
377 # OSF/1 and Unixware have some stuff in /usr/ccs/lib (like -ldb)
378 if platform
in ['osf1', 'unixware7', 'openunix8']:
379 lib_dirs
+= ['/usr/ccs/lib']
381 if platform
== 'darwin':
382 # This should work on any unixy platform ;-)
383 # If the user has bothered specifying additional -I and -L flags
384 # in OPT and LDFLAGS we might as well use them here.
385 # NOTE: using shlex.split would technically be more correct, but
386 # also gives a bootstrap problem. Let's hope nobody uses directories
387 # with whitespace in the name to store libraries.
388 cflags
, ldflags
= sysconfig
.get_config_vars(
390 for item
in cflags
.split():
391 if item
.startswith('-I'):
392 inc_dirs
.append(item
[2:])
394 for item
in ldflags
.split():
395 if item
.startswith('-L'):
396 lib_dirs
.append(item
[2:])
398 # Check for MacOS X, which doesn't need libm.a at all
400 if platform
in ['darwin', 'beos', 'mac']:
403 # XXX Omitted modules: gl, pure, dl, SGI-specific modules
406 # The following modules are all pretty straightforward, and compile
407 # on pretty much any POSIXish platform.
410 # Some modules that are normally always on:
411 exts
.append( Extension('_weakref', ['_weakref.c']) )
414 exts
.append( Extension('array', ['arraymodule.c']) )
415 # complex math library functions
416 exts
.append( Extension('cmath', ['cmathmodule.c', '_math.c'],
418 libraries
=math_libs
) )
419 # math library functions, e.g. sin()
420 exts
.append( Extension('math', ['mathmodule.c', '_math.c'],
422 libraries
=math_libs
) )
423 # fast string operations implemented in C
424 exts
.append( Extension('strop', ['stropmodule.c']) )
425 # time operations and variables
426 exts
.append( Extension('time', ['timemodule.c'],
427 libraries
=math_libs
) )
428 exts
.append( Extension('datetime', ['datetimemodule.c', 'timemodule.c'],
429 libraries
=math_libs
) )
430 # fast iterator tools implemented in C
431 exts
.append( Extension("itertools", ["itertoolsmodule.c"]) )
432 # code that will be builtins in the future, but conflict with the
434 exts
.append( Extension('future_builtins', ['future_builtins.c']) )
435 # random number generator implemented in C
436 exts
.append( Extension("_random", ["_randommodule.c"]) )
437 # high-performance collections
438 exts
.append( Extension("_collections", ["_collectionsmodule.c"]) )
440 exts
.append( Extension("_bisect", ["_bisectmodule.c"]) )
442 exts
.append( Extension("_heapq", ["_heapqmodule.c"]) )
443 # operator.add() and similar goodies
444 exts
.append( Extension('operator', ['operator.c']) )
445 # Python 3.1 _io library
446 exts
.append( Extension("_io",
447 ["_io/bufferedio.c", "_io/bytesio.c", "_io/fileio.c",
448 "_io/iobase.c", "_io/_iomodule.c", "_io/stringio.c", "_io/textio.c"],
449 depends
=["_io/_iomodule.h"], include_dirs
=["Modules/_io"]))
451 exts
.append( Extension("_functools", ["_functoolsmodule.c"]) )
453 exts
.append( Extension("_json", ["_json.c"]) )
454 # Python C API test module
455 exts
.append( Extension('_testcapi', ['_testcapimodule.c'],
456 depends
=['testcapi_long.h']) )
457 # profilers (_lsprof is for cProfile.py)
458 exts
.append( Extension('_hotshot', ['_hotshot.c']) )
459 exts
.append( Extension('_lsprof', ['_lsprof.c', 'rotatingtree.c']) )
460 # static Unicode character database
462 exts
.append( Extension('unicodedata', ['unicodedata.c']) )
464 missing
.append('unicodedata')
465 # access to ISO C locale support
466 data
= open('pyconfig.h').read()
467 m
= re
.search(r
"#s*define\s+WITH_LIBINTL\s+1\s*", data
)
469 locale_libs
= ['intl']
472 if platform
== 'darwin':
473 locale_extra_link_args
= ['-framework', 'CoreFoundation']
475 locale_extra_link_args
= []
478 exts
.append( Extension('_locale', ['_localemodule.c'],
479 libraries
=locale_libs
,
480 extra_link_args
=locale_extra_link_args
) )
482 # Modules with some UNIX dependencies -- on by default:
483 # (If you have a really backward UNIX, select and socket may not be
486 # fcntl(2) and ioctl(2)
487 exts
.append( Extension('fcntl', ['fcntlmodule.c']) )
488 if platform
not in ['mac']:
490 exts
.append( Extension('pwd', ['pwdmodule.c']) )
492 exts
.append( Extension('grp', ['grpmodule.c']) )
493 # spwd, shadow passwords
494 if (config_h_vars
.get('HAVE_GETSPNAM', False) or
495 config_h_vars
.get('HAVE_GETSPENT', False)):
496 exts
.append( Extension('spwd', ['spwdmodule.c']) )
498 missing
.append('spwd')
500 missing
.extend(['pwd', 'grp', 'spwd'])
502 # select(2); not on ancient System V
503 exts
.append( Extension('select', ['selectmodule.c']) )
505 # Fred Drake's interface to the Python parser
506 exts
.append( Extension('parser', ['parsermodule.c']) )
508 # cStringIO and cPickle
509 exts
.append( Extension('cStringIO', ['cStringIO.c']) )
510 exts
.append( Extension('cPickle', ['cPickle.c']) )
512 # Memory-mapped files (also works on Win32).
513 if platform
not in ['atheos', 'mac']:
514 exts
.append( Extension('mmap', ['mmapmodule.c']) )
516 missing
.append('mmap')
518 # Lance Ellinghaus's syslog module
519 if platform
not in ['mac']:
520 # syslog daemon interface
521 exts
.append( Extension('syslog', ['syslogmodule.c']) )
523 missing
.append('syslog')
525 # George Neville-Neil's timing module:
526 # Deprecated in PEP 4 http://www.python.org/peps/pep-0004.html
527 # http://mail.python.org/pipermail/python-dev/2006-January/060023.html
528 #exts.append( Extension('timing', ['timingmodule.c']) )
531 # Here ends the simple stuff. From here on, modules need certain
532 # libraries, are platform-specific, or present other surprises.
536 # These don't work for 64-bit platforms!!!
537 # These represent audio samples or images as strings:
539 # Operations on audio samples
540 # According to #993173, this one should actually work fine on
542 exts
.append( Extension('audioop', ['audioop.c']) )
544 # Disabled on 64-bit platforms
545 if sys
.maxint
!= 9223372036854775807L:
546 # Operations on images
547 exts
.append( Extension('imageop', ['imageop.c']) )
549 missing
.extend(['imageop'])
552 do_readline
= self
.compiler_obj
.find_library_file(lib_dirs
, 'readline')
553 if platform
== 'darwin':
554 os_release
= int(os
.uname()[2].split('.')[0])
556 # MacOSX 10.4 has a broken readline. Don't try to build
557 # the readline module unless the user has installed a fixed
559 if find_file('readline/rlconf.h', inc_dirs
, []) is None:
562 if platform
== 'darwin' and os_release
< 9:
563 # In every directory on the search path search for a dynamic
564 # library and then a static library, instead of first looking
565 # for dynamic libraries on the entiry path.
566 # This way a staticly linked custom readline gets picked up
567 # before the (broken) dynamic library in /usr/lib.
568 readline_extra_link_args
= ('-Wl,-search_paths_first',)
570 readline_extra_link_args
= ()
572 readline_libs
= ['readline']
573 if self
.compiler_obj
.find_library_file(lib_dirs
,
575 readline_libs
.append('ncursesw')
576 elif self
.compiler_obj
.find_library_file(lib_dirs
,
578 readline_libs
.append('ncurses')
579 elif self
.compiler_obj
.find_library_file(lib_dirs
, 'curses'):
580 readline_libs
.append('curses')
581 elif self
.compiler_obj
.find_library_file(lib_dirs
+
582 ['/usr/lib/termcap'],
584 readline_libs
.append('termcap')
585 exts
.append( Extension('readline', ['readline.c'],
586 library_dirs
=['/usr/lib/termcap'],
587 extra_link_args
=readline_extra_link_args
,
588 libraries
=readline_libs
) )
590 missing
.append('readline')
592 if platform
not in ['mac']:
595 if self
.compiler_obj
.find_library_file(lib_dirs
, 'crypt'):
599 exts
.append( Extension('crypt', ['cryptmodule.c'], libraries
=libs
) )
601 missing
.append('crypt')
604 exts
.append( Extension('_csv', ['_csv.c']) )
607 exts
.append( Extension('_socket', ['socketmodule.c'],
608 depends
= ['socketmodule.h']) )
609 # Detect SSL support for the socket module (via _ssl)
610 search_for_ssl_incs_in
= [
611 '/usr/local/ssl/include',
612 '/usr/contrib/ssl/include/'
614 ssl_incs
= find_file('openssl/ssl.h', inc_dirs
,
615 search_for_ssl_incs_in
617 if ssl_incs
is not None:
618 krb5_h
= find_file('krb5.h', inc_dirs
,
619 ['/usr/kerberos/include'])
622 ssl_libs
= find_library_file(self
.compiler_obj
, 'ssl',lib_dirs
,
623 ['/usr/local/ssl/lib',
624 '/usr/contrib/ssl/lib/'
627 if (ssl_incs
is not None and
628 ssl_libs
is not None):
629 exts
.append( Extension('_ssl', ['_ssl.c'],
630 include_dirs
= ssl_incs
,
631 library_dirs
= ssl_libs
,
632 libraries
= ['ssl', 'crypto'],
633 depends
= ['socketmodule.h']), )
635 missing
.append('_ssl')
637 # find out which version of OpenSSL we have
639 openssl_ver_re
= re
.compile(
640 '^\s*#\s*define\s+OPENSSL_VERSION_NUMBER\s+(0x[0-9a-fA-F]+)' )
641 for ssl_inc_dir
in inc_dirs
+ search_for_ssl_incs_in
:
642 name
= os
.path
.join(ssl_inc_dir
, 'openssl', 'opensslv.h')
643 if os
.path
.isfile(name
):
645 incfile
= open(name
, 'r')
647 m
= openssl_ver_re
.match(line
)
649 openssl_ver
= eval(m
.group(1))
654 # first version found is what we'll use (as the compiler should)
658 #print 'openssl_ver = 0x%08x' % openssl_ver
659 min_openssl_ver
= 0x00907000
660 have_any_openssl
= ssl_incs
is not None and ssl_libs
is not None
661 have_usable_openssl
= (have_any_openssl
and
662 openssl_ver
>= min_openssl_ver
)
665 if have_usable_openssl
:
666 # The _hashlib module wraps optimized implementations
667 # of hash functions from the OpenSSL library.
668 exts
.append( Extension('_hashlib', ['_hashopenssl.c'],
669 include_dirs
= ssl_incs
,
670 library_dirs
= ssl_libs
,
671 libraries
= ['ssl', 'crypto']) )
673 print ("warning: openssl 0x%08x is too old for _hashlib" %
675 missing
.append('_hashlib')
676 if COMPILED_WITH_PYDEBUG
or not have_usable_openssl
:
677 # The _sha module implements the SHA1 hash algorithm.
678 exts
.append( Extension('_sha', ['shamodule.c']) )
679 # The _md5 module implements the RSA Data Security, Inc. MD5
680 # Message-Digest Algorithm, described in RFC 1321. The
681 # necessary files md5.c and md5.h are included here.
682 exts
.append( Extension('_md5',
683 sources
= ['md5module.c', 'md5.c'],
684 depends
= ['md5.h']) )
686 min_sha2_openssl_ver
= 0x00908000
687 if COMPILED_WITH_PYDEBUG
or openssl_ver
< min_sha2_openssl_ver
:
688 # OpenSSL doesn't do these until 0.9.8 so we'll bring our own hash
689 exts
.append( Extension('_sha256', ['sha256module.c']) )
690 exts
.append( Extension('_sha512', ['sha512module.c']) )
692 # Modules that provide persistent dictionary-like semantics. You will
693 # probably want to arrange for at least one of them to be available on
694 # your machine, though none are defined by default because of library
695 # dependencies. The Python module anydbm.py provides an
696 # implementation independent wrapper for these; dumbdbm.py provides
697 # similar functionality (but slower of course) implemented in Python.
699 # Sleepycat^WOracle Berkeley DB interface.
700 # http://www.oracle.com/database/berkeley-db/db/index.html
702 # This requires the Sleepycat^WOracle DB code. The supported versions
703 # are set below. Visit the URL above to download
704 # a release. Most open source OSes come with one or more
705 # versions of BerkeleyDB already installed.
709 db_setup_debug
= False # verbose debug prints from this script?
711 def allow_db_ver(db_ver
):
712 """Returns a boolean if the given BerkeleyDB version is acceptable.
715 db_ver: A tuple of the version to verify.
717 if not (min_db_ver
<= db_ver
<= max_db_ver
):
719 # Use this function to filter out known bad configurations.
720 if (4, 6) == db_ver
[:2]:
721 # BerkeleyDB 4.6.x is not stable on many architectures.
722 arch
= platform_machine()
723 if arch
not in ('i386', 'i486', 'i586', 'i686',
728 def gen_db_minor_ver_nums(major
):
730 for x
in range(max_db_ver
[1]+1):
731 if allow_db_ver((4, x
)):
735 if allow_db_ver((3, x
)):
738 raise ValueError("unknown major BerkeleyDB version", major
)
740 # construct a list of paths to look for the header file in on
741 # top of the normal inc_dirs.
744 '/usr/local/include/db4',
745 '/opt/sfw/include/db4',
747 '/usr/local/include/db3',
748 '/opt/sfw/include/db3',
749 # Fink defaults (http://fink.sourceforge.net/)
753 # 4.x minor number specific paths
754 for x
in gen_db_minor_ver_nums(4):
755 db_inc_paths
.append('/usr/include/db4%d' % x
)
756 db_inc_paths
.append('/usr/include/db4.%d' % x
)
757 db_inc_paths
.append('/usr/local/BerkeleyDB.4.%d/include' % x
)
758 db_inc_paths
.append('/usr/local/include/db4%d' % x
)
759 db_inc_paths
.append('/pkg/db-4.%d/include' % x
)
760 db_inc_paths
.append('/opt/db-4.%d/include' % x
)
761 # MacPorts default (http://www.macports.org/)
762 db_inc_paths
.append('/opt/local/include/db4%d' % x
)
763 # 3.x minor number specific paths
764 for x
in gen_db_minor_ver_nums(3):
765 db_inc_paths
.append('/usr/include/db3%d' % x
)
766 db_inc_paths
.append('/usr/local/BerkeleyDB.3.%d/include' % x
)
767 db_inc_paths
.append('/usr/local/include/db3%d' % x
)
768 db_inc_paths
.append('/pkg/db-3.%d/include' % x
)
769 db_inc_paths
.append('/opt/db-3.%d/include' % x
)
771 # Add some common subdirectories for Sleepycat DB to the list,
772 # based on the standard include directories. This way DB3/4 gets
773 # picked up when it is installed in a non-standard prefix and
774 # the user has added that prefix into inc_dirs.
777 std_variants
.append(os
.path
.join(dn
, 'db3'))
778 std_variants
.append(os
.path
.join(dn
, 'db4'))
779 for x
in gen_db_minor_ver_nums(4):
780 std_variants
.append(os
.path
.join(dn
, "db4%d"%x))
781 std_variants
.append(os
.path
.join(dn
, "db4.%d"%x))
782 for x
in gen_db_minor_ver_nums(3):
783 std_variants
.append(os
.path
.join(dn
, "db3%d"%x))
784 std_variants
.append(os
.path
.join(dn
, "db3.%d"%x))
786 db_inc_paths
= std_variants
+ db_inc_paths
787 db_inc_paths
= [p
for p
in db_inc_paths
if os
.path
.exists(p
)]
791 class db_found(Exception): pass
793 # See whether there is a Sleepycat header in the standard
795 for d
in inc_dirs
+ db_inc_paths
:
796 f
= os
.path
.join(d
, "db.h")
797 if db_setup_debug
: print "db: looking for db.h in", f
798 if os
.path
.exists(f
):
800 m
= re
.search(r
"#define\WDB_VERSION_MAJOR\W(\d+)", f
)
802 db_major
= int(m
.group(1))
803 m
= re
.search(r
"#define\WDB_VERSION_MINOR\W(\d+)", f
)
804 db_minor
= int(m
.group(1))
805 db_ver
= (db_major
, db_minor
)
807 # Avoid 4.6 prior to 4.6.21 due to a BerkeleyDB bug
809 m
= re
.search(r
"#define\WDB_VERSION_PATCH\W(\d+)", f
)
810 db_patch
= int(m
.group(1))
812 print "db.h:", db_ver
, "patch", db_patch
,
813 print "being ignored (4.6.x must be >= 4.6.21)"
816 if ( (not db_ver_inc_map
.has_key(db_ver
)) and
817 allow_db_ver(db_ver
) ):
818 # save the include directory with the db.h version
819 # (first occurrence only)
820 db_ver_inc_map
[db_ver
] = d
822 print "db.h: found", db_ver
, "in", d
824 # we already found a header for this library version
825 if db_setup_debug
: print "db.h: ignoring", d
827 # ignore this header, it didn't contain a version number
829 print "db.h: no version number version in", d
831 db_found_vers
= db_ver_inc_map
.keys()
835 db_ver
= db_found_vers
.pop()
836 db_incdir
= db_ver_inc_map
[db_ver
]
838 # check lib directories parallel to the location of the header
840 db_incdir
.replace("include", 'lib64'),
841 db_incdir
.replace("include", 'lib'),
843 db_dirs_to_check
= filter(os
.path
.isdir
, db_dirs_to_check
)
845 # Look for a version specific db-X.Y before an ambiguoius dbX
846 # XXX should we -ever- look for a dbX name? Do any
847 # systems really not name their library by version and
848 # symlink to more general names?
849 for dblib
in (('db-%d.%d' % db_ver
),
851 ('db%d' % db_ver
[0])):
852 dblib_file
= self
.compiler_obj
.find_library_file(
853 db_dirs_to_check
+ lib_dirs
, dblib
)
855 dblib_dir
= [ os
.path
.abspath(os
.path
.dirname(dblib_file
)) ]
858 if db_setup_debug
: print "db lib: ", dblib
, "not found"
862 print "bsddb using BerkeleyDB lib:", db_ver
, dblib
863 print "bsddb lib dir:", dblib_dir
, " inc dir:", db_incdir
864 db_incs
= [db_incdir
]
866 # We add the runtime_library_dirs argument because the
867 # BerkeleyDB lib we're linking against often isn't in the
868 # system dynamic library search path. This is usually
869 # correct and most trouble free, but may cause problems in
870 # some unusual system configurations (e.g. the directory
871 # is on an NFS server that goes away).
872 exts
.append(Extension('_bsddb', ['_bsddb.c'],
873 depends
= ['bsddb.h'],
874 library_dirs
=dblib_dir
,
875 runtime_library_dirs
=dblib_dir
,
876 include_dirs
=db_incs
,
879 if db_setup_debug
: print "db: no appropriate library found"
883 missing
.append('_bsddb')
885 # The sqlite interface
886 sqlite_setup_debug
= False # verbose debug prints from this script?
888 # We hunt for #define SQLITE_VERSION "n.n.n"
889 # We need to find >= sqlite version 3.0.8
890 sqlite_incdir
= sqlite_libdir
= None
891 sqlite_inc_paths
= [ '/usr/include',
892 '/usr/include/sqlite',
893 '/usr/include/sqlite3',
894 '/usr/local/include',
895 '/usr/local/include/sqlite',
896 '/usr/local/include/sqlite3',
898 MIN_SQLITE_VERSION_NUMBER
= (3, 0, 8)
899 MIN_SQLITE_VERSION
= ".".join([str(x
)
900 for x
in MIN_SQLITE_VERSION_NUMBER
])
902 # Scan the default include directories before the SQLite specific
903 # ones. This allows one to override the copy of sqlite on OSX,
904 # where /usr/include contains an old version of sqlite.
905 for d
in inc_dirs
+ sqlite_inc_paths
:
906 f
= os
.path
.join(d
, "sqlite3.h")
907 if os
.path
.exists(f
):
908 if sqlite_setup_debug
: print "sqlite: found %s"%f
909 incf
= open(f
).read()
911 r
'\s*.*#\s*.*define\s.*SQLITE_VERSION\W*"(.*)"', incf
)
913 sqlite_version
= m
.group(1)
914 sqlite_version_tuple
= tuple([int(x
)
915 for x
in sqlite_version
.split(".")])
916 if sqlite_version_tuple
>= MIN_SQLITE_VERSION_NUMBER
:
918 if sqlite_setup_debug
:
919 print "%s/sqlite3.h: version %s"%(d
, sqlite_version
)
923 if sqlite_setup_debug
:
924 print "%s: version %d is too old, need >= %s"%(d
,
925 sqlite_version
, MIN_SQLITE_VERSION
)
926 elif sqlite_setup_debug
:
927 print "sqlite: %s had no SQLITE_VERSION"%(f
,)
930 sqlite_dirs_to_check
= [
931 os
.path
.join(sqlite_incdir
, '..', 'lib64'),
932 os
.path
.join(sqlite_incdir
, '..', 'lib'),
933 os
.path
.join(sqlite_incdir
, '..', '..', 'lib64'),
934 os
.path
.join(sqlite_incdir
, '..', '..', 'lib'),
936 sqlite_libfile
= self
.compiler_obj
.find_library_file(
937 sqlite_dirs_to_check
+ lib_dirs
, 'sqlite3')
939 sqlite_libdir
= [os
.path
.abspath(os
.path
.dirname(sqlite_libfile
))]
941 if sqlite_incdir
and sqlite_libdir
:
942 sqlite_srcs
= ['_sqlite/cache.c',
943 '_sqlite/connection.c',
945 '_sqlite/microprotocols.c',
947 '_sqlite/prepare_protocol.c',
949 '_sqlite/statement.c',
953 if sys
.platform
!= "win32":
954 sqlite_defines
.append(('MODULE_NAME', '"sqlite3"'))
956 sqlite_defines
.append(('MODULE_NAME', '\\"sqlite3\\"'))
959 if sys
.platform
== 'darwin':
960 # In every directory on the search path search for a dynamic
961 # library and then a static library, instead of first looking
962 # for dynamic libraries on the entiry path.
963 # This way a staticly linked custom sqlite gets picked up
964 # before the dynamic library in /usr/lib.
965 sqlite_extra_link_args
= ('-Wl,-search_paths_first',)
967 sqlite_extra_link_args
= ()
969 exts
.append(Extension('_sqlite3', sqlite_srcs
,
970 define_macros
=sqlite_defines
,
971 include_dirs
=["Modules/_sqlite",
973 library_dirs
=sqlite_libdir
,
974 runtime_library_dirs
=sqlite_libdir
,
975 extra_link_args
=sqlite_extra_link_args
,
976 libraries
=["sqlite3",]))
978 missing
.append('_sqlite3')
980 # Look for Berkeley db 1.85. Note that it is built as a different
981 # module name so it can be included even when later versions are
982 # available. A very restrictive search is performed to avoid
983 # accidentally building this module with a later version of the
984 # underlying db library. May BSD-ish Unixes incorporate db 1.85
985 # symbols into libc and place the include file in /usr/include.
987 # If the better bsddb library can be built (db_incs is defined)
988 # we do not build this one. Otherwise this build will pick up
989 # the more recent berkeleydb's db.h file first in the include path
990 # when attempting to compile and it will fail.
991 f
= "/usr/include/db.h"
992 if os
.path
.exists(f
) and not db_incs
:
993 data
= open(f
).read()
994 m
= re
.search(r
"#s*define\s+HASHVERSION\s+2\s*", data
)
996 # bingo - old version used hash file format version 2
997 ### XXX this should be fixed to not be platform-dependent
998 ### but I don't have direct access to an osf1 platform and
999 ### seemed to be muffing the search somehow
1000 libraries
= platform
== "osf1" and ['db'] or None
1001 if libraries
is not None:
1002 exts
.append(Extension('bsddb185', ['bsddbmodule.c'],
1003 libraries
=libraries
))
1005 exts
.append(Extension('bsddb185', ['bsddbmodule.c']))
1007 missing
.append('bsddb185')
1009 missing
.append('bsddb185')
1011 dbm_order
= ['gdbm']
1012 # The standard Unix dbm module:
1013 if platform
not in ['cygwin']:
1014 config_args
= [arg
.strip("'")
1015 for arg
in sysconfig
.get_config_var("CONFIG_ARGS").split()]
1016 dbm_args
= [arg
for arg
in config_args
1017 if arg
.startswith('--with-dbmliborder=')]
1019 dbm_order
= [arg
.split('=')[-1] for arg
in dbm_args
][-1].split(":")
1021 dbm_order
= "ndbm:gdbm:bdb".split(":")
1023 for cand
in dbm_order
:
1025 if find_file("ndbm.h", inc_dirs
, []) is not None:
1026 # Some systems have -lndbm, others don't
1027 if self
.compiler_obj
.find_library_file(lib_dirs
,
1029 ndbm_libs
= ['ndbm']
1032 print "building dbm using ndbm"
1033 dbmext
= Extension('dbm', ['dbmmodule.c'],
1035 ('HAVE_NDBM_H',None),
1037 libraries
=ndbm_libs
)
1040 elif cand
== "gdbm":
1041 if self
.compiler_obj
.find_library_file(lib_dirs
, 'gdbm'):
1042 gdbm_libs
= ['gdbm']
1043 if self
.compiler_obj
.find_library_file(lib_dirs
,
1045 gdbm_libs
.append('gdbm_compat')
1046 if find_file("gdbm/ndbm.h", inc_dirs
, []) is not None:
1047 print "building dbm using gdbm"
1049 'dbm', ['dbmmodule.c'],
1051 ('HAVE_GDBM_NDBM_H', None),
1053 libraries
= gdbm_libs
)
1055 if find_file("gdbm-ndbm.h", inc_dirs
, []) is not None:
1056 print "building dbm using gdbm"
1058 'dbm', ['dbmmodule.c'],
1060 ('HAVE_GDBM_DASH_NDBM_H', None),
1062 libraries
= gdbm_libs
)
1065 if db_incs
is not None:
1066 print "building dbm using bdb"
1067 dbmext
= Extension('dbm', ['dbmmodule.c'],
1068 library_dirs
=dblib_dir
,
1069 runtime_library_dirs
=dblib_dir
,
1070 include_dirs
=db_incs
,
1072 ('HAVE_BERKDB_H', None),
1073 ('DB_DBM_HSEARCH', None),
1077 if dbmext
is not None:
1080 missing
.append('dbm')
1082 # Anthony Baxter's gdbm module. GNU dbm(3) will require -lgdbm:
1083 if ('gdbm' in dbm_order
and
1084 self
.compiler_obj
.find_library_file(lib_dirs
, 'gdbm')):
1085 exts
.append( Extension('gdbm', ['gdbmmodule.c'],
1086 libraries
= ['gdbm'] ) )
1088 missing
.append('gdbm')
1091 if platform
not in ['mac', 'win32']:
1092 # Steen Lumholt's termios module
1093 exts
.append( Extension('termios', ['termios.c']) )
1094 # Jeremy Hylton's rlimit interface
1095 if platform
not in ['atheos']:
1096 exts
.append( Extension('resource', ['resource.c']) )
1098 missing
.append('resource')
1100 # Sun yellow pages. Some systems have the functions in libc.
1101 if (platform
not in ['cygwin', 'atheos', 'qnx6'] and
1102 find_file('rpcsvc/yp_prot.h', inc_dirs
, []) is not None):
1103 if (self
.compiler_obj
.find_library_file(lib_dirs
, 'nsl')):
1107 exts
.append( Extension('nis', ['nismodule.c'],
1110 missing
.append('nis')
1112 missing
.extend(['nis', 'resource', 'termios'])
1114 # Curses support, requiring the System V version of curses, often
1115 # provided by the ncurses library.
1116 panel_library
= 'panel'
1117 if (self
.compiler_obj
.find_library_file(lib_dirs
, 'ncursesw')):
1118 curses_libs
= ['ncursesw']
1119 # Bug 1464056: If _curses.so links with ncursesw,
1120 # _curses_panel.so must link with panelw.
1121 panel_library
= 'panelw'
1122 exts
.append( Extension('_curses', ['_cursesmodule.c'],
1123 libraries
= curses_libs
) )
1124 elif (self
.compiler_obj
.find_library_file(lib_dirs
, 'ncurses')):
1125 curses_libs
= ['ncurses']
1126 exts
.append( Extension('_curses', ['_cursesmodule.c'],
1127 libraries
= curses_libs
) )
1128 elif (self
.compiler_obj
.find_library_file(lib_dirs
, 'curses')
1129 and platform
!= 'darwin'):
1130 # OSX has an old Berkeley curses, not good enough for
1131 # the _curses module.
1132 if (self
.compiler_obj
.find_library_file(lib_dirs
, 'terminfo')):
1133 curses_libs
= ['curses', 'terminfo']
1134 elif (self
.compiler_obj
.find_library_file(lib_dirs
, 'termcap')):
1135 curses_libs
= ['curses', 'termcap']
1137 curses_libs
= ['curses']
1139 exts
.append( Extension('_curses', ['_cursesmodule.c'],
1140 libraries
= curses_libs
) )
1142 missing
.append('_curses')
1144 # If the curses module is enabled, check for the panel module
1145 if (module_enabled(exts
, '_curses') and
1146 self
.compiler_obj
.find_library_file(lib_dirs
, panel_library
)):
1147 exts
.append( Extension('_curses_panel', ['_curses_panel.c'],
1148 libraries
= [panel_library
] + curses_libs
) )
1150 missing
.append('_curses_panel')
1152 # Andrew Kuchling's zlib module. Note that some versions of zlib
1153 # 1.1.3 have security problems. See CERT Advisory CA-2002-07:
1154 # http://www.cert.org/advisories/CA-2002-07.html
1156 # zlib 1.1.4 is fixed, but at least one vendor (RedHat) has decided to
1157 # patch its zlib 1.1.3 package instead of upgrading to 1.1.4. For
1158 # now, we still accept 1.1.3, because we think it's difficult to
1159 # exploit this in Python, and we'd rather make it RedHat's problem
1160 # than our problem <wink>.
1162 # You can upgrade zlib to version 1.1.4 yourself by going to
1163 # http://www.gzip.org/zlib/
1164 zlib_inc
= find_file('zlib.h', [], inc_dirs
)
1166 if zlib_inc
is not None:
1167 zlib_h
= zlib_inc
[0] + '/zlib.h'
1169 version_req
= '"1.1.3"'
1172 line
= fp
.readline()
1175 if line
.startswith('#define ZLIB_VERSION'):
1176 version
= line
.split()[2]
1178 if version
>= version_req
:
1179 if (self
.compiler_obj
.find_library_file(lib_dirs
, 'z')):
1180 if sys
.platform
== "darwin":
1181 zlib_extra_link_args
= ('-Wl,-search_paths_first',)
1183 zlib_extra_link_args
= ()
1184 exts
.append( Extension('zlib', ['zlibmodule.c'],
1186 extra_link_args
= zlib_extra_link_args
))
1189 missing
.append('zlib')
1191 missing
.append('zlib')
1193 missing
.append('zlib')
1195 # Helper module for various ascii-encoders. Uses zlib for an optimized
1196 # crc32 if we have it. Otherwise binascii uses its own.
1198 extra_compile_args
= ['-DUSE_ZLIB_CRC32']
1200 extra_link_args
= zlib_extra_link_args
1202 extra_compile_args
= []
1204 extra_link_args
= []
1205 exts
.append( Extension('binascii', ['binascii.c'],
1206 extra_compile_args
= extra_compile_args
,
1207 libraries
= libraries
,
1208 extra_link_args
= extra_link_args
) )
1210 # Gustavo Niemeyer's bz2 module.
1211 if (self
.compiler_obj
.find_library_file(lib_dirs
, 'bz2')):
1212 if sys
.platform
== "darwin":
1213 bz2_extra_link_args
= ('-Wl,-search_paths_first',)
1215 bz2_extra_link_args
= ()
1216 exts
.append( Extension('bz2', ['bz2module.c'],
1217 libraries
= ['bz2'],
1218 extra_link_args
= bz2_extra_link_args
) )
1220 missing
.append('bz2')
1222 # Interface to the Expat XML parser
1224 # Expat was written by James Clark and is now maintained by a group of
1225 # developers on SourceForge; see www.libexpat.org for more information.
1226 # The pyexpat module was written by Paul Prescod after a prototype by
1227 # Jack Jansen. The Expat source is included in Modules/expat/. Usage
1228 # of a system shared libexpat.so is possible with --with-system-expat
1231 # More information on Expat can be found at www.libexpat.org.
1233 if '--with-system-expat' in sysconfig
.get_config_var("CONFIG_ARGS"):
1236 expat_lib
= ['expat']
1239 expat_inc
= [os
.path
.join(os
.getcwd(), srcdir
, 'Modules', 'expat')]
1241 ('HAVE_EXPAT_CONFIG_H', '1'),
1244 expat_sources
= ['expat/xmlparse.c',
1248 exts
.append(Extension('pyexpat',
1249 define_macros
= define_macros
,
1250 include_dirs
= expat_inc
,
1251 libraries
= expat_lib
,
1252 sources
= ['pyexpat.c'] + expat_sources
1255 # Fredrik Lundh's cElementTree module. Note that this also
1256 # uses expat (via the CAPI hook in pyexpat).
1258 if os
.path
.isfile(os
.path
.join(srcdir
, 'Modules', '_elementtree.c')):
1259 define_macros
.append(('USE_PYEXPAT_CAPI', None))
1260 exts
.append(Extension('_elementtree',
1261 define_macros
= define_macros
,
1262 include_dirs
= expat_inc
,
1263 libraries
= expat_lib
,
1264 sources
= ['_elementtree.c'],
1267 missing
.append('_elementtree')
1269 # Hye-Shik Chang's CJKCodecs modules.
1271 exts
.append(Extension('_multibytecodec',
1272 ['cjkcodecs/multibytecodec.c']))
1273 for loc
in ('kr', 'jp', 'cn', 'tw', 'hk', 'iso2022'):
1274 exts
.append(Extension('_codecs_%s' % loc
,
1275 ['cjkcodecs/_codecs_%s.c' % loc
]))
1277 missing
.append('_multibytecodec')
1278 for loc
in ('kr', 'jp', 'cn', 'tw', 'hk', 'iso2022'):
1279 missing
.append('_codecs_%s' % loc
)
1281 # Dynamic loading module
1282 if sys
.maxint
== 0x7fffffff:
1283 # This requires sizeof(int) == sizeof(long) == sizeof(char*)
1284 dl_inc
= find_file('dlfcn.h', [], inc_dirs
)
1285 if (dl_inc
is not None) and (platform
not in ['atheos']):
1286 exts
.append( Extension('dl', ['dlmodule.c']) )
1288 missing
.append('dl')
1290 missing
.append('dl')
1292 # Thomas Heller's _ctypes module
1293 self
.detect_ctypes(inc_dirs
, lib_dirs
)
1295 # Richard Oudkerk's multiprocessing module
1296 if platform
== 'win32': # Windows
1298 libraries
= ['ws2_32']
1300 elif platform
== 'darwin': # Mac OSX
1304 elif platform
== 'cygwin': # Cygwin
1308 elif platform
in ('freebsd4', 'freebsd5', 'freebsd6', 'freebsd7', 'freebsd8'):
1309 # FreeBSD's P1003.1b semaphore support is very experimental
1310 # and has many known problems. (as of June 2008)
1314 elif platform
.startswith('openbsd'):
1318 elif platform
.startswith('netbsd'):
1322 else: # Linux and other unices
1326 if platform
== 'win32':
1327 multiprocessing_srcs
= [ '_multiprocessing/multiprocessing.c',
1328 '_multiprocessing/semaphore.c',
1329 '_multiprocessing/pipe_connection.c',
1330 '_multiprocessing/socket_connection.c',
1331 '_multiprocessing/win32_functions.c'
1335 multiprocessing_srcs
= [ '_multiprocessing/multiprocessing.c',
1336 '_multiprocessing/socket_connection.c'
1338 if (sysconfig
.get_config_var('HAVE_SEM_OPEN') and not
1339 sysconfig
.get_config_var('POSIX_SEMAPHORES_NOT_ENABLED')):
1340 multiprocessing_srcs
.append('_multiprocessing/semaphore.c')
1342 if sysconfig
.get_config_var('WITH_THREAD'):
1343 exts
.append ( Extension('_multiprocessing', multiprocessing_srcs
,
1344 define_macros
=macros
.items(),
1345 include_dirs
=["Modules/_multiprocessing"]))
1347 missing
.append('_multiprocessing')
1349 # End multiprocessing
1352 # Platform-specific libraries
1353 if platform
== 'linux2':
1354 # Linux-specific modules
1355 exts
.append( Extension('linuxaudiodev', ['linuxaudiodev.c']) )
1357 missing
.append('linuxaudiodev')
1359 if platform
in ('linux2', 'freebsd4', 'freebsd5', 'freebsd6',
1360 'freebsd7', 'freebsd8'):
1361 exts
.append( Extension('ossaudiodev', ['ossaudiodev.c']) )
1363 missing
.append('ossaudiodev')
1365 if platform
== 'sunos5':
1366 # SunOS specific modules
1367 exts
.append( Extension('sunaudiodev', ['sunaudiodev.c']) )
1369 missing
.append('sunaudiodev')
1371 if platform
== 'darwin':
1373 exts
.append(Extension("_scproxy", [os
.path
.join(srcdir
, "Mac/Modules/_scproxy.c")],
1375 '-framework', 'SystemConfiguration',
1376 '-framework', 'CoreFoundation'
1380 if platform
== 'darwin' and ("--disable-toolbox-glue" not in
1381 sysconfig
.get_config_var("CONFIG_ARGS")):
1383 if os
.uname()[2] > '8.':
1384 # We're on Mac OS X 10.4 or later, the compiler should
1385 # support '-Wno-deprecated-declarations'. This will
1386 # surpress deprecation warnings for the Carbon extensions,
1387 # these extensions wrap the Carbon APIs and even those
1388 # parts that are deprecated.
1389 carbon_extra_compile_args
= ['-Wno-deprecated-declarations']
1391 carbon_extra_compile_args
= []
1393 # Mac OS X specific modules.
1394 def macSrcExists(name1
, name2
=''):
1399 names
= (name1
, name2
)
1400 path
= os
.path
.join(srcdir
, 'Mac', 'Modules', *names
)
1401 return os
.path
.exists(path
)
1403 def addMacExtension(name
, kwds
, extra_srcs
=[]):
1406 dirname
= name
[1:].lower()
1408 cmodulename
= name
+ 'module.c'
1409 # Check for NNN.c, NNNmodule.c, _nnn/NNN.c, _nnn/NNNmodule.c
1410 if macSrcExists(cname
):
1412 elif macSrcExists(cmodulename
):
1413 srcs
= [cmodulename
]
1414 elif macSrcExists(dirname
, cname
):
1415 # XXX(nnorwitz): If all the names ended with module, we
1416 # wouldn't need this condition. ibcarbon is the only one.
1417 srcs
= [os
.path
.join(dirname
, cname
)]
1418 elif macSrcExists(dirname
, cmodulename
):
1419 srcs
= [os
.path
.join(dirname
, cmodulename
)]
1421 raise RuntimeError("%s not found" % name
)
1423 # Here's the whole point: add the extension with sources
1424 exts
.append(Extension(name
, srcs
+ extra_srcs
, **kwds
))
1427 core_kwds
= {'extra_compile_args': carbon_extra_compile_args
,
1428 'extra_link_args': ['-framework', 'CoreFoundation'],
1430 addMacExtension('_CF', core_kwds
, ['cf/pycfbridge.c'])
1431 addMacExtension('autoGIL', core_kwds
)
1436 carbon_kwds
= {'extra_compile_args': carbon_extra_compile_args
,
1437 'extra_link_args': ['-framework', 'Carbon'],
1439 CARBON_EXTS
= ['ColorPicker', 'gestalt', 'MacOS', 'Nav',
1440 'OSATerminology', 'icglue',
1441 # All these are in subdirs
1442 '_AE', '_AH', '_App', '_CarbonEvt', '_Cm', '_Ctl',
1443 '_Dlg', '_Drag', '_Evt', '_File', '_Folder', '_Fm',
1444 '_Help', '_Icn', '_IBCarbon', '_List',
1445 '_Menu', '_Mlte', '_OSA', '_Res', '_Qd', '_Qdoffs',
1446 '_Scrap', '_Snd', '_TE',
1448 for name
in CARBON_EXTS
:
1449 addMacExtension(name
, carbon_kwds
)
1451 # Workaround for a bug in the version of gcc shipped with Xcode 3.
1452 # The _Win extension should build just like the other Carbon extensions, but
1453 # this actually results in a hard crash of the linker.
1455 if '-arch ppc64' in cflags
and '-arch ppc' in cflags
:
1456 win_kwds
= {'extra_compile_args': carbon_extra_compile_args
+ ['-arch', 'i386', '-arch', 'ppc'],
1457 'extra_link_args': ['-framework', 'Carbon', '-arch', 'i386', '-arch', 'ppc'],
1459 addMacExtension('_Win', win_kwds
)
1461 addMacExtension('_Win', carbon_kwds
)
1464 # Application Services & QuickTime
1465 app_kwds
= {'extra_compile_args': carbon_extra_compile_args
,
1466 'extra_link_args': ['-framework','ApplicationServices'],
1468 addMacExtension('_Launch', app_kwds
)
1469 addMacExtension('_CG', app_kwds
)
1471 exts
.append( Extension('_Qt', ['qt/_Qtmodule.c'],
1472 extra_compile_args
=carbon_extra_compile_args
,
1473 extra_link_args
=['-framework', 'QuickTime',
1474 '-framework', 'Carbon']) )
1477 self
.extensions
.extend(exts
)
1479 # Call the method for detecting whether _tkinter can be compiled
1480 self
.detect_tkinter(inc_dirs
, lib_dirs
)
1482 if '_tkinter' not in [e
.name
for e
in self
.extensions
]:
1483 missing
.append('_tkinter')
1487 def detect_tkinter_darwin(self
, inc_dirs
, lib_dirs
):
1488 # The _tkinter module, using frameworks. Since frameworks are quite
1489 # different the UNIX search logic is not sharable.
1490 from os
.path
import join
, exists
1492 '/Library/Frameworks',
1493 '/System/Library/Frameworks/',
1494 join(os
.getenv('HOME'), '/Library/Frameworks')
1497 # Find the directory that contains the Tcl.framework and Tk.framework
1499 # XXX distutils should support -F!
1500 for F
in framework_dirs
:
1501 # both Tcl.framework and Tk.framework should be present
1502 for fw
in 'Tcl', 'Tk':
1503 if not exists(join(F
, fw
+ '.framework')):
1506 # ok, F is now directory with both frameworks. Continure
1510 # Tk and Tcl frameworks not found. Normal "unix" tkinter search
1514 # For 8.4a2, we must add -I options that point inside the Tcl and Tk
1515 # frameworks. In later release we should hopefully be able to pass
1516 # the -F option to gcc, which specifies a framework lookup path.
1519 join(F
, fw
+ '.framework', H
)
1520 for fw
in 'Tcl', 'Tk'
1521 for H
in 'Headers', 'Versions/Current/PrivateHeaders'
1524 # For 8.4a2, the X11 headers are not included. Rather than include a
1525 # complicated search, this is a hard-coded path. It could bail out
1526 # if X11 libs are not found...
1527 include_dirs
.append('/usr/X11R6/include')
1528 frameworks
= ['-framework', 'Tcl', '-framework', 'Tk']
1530 # All existing framework builds of Tcl/Tk don't support 64-bit
1532 cflags
= sysconfig
.get_config_vars('CFLAGS')[0]
1533 archs
= re
.findall('-arch\s+(\w+)', cflags
)
1534 fp
= os
.popen("file %s/Tk.framework/Tk | grep 'for architecture'"%(F
,))
1539 detected_archs
.append(ln
.split()[-1])
1542 for a
in detected_archs
:
1543 frameworks
.append('-arch')
1544 frameworks
.append(a
)
1546 ext
= Extension('_tkinter', ['_tkinter.c', 'tkappinit.c'],
1547 define_macros
=[('WITH_APPINIT', 1)],
1548 include_dirs
= include_dirs
,
1550 extra_compile_args
= frameworks
[2:],
1551 extra_link_args
= frameworks
,
1553 self
.extensions
.append(ext
)
1557 def detect_tkinter(self
, inc_dirs
, lib_dirs
):
1558 # The _tkinter module.
1560 # Rather than complicate the code below, detecting and building
1561 # AquaTk is a separate method. Only one Tkinter will be built on
1562 # Darwin - either AquaTk, if it is found, or X11 based Tk.
1563 platform
= self
.get_platform()
1564 if (platform
== 'darwin' and
1565 self
.detect_tkinter_darwin(inc_dirs
, lib_dirs
)):
1568 # Assume we haven't found any of the libraries or include files
1569 # The versions with dots are used on Unix, and the versions without
1570 # dots on Windows, for detection by cygwin.
1571 tcllib
= tklib
= tcl_includes
= tk_includes
= None
1572 for version
in ['8.6', '86', '8.5', '85', '8.4', '84', '8.3', '83',
1573 '8.2', '82', '8.1', '81', '8.0', '80']:
1574 tklib
= self
.compiler_obj
.find_library_file(lib_dirs
,
1576 tcllib
= self
.compiler_obj
.find_library_file(lib_dirs
,
1578 if tklib
and tcllib
:
1579 # Exit the loop when we've found the Tcl/Tk libraries
1582 # Now check for the header files
1583 if tklib
and tcllib
:
1584 # Check for the include files on Debian and {Free,Open}BSD, where
1585 # they're put in /usr/include/{tcl,tk}X.Y
1586 dotversion
= version
1587 if '.' not in dotversion
and "bsd" in sys
.platform
.lower():
1588 # OpenBSD and FreeBSD use Tcl/Tk library names like libtcl83.a,
1589 # but the include subdirs are named like .../include/tcl8.3.
1590 dotversion
= dotversion
[:-1] + '.' + dotversion
[-1]
1591 tcl_include_sub
= []
1593 for dir in inc_dirs
:
1594 tcl_include_sub
+= [dir + os
.sep
+ "tcl" + dotversion
]
1595 tk_include_sub
+= [dir + os
.sep
+ "tk" + dotversion
]
1596 tk_include_sub
+= tcl_include_sub
1597 tcl_includes
= find_file('tcl.h', inc_dirs
, tcl_include_sub
)
1598 tk_includes
= find_file('tk.h', inc_dirs
, tk_include_sub
)
1600 if (tcllib
is None or tklib
is None or
1601 tcl_includes
is None or tk_includes
is None):
1602 self
.announce("INFO: Can't locate Tcl/Tk libs and/or headers", 2)
1605 # OK... everything seems to be present for Tcl/Tk.
1607 include_dirs
= [] ; libs
= [] ; defs
= [] ; added_lib_dirs
= []
1608 for dir in tcl_includes
+ tk_includes
:
1609 if dir not in include_dirs
:
1610 include_dirs
.append(dir)
1612 # Check for various platform-specific directories
1613 if platform
== 'sunos5':
1614 include_dirs
.append('/usr/openwin/include')
1615 added_lib_dirs
.append('/usr/openwin/lib')
1616 elif os
.path
.exists('/usr/X11R6/include'):
1617 include_dirs
.append('/usr/X11R6/include')
1618 added_lib_dirs
.append('/usr/X11R6/lib64')
1619 added_lib_dirs
.append('/usr/X11R6/lib')
1620 elif os
.path
.exists('/usr/X11R5/include'):
1621 include_dirs
.append('/usr/X11R5/include')
1622 added_lib_dirs
.append('/usr/X11R5/lib')
1624 # Assume default location for X11
1625 include_dirs
.append('/usr/X11/include')
1626 added_lib_dirs
.append('/usr/X11/lib')
1628 # If Cygwin, then verify that X is installed before proceeding
1629 if platform
== 'cygwin':
1630 x11_inc
= find_file('X11/Xlib.h', [], include_dirs
)
1634 # Check for BLT extension
1635 if self
.compiler_obj
.find_library_file(lib_dirs
+ added_lib_dirs
,
1637 defs
.append( ('WITH_BLT', 1) )
1638 libs
.append('BLT8.0')
1639 elif self
.compiler_obj
.find_library_file(lib_dirs
+ added_lib_dirs
,
1641 defs
.append( ('WITH_BLT', 1) )
1644 # Add the Tcl/Tk libraries
1645 libs
.append('tk'+ version
)
1646 libs
.append('tcl'+ version
)
1648 if platform
in ['aix3', 'aix4']:
1651 # Finally, link with the X11 libraries (not appropriate on cygwin)
1652 if platform
!= "cygwin":
1655 ext
= Extension('_tkinter', ['_tkinter.c', 'tkappinit.c'],
1656 define_macros
=[('WITH_APPINIT', 1)] + defs
,
1657 include_dirs
= include_dirs
,
1659 library_dirs
= added_lib_dirs
,
1661 self
.extensions
.append(ext
)
1663 ## # Uncomment these lines if you want to play with xxmodule.c
1664 ## ext = Extension('xx', ['xxmodule.c'])
1665 ## self.extensions.append(ext)
1667 # XXX handle these, but how to detect?
1668 # *** Uncomment and edit for PIL (TkImaging) extension only:
1669 # -DWITH_PIL -I../Extensions/Imaging/libImaging tkImaging.c \
1670 # *** Uncomment and edit for TOGL extension only:
1671 # -DWITH_TOGL togl.c \
1672 # *** Uncomment these for TOGL extension only:
1673 # -lGL -lGLU -lXext -lXmu \
1675 def configure_ctypes_darwin(self
, ext
):
1676 # Darwin (OS X) uses preconfigured files, in
1677 # the Modules/_ctypes/libffi_osx directory.
1678 srcdir
= sysconfig
.get_config_var('srcdir')
1679 ffi_srcdir
= os
.path
.abspath(os
.path
.join(srcdir
, 'Modules',
1680 '_ctypes', 'libffi_osx'))
1681 sources
= [os
.path
.join(ffi_srcdir
, p
)
1685 'x86/x86-ffi_darwin.c',
1687 'powerpc/ppc-darwin.S',
1688 'powerpc/ppc-darwin_closure.S',
1689 'powerpc/ppc-ffi_darwin.c',
1690 'powerpc/ppc64-darwin_closure.S',
1693 # Add .S (preprocessed assembly) to C compiler source extensions.
1694 self
.compiler_obj
.src_extensions
.append('.S')
1696 include_dirs
= [os
.path
.join(ffi_srcdir
, 'include'),
1697 os
.path
.join(ffi_srcdir
, 'powerpc')]
1698 ext
.include_dirs
.extend(include_dirs
)
1699 ext
.sources
.extend(sources
)
1702 def configure_ctypes(self
, ext
):
1703 if not self
.use_system_libffi
:
1704 if sys
.platform
== 'darwin':
1705 return self
.configure_ctypes_darwin(ext
)
1707 srcdir
= sysconfig
.get_config_var('srcdir')
1708 ffi_builddir
= os
.path
.join(self
.build_temp
, 'libffi')
1709 ffi_srcdir
= os
.path
.abspath(os
.path
.join(srcdir
, 'Modules',
1710 '_ctypes', 'libffi'))
1711 ffi_configfile
= os
.path
.join(ffi_builddir
, 'fficonfig.py')
1713 from distutils
.dep_util
import newer_group
1715 config_sources
= [os
.path
.join(ffi_srcdir
, fname
)
1716 for fname
in os
.listdir(ffi_srcdir
)
1717 if os
.path
.isfile(os
.path
.join(ffi_srcdir
, fname
))]
1718 if self
.force
or newer_group(config_sources
,
1720 from distutils
.dir_util
import mkpath
1721 mkpath(ffi_builddir
)
1724 # Pass empty CFLAGS because we'll just append the resulting
1725 # CFLAGS to Python's; -g or -O2 is to be avoided.
1726 cmd
= "cd %s && env CFLAGS='' '%s/configure' %s" \
1727 % (ffi_builddir
, ffi_srcdir
, " ".join(config_args
))
1729 res
= os
.system(cmd
)
1730 if res
or not os
.path
.exists(ffi_configfile
):
1731 print "Failed to configure _ctypes module"
1735 execfile(ffi_configfile
, globals(), fficonfig
)
1736 ffi_srcdir
= os
.path
.join(fficonfig
['ffi_srcdir'], 'src')
1738 # Add .S (preprocessed assembly) to C compiler source extensions.
1739 self
.compiler_obj
.src_extensions
.append('.S')
1741 include_dirs
= [os
.path
.join(ffi_builddir
, 'include'),
1742 ffi_builddir
, ffi_srcdir
]
1743 extra_compile_args
= fficonfig
['ffi_cflags'].split()
1745 ext
.sources
.extend(fficonfig
['ffi_sources'])
1746 ext
.include_dirs
.extend(include_dirs
)
1747 ext
.extra_compile_args
.extend(extra_compile_args
)
1750 def detect_ctypes(self
, inc_dirs
, lib_dirs
):
1751 self
.use_system_libffi
= False
1753 extra_compile_args
= []
1754 extra_link_args
= []
1755 sources
= ['_ctypes/_ctypes.c',
1756 '_ctypes/callbacks.c',
1757 '_ctypes/callproc.c',
1758 '_ctypes/stgdict.c',
1760 '_ctypes/malloc_closure.c']
1761 depends
= ['_ctypes/ctypes.h']
1763 if sys
.platform
== 'darwin':
1764 sources
.append('_ctypes/darwin/dlfcn_simple.c')
1765 extra_compile_args
.append('-DMACOSX')
1766 include_dirs
.append('_ctypes/darwin')
1767 # XXX Is this still needed?
1768 ## extra_link_args.extend(['-read_only_relocs', 'warning'])
1770 elif sys
.platform
== 'sunos5':
1771 # XXX This shouldn't be necessary; it appears that some
1772 # of the assembler code is non-PIC (i.e. it has relocations
1773 # when it shouldn't. The proper fix would be to rewrite
1774 # the assembler code to be PIC.
1775 # This only works with GCC; the Sun compiler likely refuses
1776 # this option. If you want to compile ctypes with the Sun
1777 # compiler, please research a proper solution, instead of
1778 # finding some -z option for the Sun compiler.
1779 extra_link_args
.append('-mimpure-text')
1781 elif sys
.platform
.startswith('hp-ux'):
1782 extra_link_args
.append('-fPIC')
1784 ext
= Extension('_ctypes',
1785 include_dirs
=include_dirs
,
1786 extra_compile_args
=extra_compile_args
,
1787 extra_link_args
=extra_link_args
,
1791 ext_test
= Extension('_ctypes_test',
1792 sources
=['_ctypes/_ctypes_test.c'])
1793 self
.extensions
.extend([ext
, ext_test
])
1795 if not '--with-system-ffi' in sysconfig
.get_config_var("CONFIG_ARGS"):
1798 if sys
.platform
== 'darwin':
1799 # OS X 10.5 comes with libffi.dylib; the include files are
1800 # in /usr/include/ffi
1801 inc_dirs
.append('/usr/include/ffi')
1803 ffi_inc
= [sysconfig
.get_config_var("LIBFFI_INCLUDEDIR")]
1805 ffi_inc
= find_file('ffi.h', [], inc_dirs
)
1806 if ffi_inc
is not None:
1807 ffi_h
= ffi_inc
[0] + '/ffi.h'
1810 line
= fp
.readline()
1814 if line
.startswith('#define LIBFFI_H'):
1817 if ffi_inc
is not None:
1818 for lib_name
in ('ffi_convenience', 'ffi_pic', 'ffi'):
1819 if (self
.compiler_obj
.find_library_file(lib_dirs
, lib_name
)):
1823 if ffi_inc
and ffi_lib
:
1824 ext
.include_dirs
.extend(ffi_inc
)
1825 ext
.libraries
.append(ffi_lib
)
1826 self
.use_system_libffi
= True
1829 class PyBuildInstall(install
):
1830 # Suppress the warning about installation into the lib_dynload
1831 # directory, which is not in sys.path when running Python during
1833 def initialize_options (self
):
1834 install
.initialize_options(self
)
1837 class PyBuildInstallLib(install_lib
):
1838 # Do exactly what install_lib does but make sure correct access modes get
1839 # set on installed directories and files. All installed files with get
1840 # mode 644 unless they are a shared library in which case they will get
1841 # mode 755. All installed directories will get mode 755.
1843 so_ext
= sysconfig
.get_config_var("SO")
1846 outfiles
= install_lib
.install(self
)
1847 self
.set_file_modes(outfiles
, 0644, 0755)
1848 self
.set_dir_modes(self
.install_dir
, 0755)
1851 def set_file_modes(self
, files
, defaultMode
, sharedLibMode
):
1852 if not self
.is_chmod_supported(): return
1853 if not files
: return
1855 for filename
in files
:
1856 if os
.path
.islink(filename
): continue
1858 if filename
.endswith(self
.so_ext
): mode
= sharedLibMode
1859 log
.info("changing mode of %s to %o", filename
, mode
)
1860 if not self
.dry_run
: os
.chmod(filename
, mode
)
1862 def set_dir_modes(self
, dirname
, mode
):
1863 if not self
.is_chmod_supported(): return
1864 os
.path
.walk(dirname
, self
.set_dir_modes_visitor
, mode
)
1866 def set_dir_modes_visitor(self
, mode
, dirname
, names
):
1867 if os
.path
.islink(dirname
): return
1868 log
.info("changing mode of %s to %o", dirname
, mode
)
1869 if not self
.dry_run
: os
.chmod(dirname
, mode
)
1871 def is_chmod_supported(self
):
1872 return hasattr(os
, 'chmod')
1875 Python is an interpreted, interactive, object-oriented programming
1876 language. It is often compared to Tcl, Perl, Scheme or Java.
1878 Python combines remarkable power with very clear syntax. It has
1879 modules, classes, exceptions, very high level dynamic data types, and
1880 dynamic typing. There are interfaces to many system calls and
1881 libraries, as well as to various windowing systems (X11, Motif, Tk,
1882 Mac, MFC). New built-in modules are easily written in C or C++. Python
1883 is also usable as an extension language for applications that need a
1884 programmable interface.
1886 The Python implementation is portable: it runs on many brands of UNIX,
1887 on Windows, DOS, OS/2, Mac, Amiga... If your favorite system isn't
1888 listed here, it may still be supported, if there's a C compiler for
1889 it. Ask around on comp.lang.python -- or just try compiling Python
1894 Development Status :: 6 - Mature
1895 License :: OSI Approved :: Python Software Foundation License
1896 Natural Language :: English
1897 Programming Language :: C
1898 Programming Language :: Python
1899 Topic :: Software Development
1903 # turn off warnings when deprecated modules are imported
1905 warnings
.filterwarnings("ignore",category
=DeprecationWarning)
1906 setup(# PyPI Metadata (PEP 301)
1908 version
= sys
.version
.split()[0],
1909 url
= "http://www.python.org/%s" % sys
.version
[:3],
1910 maintainer
= "Guido van Rossum and the Python community",
1911 maintainer_email
= "python-dev@python.org",
1912 description
= "A high-level object-oriented programming language",
1913 long_description
= SUMMARY
.strip(),
1914 license
= "PSF license",
1915 classifiers
= filter(None, CLASSIFIERS
.split("\n")),
1916 platforms
= ["Many"],
1919 cmdclass
= {'build_ext':PyBuildExt
, 'install':PyBuildInstall
,
1920 'install_lib':PyBuildInstallLib
},
1921 # The struct module is defined here, because build_ext won't be
1922 # called unless there's at least one extension module defined.
1923 ext_modules
=[Extension('_struct', ['_struct.c'])],
1925 # Scripts to install
1926 scripts
= ['Tools/scripts/pydoc', 'Tools/scripts/idle',
1927 'Tools/scripts/2to3',
1932 if __name__
== '__main__':