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']) )
512 missing
.extend(['imageop'])
515 do_readline
= self
.compiler
.find_library_file(lib_dirs
, 'readline')
516 if platform
== 'darwin':
517 # MacOSX 10.4 has a broken readline. Don't try to build
518 # the readline module unless the user has installed a fixed
520 if find_file('readline/rlconf.h', inc_dirs
, []) is None:
523 if sys
.platform
== 'darwin':
524 # In every directory on the search path search for a dynamic
525 # library and then a static library, instead of first looking
526 # for dynamic libraries on the entiry path.
527 # This way a staticly linked custom readline gets picked up
528 # before the (broken) dynamic library in /usr/lib.
529 readline_extra_link_args
= ('-Wl,-search_paths_first',)
531 readline_extra_link_args
= ()
533 readline_libs
= ['readline']
534 if self
.compiler
.find_library_file(lib_dirs
,
536 readline_libs
.append('ncursesw')
537 elif self
.compiler
.find_library_file(lib_dirs
,
539 readline_libs
.append('ncurses')
540 elif self
.compiler
.find_library_file(lib_dirs
, 'curses'):
541 readline_libs
.append('curses')
542 elif self
.compiler
.find_library_file(lib_dirs
+
543 ['/usr/lib/termcap'],
545 readline_libs
.append('termcap')
546 exts
.append( Extension('readline', ['readline.c'],
547 library_dirs
=['/usr/lib/termcap'],
548 extra_link_args
=readline_extra_link_args
,
549 libraries
=readline_libs
) )
551 missing
.append('readline')
553 if platform
not in ['mac']:
556 if self
.compiler
.find_library_file(lib_dirs
, 'crypt'):
560 exts
.append( Extension('crypt', ['cryptmodule.c'], libraries
=libs
) )
562 missing
.append('crypt')
565 exts
.append( Extension('_csv', ['_csv.c']) )
568 exts
.append( Extension('_socket', ['socketmodule.c'],
569 depends
= ['socketmodule.h']) )
570 # Detect SSL support for the socket module (via _ssl)
571 search_for_ssl_incs_in
= [
572 '/usr/local/ssl/include',
573 '/usr/contrib/ssl/include/'
575 ssl_incs
= find_file('openssl/ssl.h', inc_dirs
,
576 search_for_ssl_incs_in
578 if ssl_incs
is not None:
579 krb5_h
= find_file('krb5.h', inc_dirs
,
580 ['/usr/kerberos/include'])
583 ssl_libs
= find_library_file(self
.compiler
, 'ssl',lib_dirs
,
584 ['/usr/local/ssl/lib',
585 '/usr/contrib/ssl/lib/'
588 if (ssl_incs
is not None and
589 ssl_libs
is not None):
590 exts
.append( Extension('_ssl', ['_ssl.c'],
591 include_dirs
= ssl_incs
,
592 library_dirs
= ssl_libs
,
593 libraries
= ['ssl', 'crypto'],
594 depends
= ['socketmodule.h']), )
596 missing
.append('_ssl')
598 # find out which version of OpenSSL we have
600 openssl_ver_re
= re
.compile(
601 '^\s*#\s*define\s+OPENSSL_VERSION_NUMBER\s+(0x[0-9a-fA-F]+)' )
602 for ssl_inc_dir
in inc_dirs
+ search_for_ssl_incs_in
:
603 name
= os
.path
.join(ssl_inc_dir
, 'openssl', 'opensslv.h')
604 if os
.path
.isfile(name
):
606 incfile
= open(name
, 'r')
608 m
= openssl_ver_re
.match(line
)
610 openssl_ver
= eval(m
.group(1))
615 # first version found is what we'll use (as the compiler should)
619 #print 'openssl_ver = 0x%08x' % openssl_ver
621 if (ssl_incs
is not None and
622 ssl_libs
is not None and
623 openssl_ver
>= 0x00907000):
624 # The _hashlib module wraps optimized implementations
625 # of hash functions from the OpenSSL library.
626 exts
.append( Extension('_hashlib', ['_hashopenssl.c'],
627 include_dirs
= ssl_incs
,
628 library_dirs
= ssl_libs
,
629 libraries
= ['ssl', 'crypto']) )
630 missing
.extend(['_sha', '_md5'])
632 # The _sha module implements the SHA1 hash algorithm.
633 exts
.append( Extension('_sha', ['shamodule.c']) )
634 # The _md5 module implements the RSA Data Security, Inc. MD5
635 # Message-Digest Algorithm, described in RFC 1321. The
636 # necessary files md5.c and md5.h are included here.
637 exts
.append( Extension('_md5',
638 sources
= ['md5module.c', 'md5.c'],
639 depends
= ['md5.h']) )
640 missing
.append('_hashlib')
642 if (openssl_ver
< 0x00908000):
643 # OpenSSL doesn't do these until 0.9.8 so we'll bring our own hash
644 exts
.append( Extension('_sha256', ['sha256module.c']) )
645 exts
.append( Extension('_sha512', ['sha512module.c']) )
647 missing
.extend(['_sha256', '_sha512'])
649 # Modules that provide persistent dictionary-like semantics. You will
650 # probably want to arrange for at least one of them to be available on
651 # your machine, though none are defined by default because of library
652 # dependencies. The Python module anydbm.py provides an
653 # implementation independent wrapper for these; dumbdbm.py provides
654 # similar functionality (but slower of course) implemented in Python.
656 # Sleepycat Berkeley DB interface. http://www.sleepycat.com
658 # This requires the Sleepycat DB code. The supported versions
659 # are set below. Visit http://www.sleepycat.com/ to download
660 # a release. Most open source OSes come with one or more
661 # versions of BerkeleyDB already installed.
665 db_setup_debug
= False # verbose debug prints from this script?
667 # construct a list of paths to look for the header file in on
668 # top of the normal inc_dirs.
671 '/usr/local/include/db4',
672 '/opt/sfw/include/db4',
674 '/usr/local/include/db3',
675 '/opt/sfw/include/db3',
676 # Fink defaults (http://fink.sourceforge.net/)
680 # 4.x minor number specific paths
681 for x
in (0,1,2,3,4,5):
682 db_inc_paths
.append('/usr/include/db4%d' % x
)
683 db_inc_paths
.append('/usr/include/db4.%d' % x
)
684 db_inc_paths
.append('/usr/local/BerkeleyDB.4.%d/include' % x
)
685 db_inc_paths
.append('/usr/local/include/db4%d' % x
)
686 db_inc_paths
.append('/pkg/db-4.%d/include' % x
)
687 db_inc_paths
.append('/opt/db-4.%d/include' % x
)
688 # MacPorts default (http://www.macports.org/)
689 db_inc_paths
.append('/opt/local/include/db4%d' % x
)
690 # 3.x minor number specific paths
692 db_inc_paths
.append('/usr/include/db3%d' % x
)
693 db_inc_paths
.append('/usr/local/BerkeleyDB.3.%d/include' % x
)
694 db_inc_paths
.append('/usr/local/include/db3%d' % x
)
695 db_inc_paths
.append('/pkg/db-3.%d/include' % x
)
696 db_inc_paths
.append('/opt/db-3.%d/include' % x
)
698 # Add some common subdirectories for Sleepycat DB to the list,
699 # based on the standard include directories. This way DB3/4 gets
700 # picked up when it is installed in a non-standard prefix and
701 # the user has added that prefix into inc_dirs.
704 std_variants
.append(os
.path
.join(dn
, 'db3'))
705 std_variants
.append(os
.path
.join(dn
, 'db4'))
706 for x
in (0,1,2,3,4):
707 std_variants
.append(os
.path
.join(dn
, "db4%d"%x))
708 std_variants
.append(os
.path
.join(dn
, "db4.%d"%x))
710 std_variants
.append(os
.path
.join(dn
, "db3%d"%x))
711 std_variants
.append(os
.path
.join(dn
, "db3.%d"%x))
713 db_inc_paths
= std_variants
+ db_inc_paths
714 db_inc_paths
= [p
for p
in db_inc_paths
if os
.path
.exists(p
)]
718 class db_found(Exception): pass
720 # See whether there is a Sleepycat header in the standard
722 for d
in inc_dirs
+ db_inc_paths
:
723 f
= os
.path
.join(d
, "db.h")
724 if db_setup_debug
: print "db: looking for db.h in", f
725 if os
.path
.exists(f
):
727 m
= re
.search(r
"#define\WDB_VERSION_MAJOR\W(\d+)", f
)
729 db_major
= int(m
.group(1))
730 m
= re
.search(r
"#define\WDB_VERSION_MINOR\W(\d+)", f
)
731 db_minor
= int(m
.group(1))
732 db_ver
= (db_major
, db_minor
)
734 if ( (not db_ver_inc_map
.has_key(db_ver
)) and
735 (db_ver
<= max_db_ver
and db_ver
>= min_db_ver
) ):
736 # save the include directory with the db.h version
737 # (first occurrence only)
738 db_ver_inc_map
[db_ver
] = d
740 print "db.h: found", db_ver
, "in", d
742 # we already found a header for this library version
743 if db_setup_debug
: print "db.h: ignoring", d
745 # ignore this header, it didn't contain a version number
747 print "db.h: no version number version in", d
749 db_found_vers
= db_ver_inc_map
.keys()
753 db_ver
= db_found_vers
.pop()
754 db_incdir
= db_ver_inc_map
[db_ver
]
756 # check lib directories parallel to the location of the header
758 db_incdir
.replace("include", 'lib64'),
759 db_incdir
.replace("include", 'lib'),
761 db_dirs_to_check
= filter(os
.path
.isdir
, db_dirs_to_check
)
763 # Look for a version specific db-X.Y before an ambiguoius dbX
764 # XXX should we -ever- look for a dbX name? Do any
765 # systems really not name their library by version and
766 # symlink to more general names?
767 for dblib
in (('db-%d.%d' % db_ver
),
769 ('db%d' % db_ver
[0])):
770 dblib_file
= self
.compiler
.find_library_file(
771 db_dirs_to_check
+ lib_dirs
, dblib
)
773 dblib_dir
= [ os
.path
.abspath(os
.path
.dirname(dblib_file
)) ]
776 if db_setup_debug
: print "db lib: ", dblib
, "not found"
780 print "db lib: using", db_ver
, dblib
781 print "db: lib dir", dblib_dir
, "inc dir", db_incdir
782 db_incs
= [db_incdir
]
784 # We add the runtime_library_dirs argument because the
785 # BerkeleyDB lib we're linking against often isn't in the
786 # system dynamic library search path. This is usually
787 # correct and most trouble free, but may cause problems in
788 # some unusual system configurations (e.g. the directory
789 # is on an NFS server that goes away).
790 exts
.append(Extension('_bsddb', ['_bsddb.c'],
791 library_dirs
=dblib_dir
,
792 runtime_library_dirs
=dblib_dir
,
793 include_dirs
=db_incs
,
796 if db_setup_debug
: print "db: no appropriate library found"
800 missing
.append('_bsddb')
802 # The sqlite interface
803 sqlite_setup_debug
= False # verbose debug prints from this script?
805 # We hunt for #define SQLITE_VERSION "n.n.n"
806 # We need to find >= sqlite version 3.0.8
807 sqlite_incdir
= sqlite_libdir
= None
808 sqlite_inc_paths
= [ '/usr/include',
809 '/usr/include/sqlite',
810 '/usr/include/sqlite3',
811 '/usr/local/include',
812 '/usr/local/include/sqlite',
813 '/usr/local/include/sqlite3',
815 MIN_SQLITE_VERSION_NUMBER
= (3, 0, 8)
816 MIN_SQLITE_VERSION
= ".".join([str(x
)
817 for x
in MIN_SQLITE_VERSION_NUMBER
])
819 # Scan the default include directories before the SQLite specific
820 # ones. This allows one to override the copy of sqlite on OSX,
821 # where /usr/include contains an old version of sqlite.
822 for d
in inc_dirs
+ sqlite_inc_paths
:
823 f
= os
.path
.join(d
, "sqlite3.h")
824 if os
.path
.exists(f
):
825 if sqlite_setup_debug
: print "sqlite: found %s"%f
826 incf
= open(f
).read()
828 r
'\s*.*#\s*.*define\s.*SQLITE_VERSION\W*"(.*)"', incf
)
830 sqlite_version
= m
.group(1)
831 sqlite_version_tuple
= tuple([int(x
)
832 for x
in sqlite_version
.split(".")])
833 if sqlite_version_tuple
>= MIN_SQLITE_VERSION_NUMBER
:
835 if sqlite_setup_debug
:
836 print "%s/sqlite3.h: version %s"%(d
, sqlite_version
)
840 if sqlite_setup_debug
:
841 print "%s: version %d is too old, need >= %s"%(d
,
842 sqlite_version
, MIN_SQLITE_VERSION
)
843 elif sqlite_setup_debug
:
844 print "sqlite: %s had no SQLITE_VERSION"%(f
,)
847 sqlite_dirs_to_check
= [
848 os
.path
.join(sqlite_incdir
, '..', 'lib64'),
849 os
.path
.join(sqlite_incdir
, '..', 'lib'),
850 os
.path
.join(sqlite_incdir
, '..', '..', 'lib64'),
851 os
.path
.join(sqlite_incdir
, '..', '..', 'lib'),
853 sqlite_libfile
= self
.compiler
.find_library_file(
854 sqlite_dirs_to_check
+ lib_dirs
, 'sqlite3')
855 sqlite_libdir
= [os
.path
.abspath(os
.path
.dirname(sqlite_libfile
))]
857 if sqlite_incdir
and sqlite_libdir
:
858 sqlite_srcs
= ['_sqlite/cache.c',
859 '_sqlite/connection.c',
861 '_sqlite/microprotocols.c',
863 '_sqlite/prepare_protocol.c',
865 '_sqlite/statement.c',
869 if sys
.platform
!= "win32":
870 sqlite_defines
.append(('MODULE_NAME', '"sqlite3"'))
872 sqlite_defines
.append(('MODULE_NAME', '\\"sqlite3\\"'))
875 if sys
.platform
== 'darwin':
876 # In every directory on the search path search for a dynamic
877 # library and then a static library, instead of first looking
878 # for dynamic libraries on the entiry path.
879 # This way a staticly linked custom sqlite gets picked up
880 # before the dynamic library in /usr/lib.
881 sqlite_extra_link_args
= ('-Wl,-search_paths_first',)
883 sqlite_extra_link_args
= ()
885 exts
.append(Extension('_sqlite3', sqlite_srcs
,
886 define_macros
=sqlite_defines
,
887 include_dirs
=["Modules/_sqlite",
889 library_dirs
=sqlite_libdir
,
890 runtime_library_dirs
=sqlite_libdir
,
891 extra_link_args
=sqlite_extra_link_args
,
892 libraries
=["sqlite3",]))
894 missing
.append('_sqlite3')
896 # Look for Berkeley db 1.85. Note that it is built as a different
897 # module name so it can be included even when later versions are
898 # available. A very restrictive search is performed to avoid
899 # accidentally building this module with a later version of the
900 # underlying db library. May BSD-ish Unixes incorporate db 1.85
901 # symbols into libc and place the include file in /usr/include.
902 f
= "/usr/include/db.h"
903 if os
.path
.exists(f
):
904 data
= open(f
).read()
905 m
= re
.search(r
"#s*define\s+HASHVERSION\s+2\s*", data
)
907 # bingo - old version used hash file format version 2
908 ### XXX this should be fixed to not be platform-dependent
909 ### but I don't have direct access to an osf1 platform and
910 ### seemed to be muffing the search somehow
911 libraries
= platform
== "osf1" and ['db'] or None
912 if libraries
is not None:
913 exts
.append(Extension('bsddb185', ['bsddbmodule.c'],
914 libraries
=libraries
))
916 exts
.append(Extension('bsddb185', ['bsddbmodule.c']))
918 missing
.append('bsddb185')
920 missing
.append('bsddb185')
922 # The standard Unix dbm module:
923 if platform
not in ['cygwin']:
924 if find_file("ndbm.h", inc_dirs
, []) is not None:
925 # Some systems have -lndbm, others don't
926 if self
.compiler
.find_library_file(lib_dirs
, 'ndbm'):
930 exts
.append( Extension('dbm', ['dbmmodule.c'],
931 define_macros
=[('HAVE_NDBM_H',None)],
932 libraries
= ndbm_libs
) )
933 elif (self
.compiler
.find_library_file(lib_dirs
, 'gdbm')
934 and find_file("gdbm/ndbm.h", inc_dirs
, []) is not None):
935 exts
.append( Extension('dbm', ['dbmmodule.c'],
936 define_macros
=[('HAVE_GDBM_NDBM_H',None)],
937 libraries
= ['gdbm'] ) )
938 elif db_incs
is not None:
939 exts
.append( Extension('dbm', ['dbmmodule.c'],
940 library_dirs
=dblib_dir
,
941 runtime_library_dirs
=dblib_dir
,
942 include_dirs
=db_incs
,
943 define_macros
=[('HAVE_BERKDB_H',None),
944 ('DB_DBM_HSEARCH',None)],
947 missing
.append('dbm')
949 # Anthony Baxter's gdbm module. GNU dbm(3) will require -lgdbm:
950 if (self
.compiler
.find_library_file(lib_dirs
, 'gdbm')):
951 exts
.append( Extension('gdbm', ['gdbmmodule.c'],
952 libraries
= ['gdbm'] ) )
954 missing
.append('gdbm')
957 if platform
not in ['mac', 'win32']:
958 # Steen Lumholt's termios module
959 exts
.append( Extension('termios', ['termios.c']) )
960 # Jeremy Hylton's rlimit interface
961 if platform
not in ['atheos']:
962 exts
.append( Extension('resource', ['resource.c']) )
964 missing
.append('resource')
966 # Sun yellow pages. Some systems have the functions in libc.
967 if platform
not in ['cygwin', 'atheos']:
968 if (self
.compiler
.find_library_file(lib_dirs
, 'nsl')):
972 exts
.append( Extension('nis', ['nismodule.c'],
975 missing
.append('nis')
977 missing
.extend(['nis', 'resource', 'termios'])
979 # Curses support, requiring the System V version of curses, often
980 # provided by the ncurses library.
981 panel_library
= 'panel'
982 if (self
.compiler
.find_library_file(lib_dirs
, 'ncursesw')):
983 curses_libs
= ['ncursesw']
984 # Bug 1464056: If _curses.so links with ncursesw,
985 # _curses_panel.so must link with panelw.
986 panel_library
= 'panelw'
987 exts
.append( Extension('_curses', ['_cursesmodule.c'],
988 libraries
= curses_libs
) )
989 elif (self
.compiler
.find_library_file(lib_dirs
, 'ncurses')):
990 curses_libs
= ['ncurses']
991 exts
.append( Extension('_curses', ['_cursesmodule.c'],
992 libraries
= curses_libs
) )
993 elif (self
.compiler
.find_library_file(lib_dirs
, 'curses')
994 and platform
!= 'darwin'):
995 # OSX has an old Berkeley curses, not good enough for
996 # the _curses module.
997 if (self
.compiler
.find_library_file(lib_dirs
, 'terminfo')):
998 curses_libs
= ['curses', 'terminfo']
999 elif (self
.compiler
.find_library_file(lib_dirs
, 'termcap')):
1000 curses_libs
= ['curses', 'termcap']
1002 curses_libs
= ['curses']
1004 exts
.append( Extension('_curses', ['_cursesmodule.c'],
1005 libraries
= curses_libs
) )
1007 missing
.append('_curses')
1009 # If the curses module is enabled, check for the panel module
1010 if (module_enabled(exts
, '_curses') and
1011 self
.compiler
.find_library_file(lib_dirs
, panel_library
)):
1012 exts
.append( Extension('_curses_panel', ['_curses_panel.c'],
1013 libraries
= [panel_library
] + curses_libs
) )
1015 missing
.append('_curses_panel')
1017 # Andrew Kuchling's zlib module. Note that some versions of zlib
1018 # 1.1.3 have security problems. See CERT Advisory CA-2002-07:
1019 # http://www.cert.org/advisories/CA-2002-07.html
1021 # zlib 1.1.4 is fixed, but at least one vendor (RedHat) has decided to
1022 # patch its zlib 1.1.3 package instead of upgrading to 1.1.4. For
1023 # now, we still accept 1.1.3, because we think it's difficult to
1024 # exploit this in Python, and we'd rather make it RedHat's problem
1025 # than our problem <wink>.
1027 # You can upgrade zlib to version 1.1.4 yourself by going to
1028 # http://www.gzip.org/zlib/
1029 zlib_inc
= find_file('zlib.h', [], inc_dirs
)
1030 if zlib_inc
is not None:
1031 zlib_h
= zlib_inc
[0] + '/zlib.h'
1033 version_req
= '"1.1.3"'
1036 line
= fp
.readline()
1039 if line
.startswith('#define ZLIB_VERSION'):
1040 version
= line
.split()[2]
1042 if version
>= version_req
:
1043 if (self
.compiler
.find_library_file(lib_dirs
, 'z')):
1044 if sys
.platform
== "darwin":
1045 zlib_extra_link_args
= ('-Wl,-search_paths_first',)
1047 zlib_extra_link_args
= ()
1048 exts
.append( Extension('zlib', ['zlibmodule.c'],
1050 extra_link_args
= zlib_extra_link_args
))
1052 missing
.append('zlib')
1054 missing
.append('zlib')
1056 missing
.append('zlib')
1058 # Gustavo Niemeyer's bz2 module.
1059 if (self
.compiler
.find_library_file(lib_dirs
, 'bz2')):
1060 if sys
.platform
== "darwin":
1061 bz2_extra_link_args
= ('-Wl,-search_paths_first',)
1063 bz2_extra_link_args
= ()
1064 exts
.append( Extension('bz2', ['bz2module.c'],
1065 libraries
= ['bz2'],
1066 extra_link_args
= bz2_extra_link_args
) )
1068 missing
.append('bz2')
1070 # Interface to the Expat XML parser
1072 # Expat was written by James Clark and is now maintained by a
1073 # group of developers on SourceForge; see www.libexpat.org for
1074 # more information. The pyexpat module was written by Paul
1075 # Prescod after a prototype by Jack Jansen. The Expat source
1076 # is included in Modules/expat/. Usage of a system
1077 # shared libexpat.so/expat.dll is not advised.
1079 # More information on Expat can be found at www.libexpat.org.
1081 expatinc
= os
.path
.join(os
.getcwd(), srcdir
, 'Modules', 'expat')
1083 ('HAVE_EXPAT_CONFIG_H', '1'),
1086 exts
.append(Extension('pyexpat',
1087 define_macros
= define_macros
,
1088 include_dirs
= [expatinc
],
1089 sources
= ['pyexpat.c',
1096 # Fredrik Lundh's cElementTree module. Note that this also
1097 # uses expat (via the CAPI hook in pyexpat).
1099 if os
.path
.isfile(os
.path
.join(srcdir
, 'Modules', '_elementtree.c')):
1100 define_macros
.append(('USE_PYEXPAT_CAPI', None))
1101 exts
.append(Extension('_elementtree',
1102 define_macros
= define_macros
,
1103 include_dirs
= [expatinc
],
1104 sources
= ['_elementtree.c'],
1107 missing
.append('_elementtree')
1109 # Hye-Shik Chang's CJKCodecs modules.
1111 exts
.append(Extension('_multibytecodec',
1112 ['cjkcodecs/multibytecodec.c']))
1113 for loc
in ('kr', 'jp', 'cn', 'tw', 'hk', 'iso2022'):
1114 exts
.append(Extension('_codecs_%s' % loc
,
1115 ['cjkcodecs/_codecs_%s.c' % loc
]))
1117 missing
.append('_multibytecodec')
1118 for loc
in ('kr', 'jp', 'cn', 'tw', 'hk', 'iso2022'):
1119 missing
.append('_codecs_%s' % loc
)
1121 # Dynamic loading module
1122 if sys
.maxint
== 0x7fffffff:
1123 # This requires sizeof(int) == sizeof(long) == sizeof(char*)
1124 dl_inc
= find_file('dlfcn.h', [], inc_dirs
)
1125 if (dl_inc
is not None) and (platform
not in ['atheos']):
1126 exts
.append( Extension('dl', ['dlmodule.c']) )
1128 missing
.append('dl')
1130 missing
.append('dl')
1132 # Thomas Heller's _ctypes module
1133 self
.detect_ctypes(inc_dirs
, lib_dirs
)
1135 # Platform-specific libraries
1136 if platform
== 'linux2':
1137 # Linux-specific modules
1138 exts
.append( Extension('linuxaudiodev', ['linuxaudiodev.c']) )
1140 missing
.append('linuxaudiodev')
1142 if platform
in ('linux2', 'freebsd4', 'freebsd5', 'freebsd6',
1144 exts
.append( Extension('ossaudiodev', ['ossaudiodev.c']) )
1146 missing
.append('ossaudiodev')
1148 if platform
== 'sunos5':
1149 # SunOS specific modules
1150 exts
.append( Extension('sunaudiodev', ['sunaudiodev.c']) )
1152 missing
.append('sunaudiodev')
1154 if platform
== 'darwin' and ("--disable-toolbox-glue" not in
1155 sysconfig
.get_config_var("CONFIG_ARGS")):
1157 if os
.uname()[2] > '8.':
1158 # We're on Mac OS X 10.4 or later, the compiler should
1159 # support '-Wno-deprecated-declarations'. This will
1160 # surpress deprecation warnings for the Carbon extensions,
1161 # these extensions wrap the Carbon APIs and even those
1162 # parts that are deprecated.
1163 carbon_extra_compile_args
= ['-Wno-deprecated-declarations']
1165 carbon_extra_compile_args
= []
1167 # Mac OS X specific modules.
1168 def macSrcExists(name1
, name2
=''):
1173 names
= (name1
, name2
)
1174 path
= os
.path
.join(srcdir
, 'Mac', 'Modules', *names
)
1175 return os
.path
.exists(path
)
1177 def addMacExtension(name
, kwds
, extra_srcs
=[]):
1180 dirname
= name
[1:].lower()
1182 cmodulename
= name
+ 'module.c'
1183 # Check for NNN.c, NNNmodule.c, _nnn/NNN.c, _nnn/NNNmodule.c
1184 if macSrcExists(cname
):
1186 elif macSrcExists(cmodulename
):
1187 srcs
= [cmodulename
]
1188 elif macSrcExists(dirname
, cname
):
1189 # XXX(nnorwitz): If all the names ended with module, we
1190 # wouldn't need this condition. ibcarbon is the only one.
1191 srcs
= [os
.path
.join(dirname
, cname
)]
1192 elif macSrcExists(dirname
, cmodulename
):
1193 srcs
= [os
.path
.join(dirname
, cmodulename
)]
1195 raise RuntimeError("%s not found" % name
)
1197 # Here's the whole point: add the extension with sources
1198 exts
.append(Extension(name
, srcs
+ extra_srcs
, **kwds
))
1201 core_kwds
= {'extra_compile_args': carbon_extra_compile_args
,
1202 'extra_link_args': ['-framework', 'CoreFoundation'],
1204 addMacExtension('_CF', core_kwds
, ['cf/pycfbridge.c'])
1205 addMacExtension('autoGIL', core_kwds
)
1208 carbon_kwds
= {'extra_compile_args': carbon_extra_compile_args
,
1209 'extra_link_args': ['-framework', 'Carbon'],
1211 CARBON_EXTS
= ['ColorPicker', 'gestalt', 'MacOS', 'Nav',
1212 'OSATerminology', 'icglue',
1213 # All these are in subdirs
1214 '_AE', '_AH', '_App', '_CarbonEvt', '_Cm', '_Ctl',
1215 '_Dlg', '_Drag', '_Evt', '_File', '_Folder', '_Fm',
1216 '_Help', '_Icn', '_IBCarbon', '_List',
1217 '_Menu', '_Mlte', '_OSA', '_Res', '_Qd', '_Qdoffs',
1218 '_Scrap', '_Snd', '_TE', '_Win',
1220 for name
in CARBON_EXTS
:
1221 addMacExtension(name
, carbon_kwds
)
1223 # Application Services & QuickTime
1224 app_kwds
= {'extra_compile_args': carbon_extra_compile_args
,
1225 'extra_link_args': ['-framework','ApplicationServices'],
1227 addMacExtension('_Launch', app_kwds
)
1228 addMacExtension('_CG', app_kwds
)
1230 exts
.append( Extension('_Qt', ['qt/_Qtmodule.c'],
1231 extra_compile_args
=carbon_extra_compile_args
,
1232 extra_link_args
=['-framework', 'QuickTime',
1233 '-framework', 'Carbon']) )
1236 self
.extensions
.extend(exts
)
1238 # Call the method for detecting whether _tkinter can be compiled
1239 self
.detect_tkinter(inc_dirs
, lib_dirs
)
1241 if '_tkinter' not in [e
.name
for e
in self
.extensions
]:
1242 missing
.append('_tkinter')
1246 def detect_tkinter_darwin(self
, inc_dirs
, lib_dirs
):
1247 # The _tkinter module, using frameworks. Since frameworks are quite
1248 # different the UNIX search logic is not sharable.
1249 from os
.path
import join
, exists
1251 '/System/Library/Frameworks/',
1252 '/Library/Frameworks',
1253 join(os
.getenv('HOME'), '/Library/Frameworks')
1256 # Find the directory that contains the Tcl.framework and Tk.framework
1258 # XXX distutils should support -F!
1259 for F
in framework_dirs
:
1260 # both Tcl.framework and Tk.framework should be present
1261 for fw
in 'Tcl', 'Tk':
1262 if not exists(join(F
, fw
+ '.framework')):
1265 # ok, F is now directory with both frameworks. Continure
1269 # Tk and Tcl frameworks not found. Normal "unix" tkinter search
1273 # For 8.4a2, we must add -I options that point inside the Tcl and Tk
1274 # frameworks. In later release we should hopefully be able to pass
1275 # the -F option to gcc, which specifies a framework lookup path.
1278 join(F
, fw
+ '.framework', H
)
1279 for fw
in 'Tcl', 'Tk'
1280 for H
in 'Headers', 'Versions/Current/PrivateHeaders'
1283 # For 8.4a2, the X11 headers are not included. Rather than include a
1284 # complicated search, this is a hard-coded path. It could bail out
1285 # if X11 libs are not found...
1286 include_dirs
.append('/usr/X11R6/include')
1287 frameworks
= ['-framework', 'Tcl', '-framework', 'Tk']
1289 ext
= Extension('_tkinter', ['_tkinter.c', 'tkappinit.c'],
1290 define_macros
=[('WITH_APPINIT', 1)],
1291 include_dirs
= include_dirs
,
1293 extra_compile_args
= frameworks
,
1294 extra_link_args
= frameworks
,
1296 self
.extensions
.append(ext
)
1300 def detect_tkinter(self
, inc_dirs
, lib_dirs
):
1301 # The _tkinter module.
1303 # Rather than complicate the code below, detecting and building
1304 # AquaTk is a separate method. Only one Tkinter will be built on
1305 # Darwin - either AquaTk, if it is found, or X11 based Tk.
1306 platform
= self
.get_platform()
1307 if (platform
== 'darwin' and
1308 self
.detect_tkinter_darwin(inc_dirs
, lib_dirs
)):
1311 # Assume we haven't found any of the libraries or include files
1312 # The versions with dots are used on Unix, and the versions without
1313 # dots on Windows, for detection by cygwin.
1314 tcllib
= tklib
= tcl_includes
= tk_includes
= None
1315 for version
in ['8.5', '85', '8.4', '84', '8.3', '83', '8.2',
1316 '82', '8.1', '81', '8.0', '80']:
1317 tklib
= self
.compiler
.find_library_file(lib_dirs
, 'tk' + version
)
1318 tcllib
= self
.compiler
.find_library_file(lib_dirs
, 'tcl' + version
)
1319 if tklib
and tcllib
:
1320 # Exit the loop when we've found the Tcl/Tk libraries
1323 # Now check for the header files
1324 if tklib
and tcllib
:
1325 # Check for the include files on Debian and {Free,Open}BSD, where
1326 # they're put in /usr/include/{tcl,tk}X.Y
1327 dotversion
= version
1328 if '.' not in dotversion
and "bsd" in sys
.platform
.lower():
1329 # OpenBSD and FreeBSD use Tcl/Tk library names like libtcl83.a,
1330 # but the include subdirs are named like .../include/tcl8.3.
1331 dotversion
= dotversion
[:-1] + '.' + dotversion
[-1]
1332 tcl_include_sub
= []
1334 for dir in inc_dirs
:
1335 tcl_include_sub
+= [dir + os
.sep
+ "tcl" + dotversion
]
1336 tk_include_sub
+= [dir + os
.sep
+ "tk" + dotversion
]
1337 tk_include_sub
+= tcl_include_sub
1338 tcl_includes
= find_file('tcl.h', inc_dirs
, tcl_include_sub
)
1339 tk_includes
= find_file('tk.h', inc_dirs
, tk_include_sub
)
1341 if (tcllib
is None or tklib
is None or
1342 tcl_includes
is None or tk_includes
is None):
1343 self
.announce("INFO: Can't locate Tcl/Tk libs and/or headers", 2)
1346 # OK... everything seems to be present for Tcl/Tk.
1348 include_dirs
= [] ; libs
= [] ; defs
= [] ; added_lib_dirs
= []
1349 for dir in tcl_includes
+ tk_includes
:
1350 if dir not in include_dirs
:
1351 include_dirs
.append(dir)
1353 # Check for various platform-specific directories
1354 if platform
== 'sunos5':
1355 include_dirs
.append('/usr/openwin/include')
1356 added_lib_dirs
.append('/usr/openwin/lib')
1357 elif os
.path
.exists('/usr/X11R6/include'):
1358 include_dirs
.append('/usr/X11R6/include')
1359 added_lib_dirs
.append('/usr/X11R6/lib64')
1360 added_lib_dirs
.append('/usr/X11R6/lib')
1361 elif os
.path
.exists('/usr/X11R5/include'):
1362 include_dirs
.append('/usr/X11R5/include')
1363 added_lib_dirs
.append('/usr/X11R5/lib')
1365 # Assume default location for X11
1366 include_dirs
.append('/usr/X11/include')
1367 added_lib_dirs
.append('/usr/X11/lib')
1369 # If Cygwin, then verify that X is installed before proceeding
1370 if platform
== 'cygwin':
1371 x11_inc
= find_file('X11/Xlib.h', [], include_dirs
)
1375 # Check for BLT extension
1376 if self
.compiler
.find_library_file(lib_dirs
+ added_lib_dirs
,
1378 defs
.append( ('WITH_BLT', 1) )
1379 libs
.append('BLT8.0')
1380 elif self
.compiler
.find_library_file(lib_dirs
+ added_lib_dirs
,
1382 defs
.append( ('WITH_BLT', 1) )
1385 # Add the Tcl/Tk libraries
1386 libs
.append('tk'+ version
)
1387 libs
.append('tcl'+ version
)
1389 if platform
in ['aix3', 'aix4']:
1392 # Finally, link with the X11 libraries (not appropriate on cygwin)
1393 if platform
!= "cygwin":
1396 ext
= Extension('_tkinter', ['_tkinter.c', 'tkappinit.c'],
1397 define_macros
=[('WITH_APPINIT', 1)] + defs
,
1398 include_dirs
= include_dirs
,
1400 library_dirs
= added_lib_dirs
,
1402 self
.extensions
.append(ext
)
1404 ## # Uncomment these lines if you want to play with xxmodule.c
1405 ## ext = Extension('xx', ['xxmodule.c'])
1406 ## self.extensions.append(ext)
1408 # XXX handle these, but how to detect?
1409 # *** Uncomment and edit for PIL (TkImaging) extension only:
1410 # -DWITH_PIL -I../Extensions/Imaging/libImaging tkImaging.c \
1411 # *** Uncomment and edit for TOGL extension only:
1412 # -DWITH_TOGL togl.c \
1413 # *** Uncomment these for TOGL extension only:
1414 # -lGL -lGLU -lXext -lXmu \
1416 def configure_ctypes(self
, ext
):
1417 if not self
.use_system_libffi
:
1418 (srcdir
,) = sysconfig
.get_config_vars('srcdir')
1419 ffi_builddir
= os
.path
.join(self
.build_temp
, 'libffi')
1420 ffi_srcdir
= os
.path
.abspath(os
.path
.join(srcdir
, 'Modules',
1421 '_ctypes', 'libffi'))
1422 ffi_configfile
= os
.path
.join(ffi_builddir
, 'fficonfig.py')
1424 from distutils
.dep_util
import newer_group
1426 config_sources
= [os
.path
.join(ffi_srcdir
, fname
)
1427 for fname
in os
.listdir(ffi_srcdir
)
1428 if os
.path
.isfile(os
.path
.join(ffi_srcdir
, fname
))]
1429 if self
.force
or newer_group(config_sources
,
1431 from distutils
.dir_util
import mkpath
1432 mkpath(ffi_builddir
)
1435 # Pass empty CFLAGS because we'll just append the resulting
1436 # CFLAGS to Python's; -g or -O2 is to be avoided.
1437 cmd
= "cd %s && env CFLAGS='' '%s/configure' %s" \
1438 % (ffi_builddir
, ffi_srcdir
, " ".join(config_args
))
1440 res
= os
.system(cmd
)
1441 if res
or not os
.path
.exists(ffi_configfile
):
1442 print "Failed to configure _ctypes module"
1446 execfile(ffi_configfile
, globals(), fficonfig
)
1447 ffi_srcdir
= os
.path
.join(fficonfig
['ffi_srcdir'], 'src')
1449 # Add .S (preprocessed assembly) to C compiler source extensions.
1450 self
.compiler
.src_extensions
.append('.S')
1452 include_dirs
= [os
.path
.join(ffi_builddir
, 'include'),
1453 ffi_builddir
, ffi_srcdir
]
1454 extra_compile_args
= fficonfig
['ffi_cflags'].split()
1456 ext
.sources
.extend(fficonfig
['ffi_sources'])
1457 ext
.include_dirs
.extend(include_dirs
)
1458 ext
.extra_compile_args
.extend(extra_compile_args
)
1461 def detect_ctypes(self
, inc_dirs
, lib_dirs
):
1462 self
.use_system_libffi
= False
1464 extra_compile_args
= []
1465 extra_link_args
= []
1466 sources
= ['_ctypes/_ctypes.c',
1467 '_ctypes/callbacks.c',
1468 '_ctypes/callproc.c',
1469 '_ctypes/stgdict.c',
1471 '_ctypes/malloc_closure.c']
1472 depends
= ['_ctypes/ctypes.h']
1474 if sys
.platform
== 'darwin':
1475 sources
.append('_ctypes/darwin/dlfcn_simple.c')
1476 include_dirs
.append('_ctypes/darwin')
1477 # XXX Is this still needed?
1478 ## extra_link_args.extend(['-read_only_relocs', 'warning'])
1480 elif sys
.platform
== 'sunos5':
1481 # XXX This shouldn't be necessary; it appears that some
1482 # of the assembler code is non-PIC (i.e. it has relocations
1483 # when it shouldn't. The proper fix would be to rewrite
1484 # the assembler code to be PIC.
1485 # This only works with GCC; the Sun compiler likely refuses
1486 # this option. If you want to compile ctypes with the Sun
1487 # compiler, please research a proper solution, instead of
1488 # finding some -z option for the Sun compiler.
1489 extra_link_args
.append('-mimpure-text')
1491 ext
= Extension('_ctypes',
1492 include_dirs
=include_dirs
,
1493 extra_compile_args
=extra_compile_args
,
1494 extra_link_args
=extra_link_args
,
1498 ext_test
= Extension('_ctypes_test',
1499 sources
=['_ctypes/_ctypes_test.c'])
1500 self
.extensions
.extend([ext
, ext_test
])
1502 if not '--with-system-ffi' in sysconfig
.get_config_var("CONFIG_ARGS"):
1505 ffi_inc
= find_file('ffi.h', [], inc_dirs
)
1506 if ffi_inc
is not None:
1507 ffi_h
= ffi_inc
[0] + '/ffi.h'
1510 line
= fp
.readline()
1514 if line
.startswith('#define LIBFFI_H'):
1517 if ffi_inc
is not None:
1518 for lib_name
in ('ffi_convenience', 'ffi_pic', 'ffi'):
1519 if (self
.compiler
.find_library_file(lib_dirs
, lib_name
)):
1523 if ffi_inc
and ffi_lib
:
1524 ext
.include_dirs
.extend(ffi_inc
)
1525 ext
.libraries
.append(ffi_lib
)
1526 self
.use_system_libffi
= True
1529 class PyBuildInstall(install
):
1530 # Suppress the warning about installation into the lib_dynload
1531 # directory, which is not in sys.path when running Python during
1533 def initialize_options (self
):
1534 install
.initialize_options(self
)
1537 class PyBuildInstallLib(install_lib
):
1538 # Do exactly what install_lib does but make sure correct access modes get
1539 # set on installed directories and files. All installed files with get
1540 # mode 644 unless they are a shared library in which case they will get
1541 # mode 755. All installed directories will get mode 755.
1543 so_ext
= sysconfig
.get_config_var("SO")
1546 outfiles
= install_lib
.install(self
)
1547 self
.set_file_modes(outfiles
, 0644, 0755)
1548 self
.set_dir_modes(self
.install_dir
, 0755)
1551 def set_file_modes(self
, files
, defaultMode
, sharedLibMode
):
1552 if not self
.is_chmod_supported(): return
1553 if not files
: return
1555 for filename
in files
:
1556 if os
.path
.islink(filename
): continue
1558 if filename
.endswith(self
.so_ext
): mode
= sharedLibMode
1559 log
.info("changing mode of %s to %o", filename
, mode
)
1560 if not self
.dry_run
: os
.chmod(filename
, mode
)
1562 def set_dir_modes(self
, dirname
, mode
):
1563 if not self
.is_chmod_supported(): return
1564 os
.path
.walk(dirname
, self
.set_dir_modes_visitor
, mode
)
1566 def set_dir_modes_visitor(self
, mode
, dirname
, names
):
1567 if os
.path
.islink(dirname
): return
1568 log
.info("changing mode of %s to %o", dirname
, mode
)
1569 if not self
.dry_run
: os
.chmod(dirname
, mode
)
1571 def is_chmod_supported(self
):
1572 return hasattr(os
, 'chmod')
1575 Python is an interpreted, interactive, object-oriented programming
1576 language. It is often compared to Tcl, Perl, Scheme or Java.
1578 Python combines remarkable power with very clear syntax. It has
1579 modules, classes, exceptions, very high level dynamic data types, and
1580 dynamic typing. There are interfaces to many system calls and
1581 libraries, as well as to various windowing systems (X11, Motif, Tk,
1582 Mac, MFC). New built-in modules are easily written in C or C++. Python
1583 is also usable as an extension language for applications that need a
1584 programmable interface.
1586 The Python implementation is portable: it runs on many brands of UNIX,
1587 on Windows, DOS, OS/2, Mac, Amiga... If your favorite system isn't
1588 listed here, it may still be supported, if there's a C compiler for
1589 it. Ask around on comp.lang.python -- or just try compiling Python
1594 Development Status :: 3 - Alpha
1595 Development Status :: 6 - Mature
1596 License :: OSI Approved :: Python Software Foundation License
1597 Natural Language :: English
1598 Programming Language :: C
1599 Programming Language :: Python
1600 Topic :: Software Development
1604 # turn off warnings when deprecated modules are imported
1606 warnings
.filterwarnings("ignore",category
=DeprecationWarning)
1607 setup(# PyPI Metadata (PEP 301)
1609 version
= sys
.version
.split()[0],
1610 url
= "http://www.python.org/%s" % sys
.version
[:3],
1611 maintainer
= "Guido van Rossum and the Python community",
1612 maintainer_email
= "python-dev@python.org",
1613 description
= "A high-level object-oriented programming language",
1614 long_description
= SUMMARY
.strip(),
1615 license
= "PSF license",
1616 classifiers
= filter(None, CLASSIFIERS
.split("\n")),
1617 platforms
= ["Many"],
1620 cmdclass
= {'build_ext':PyBuildExt
, 'install':PyBuildInstall
,
1621 'install_lib':PyBuildInstallLib
},
1622 # The struct module is defined here, because build_ext won't be
1623 # called unless there's at least one extension module defined.
1624 ext_modules
=[Extension('_struct', ['_struct.c'])],
1626 # Scripts to install
1627 scripts
= ['Tools/scripts/pydoc', 'Tools/scripts/idle',
1632 if __name__
== '__main__':