1 # Autodetecting setup.py script for building the Python extensions
4 __version__
= "$Revision$"
6 import sys
, os
, imp
, re
, optparse
8 from distutils
import log
9 from distutils
import sysconfig
10 from distutils
import text_file
11 from distutils
.errors
import *
12 from distutils
.core
import Extension
, setup
13 from distutils
.command
.build_ext
import build_ext
14 from distutils
.command
.install
import install
15 from distutils
.command
.install_lib
import install_lib
17 # This global variable is used to hold the list of modules to be disabled.
18 disabled_module_list
= []
20 def add_dir_to_list(dirlist
, dir):
21 """Add the directory 'dir' to the list 'dirlist' (at the front) if
22 1) 'dir' is not already in 'dirlist'
23 2) 'dir' actually exists, and is a directory."""
24 if dir is not None and os
.path
.isdir(dir) and dir not in dirlist
:
25 dirlist
.insert(0, dir)
27 def find_file(filename
, std_dirs
, paths
):
28 """Searches for the directory where a given file is located,
29 and returns a possibly-empty list of additional directories, or None
30 if the file couldn't be found at all.
32 'filename' is the name of a file, such as readline.h or libcrypto.a.
33 'std_dirs' is the list of standard system directories; if the
34 file is found in one of them, no additional directives are needed.
35 'paths' is a list of additional locations to check; if the file is
36 found in one of them, the resulting list will contain the directory.
39 # Check the standard locations
41 f
= os
.path
.join(dir, filename
)
42 if os
.path
.exists(f
): return []
44 # Check the additional directories
46 f
= os
.path
.join(dir, filename
)
53 def find_library_file(compiler
, libname
, std_dirs
, paths
):
54 result
= compiler
.find_library_file(std_dirs
+ paths
, libname
)
58 # Check whether the found file is in one of the standard directories
59 dirname
= os
.path
.dirname(result
)
61 # Ensure path doesn't end with path separator
66 # Otherwise, it must have been in one of the additional directories,
67 # so we have to figure out which one.
69 # Ensure path doesn't end with path separator
74 assert False, "Internal error: Path not found in std_dirs or paths"
76 def module_enabled(extlist
, modname
):
77 """Returns whether the module 'modname' is present in the list
78 of extensions 'extlist'."""
79 extlist
= [ext
for ext
in extlist
if ext
.name
== modname
]
82 def find_module_file(module
, dirlist
):
83 """Find a module in a set of possible folders. If it is not found
84 return the unadorned filename"""
85 list = find_file(module
, [], dirlist
)
89 log
.info("WARNING: multiple copies of %s found"%module
)
90 return os
.path
.join(list[0], module
)
92 class PyBuildExt(build_ext
):
94 def __init__(self
, dist
):
95 build_ext
.__init
__(self
, dist
)
98 def build_extensions(self
):
100 # Detect which modules should be compiled
101 missing
= self
.detect_modules()
103 # Remove modules that are present on the disabled list
104 self
.extensions
= [ext
for ext
in self
.extensions
105 if ext
.name
not in disabled_module_list
]
107 # Fix up the autodetected modules, prefixing all the source files
108 # with Modules/ and adding Python's include directory to the path.
109 (srcdir
,) = sysconfig
.get_config_vars('srcdir')
111 # Maybe running on Windows but not using CYGWIN?
112 raise ValueError("No source directory; cannot proceed.")
114 # Figure out the location of the source code for extension modules
115 moddir
= os
.path
.join(os
.getcwd(), srcdir
, 'Modules')
116 moddir
= os
.path
.normpath(moddir
)
117 srcdir
, tail
= os
.path
.split(moddir
)
118 srcdir
= os
.path
.normpath(srcdir
)
119 moddir
= os
.path
.normpath(moddir
)
121 moddirlist
= [moddir
]
122 incdirlist
= ['./Include']
124 # Platform-dependent module source and include directories
125 platform
= self
.get_platform()
126 if platform
in ('darwin', 'mac') and ("--disable-toolbox-glue" not in
127 sysconfig
.get_config_var("CONFIG_ARGS")):
128 # Mac OS X also includes some mac-specific modules
129 macmoddir
= os
.path
.join(os
.getcwd(), srcdir
, 'Mac/Modules')
130 moddirlist
.append(macmoddir
)
131 incdirlist
.append('./Mac/Include')
133 alldirlist
= moddirlist
+ incdirlist
135 # Fix up the paths for scripts, too
136 self
.distribution
.scripts
= [os
.path
.join(srcdir
, filename
)
137 for filename
in self
.distribution
.scripts
]
139 for ext
in self
.extensions
[:]:
140 ext
.sources
= [ find_module_file(filename
, moddirlist
)
141 for filename
in ext
.sources
]
142 if ext
.depends
is not None:
143 ext
.depends
= [find_module_file(filename
, alldirlist
)
144 for filename
in ext
.depends
]
145 ext
.include_dirs
.append( '.' ) # to get config.h
146 for incdir
in incdirlist
:
147 ext
.include_dirs
.append( os
.path
.join(srcdir
, incdir
) )
149 # If a module has already been built statically,
150 # don't build it here
151 if ext
.name
in sys
.builtin_module_names
:
152 self
.extensions
.remove(ext
)
154 if platform
!= 'mac':
155 # Parse Modules/Setup and Modules/Setup.local to figure out which
156 # modules are turned on in the file.
158 for filename
in ('Modules/Setup', 'Modules/Setup.local'):
159 input = text_file
.TextFile(filename
, join_lines
=1)
161 line
= input.readline()
164 remove_modules
.append(line
[0])
167 for ext
in self
.extensions
[:]:
168 if ext
.name
in remove_modules
:
169 self
.extensions
.remove(ext
)
171 # When you run "make CC=altcc" or something similar, you really want
172 # those environment variables passed into the setup.py phase. Here's
173 # a small set of useful ones.
174 compiler
= os
.environ
.get('CC')
176 # unfortunately, distutils doesn't let us provide separate C and C++
178 if compiler
is not None:
179 (ccshared
,cflags
) = sysconfig
.get_config_vars('CCSHARED','CFLAGS')
180 args
['compiler_so'] = compiler
+ ' ' + ccshared
+ ' ' + cflags
181 self
.compiler
.set_executables(**args
)
183 build_ext
.build_extensions(self
)
185 longest
= max([len(e
.name
) for e
in self
.extensions
])
187 longest
= max(longest
, max([len(name
) for name
in self
.failed
]))
189 def print_three_column(lst
):
190 lst
.sort(key
=str.lower
)
191 # guarantee zip() doesn't drop anything
194 for e
, f
, g
in zip(lst
[::3], lst
[1::3], lst
[2::3]):
195 print "%-*s %-*s %-*s" % (longest
, e
, longest
, f
,
201 print "Failed to find the necessary bits to build these modules:"
202 print_three_column(missing
)
205 failed
= self
.failed
[:]
207 print "Failed to build these modules:"
208 print_three_column(failed
)
210 def build_extension(self
, ext
):
212 if ext
.name
== '_ctypes':
213 if not self
.configure_ctypes(ext
):
217 build_ext
.build_extension(self
, ext
)
218 except (CCompilerError
, DistutilsError
), why
:
219 self
.announce('WARNING: building of extension "%s" failed: %s' %
220 (ext
.name
, sys
.exc_info()[1]))
221 self
.failed
.append(ext
.name
)
223 # Workaround for Mac OS X: The Carbon-based modules cannot be
224 # reliably imported into a command-line Python
225 if 'Carbon' in ext
.extra_link_args
:
227 'WARNING: skipping import check for Carbon-based "%s"' %
230 # Workaround for Cygwin: Cygwin currently has fork issues when many
231 # modules have been imported
232 if self
.get_platform() == 'cygwin':
233 self
.announce('WARNING: skipping import check for Cygwin-based "%s"'
236 ext_filename
= os
.path
.join(
238 self
.get_ext_filename(self
.get_ext_fullname(ext
.name
)))
240 imp
.load_dynamic(ext
.name
, ext_filename
)
241 except ImportError, why
:
242 self
.failed
.append(ext
.name
)
243 self
.announce('*** WARNING: renaming "%s" since importing it'
244 ' failed: %s' % (ext
.name
, why
), level
=3)
245 assert not self
.inplace
246 basename
, tail
= os
.path
.splitext(ext_filename
)
247 newname
= basename
+ "_failed" + tail
248 if os
.path
.exists(newname
):
250 os
.rename(ext_filename
, newname
)
252 # XXX -- This relies on a Vile HACK in
253 # distutils.command.build_ext.build_extension(). The
254 # _built_objects attribute is stored there strictly for
256 # If there is a failure, _built_objects may not be there,
257 # so catch the AttributeError and move on.
259 for filename
in self
._built
_objects
:
261 except AttributeError:
262 self
.announce('unable to remove files (ignored)')
264 exc_type
, why
, tb
= sys
.exc_info()
265 self
.announce('*** WARNING: importing extension "%s" '
266 'failed with %s: %s' % (ext
.name
, exc_type
, why
),
268 self
.failed
.append(ext
.name
)
270 def get_platform(self
):
271 # Get value of sys.platform
272 for platform
in ['cygwin', 'beos', 'darwin', 'atheos', 'osf1']:
273 if sys
.platform
.startswith(platform
):
277 def detect_modules(self
):
278 # Ensure that /usr/local is always used
279 add_dir_to_list(self
.compiler
.library_dirs
, '/usr/local/lib')
280 add_dir_to_list(self
.compiler
.include_dirs
, '/usr/local/include')
282 # Add paths specified in the environment variables LDFLAGS and
283 # CPPFLAGS for header and library files.
284 # We must get the values from the Makefile and not the environment
285 # directly since an inconsistently reproducible issue comes up where
286 # the environment variable is not set even though the value were passed
287 # into configure and stored in the Makefile (issue found on OS X 10.3).
288 for env_var
, arg_name
, dir_list
in (
289 ('LDFLAGS', '-L', self
.compiler
.library_dirs
),
290 ('CPPFLAGS', '-I', self
.compiler
.include_dirs
)):
291 env_val
= sysconfig
.get_config_var(env_var
)
293 # To prevent optparse from raising an exception about any
294 # options in env_val that is doesn't know about we strip out
295 # all double dashes and any dashes followed by a character
296 # that is not for the option we are dealing with.
298 # Please note that order of the regex is important! We must
299 # strip out double-dashes first so that we don't end up with
300 # substituting "--Long" to "-Long" and thus lead to "ong" being
301 # used for a library directory.
302 env_val
= re
.sub(r
'(^|\s+)-(-|(?!%s))' % arg_name
[1], '', env_val
)
303 parser
= optparse
.OptionParser()
304 # Make sure that allowing args interspersed with options is
306 parser
.allow_interspersed_args
= True
307 parser
.error
= lambda msg
: None
308 parser
.add_option(arg_name
, dest
="dirs", action
="append")
309 options
= parser
.parse_args(env_val
.split())[0]
311 for directory
in options
.dirs
:
312 add_dir_to_list(dir_list
, directory
)
314 if os
.path
.normpath(sys
.prefix
) != '/usr':
315 add_dir_to_list(self
.compiler
.library_dirs
,
316 sysconfig
.get_config_var("LIBDIR"))
317 add_dir_to_list(self
.compiler
.include_dirs
,
318 sysconfig
.get_config_var("INCLUDEDIR"))
321 have_unicode
= unicode
325 # lib_dirs and inc_dirs are used to search for files;
326 # if a file is found in one of those directories, it can
327 # be assumed that no additional -I,-L directives are needed.
328 lib_dirs
= self
.compiler
.library_dirs
+ [
329 '/lib64', '/usr/lib64',
332 inc_dirs
= self
.compiler
.include_dirs
+ ['/usr/include']
336 config_h
= sysconfig
.get_config_h_filename()
337 config_h_vars
= sysconfig
.parse_config_h(open(config_h
))
339 platform
= self
.get_platform()
340 (srcdir
,) = sysconfig
.get_config_vars('srcdir')
342 # Check for AtheOS which has libraries in non-standard locations
343 if platform
== 'atheos':
344 lib_dirs
+= ['/system/libs', '/atheos/autolnk/lib']
345 lib_dirs
+= os
.getenv('LIBRARY_PATH', '').split(os
.pathsep
)
346 inc_dirs
+= ['/system/include', '/atheos/autolnk/include']
347 inc_dirs
+= os
.getenv('C_INCLUDE_PATH', '').split(os
.pathsep
)
349 # OSF/1 and Unixware have some stuff in /usr/ccs/lib (like -ldb)
350 if platform
in ['osf1', 'unixware7', 'openunix8']:
351 lib_dirs
+= ['/usr/ccs/lib']
353 if platform
== 'darwin':
354 # This should work on any unixy platform ;-)
355 # If the user has bothered specifying additional -I and -L flags
356 # in OPT and LDFLAGS we might as well use them here.
357 # NOTE: using shlex.split would technically be more correct, but
358 # also gives a bootstrap problem. Let's hope nobody uses directories
359 # with whitespace in the name to store libraries.
360 cflags
, ldflags
= sysconfig
.get_config_vars(
362 for item
in cflags
.split():
363 if item
.startswith('-I'):
364 inc_dirs
.append(item
[2:])
366 for item
in ldflags
.split():
367 if item
.startswith('-L'):
368 lib_dirs
.append(item
[2:])
370 # Check for MacOS X, which doesn't need libm.a at all
372 if platform
in ['darwin', 'beos', 'mac']:
375 # XXX Omitted modules: gl, pure, dl, SGI-specific modules
378 # The following modules are all pretty straightforward, and compile
379 # on pretty much any POSIXish platform.
382 # Some modules that are normally always on:
383 exts
.append( Extension('_weakref', ['_weakref.c']) )
386 exts
.append( Extension('array', ['arraymodule.c']) )
387 # complex math library functions
388 exts
.append( Extension('cmath', ['cmathmodule.c'],
389 libraries
=math_libs
) )
391 # math library functions, e.g. sin()
392 exts
.append( Extension('math', ['mathmodule.c'],
393 libraries
=math_libs
) )
394 # fast string operations implemented in C
395 exts
.append( Extension('strop', ['stropmodule.c']) )
396 # time operations and variables
397 exts
.append( Extension('time', ['timemodule.c'],
398 libraries
=math_libs
) )
399 exts
.append( Extension('datetime', ['datetimemodule.c', 'timemodule.c'],
400 libraries
=math_libs
) )
401 # random number generator implemented in C
402 exts
.append( Extension("_random", ["_randommodule.c"]) )
403 # fast iterator tools implemented in C
404 exts
.append( Extension("itertools", ["itertoolsmodule.c"]) )
405 # high-performance collections
406 exts
.append( Extension("_collections", ["_collectionsmodule.c"]) )
408 exts
.append( Extension("_bisect", ["_bisectmodule.c"]) )
410 exts
.append( Extension("_heapq", ["_heapqmodule.c"]) )
411 # operator.add() and similar goodies
412 exts
.append( Extension('operator', ['operator.c']) )
414 exts
.append( Extension("_functools", ["_functoolsmodule.c"]) )
415 # Python C API test module
416 exts
.append( Extension('_testcapi', ['_testcapimodule.c']) )
417 # profilers (_lsprof is for cProfile.py)
418 exts
.append( Extension('_hotshot', ['_hotshot.c']) )
419 exts
.append( Extension('_lsprof', ['_lsprof.c', 'rotatingtree.c']) )
420 # static Unicode character database
422 exts
.append( Extension('unicodedata', ['unicodedata.c']) )
424 missing
.append('unicodedata')
425 # access to ISO C locale support
426 data
= open('pyconfig.h').read()
427 m
= re
.search(r
"#s*define\s+WITH_LIBINTL\s+1\s*", data
)
429 locale_libs
= ['intl']
432 if platform
== 'darwin':
433 locale_extra_link_args
= ['-framework', 'CoreFoundation']
435 locale_extra_link_args
= []
438 exts
.append( Extension('_locale', ['_localemodule.c'],
439 libraries
=locale_libs
,
440 extra_link_args
=locale_extra_link_args
) )
442 # Modules with some UNIX dependencies -- on by default:
443 # (If you have a really backward UNIX, select and socket may not be
446 # fcntl(2) and ioctl(2)
447 exts
.append( Extension('fcntl', ['fcntlmodule.c']) )
448 if platform
not in ['mac']:
450 exts
.append( Extension('pwd', ['pwdmodule.c']) )
452 exts
.append( Extension('grp', ['grpmodule.c']) )
453 # spwd, shadow passwords
454 if (config_h_vars
.get('HAVE_GETSPNAM', False) or
455 config_h_vars
.get('HAVE_GETSPENT', False)):
456 exts
.append( Extension('spwd', ['spwdmodule.c']) )
458 missing
.append('spwd')
460 missing
.extend(['pwd', 'grp', 'spwd'])
462 # select(2); not on ancient System V
463 exts
.append( Extension('select', ['selectmodule.c']) )
465 # Helper module for various ascii-encoders
466 exts
.append( Extension('binascii', ['binascii.c']) )
468 # Fred Drake's interface to the Python parser
469 exts
.append( Extension('parser', ['parsermodule.c']) )
471 # cStringIO and cPickle
472 exts
.append( Extension('cStringIO', ['cStringIO.c']) )
473 exts
.append( Extension('cPickle', ['cPickle.c']) )
475 # Memory-mapped files (also works on Win32).
476 if platform
not in ['atheos', 'mac']:
477 exts
.append( Extension('mmap', ['mmapmodule.c']) )
479 missing
.append('mmap')
481 # Lance Ellinghaus's syslog module
482 if platform
not in ['mac']:
483 # syslog daemon interface
484 exts
.append( Extension('syslog', ['syslogmodule.c']) )
486 missing
.append('syslog')
488 # George Neville-Neil's timing module:
489 # Deprecated in PEP 4 http://www.python.org/peps/pep-0004.html
490 # http://mail.python.org/pipermail/python-dev/2006-January/060023.html
491 #exts.append( Extension('timing', ['timingmodule.c']) )
494 # Here ends the simple stuff. From here on, modules need certain
495 # libraries, are platform-specific, or present other surprises.
499 # These don't work for 64-bit platforms!!!
500 # These represent audio samples or images as strings:
502 # Operations on audio samples
503 # According to #993173, this one should actually work fine on
505 exts
.append( Extension('audioop', ['audioop.c']) )
507 # Disabled on 64-bit platforms
508 if sys
.maxint
!= 9223372036854775807L:
509 # Operations on images
510 exts
.append( Extension('imageop', ['imageop.c']) )
511 # Read SGI RGB image files (but coded portably)
512 exts
.append( Extension('rgbimg', ['rgbimgmodule.c']) )
514 missing
.extend(['imageop', 'rgbimg'])
517 do_readline
= self
.compiler
.find_library_file(lib_dirs
, 'readline')
518 if platform
== 'darwin':
519 # MacOSX 10.4 has a broken readline. Don't try to build
520 # the readline module unless the user has installed a fixed
522 if find_file('readline/rlconf.h', inc_dirs
, []) is None:
525 if sys
.platform
== 'darwin':
526 # In every directory on the search path search for a dynamic
527 # library and then a static library, instead of first looking
528 # for dynamic libraries on the entiry path.
529 # This way a staticly linked custom readline gets picked up
530 # before the (broken) dynamic library in /usr/lib.
531 readline_extra_link_args
= ('-Wl,-search_paths_first',)
533 readline_extra_link_args
= ()
535 readline_libs
= ['readline']
536 if self
.compiler
.find_library_file(lib_dirs
,
538 readline_libs
.append('ncursesw')
539 elif self
.compiler
.find_library_file(lib_dirs
,
541 readline_libs
.append('ncurses')
542 elif self
.compiler
.find_library_file(lib_dirs
, 'curses'):
543 readline_libs
.append('curses')
544 elif self
.compiler
.find_library_file(lib_dirs
+
545 ['/usr/lib/termcap'],
547 readline_libs
.append('termcap')
548 exts
.append( Extension('readline', ['readline.c'],
549 library_dirs
=['/usr/lib/termcap'],
550 extra_link_args
=readline_extra_link_args
,
551 libraries
=readline_libs
) )
553 missing
.append('readline')
555 if platform
not in ['mac']:
558 if self
.compiler
.find_library_file(lib_dirs
, 'crypt'):
562 exts
.append( Extension('crypt', ['cryptmodule.c'], libraries
=libs
) )
564 missing
.append('crypt')
567 exts
.append( Extension('_csv', ['_csv.c']) )
570 exts
.append( Extension('_socket', ['socketmodule.c'],
571 depends
= ['socketmodule.h']) )
572 # Detect SSL support for the socket module (via _ssl)
573 search_for_ssl_incs_in
= [
574 '/usr/local/ssl/include',
575 '/usr/contrib/ssl/include/'
577 ssl_incs
= find_file('openssl/ssl.h', inc_dirs
,
578 search_for_ssl_incs_in
580 if ssl_incs
is not None:
581 krb5_h
= find_file('krb5.h', inc_dirs
,
582 ['/usr/kerberos/include'])
585 ssl_libs
= find_library_file(self
.compiler
, 'ssl',lib_dirs
,
586 ['/usr/local/ssl/lib',
587 '/usr/contrib/ssl/lib/'
590 if (ssl_incs
is not None and
591 ssl_libs
is not None):
592 exts
.append( Extension('_ssl', ['_ssl.c'],
593 include_dirs
= ssl_incs
,
594 library_dirs
= ssl_libs
,
595 libraries
= ['ssl', 'crypto'],
596 depends
= ['socketmodule.h']), )
598 missing
.append('_ssl')
600 # find out which version of OpenSSL we have
602 openssl_ver_re
= re
.compile(
603 '^\s*#\s*define\s+OPENSSL_VERSION_NUMBER\s+(0x[0-9a-fA-F]+)' )
604 for ssl_inc_dir
in inc_dirs
+ search_for_ssl_incs_in
:
605 name
= os
.path
.join(ssl_inc_dir
, 'openssl', 'opensslv.h')
606 if os
.path
.isfile(name
):
608 incfile
= open(name
, 'r')
610 m
= openssl_ver_re
.match(line
)
612 openssl_ver
= eval(m
.group(1))
617 # first version found is what we'll use (as the compiler should)
621 #print 'openssl_ver = 0x%08x' % openssl_ver
623 if (ssl_incs
is not None and
624 ssl_libs
is not None and
625 openssl_ver
>= 0x00907000):
626 # The _hashlib module wraps optimized implementations
627 # of hash functions from the OpenSSL library.
628 exts
.append( Extension('_hashlib', ['_hashopenssl.c'],
629 include_dirs
= ssl_incs
,
630 library_dirs
= ssl_libs
,
631 libraries
= ['ssl', 'crypto']) )
632 missing
.extend(['_sha', '_md5'])
634 # The _sha module implements the SHA1 hash algorithm.
635 exts
.append( Extension('_sha', ['shamodule.c']) )
636 # The _md5 module implements the RSA Data Security, Inc. MD5
637 # Message-Digest Algorithm, described in RFC 1321. The
638 # necessary files md5.c and md5.h are included here.
639 exts
.append( Extension('_md5',
640 sources
= ['md5module.c', 'md5.c'],
641 depends
= ['md5.h']) )
642 missing
.append('_hashlib')
644 if (openssl_ver
< 0x00908000):
645 # OpenSSL doesn't do these until 0.9.8 so we'll bring our own hash
646 exts
.append( Extension('_sha256', ['sha256module.c']) )
647 exts
.append( Extension('_sha512', ['sha512module.c']) )
649 missing
.extend(['_sha256', '_sha512'])
651 # Modules that provide persistent dictionary-like semantics. You will
652 # probably want to arrange for at least one of them to be available on
653 # your machine, though none are defined by default because of library
654 # dependencies. The Python module anydbm.py provides an
655 # implementation independent wrapper for these; dumbdbm.py provides
656 # similar functionality (but slower of course) implemented in Python.
658 # Sleepycat Berkeley DB interface. http://www.sleepycat.com
660 # This requires the Sleepycat DB code. The supported versions
661 # are set below. Visit http://www.sleepycat.com/ to download
662 # a release. Most open source OSes come with one or more
663 # versions of BerkeleyDB already installed.
667 db_setup_debug
= False # verbose debug prints from this script?
669 # construct a list of paths to look for the header file in on
670 # top of the normal inc_dirs.
673 '/usr/local/include/db4',
674 '/opt/sfw/include/db4',
676 '/usr/local/include/db3',
677 '/opt/sfw/include/db3',
678 # Fink defaults (http://fink.sourceforge.net/)
682 # 4.x minor number specific paths
683 for x
in (0,1,2,3,4,5):
684 db_inc_paths
.append('/usr/include/db4%d' % x
)
685 db_inc_paths
.append('/usr/include/db4.%d' % x
)
686 db_inc_paths
.append('/usr/local/BerkeleyDB.4.%d/include' % x
)
687 db_inc_paths
.append('/usr/local/include/db4%d' % x
)
688 db_inc_paths
.append('/pkg/db-4.%d/include' % x
)
689 db_inc_paths
.append('/opt/db-4.%d/include' % x
)
690 # MacPorts default (http://www.macports.org/)
691 db_inc_paths
.append('/opt/local/include/db4%d' % x
)
692 # 3.x minor number specific paths
694 db_inc_paths
.append('/usr/include/db3%d' % x
)
695 db_inc_paths
.append('/usr/local/BerkeleyDB.3.%d/include' % x
)
696 db_inc_paths
.append('/usr/local/include/db3%d' % x
)
697 db_inc_paths
.append('/pkg/db-3.%d/include' % x
)
698 db_inc_paths
.append('/opt/db-3.%d/include' % x
)
700 # Add some common subdirectories for Sleepycat DB to the list,
701 # based on the standard include directories. This way DB3/4 gets
702 # picked up when it is installed in a non-standard prefix and
703 # the user has added that prefix into inc_dirs.
706 std_variants
.append(os
.path
.join(dn
, 'db3'))
707 std_variants
.append(os
.path
.join(dn
, 'db4'))
708 for x
in (0,1,2,3,4):
709 std_variants
.append(os
.path
.join(dn
, "db4%d"%x))
710 std_variants
.append(os
.path
.join(dn
, "db4.%d"%x))
712 std_variants
.append(os
.path
.join(dn
, "db3%d"%x))
713 std_variants
.append(os
.path
.join(dn
, "db3.%d"%x))
715 db_inc_paths
= std_variants
+ db_inc_paths
716 db_inc_paths
= [p
for p
in db_inc_paths
if os
.path
.exists(p
)]
720 class db_found(Exception): pass
722 # See whether there is a Sleepycat header in the standard
724 for d
in inc_dirs
+ db_inc_paths
:
725 f
= os
.path
.join(d
, "db.h")
726 if db_setup_debug
: print "db: looking for db.h in", f
727 if os
.path
.exists(f
):
729 m
= re
.search(r
"#define\WDB_VERSION_MAJOR\W(\d+)", f
)
731 db_major
= int(m
.group(1))
732 m
= re
.search(r
"#define\WDB_VERSION_MINOR\W(\d+)", f
)
733 db_minor
= int(m
.group(1))
734 db_ver
= (db_major
, db_minor
)
736 if ( (not db_ver_inc_map
.has_key(db_ver
)) and
737 (db_ver
<= max_db_ver
and db_ver
>= min_db_ver
) ):
738 # save the include directory with the db.h version
739 # (first occurrence only)
740 db_ver_inc_map
[db_ver
] = d
742 print "db.h: found", db_ver
, "in", d
744 # we already found a header for this library version
745 if db_setup_debug
: print "db.h: ignoring", d
747 # ignore this header, it didn't contain a version number
749 print "db.h: no version number version in", d
751 db_found_vers
= db_ver_inc_map
.keys()
755 db_ver
= db_found_vers
.pop()
756 db_incdir
= db_ver_inc_map
[db_ver
]
758 # check lib directories parallel to the location of the header
760 db_incdir
.replace("include", 'lib64'),
761 db_incdir
.replace("include", 'lib'),
763 db_dirs_to_check
= filter(os
.path
.isdir
, db_dirs_to_check
)
765 # Look for a version specific db-X.Y before an ambiguoius dbX
766 # XXX should we -ever- look for a dbX name? Do any
767 # systems really not name their library by version and
768 # symlink to more general names?
769 for dblib
in (('db-%d.%d' % db_ver
),
771 ('db%d' % db_ver
[0])):
772 dblib_file
= self
.compiler
.find_library_file(
773 db_dirs_to_check
+ lib_dirs
, dblib
)
775 dblib_dir
= [ os
.path
.abspath(os
.path
.dirname(dblib_file
)) ]
778 if db_setup_debug
: print "db lib: ", dblib
, "not found"
782 print "db lib: using", db_ver
, dblib
783 print "db: lib dir", dblib_dir
, "inc dir", db_incdir
784 db_incs
= [db_incdir
]
786 # We add the runtime_library_dirs argument because the
787 # BerkeleyDB lib we're linking against often isn't in the
788 # system dynamic library search path. This is usually
789 # correct and most trouble free, but may cause problems in
790 # some unusual system configurations (e.g. the directory
791 # is on an NFS server that goes away).
792 exts
.append(Extension('_bsddb', ['_bsddb.c'],
793 library_dirs
=dblib_dir
,
794 runtime_library_dirs
=dblib_dir
,
795 include_dirs
=db_incs
,
798 if db_setup_debug
: print "db: no appropriate library found"
802 missing
.append('_bsddb')
804 # The sqlite interface
805 sqlite_setup_debug
= False # verbose debug prints from this script?
807 # We hunt for #define SQLITE_VERSION "n.n.n"
808 # We need to find >= sqlite version 3.0.8
809 sqlite_incdir
= sqlite_libdir
= None
810 sqlite_inc_paths
= [ '/usr/include',
811 '/usr/include/sqlite',
812 '/usr/include/sqlite3',
813 '/usr/local/include',
814 '/usr/local/include/sqlite',
815 '/usr/local/include/sqlite3',
817 MIN_SQLITE_VERSION_NUMBER
= (3, 0, 8)
818 MIN_SQLITE_VERSION
= ".".join([str(x
)
819 for x
in MIN_SQLITE_VERSION_NUMBER
])
821 # Scan the default include directories before the SQLite specific
822 # ones. This allows one to override the copy of sqlite on OSX,
823 # where /usr/include contains an old version of sqlite.
824 for d
in inc_dirs
+ sqlite_inc_paths
:
825 f
= os
.path
.join(d
, "sqlite3.h")
826 if os
.path
.exists(f
):
827 if sqlite_setup_debug
: print "sqlite: found %s"%f
828 incf
= open(f
).read()
830 r
'\s*.*#\s*.*define\s.*SQLITE_VERSION\W*"(.*)"', incf
)
832 sqlite_version
= m
.group(1)
833 sqlite_version_tuple
= tuple([int(x
)
834 for x
in sqlite_version
.split(".")])
835 if sqlite_version_tuple
>= MIN_SQLITE_VERSION_NUMBER
:
837 if sqlite_setup_debug
:
838 print "%s/sqlite3.h: version %s"%(d
, sqlite_version
)
842 if sqlite_setup_debug
:
843 print "%s: version %d is too old, need >= %s"%(d
,
844 sqlite_version
, MIN_SQLITE_VERSION
)
845 elif sqlite_setup_debug
:
846 print "sqlite: %s had no SQLITE_VERSION"%(f
,)
849 sqlite_dirs_to_check
= [
850 os
.path
.join(sqlite_incdir
, '..', 'lib64'),
851 os
.path
.join(sqlite_incdir
, '..', 'lib'),
852 os
.path
.join(sqlite_incdir
, '..', '..', 'lib64'),
853 os
.path
.join(sqlite_incdir
, '..', '..', 'lib'),
855 sqlite_libfile
= self
.compiler
.find_library_file(
856 sqlite_dirs_to_check
+ lib_dirs
, 'sqlite3')
857 sqlite_libdir
= [os
.path
.abspath(os
.path
.dirname(sqlite_libfile
))]
859 if sqlite_incdir
and sqlite_libdir
:
860 sqlite_srcs
= ['_sqlite/cache.c',
861 '_sqlite/connection.c',
863 '_sqlite/microprotocols.c',
865 '_sqlite/prepare_protocol.c',
867 '_sqlite/statement.c',
871 if sys
.platform
!= "win32":
872 sqlite_defines
.append(('MODULE_NAME', '"sqlite3"'))
874 sqlite_defines
.append(('MODULE_NAME', '\\"sqlite3\\"'))
877 if sys
.platform
== 'darwin':
878 # In every directory on the search path search for a dynamic
879 # library and then a static library, instead of first looking
880 # for dynamic libraries on the entiry path.
881 # This way a staticly linked custom sqlite gets picked up
882 # before the dynamic library in /usr/lib.
883 sqlite_extra_link_args
= ('-Wl,-search_paths_first',)
885 sqlite_extra_link_args
= ()
887 exts
.append(Extension('_sqlite3', sqlite_srcs
,
888 define_macros
=sqlite_defines
,
889 include_dirs
=["Modules/_sqlite",
891 library_dirs
=sqlite_libdir
,
892 runtime_library_dirs
=sqlite_libdir
,
893 extra_link_args
=sqlite_extra_link_args
,
894 libraries
=["sqlite3",]))
896 missing
.append('_sqlite3')
898 # Look for Berkeley db 1.85. Note that it is built as a different
899 # module name so it can be included even when later versions are
900 # available. A very restrictive search is performed to avoid
901 # accidentally building this module with a later version of the
902 # underlying db library. May BSD-ish Unixes incorporate db 1.85
903 # symbols into libc and place the include file in /usr/include.
904 f
= "/usr/include/db.h"
905 if os
.path
.exists(f
):
906 data
= open(f
).read()
907 m
= re
.search(r
"#s*define\s+HASHVERSION\s+2\s*", data
)
909 # bingo - old version used hash file format version 2
910 ### XXX this should be fixed to not be platform-dependent
911 ### but I don't have direct access to an osf1 platform and
912 ### seemed to be muffing the search somehow
913 libraries
= platform
== "osf1" and ['db'] or None
914 if libraries
is not None:
915 exts
.append(Extension('bsddb185', ['bsddbmodule.c'],
916 libraries
=libraries
))
918 exts
.append(Extension('bsddb185', ['bsddbmodule.c']))
920 missing
.append('bsddb185')
922 missing
.append('bsddb185')
924 # The standard Unix dbm module:
925 if platform
not in ['cygwin']:
926 if find_file("ndbm.h", inc_dirs
, []) is not None:
927 # Some systems have -lndbm, others don't
928 if self
.compiler
.find_library_file(lib_dirs
, 'ndbm'):
932 exts
.append( Extension('dbm', ['dbmmodule.c'],
933 define_macros
=[('HAVE_NDBM_H',None)],
934 libraries
= ndbm_libs
) )
935 elif (self
.compiler
.find_library_file(lib_dirs
, 'gdbm')
936 and find_file("gdbm/ndbm.h", inc_dirs
, []) is not None):
937 exts
.append( Extension('dbm', ['dbmmodule.c'],
938 define_macros
=[('HAVE_GDBM_NDBM_H',None)],
939 libraries
= ['gdbm'] ) )
940 elif db_incs
is not None:
941 exts
.append( Extension('dbm', ['dbmmodule.c'],
942 library_dirs
=dblib_dir
,
943 runtime_library_dirs
=dblib_dir
,
944 include_dirs
=db_incs
,
945 define_macros
=[('HAVE_BERKDB_H',None),
946 ('DB_DBM_HSEARCH',None)],
949 missing
.append('dbm')
951 # Anthony Baxter's gdbm module. GNU dbm(3) will require -lgdbm:
952 if (self
.compiler
.find_library_file(lib_dirs
, 'gdbm')):
953 exts
.append( Extension('gdbm', ['gdbmmodule.c'],
954 libraries
= ['gdbm'] ) )
956 missing
.append('gdbm')
959 if platform
not in ['mac', 'win32']:
960 # Steen Lumholt's termios module
961 exts
.append( Extension('termios', ['termios.c']) )
962 # Jeremy Hylton's rlimit interface
963 if platform
not in ['atheos']:
964 exts
.append( Extension('resource', ['resource.c']) )
966 missing
.append('resource')
968 # Sun yellow pages. Some systems have the functions in libc.
969 if platform
not in ['cygwin', 'atheos']:
970 if (self
.compiler
.find_library_file(lib_dirs
, 'nsl')):
974 exts
.append( Extension('nis', ['nismodule.c'],
977 missing
.append('nis')
979 missing
.extend(['nis', 'resource', 'termios'])
981 # Curses support, requiring the System V version of curses, often
982 # provided by the ncurses library.
983 panel_library
= 'panel'
984 if (self
.compiler
.find_library_file(lib_dirs
, 'ncursesw')):
985 curses_libs
= ['ncursesw']
986 # Bug 1464056: If _curses.so links with ncursesw,
987 # _curses_panel.so must link with panelw.
988 panel_library
= 'panelw'
989 exts
.append( Extension('_curses', ['_cursesmodule.c'],
990 libraries
= curses_libs
) )
991 elif (self
.compiler
.find_library_file(lib_dirs
, 'ncurses')):
992 curses_libs
= ['ncurses']
993 exts
.append( Extension('_curses', ['_cursesmodule.c'],
994 libraries
= curses_libs
) )
995 elif (self
.compiler
.find_library_file(lib_dirs
, 'curses')
996 and platform
!= 'darwin'):
997 # OSX has an old Berkeley curses, not good enough for
998 # the _curses module.
999 if (self
.compiler
.find_library_file(lib_dirs
, 'terminfo')):
1000 curses_libs
= ['curses', 'terminfo']
1001 elif (self
.compiler
.find_library_file(lib_dirs
, 'termcap')):
1002 curses_libs
= ['curses', 'termcap']
1004 curses_libs
= ['curses']
1006 exts
.append( Extension('_curses', ['_cursesmodule.c'],
1007 libraries
= curses_libs
) )
1009 missing
.append('_curses')
1011 # If the curses module is enabled, check for the panel module
1012 if (module_enabled(exts
, '_curses') and
1013 self
.compiler
.find_library_file(lib_dirs
, panel_library
)):
1014 exts
.append( Extension('_curses_panel', ['_curses_panel.c'],
1015 libraries
= [panel_library
] + curses_libs
) )
1017 missing
.append('_curses_panel')
1019 # Andrew Kuchling's zlib module. Note that some versions of zlib
1020 # 1.1.3 have security problems. See CERT Advisory CA-2002-07:
1021 # http://www.cert.org/advisories/CA-2002-07.html
1023 # zlib 1.1.4 is fixed, but at least one vendor (RedHat) has decided to
1024 # patch its zlib 1.1.3 package instead of upgrading to 1.1.4. For
1025 # now, we still accept 1.1.3, because we think it's difficult to
1026 # exploit this in Python, and we'd rather make it RedHat's problem
1027 # than our problem <wink>.
1029 # You can upgrade zlib to version 1.1.4 yourself by going to
1030 # http://www.gzip.org/zlib/
1031 zlib_inc
= find_file('zlib.h', [], inc_dirs
)
1032 if zlib_inc
is not None:
1033 zlib_h
= zlib_inc
[0] + '/zlib.h'
1035 version_req
= '"1.1.3"'
1038 line
= fp
.readline()
1041 if line
.startswith('#define ZLIB_VERSION'):
1042 version
= line
.split()[2]
1044 if version
>= version_req
:
1045 if (self
.compiler
.find_library_file(lib_dirs
, 'z')):
1046 if sys
.platform
== "darwin":
1047 zlib_extra_link_args
= ('-Wl,-search_paths_first',)
1049 zlib_extra_link_args
= ()
1050 exts
.append( Extension('zlib', ['zlibmodule.c'],
1052 extra_link_args
= zlib_extra_link_args
))
1054 missing
.append('zlib')
1056 missing
.append('zlib')
1058 missing
.append('zlib')
1060 # Gustavo Niemeyer's bz2 module.
1061 if (self
.compiler
.find_library_file(lib_dirs
, 'bz2')):
1062 if sys
.platform
== "darwin":
1063 bz2_extra_link_args
= ('-Wl,-search_paths_first',)
1065 bz2_extra_link_args
= ()
1066 exts
.append( Extension('bz2', ['bz2module.c'],
1067 libraries
= ['bz2'],
1068 extra_link_args
= bz2_extra_link_args
) )
1070 missing
.append('bz2')
1072 # Interface to the Expat XML parser
1074 # Expat was written by James Clark and is now maintained by a
1075 # group of developers on SourceForge; see www.libexpat.org for
1076 # more information. The pyexpat module was written by Paul
1077 # Prescod after a prototype by Jack Jansen. The Expat source
1078 # is included in Modules/expat/. Usage of a system
1079 # shared libexpat.so/expat.dll is not advised.
1081 # More information on Expat can be found at www.libexpat.org.
1083 expatinc
= os
.path
.join(os
.getcwd(), srcdir
, 'Modules', 'expat')
1085 ('HAVE_EXPAT_CONFIG_H', '1'),
1088 exts
.append(Extension('pyexpat',
1089 define_macros
= define_macros
,
1090 include_dirs
= [expatinc
],
1091 sources
= ['pyexpat.c',
1098 # Fredrik Lundh's cElementTree module. Note that this also
1099 # uses expat (via the CAPI hook in pyexpat).
1101 if os
.path
.isfile(os
.path
.join(srcdir
, 'Modules', '_elementtree.c')):
1102 define_macros
.append(('USE_PYEXPAT_CAPI', None))
1103 exts
.append(Extension('_elementtree',
1104 define_macros
= define_macros
,
1105 include_dirs
= [expatinc
],
1106 sources
= ['_elementtree.c'],
1109 missing
.append('_elementtree')
1111 # Hye-Shik Chang's CJKCodecs modules.
1113 exts
.append(Extension('_multibytecodec',
1114 ['cjkcodecs/multibytecodec.c']))
1115 for loc
in ('kr', 'jp', 'cn', 'tw', 'hk', 'iso2022'):
1116 exts
.append(Extension('_codecs_%s' % loc
,
1117 ['cjkcodecs/_codecs_%s.c' % loc
]))
1119 missing
.append('_multibytecodec')
1120 for loc
in ('kr', 'jp', 'cn', 'tw', 'hk', 'iso2022'):
1121 missing
.append('_codecs_%s' % loc
)
1123 # Dynamic loading module
1124 if sys
.maxint
== 0x7fffffff:
1125 # This requires sizeof(int) == sizeof(long) == sizeof(char*)
1126 dl_inc
= find_file('dlfcn.h', [], inc_dirs
)
1127 if (dl_inc
is not None) and (platform
not in ['atheos']):
1128 exts
.append( Extension('dl', ['dlmodule.c']) )
1130 missing
.append('dl')
1132 missing
.append('dl')
1134 # Thomas Heller's _ctypes module
1135 self
.detect_ctypes(inc_dirs
, lib_dirs
)
1137 # Platform-specific libraries
1138 if platform
== 'linux2':
1139 # Linux-specific modules
1140 exts
.append( Extension('linuxaudiodev', ['linuxaudiodev.c']) )
1142 missing
.append('linuxaudiodev')
1144 if platform
in ('linux2', 'freebsd4', 'freebsd5', 'freebsd6',
1146 exts
.append( Extension('ossaudiodev', ['ossaudiodev.c']) )
1148 missing
.append('ossaudiodev')
1150 if platform
== 'sunos5':
1151 # SunOS specific modules
1152 exts
.append( Extension('sunaudiodev', ['sunaudiodev.c']) )
1154 missing
.append('sunaudiodev')
1156 if platform
== 'darwin' and ("--disable-toolbox-glue" not in
1157 sysconfig
.get_config_var("CONFIG_ARGS")):
1159 if os
.uname()[2] > '8.':
1160 # We're on Mac OS X 10.4 or later, the compiler should
1161 # support '-Wno-deprecated-declarations'. This will
1162 # surpress deprecation warnings for the Carbon extensions,
1163 # these extensions wrap the Carbon APIs and even those
1164 # parts that are deprecated.
1165 carbon_extra_compile_args
= ['-Wno-deprecated-declarations']
1167 carbon_extra_compile_args
= []
1169 # Mac OS X specific modules.
1170 def macSrcExists(name1
, name2
=''):
1175 names
= (name1
, name2
)
1176 path
= os
.path
.join(srcdir
, 'Mac', 'Modules', *names
)
1177 return os
.path
.exists(path
)
1179 def addMacExtension(name
, kwds
, extra_srcs
=[]):
1182 dirname
= name
[1:].lower()
1184 cmodulename
= name
+ 'module.c'
1185 # Check for NNN.c, NNNmodule.c, _nnn/NNN.c, _nnn/NNNmodule.c
1186 if macSrcExists(cname
):
1188 elif macSrcExists(cmodulename
):
1189 srcs
= [cmodulename
]
1190 elif macSrcExists(dirname
, cname
):
1191 # XXX(nnorwitz): If all the names ended with module, we
1192 # wouldn't need this condition. ibcarbon is the only one.
1193 srcs
= [os
.path
.join(dirname
, cname
)]
1194 elif macSrcExists(dirname
, cmodulename
):
1195 srcs
= [os
.path
.join(dirname
, cmodulename
)]
1197 raise RuntimeError("%s not found" % name
)
1199 # Here's the whole point: add the extension with sources
1200 exts
.append(Extension(name
, srcs
+ extra_srcs
, **kwds
))
1203 core_kwds
= {'extra_compile_args': carbon_extra_compile_args
,
1204 'extra_link_args': ['-framework', 'CoreFoundation'],
1206 addMacExtension('_CF', core_kwds
, ['cf/pycfbridge.c'])
1207 addMacExtension('autoGIL', core_kwds
)
1210 carbon_kwds
= {'extra_compile_args': carbon_extra_compile_args
,
1211 'extra_link_args': ['-framework', 'Carbon'],
1213 CARBON_EXTS
= ['ColorPicker', 'gestalt', 'MacOS', 'Nav',
1214 'OSATerminology', 'icglue',
1215 # All these are in subdirs
1216 '_AE', '_AH', '_App', '_CarbonEvt', '_Cm', '_Ctl',
1217 '_Dlg', '_Drag', '_Evt', '_File', '_Folder', '_Fm',
1218 '_Help', '_Icn', '_IBCarbon', '_List',
1219 '_Menu', '_Mlte', '_OSA', '_Res', '_Qd', '_Qdoffs',
1220 '_Scrap', '_Snd', '_TE', '_Win',
1222 for name
in CARBON_EXTS
:
1223 addMacExtension(name
, carbon_kwds
)
1225 # Application Services & QuickTime
1226 app_kwds
= {'extra_compile_args': carbon_extra_compile_args
,
1227 'extra_link_args': ['-framework','ApplicationServices'],
1229 addMacExtension('_Launch', app_kwds
)
1230 addMacExtension('_CG', app_kwds
)
1232 exts
.append( Extension('_Qt', ['qt/_Qtmodule.c'],
1233 extra_compile_args
=carbon_extra_compile_args
,
1234 extra_link_args
=['-framework', 'QuickTime',
1235 '-framework', 'Carbon']) )
1238 self
.extensions
.extend(exts
)
1240 # Call the method for detecting whether _tkinter can be compiled
1241 self
.detect_tkinter(inc_dirs
, lib_dirs
)
1243 if '_tkinter' not in [e
.name
for e
in self
.extensions
]:
1244 missing
.append('_tkinter')
1248 def detect_tkinter_darwin(self
, inc_dirs
, lib_dirs
):
1249 # The _tkinter module, using frameworks. Since frameworks are quite
1250 # different the UNIX search logic is not sharable.
1251 from os
.path
import join
, exists
1253 '/System/Library/Frameworks/',
1254 '/Library/Frameworks',
1255 join(os
.getenv('HOME'), '/Library/Frameworks')
1258 # Find the directory that contains the Tcl.framework and Tk.framework
1260 # XXX distutils should support -F!
1261 for F
in framework_dirs
:
1262 # both Tcl.framework and Tk.framework should be present
1263 for fw
in 'Tcl', 'Tk':
1264 if not exists(join(F
, fw
+ '.framework')):
1267 # ok, F is now directory with both frameworks. Continure
1271 # Tk and Tcl frameworks not found. Normal "unix" tkinter search
1275 # For 8.4a2, we must add -I options that point inside the Tcl and Tk
1276 # frameworks. In later release we should hopefully be able to pass
1277 # the -F option to gcc, which specifies a framework lookup path.
1280 join(F
, fw
+ '.framework', H
)
1281 for fw
in 'Tcl', 'Tk'
1282 for H
in 'Headers', 'Versions/Current/PrivateHeaders'
1285 # For 8.4a2, the X11 headers are not included. Rather than include a
1286 # complicated search, this is a hard-coded path. It could bail out
1287 # if X11 libs are not found...
1288 include_dirs
.append('/usr/X11R6/include')
1289 frameworks
= ['-framework', 'Tcl', '-framework', 'Tk']
1291 ext
= Extension('_tkinter', ['_tkinter.c', 'tkappinit.c'],
1292 define_macros
=[('WITH_APPINIT', 1)],
1293 include_dirs
= include_dirs
,
1295 extra_compile_args
= frameworks
,
1296 extra_link_args
= frameworks
,
1298 self
.extensions
.append(ext
)
1302 def detect_tkinter(self
, inc_dirs
, lib_dirs
):
1303 # The _tkinter module.
1305 # Rather than complicate the code below, detecting and building
1306 # AquaTk is a separate method. Only one Tkinter will be built on
1307 # Darwin - either AquaTk, if it is found, or X11 based Tk.
1308 platform
= self
.get_platform()
1309 if (platform
== 'darwin' and
1310 self
.detect_tkinter_darwin(inc_dirs
, lib_dirs
)):
1313 # Assume we haven't found any of the libraries or include files
1314 # The versions with dots are used on Unix, and the versions without
1315 # dots on Windows, for detection by cygwin.
1316 tcllib
= tklib
= tcl_includes
= tk_includes
= None
1317 for version
in ['8.5', '85', '8.4', '84', '8.3', '83', '8.2',
1318 '82', '8.1', '81', '8.0', '80']:
1319 tklib
= self
.compiler
.find_library_file(lib_dirs
, 'tk' + version
)
1320 tcllib
= self
.compiler
.find_library_file(lib_dirs
, 'tcl' + version
)
1321 if tklib
and tcllib
:
1322 # Exit the loop when we've found the Tcl/Tk libraries
1325 # Now check for the header files
1326 if tklib
and tcllib
:
1327 # Check for the include files on Debian and {Free,Open}BSD, where
1328 # they're put in /usr/include/{tcl,tk}X.Y
1329 dotversion
= version
1330 if '.' not in dotversion
and "bsd" in sys
.platform
.lower():
1331 # OpenBSD and FreeBSD use Tcl/Tk library names like libtcl83.a,
1332 # but the include subdirs are named like .../include/tcl8.3.
1333 dotversion
= dotversion
[:-1] + '.' + dotversion
[-1]
1334 tcl_include_sub
= []
1336 for dir in inc_dirs
:
1337 tcl_include_sub
+= [dir + os
.sep
+ "tcl" + dotversion
]
1338 tk_include_sub
+= [dir + os
.sep
+ "tk" + dotversion
]
1339 tk_include_sub
+= tcl_include_sub
1340 tcl_includes
= find_file('tcl.h', inc_dirs
, tcl_include_sub
)
1341 tk_includes
= find_file('tk.h', inc_dirs
, tk_include_sub
)
1343 if (tcllib
is None or tklib
is None or
1344 tcl_includes
is None or tk_includes
is None):
1345 self
.announce("INFO: Can't locate Tcl/Tk libs and/or headers", 2)
1348 # OK... everything seems to be present for Tcl/Tk.
1350 include_dirs
= [] ; libs
= [] ; defs
= [] ; added_lib_dirs
= []
1351 for dir in tcl_includes
+ tk_includes
:
1352 if dir not in include_dirs
:
1353 include_dirs
.append(dir)
1355 # Check for various platform-specific directories
1356 if platform
== 'sunos5':
1357 include_dirs
.append('/usr/openwin/include')
1358 added_lib_dirs
.append('/usr/openwin/lib')
1359 elif os
.path
.exists('/usr/X11R6/include'):
1360 include_dirs
.append('/usr/X11R6/include')
1361 added_lib_dirs
.append('/usr/X11R6/lib64')
1362 added_lib_dirs
.append('/usr/X11R6/lib')
1363 elif os
.path
.exists('/usr/X11R5/include'):
1364 include_dirs
.append('/usr/X11R5/include')
1365 added_lib_dirs
.append('/usr/X11R5/lib')
1367 # Assume default location for X11
1368 include_dirs
.append('/usr/X11/include')
1369 added_lib_dirs
.append('/usr/X11/lib')
1371 # If Cygwin, then verify that X is installed before proceeding
1372 if platform
== 'cygwin':
1373 x11_inc
= find_file('X11/Xlib.h', [], include_dirs
)
1377 # Check for BLT extension
1378 if self
.compiler
.find_library_file(lib_dirs
+ added_lib_dirs
,
1380 defs
.append( ('WITH_BLT', 1) )
1381 libs
.append('BLT8.0')
1382 elif self
.compiler
.find_library_file(lib_dirs
+ added_lib_dirs
,
1384 defs
.append( ('WITH_BLT', 1) )
1387 # Add the Tcl/Tk libraries
1388 libs
.append('tk'+ version
)
1389 libs
.append('tcl'+ version
)
1391 if platform
in ['aix3', 'aix4']:
1394 # Finally, link with the X11 libraries (not appropriate on cygwin)
1395 if platform
!= "cygwin":
1398 ext
= Extension('_tkinter', ['_tkinter.c', 'tkappinit.c'],
1399 define_macros
=[('WITH_APPINIT', 1)] + defs
,
1400 include_dirs
= include_dirs
,
1402 library_dirs
= added_lib_dirs
,
1404 self
.extensions
.append(ext
)
1406 ## # Uncomment these lines if you want to play with xxmodule.c
1407 ## ext = Extension('xx', ['xxmodule.c'])
1408 ## self.extensions.append(ext)
1410 # XXX handle these, but how to detect?
1411 # *** Uncomment and edit for PIL (TkImaging) extension only:
1412 # -DWITH_PIL -I../Extensions/Imaging/libImaging tkImaging.c \
1413 # *** Uncomment and edit for TOGL extension only:
1414 # -DWITH_TOGL togl.c \
1415 # *** Uncomment these for TOGL extension only:
1416 # -lGL -lGLU -lXext -lXmu \
1418 def configure_ctypes(self
, ext
):
1419 if not self
.use_system_libffi
:
1420 (srcdir
,) = sysconfig
.get_config_vars('srcdir')
1421 ffi_builddir
= os
.path
.join(self
.build_temp
, 'libffi')
1422 ffi_srcdir
= os
.path
.abspath(os
.path
.join(srcdir
, 'Modules',
1423 '_ctypes', 'libffi'))
1424 ffi_configfile
= os
.path
.join(ffi_builddir
, 'fficonfig.py')
1426 from distutils
.dep_util
import newer_group
1428 config_sources
= [os
.path
.join(ffi_srcdir
, fname
)
1429 for fname
in os
.listdir(ffi_srcdir
)
1430 if os
.path
.isfile(os
.path
.join(ffi_srcdir
, fname
))]
1431 if self
.force
or newer_group(config_sources
,
1433 from distutils
.dir_util
import mkpath
1434 mkpath(ffi_builddir
)
1437 # Pass empty CFLAGS because we'll just append the resulting
1438 # CFLAGS to Python's; -g or -O2 is to be avoided.
1439 cmd
= "cd %s && env CFLAGS='' '%s/configure' %s" \
1440 % (ffi_builddir
, ffi_srcdir
, " ".join(config_args
))
1442 res
= os
.system(cmd
)
1443 if res
or not os
.path
.exists(ffi_configfile
):
1444 print "Failed to configure _ctypes module"
1448 execfile(ffi_configfile
, globals(), fficonfig
)
1449 ffi_srcdir
= os
.path
.join(fficonfig
['ffi_srcdir'], 'src')
1451 # Add .S (preprocessed assembly) to C compiler source extensions.
1452 self
.compiler
.src_extensions
.append('.S')
1454 include_dirs
= [os
.path
.join(ffi_builddir
, 'include'),
1455 ffi_builddir
, ffi_srcdir
]
1456 extra_compile_args
= fficonfig
['ffi_cflags'].split()
1458 ext
.sources
.extend(fficonfig
['ffi_sources'])
1459 ext
.include_dirs
.extend(include_dirs
)
1460 ext
.extra_compile_args
.extend(extra_compile_args
)
1463 def detect_ctypes(self
, inc_dirs
, lib_dirs
):
1464 self
.use_system_libffi
= False
1466 extra_compile_args
= []
1467 extra_link_args
= []
1468 sources
= ['_ctypes/_ctypes.c',
1469 '_ctypes/callbacks.c',
1470 '_ctypes/callproc.c',
1471 '_ctypes/stgdict.c',
1473 '_ctypes/malloc_closure.c']
1474 depends
= ['_ctypes/ctypes.h']
1476 if sys
.platform
== 'darwin':
1477 sources
.append('_ctypes/darwin/dlfcn_simple.c')
1478 include_dirs
.append('_ctypes/darwin')
1479 # XXX Is this still needed?
1480 ## extra_link_args.extend(['-read_only_relocs', 'warning'])
1482 elif sys
.platform
== 'sunos5':
1483 # XXX This shouldn't be necessary; it appears that some
1484 # of the assembler code is non-PIC (i.e. it has relocations
1485 # when it shouldn't. The proper fix would be to rewrite
1486 # the assembler code to be PIC.
1487 # This only works with GCC; the Sun compiler likely refuses
1488 # this option. If you want to compile ctypes with the Sun
1489 # compiler, please research a proper solution, instead of
1490 # finding some -z option for the Sun compiler.
1491 extra_link_args
.append('-mimpure-text')
1493 ext
= Extension('_ctypes',
1494 include_dirs
=include_dirs
,
1495 extra_compile_args
=extra_compile_args
,
1496 extra_link_args
=extra_link_args
,
1500 ext_test
= Extension('_ctypes_test',
1501 sources
=['_ctypes/_ctypes_test.c'])
1502 self
.extensions
.extend([ext
, ext_test
])
1504 if not '--with-system-ffi' in sysconfig
.get_config_var("CONFIG_ARGS"):
1507 ffi_inc
= find_file('ffi.h', [], inc_dirs
)
1508 if ffi_inc
is not None:
1509 ffi_h
= ffi_inc
[0] + '/ffi.h'
1512 line
= fp
.readline()
1516 if line
.startswith('#define LIBFFI_H'):
1519 if ffi_inc
is not None:
1520 for lib_name
in ('ffi_convenience', 'ffi_pic', 'ffi'):
1521 if (self
.compiler
.find_library_file(lib_dirs
, lib_name
)):
1525 if ffi_inc
and ffi_lib
:
1526 ext
.include_dirs
.extend(ffi_inc
)
1527 ext
.libraries
.append(ffi_lib
)
1528 self
.use_system_libffi
= True
1531 class PyBuildInstall(install
):
1532 # Suppress the warning about installation into the lib_dynload
1533 # directory, which is not in sys.path when running Python during
1535 def initialize_options (self
):
1536 install
.initialize_options(self
)
1539 class PyBuildInstallLib(install_lib
):
1540 # Do exactly what install_lib does but make sure correct access modes get
1541 # set on installed directories and files. All installed files with get
1542 # mode 644 unless they are a shared library in which case they will get
1543 # mode 755. All installed directories will get mode 755.
1545 so_ext
= sysconfig
.get_config_var("SO")
1548 outfiles
= install_lib
.install(self
)
1549 self
.set_file_modes(outfiles
, 0644, 0755)
1550 self
.set_dir_modes(self
.install_dir
, 0755)
1553 def set_file_modes(self
, files
, defaultMode
, sharedLibMode
):
1554 if not self
.is_chmod_supported(): return
1555 if not files
: return
1557 for filename
in files
:
1558 if os
.path
.islink(filename
): continue
1560 if filename
.endswith(self
.so_ext
): mode
= sharedLibMode
1561 log
.info("changing mode of %s to %o", filename
, mode
)
1562 if not self
.dry_run
: os
.chmod(filename
, mode
)
1564 def set_dir_modes(self
, dirname
, mode
):
1565 if not self
.is_chmod_supported(): return
1566 os
.path
.walk(dirname
, self
.set_dir_modes_visitor
, mode
)
1568 def set_dir_modes_visitor(self
, mode
, dirname
, names
):
1569 if os
.path
.islink(dirname
): return
1570 log
.info("changing mode of %s to %o", dirname
, mode
)
1571 if not self
.dry_run
: os
.chmod(dirname
, mode
)
1573 def is_chmod_supported(self
):
1574 return hasattr(os
, 'chmod')
1577 Python is an interpreted, interactive, object-oriented programming
1578 language. It is often compared to Tcl, Perl, Scheme or Java.
1580 Python combines remarkable power with very clear syntax. It has
1581 modules, classes, exceptions, very high level dynamic data types, and
1582 dynamic typing. There are interfaces to many system calls and
1583 libraries, as well as to various windowing systems (X11, Motif, Tk,
1584 Mac, MFC). New built-in modules are easily written in C or C++. Python
1585 is also usable as an extension language for applications that need a
1586 programmable interface.
1588 The Python implementation is portable: it runs on many brands of UNIX,
1589 on Windows, DOS, OS/2, Mac, Amiga... If your favorite system isn't
1590 listed here, it may still be supported, if there's a C compiler for
1591 it. Ask around on comp.lang.python -- or just try compiling Python
1596 Development Status :: 3 - Alpha
1597 Development Status :: 6 - Mature
1598 License :: OSI Approved :: Python Software Foundation License
1599 Natural Language :: English
1600 Programming Language :: C
1601 Programming Language :: Python
1602 Topic :: Software Development
1606 # turn off warnings when deprecated modules are imported
1608 warnings
.filterwarnings("ignore",category
=DeprecationWarning)
1609 setup(# PyPI Metadata (PEP 301)
1611 version
= sys
.version
.split()[0],
1612 url
= "http://www.python.org/%s" % sys
.version
[:3],
1613 maintainer
= "Guido van Rossum and the Python community",
1614 maintainer_email
= "python-dev@python.org",
1615 description
= "A high-level object-oriented programming language",
1616 long_description
= SUMMARY
.strip(),
1617 license
= "PSF license",
1618 classifiers
= filter(None, CLASSIFIERS
.split("\n")),
1619 platforms
= ["Many"],
1622 cmdclass
= {'build_ext':PyBuildExt
, 'install':PyBuildInstall
,
1623 'install_lib':PyBuildInstallLib
},
1624 # The struct module is defined here, because build_ext won't be
1625 # called unless there's at least one extension module defined.
1626 ext_modules
=[Extension('_struct', ['_struct.c'])],
1628 # Scripts to install
1629 scripts
= ['Tools/scripts/pydoc', 'Tools/scripts/idle',
1634 if __name__
== '__main__':