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 build_extensions(self
):
96 # Detect which modules should be compiled
99 # Remove modules that are present on the disabled list
100 self
.extensions
= [ext
for ext
in self
.extensions
101 if ext
.name
not in disabled_module_list
]
103 # Fix up the autodetected modules, prefixing all the source files
104 # with Modules/ and adding Python's include directory to the path.
105 (srcdir
,) = sysconfig
.get_config_vars('srcdir')
107 # Maybe running on Windows but not using CYGWIN?
108 raise ValueError("No source directory; cannot proceed.")
110 # Figure out the location of the source code for extension modules
111 moddir
= os
.path
.join(os
.getcwd(), srcdir
, 'Modules')
112 moddir
= os
.path
.normpath(moddir
)
113 srcdir
, tail
= os
.path
.split(moddir
)
114 srcdir
= os
.path
.normpath(srcdir
)
115 moddir
= os
.path
.normpath(moddir
)
117 moddirlist
= [moddir
]
118 incdirlist
= ['./Include']
120 # Platform-dependent module source and include directories
121 platform
= self
.get_platform()
122 if platform
in ('darwin', 'mac') and ("--disable-toolbox-glue" not in
123 sysconfig
.get_config_var("CONFIG_ARGS")):
124 # Mac OS X also includes some mac-specific modules
125 macmoddir
= os
.path
.join(os
.getcwd(), srcdir
, 'Mac/Modules')
126 moddirlist
.append(macmoddir
)
127 incdirlist
.append('./Mac/Include')
129 alldirlist
= moddirlist
+ incdirlist
131 # Fix up the paths for scripts, too
132 self
.distribution
.scripts
= [os
.path
.join(srcdir
, filename
)
133 for filename
in self
.distribution
.scripts
]
135 for ext
in self
.extensions
[:]:
136 ext
.sources
= [ find_module_file(filename
, moddirlist
)
137 for filename
in ext
.sources
]
138 if ext
.depends
is not None:
139 ext
.depends
= [find_module_file(filename
, alldirlist
)
140 for filename
in ext
.depends
]
141 ext
.include_dirs
.append( '.' ) # to get config.h
142 for incdir
in incdirlist
:
143 ext
.include_dirs
.append( os
.path
.join(srcdir
, incdir
) )
145 # If a module has already been built statically,
146 # don't build it here
147 if ext
.name
in sys
.builtin_module_names
:
148 self
.extensions
.remove(ext
)
150 if platform
!= 'mac':
151 # Parse Modules/Setup and Modules/Setup.local to figure out which
152 # modules are turned on in the file.
154 for filename
in ('Modules/Setup', 'Modules/Setup.local'):
155 input = text_file
.TextFile(filename
, join_lines
=1)
157 line
= input.readline()
160 remove_modules
.append(line
[0])
163 for ext
in self
.extensions
[:]:
164 if ext
.name
in remove_modules
:
165 self
.extensions
.remove(ext
)
167 # When you run "make CC=altcc" or something similar, you really want
168 # those environment variables passed into the setup.py phase. Here's
169 # a small set of useful ones.
170 compiler
= os
.environ
.get('CC')
172 # unfortunately, distutils doesn't let us provide separate C and C++
174 if compiler
is not None:
175 (ccshared
,cflags
) = sysconfig
.get_config_vars('CCSHARED','CFLAGS')
176 args
['compiler_so'] = compiler
+ ' ' + ccshared
+ ' ' + cflags
177 self
.compiler
.set_executables(**args
)
179 build_ext
.build_extensions(self
)
181 def build_extension(self
, ext
):
183 if ext
.name
== '_ctypes':
184 if not self
.configure_ctypes(ext
):
188 build_ext
.build_extension(self
, ext
)
189 except (CCompilerError
, DistutilsError
), why
:
190 self
.announce('WARNING: building of extension "%s" failed: %s' %
191 (ext
.name
, sys
.exc_info()[1]))
193 # Workaround for Mac OS X: The Carbon-based modules cannot be
194 # reliably imported into a command-line Python
195 if 'Carbon' in ext
.extra_link_args
:
197 'WARNING: skipping import check for Carbon-based "%s"' %
200 # Workaround for Cygwin: Cygwin currently has fork issues when many
201 # modules have been imported
202 if self
.get_platform() == 'cygwin':
203 self
.announce('WARNING: skipping import check for Cygwin-based "%s"'
206 ext_filename
= os
.path
.join(
208 self
.get_ext_filename(self
.get_ext_fullname(ext
.name
)))
210 imp
.load_dynamic(ext
.name
, ext_filename
)
211 except ImportError, why
:
212 self
.announce('*** WARNING: renaming "%s" since importing it'
213 ' failed: %s' % (ext
.name
, why
), level
=3)
214 assert not self
.inplace
215 basename
, tail
= os
.path
.splitext(ext_filename
)
216 newname
= basename
+ "_failed" + tail
217 if os
.path
.exists(newname
):
219 os
.rename(ext_filename
, newname
)
221 # XXX -- This relies on a Vile HACK in
222 # distutils.command.build_ext.build_extension(). The
223 # _built_objects attribute is stored there strictly for
225 # If there is a failure, _built_objects may not be there,
226 # so catch the AttributeError and move on.
228 for filename
in self
._built
_objects
:
230 except AttributeError:
231 self
.announce('unable to remove files (ignored)')
233 exc_type
, why
, tb
= sys
.exc_info()
234 self
.announce('*** WARNING: importing extension "%s" '
235 'failed with %s: %s' % (ext
.name
, exc_type
, why
),
238 def get_platform(self
):
239 # Get value of sys.platform
240 for platform
in ['cygwin', 'beos', 'darwin', 'atheos', 'osf1']:
241 if sys
.platform
.startswith(platform
):
245 def detect_modules(self
):
246 # Ensure that /usr/local is always used
247 add_dir_to_list(self
.compiler
.library_dirs
, '/usr/local/lib')
248 add_dir_to_list(self
.compiler
.include_dirs
, '/usr/local/include')
250 # Add paths specified in the environment variables LDFLAGS and
251 # CPPFLAGS for header and library files.
252 # We must get the values from the Makefile and not the environment
253 # directly since an inconsistently reproducible issue comes up where
254 # the environment variable is not set even though the value were passed
255 # into configure and stored in the Makefile (issue found on OS X 10.3).
256 for env_var
, arg_name
, dir_list
in (
257 ('LDFLAGS', '-L', self
.compiler
.library_dirs
),
258 ('CPPFLAGS', '-I', self
.compiler
.include_dirs
)):
259 env_val
= sysconfig
.get_config_var(env_var
)
261 # To prevent optparse from raising an exception about any
262 # options in env_val that is doesn't know about we strip out
263 # all double dashes and any dashes followed by a character
264 # that is not for the option we are dealing with.
266 # Please note that order of the regex is important! We must
267 # strip out double-dashes first so that we don't end up with
268 # substituting "--Long" to "-Long" and thus lead to "ong" being
269 # used for a library directory.
270 env_val
= re
.sub(r
'(^|\s+)-(-|(?!%s))' % arg_name
[1], '', env_val
)
271 parser
= optparse
.OptionParser()
272 # Make sure that allowing args interspersed with options is
274 parser
.allow_interspersed_args
= True
275 parser
.error
= lambda msg
: None
276 parser
.add_option(arg_name
, dest
="dirs", action
="append")
277 options
= parser
.parse_args(env_val
.split())[0]
279 for directory
in options
.dirs
:
280 add_dir_to_list(dir_list
, directory
)
282 if os
.path
.normpath(sys
.prefix
) != '/usr':
283 add_dir_to_list(self
.compiler
.library_dirs
,
284 sysconfig
.get_config_var("LIBDIR"))
285 add_dir_to_list(self
.compiler
.include_dirs
,
286 sysconfig
.get_config_var("INCLUDEDIR"))
289 have_unicode
= unicode
293 # lib_dirs and inc_dirs are used to search for files;
294 # if a file is found in one of those directories, it can
295 # be assumed that no additional -I,-L directives are needed.
296 lib_dirs
= self
.compiler
.library_dirs
+ [
297 '/lib64', '/usr/lib64',
300 inc_dirs
= self
.compiler
.include_dirs
+ ['/usr/include']
303 config_h
= sysconfig
.get_config_h_filename()
304 config_h_vars
= sysconfig
.parse_config_h(open(config_h
))
306 platform
= self
.get_platform()
307 (srcdir
,) = sysconfig
.get_config_vars('srcdir')
309 # Check for AtheOS which has libraries in non-standard locations
310 if platform
== 'atheos':
311 lib_dirs
+= ['/system/libs', '/atheos/autolnk/lib']
312 lib_dirs
+= os
.getenv('LIBRARY_PATH', '').split(os
.pathsep
)
313 inc_dirs
+= ['/system/include', '/atheos/autolnk/include']
314 inc_dirs
+= os
.getenv('C_INCLUDE_PATH', '').split(os
.pathsep
)
316 # OSF/1 and Unixware have some stuff in /usr/ccs/lib (like -ldb)
317 if platform
in ['osf1', 'unixware7', 'openunix8']:
318 lib_dirs
+= ['/usr/ccs/lib']
320 if platform
== 'darwin':
321 # This should work on any unixy platform ;-)
322 # If the user has bothered specifying additional -I and -L flags
323 # in OPT and LDFLAGS we might as well use them here.
324 # NOTE: using shlex.split would technically be more correct, but
325 # also gives a bootstrap problem. Let's hope nobody uses directories
326 # with whitespace in the name to store libraries.
327 cflags
, ldflags
= sysconfig
.get_config_vars(
329 for item
in cflags
.split():
330 if item
.startswith('-I'):
331 inc_dirs
.append(item
[2:])
333 for item
in ldflags
.split():
334 if item
.startswith('-L'):
335 lib_dirs
.append(item
[2:])
337 # Check for MacOS X, which doesn't need libm.a at all
339 if platform
in ['darwin', 'beos', 'mac']:
342 # XXX Omitted modules: gl, pure, dl, SGI-specific modules
345 # The following modules are all pretty straightforward, and compile
346 # on pretty much any POSIXish platform.
349 # Some modules that are normally always on:
350 exts
.append( Extension('_weakref', ['_weakref.c']) )
353 exts
.append( Extension('array', ['arraymodule.c']) )
354 # complex math library functions
355 exts
.append( Extension('cmath', ['cmathmodule.c'],
356 libraries
=math_libs
) )
358 # math library functions, e.g. sin()
359 exts
.append( Extension('math', ['mathmodule.c'],
360 libraries
=math_libs
) )
361 # fast string operations implemented in C
362 exts
.append( Extension('strop', ['stropmodule.c']) )
363 # time operations and variables
364 exts
.append( Extension('time', ['timemodule.c'],
365 libraries
=math_libs
) )
366 exts
.append( Extension('datetime', ['datetimemodule.c', 'timemodule.c'],
367 libraries
=math_libs
) )
368 # random number generator implemented in C
369 exts
.append( Extension("_random", ["_randommodule.c"]) )
370 # fast iterator tools implemented in C
371 exts
.append( Extension("itertools", ["itertoolsmodule.c"]) )
372 # high-performance collections
373 exts
.append( Extension("collections", ["collectionsmodule.c"]) )
375 exts
.append( Extension("_bisect", ["_bisectmodule.c"]) )
377 exts
.append( Extension("_heapq", ["_heapqmodule.c"]) )
378 # operator.add() and similar goodies
379 exts
.append( Extension('operator', ['operator.c']) )
381 exts
.append( Extension("_functools", ["_functoolsmodule.c"]) )
382 # Python C API test module
383 exts
.append( Extension('_testcapi', ['_testcapimodule.c']) )
384 # profilers (_lsprof is for cProfile.py)
385 exts
.append( Extension('_hotshot', ['_hotshot.c']) )
386 exts
.append( Extension('_lsprof', ['_lsprof.c', 'rotatingtree.c']) )
387 # static Unicode character database
389 exts
.append( Extension('unicodedata', ['unicodedata.c']) )
390 # access to ISO C locale support
391 data
= open('pyconfig.h').read()
392 m
= re
.search(r
"#s*define\s+WITH_LIBINTL\s+1\s*", data
)
394 locale_libs
= ['intl']
397 if platform
== 'darwin':
398 locale_extra_link_args
= ['-framework', 'CoreFoundation']
400 locale_extra_link_args
= []
403 exts
.append( Extension('_locale', ['_localemodule.c'],
404 libraries
=locale_libs
,
405 extra_link_args
=locale_extra_link_args
) )
407 # Modules with some UNIX dependencies -- on by default:
408 # (If you have a really backward UNIX, select and socket may not be
411 # fcntl(2) and ioctl(2)
412 exts
.append( Extension('fcntl', ['fcntlmodule.c']) )
413 if platform
not in ['mac']:
415 exts
.append( Extension('pwd', ['pwdmodule.c']) )
417 exts
.append( Extension('grp', ['grpmodule.c']) )
418 # spwd, shadow passwords
419 if (config_h_vars
.get('HAVE_GETSPNAM', False) or
420 config_h_vars
.get('HAVE_GETSPENT', False)):
421 exts
.append( Extension('spwd', ['spwdmodule.c']) )
422 # select(2); not on ancient System V
423 exts
.append( Extension('select', ['selectmodule.c']) )
425 # Helper module for various ascii-encoders
426 exts
.append( Extension('binascii', ['binascii.c']) )
428 # Fred Drake's interface to the Python parser
429 exts
.append( Extension('parser', ['parsermodule.c']) )
431 # cStringIO and cPickle
432 exts
.append( Extension('cStringIO', ['cStringIO.c']) )
433 exts
.append( Extension('cPickle', ['cPickle.c']) )
435 # Memory-mapped files (also works on Win32).
436 if platform
not in ['atheos', 'mac']:
437 exts
.append( Extension('mmap', ['mmapmodule.c']) )
439 # Lance Ellinghaus's syslog module
440 if platform
not in ['mac']:
441 # syslog daemon interface
442 exts
.append( Extension('syslog', ['syslogmodule.c']) )
444 # George Neville-Neil's timing module:
445 # Deprecated in PEP 4 http://www.python.org/peps/pep-0004.html
446 # http://mail.python.org/pipermail/python-dev/2006-January/060023.html
447 #exts.append( Extension('timing', ['timingmodule.c']) )
450 # Here ends the simple stuff. From here on, modules need certain
451 # libraries, are platform-specific, or present other surprises.
455 # These don't work for 64-bit platforms!!!
456 # These represent audio samples or images as strings:
458 # Operations on audio samples
459 # According to #993173, this one should actually work fine on
461 exts
.append( Extension('audioop', ['audioop.c']) )
463 # Disabled on 64-bit platforms
464 if sys
.maxint
!= 9223372036854775807L:
465 # Operations on images
466 exts
.append( Extension('imageop', ['imageop.c']) )
467 # Read SGI RGB image files (but coded portably)
468 exts
.append( Extension('rgbimg', ['rgbimgmodule.c']) )
471 do_readline
= self
.compiler
.find_library_file(lib_dirs
, 'readline')
472 if platform
== 'darwin':
473 # MacOSX 10.4 has a broken readline. Don't try to build
474 # the readline module unless the user has installed a fixed
476 if find_file('readline/rlconf.h', inc_dirs
, []) is None:
479 if sys
.platform
== 'darwin':
480 # In every directory on the search path search for a dynamic
481 # library and then a static library, instead of first looking
482 # for dynamic libraries on the entiry path.
483 # This way a staticly linked custom readline gets picked up
484 # before the (broken) dynamic library in /usr/lib.
485 readline_extra_link_args
= ('-Wl,-search_paths_first',)
487 readline_extra_link_args
= ()
489 readline_libs
= ['readline']
490 if self
.compiler
.find_library_file(lib_dirs
,
492 readline_libs
.append('ncursesw')
493 elif self
.compiler
.find_library_file(lib_dirs
,
495 readline_libs
.append('ncurses')
496 elif self
.compiler
.find_library_file(lib_dirs
, 'curses'):
497 readline_libs
.append('curses')
498 elif self
.compiler
.find_library_file(lib_dirs
+
499 ['/usr/lib/termcap'],
501 readline_libs
.append('termcap')
502 exts
.append( Extension('readline', ['readline.c'],
503 library_dirs
=['/usr/lib/termcap'],
504 extra_link_args
=readline_extra_link_args
,
505 libraries
=readline_libs
) )
506 if platform
not in ['mac']:
509 if self
.compiler
.find_library_file(lib_dirs
, 'crypt'):
513 exts
.append( Extension('crypt', ['cryptmodule.c'], libraries
=libs
) )
516 exts
.append( Extension('_csv', ['_csv.c']) )
519 exts
.append( Extension('_socket', ['socketmodule.c'],
520 depends
= ['socketmodule.h']) )
521 # Detect SSL support for the socket module (via _ssl)
522 search_for_ssl_incs_in
= [
523 '/usr/local/ssl/include',
524 '/usr/contrib/ssl/include/'
526 ssl_incs
= find_file('openssl/ssl.h', inc_dirs
,
527 search_for_ssl_incs_in
529 if ssl_incs
is not None:
530 krb5_h
= find_file('krb5.h', inc_dirs
,
531 ['/usr/kerberos/include'])
534 ssl_libs
= find_library_file(self
.compiler
, 'ssl',lib_dirs
,
535 ['/usr/local/ssl/lib',
536 '/usr/contrib/ssl/lib/'
539 if (ssl_incs
is not None and
540 ssl_libs
is not None):
541 exts
.append( Extension('_ssl', ['_ssl.c'],
542 include_dirs
= ssl_incs
,
543 library_dirs
= ssl_libs
,
544 libraries
= ['ssl', 'crypto'],
545 depends
= ['socketmodule.h']), )
547 # find out which version of OpenSSL we have
549 openssl_ver_re
= re
.compile(
550 '^\s*#\s*define\s+OPENSSL_VERSION_NUMBER\s+(0x[0-9a-fA-F]+)' )
551 for ssl_inc_dir
in inc_dirs
+ search_for_ssl_incs_in
:
552 name
= os
.path
.join(ssl_inc_dir
, 'openssl', 'opensslv.h')
553 if os
.path
.isfile(name
):
555 incfile
= open(name
, 'r')
557 m
= openssl_ver_re
.match(line
)
559 openssl_ver
= eval(m
.group(1))
564 # first version found is what we'll use (as the compiler should)
568 #print 'openssl_ver = 0x%08x' % openssl_ver
570 if (ssl_incs
is not None and
571 ssl_libs
is not None and
572 openssl_ver
>= 0x00907000):
573 # The _hashlib module wraps optimized implementations
574 # of hash functions from the OpenSSL library.
575 exts
.append( Extension('_hashlib', ['_hashopenssl.c'],
576 include_dirs
= ssl_incs
,
577 library_dirs
= ssl_libs
,
578 libraries
= ['ssl', 'crypto']) )
580 # The _sha module implements the SHA1 hash algorithm.
581 exts
.append( Extension('_sha', ['shamodule.c']) )
582 # The _md5 module implements the RSA Data Security, Inc. MD5
583 # Message-Digest Algorithm, described in RFC 1321. The
584 # necessary files md5.c and md5.h are included here.
585 exts
.append( Extension('_md5',
586 sources
= ['md5module.c', 'md5.c'],
587 depends
= ['md5.h']) )
589 if (openssl_ver
< 0x00908000):
590 # OpenSSL doesn't do these until 0.9.8 so we'll bring our own hash
591 exts
.append( Extension('_sha256', ['sha256module.c']) )
592 exts
.append( Extension('_sha512', ['sha512module.c']) )
595 # Modules that provide persistent dictionary-like semantics. You will
596 # probably want to arrange for at least one of them to be available on
597 # your machine, though none are defined by default because of library
598 # dependencies. The Python module anydbm.py provides an
599 # implementation independent wrapper for these; dumbdbm.py provides
600 # similar functionality (but slower of course) implemented in Python.
602 # Sleepycat Berkeley DB interface. http://www.sleepycat.com
604 # This requires the Sleepycat DB code. The supported versions
605 # are set below. Visit http://www.sleepycat.com/ to download
606 # a release. Most open source OSes come with one or more
607 # versions of BerkeleyDB already installed.
611 db_setup_debug
= False # verbose debug prints from this script?
613 # construct a list of paths to look for the header file in on
614 # top of the normal inc_dirs.
617 '/usr/local/include/db4',
618 '/opt/sfw/include/db4',
621 '/usr/local/include/db3',
622 '/opt/sfw/include/db3',
625 # 4.x minor number specific paths
626 for x
in (0,1,2,3,4):
627 db_inc_paths
.append('/usr/include/db4%d' % x
)
628 db_inc_paths
.append('/usr/include/db4.%d' % x
)
629 db_inc_paths
.append('/usr/local/BerkeleyDB.4.%d/include' % x
)
630 db_inc_paths
.append('/usr/local/include/db4%d' % x
)
631 db_inc_paths
.append('/pkg/db-4.%d/include' % x
)
632 db_inc_paths
.append('/opt/db-4.%d/include' % x
)
633 # 3.x minor number specific paths
635 db_inc_paths
.append('/usr/include/db3%d' % x
)
636 db_inc_paths
.append('/usr/local/BerkeleyDB.3.%d/include' % x
)
637 db_inc_paths
.append('/usr/local/include/db3%d' % x
)
638 db_inc_paths
.append('/pkg/db-3.%d/include' % x
)
639 db_inc_paths
.append('/opt/db-3.%d/include' % x
)
641 # Add some common subdirectories for Sleepycat DB to the list,
642 # based on the standard include directories. This way DB3/4 gets
643 # picked up when it is installed in a non-standard prefix and
644 # the user has added that prefix into inc_dirs.
647 std_variants
.append(os
.path
.join(dn
, 'db3'))
648 std_variants
.append(os
.path
.join(dn
, 'db4'))
649 for x
in (0,1,2,3,4):
650 std_variants
.append(os
.path
.join(dn
, "db4%d"%x))
651 std_variants
.append(os
.path
.join(dn
, "db4.%d"%x))
653 std_variants
.append(os
.path
.join(dn
, "db3%d"%x))
654 std_variants
.append(os
.path
.join(dn
, "db3.%d"%x))
656 db_inc_paths
= std_variants
+ db_inc_paths
661 class db_found(Exception): pass
663 # See whether there is a Sleepycat header in the standard
665 for d
in inc_dirs
+ db_inc_paths
:
666 f
= os
.path
.join(d
, "db.h")
667 if db_setup_debug
: print "db: looking for db.h in", f
668 if os
.path
.exists(f
):
670 m
= re
.search(r
"#define\WDB_VERSION_MAJOR\W(\d+)", f
)
672 db_major
= int(m
.group(1))
673 m
= re
.search(r
"#define\WDB_VERSION_MINOR\W(\d+)", f
)
674 db_minor
= int(m
.group(1))
675 db_ver
= (db_major
, db_minor
)
677 if ( (not db_ver_inc_map
.has_key(db_ver
)) and
678 (db_ver
<= max_db_ver
and db_ver
>= min_db_ver
) ):
679 # save the include directory with the db.h version
680 # (first occurrance only)
681 db_ver_inc_map
[db_ver
] = d
682 print "db.h: found", db_ver
, "in", d
684 # we already found a header for this library version
685 if db_setup_debug
: print "db.h: ignoring", d
687 # ignore this header, it didn't contain a version number
688 if db_setup_debug
: print "db.h: unsupported version", db_ver
, "in", d
690 db_found_vers
= db_ver_inc_map
.keys()
694 db_ver
= db_found_vers
.pop()
695 db_incdir
= db_ver_inc_map
[db_ver
]
697 # check lib directories parallel to the location of the header
699 os
.path
.join(db_incdir
, '..', 'lib64'),
700 os
.path
.join(db_incdir
, '..', 'lib'),
701 os
.path
.join(db_incdir
, '..', '..', 'lib64'),
702 os
.path
.join(db_incdir
, '..', '..', 'lib'),
704 db_dirs_to_check
= filter(os
.path
.isdir
, db_dirs_to_check
)
706 # Look for a version specific db-X.Y before an ambiguoius dbX
707 # XXX should we -ever- look for a dbX name? Do any
708 # systems really not name their library by version and
709 # symlink to more general names?
710 for dblib
in (('db-%d.%d' % db_ver
),
712 ('db%d' % db_ver
[0])):
713 dblib_file
= self
.compiler
.find_library_file(
714 db_dirs_to_check
+ lib_dirs
, dblib
)
716 dblib_dir
= [ os
.path
.abspath(os
.path
.dirname(dblib_file
)) ]
719 if db_setup_debug
: print "db lib: ", dblib
, "not found"
722 print "db lib: using", db_ver
, dblib
723 if db_setup_debug
: print "db: lib dir", dblib_dir
, "inc dir", db_incdir
724 db_incs
= [db_incdir
]
726 # We add the runtime_library_dirs argument because the
727 # BerkeleyDB lib we're linking against often isn't in the
728 # system dynamic library search path. This is usually
729 # correct and most trouble free, but may cause problems in
730 # some unusual system configurations (e.g. the directory
731 # is on an NFS server that goes away).
732 exts
.append(Extension('_bsddb', ['_bsddb.c'],
733 library_dirs
=dblib_dir
,
734 runtime_library_dirs
=dblib_dir
,
735 include_dirs
=db_incs
,
738 if db_setup_debug
: print "db: no appropriate library found"
743 # The sqlite interface
744 sqlite_setup_debug
= True # verbose debug prints from this script?
746 # We hunt for #define SQLITE_VERSION "n.n.n"
747 # We need to find >= sqlite version 3.0.8
748 sqlite_incdir
= sqlite_libdir
= None
749 sqlite_inc_paths
= [ '/usr/include',
750 '/usr/include/sqlite',
751 '/usr/include/sqlite3',
752 '/usr/local/include',
753 '/usr/local/include/sqlite',
754 '/usr/local/include/sqlite3',
756 MIN_SQLITE_VERSION_NUMBER
= (3, 0, 8)
757 MIN_SQLITE_VERSION
= ".".join([str(x
)
758 for x
in MIN_SQLITE_VERSION_NUMBER
])
760 # Scan the default include directories before the SQLite specific
761 # ones. This allows one to override the copy of sqlite on OSX,
762 # where /usr/include contains an old version of sqlite.
763 for d
in inc_dirs
+ sqlite_inc_paths
:
764 f
= os
.path
.join(d
, "sqlite3.h")
765 if os
.path
.exists(f
):
766 if sqlite_setup_debug
: print "sqlite: found %s"%f
767 incf
= open(f
).read()
769 r
'\s*.*#\s*.*define\s.*SQLITE_VERSION\W*"(.*)"', incf
)
771 sqlite_version
= m
.group(1)
772 sqlite_version_tuple
= tuple([int(x
)
773 for x
in sqlite_version
.split(".")])
774 if sqlite_version_tuple
>= MIN_SQLITE_VERSION_NUMBER
:
776 print "%s/sqlite3.h: version %s"%(d
, sqlite_version
)
780 if sqlite_setup_debug
:
781 print "%s: version %d is too old, need >= %s"%(d
,
782 sqlite_version
, MIN_SQLITE_VERSION
)
783 elif sqlite_setup_debug
:
784 print "sqlite: %s had no SQLITE_VERSION"%(f
,)
787 sqlite_dirs_to_check
= [
788 os
.path
.join(sqlite_incdir
, '..', 'lib64'),
789 os
.path
.join(sqlite_incdir
, '..', 'lib'),
790 os
.path
.join(sqlite_incdir
, '..', '..', 'lib64'),
791 os
.path
.join(sqlite_incdir
, '..', '..', 'lib'),
793 sqlite_libfile
= self
.compiler
.find_library_file(
794 sqlite_dirs_to_check
+ lib_dirs
, 'sqlite3')
795 sqlite_libdir
= [os
.path
.abspath(os
.path
.dirname(sqlite_libfile
))]
797 if sqlite_incdir
and sqlite_libdir
:
798 sqlite_srcs
= ['_sqlite/cache.c',
799 '_sqlite/connection.c',
801 '_sqlite/microprotocols.c',
803 '_sqlite/prepare_protocol.c',
805 '_sqlite/statement.c',
809 if sys
.platform
!= "win32":
810 sqlite_defines
.append(('MODULE_NAME', '"sqlite3"'))
812 sqlite_defines
.append(('MODULE_NAME', '\\"sqlite3\\"'))
815 if sys
.platform
== 'darwin':
816 # In every directory on the search path search for a dynamic
817 # library and then a static library, instead of first looking
818 # for dynamic libraries on the entiry path.
819 # This way a staticly linked custom sqlite gets picked up
820 # before the dynamic library in /usr/lib.
821 sqlite_extra_link_args
= ('-Wl,-search_paths_first',)
823 sqlite_extra_link_args
= ()
825 exts
.append(Extension('_sqlite3', sqlite_srcs
,
826 define_macros
=sqlite_defines
,
827 include_dirs
=["Modules/_sqlite",
829 library_dirs
=sqlite_libdir
,
830 runtime_library_dirs
=sqlite_libdir
,
831 extra_link_args
=sqlite_extra_link_args
,
832 libraries
=["sqlite3",]))
834 # Look for Berkeley db 1.85. Note that it is built as a different
835 # module name so it can be included even when later versions are
836 # available. A very restrictive search is performed to avoid
837 # accidentally building this module with a later version of the
838 # underlying db library. May BSD-ish Unixes incorporate db 1.85
839 # symbols into libc and place the include file in /usr/include.
840 f
= "/usr/include/db.h"
841 if os
.path
.exists(f
):
842 data
= open(f
).read()
843 m
= re
.search(r
"#s*define\s+HASHVERSION\s+2\s*", data
)
845 # bingo - old version used hash file format version 2
846 ### XXX this should be fixed to not be platform-dependent
847 ### but I don't have direct access to an osf1 platform and
848 ### seemed to be muffing the search somehow
849 libraries
= platform
== "osf1" and ['db'] or None
850 if libraries
is not None:
851 exts
.append(Extension('bsddb185', ['bsddbmodule.c'],
852 libraries
=libraries
))
854 exts
.append(Extension('bsddb185', ['bsddbmodule.c']))
856 # The standard Unix dbm module:
857 if platform
not in ['cygwin']:
858 if find_file("ndbm.h", inc_dirs
, []) is not None:
859 # Some systems have -lndbm, others don't
860 if self
.compiler
.find_library_file(lib_dirs
, 'ndbm'):
864 exts
.append( Extension('dbm', ['dbmmodule.c'],
865 define_macros
=[('HAVE_NDBM_H',None)],
866 libraries
= ndbm_libs
) )
867 elif (self
.compiler
.find_library_file(lib_dirs
, 'gdbm')
868 and find_file("gdbm/ndbm.h", inc_dirs
, []) is not None):
869 exts
.append( Extension('dbm', ['dbmmodule.c'],
870 define_macros
=[('HAVE_GDBM_NDBM_H',None)],
871 libraries
= ['gdbm'] ) )
872 elif db_incs
is not None:
873 exts
.append( Extension('dbm', ['dbmmodule.c'],
874 library_dirs
=dblib_dir
,
875 runtime_library_dirs
=dblib_dir
,
876 include_dirs
=db_incs
,
877 define_macros
=[('HAVE_BERKDB_H',None),
878 ('DB_DBM_HSEARCH',None)],
881 # Anthony Baxter's gdbm module. GNU dbm(3) will require -lgdbm:
882 if (self
.compiler
.find_library_file(lib_dirs
, 'gdbm')):
883 exts
.append( Extension('gdbm', ['gdbmmodule.c'],
884 libraries
= ['gdbm'] ) )
887 if platform
not in ['mac', 'win32']:
888 # Steen Lumholt's termios module
889 exts
.append( Extension('termios', ['termios.c']) )
890 # Jeremy Hylton's rlimit interface
891 if platform
not in ['atheos']:
892 exts
.append( Extension('resource', ['resource.c']) )
894 # Sun yellow pages. Some systems have the functions in libc.
895 if platform
not in ['cygwin', 'atheos']:
896 if (self
.compiler
.find_library_file(lib_dirs
, 'nsl')):
900 exts
.append( Extension('nis', ['nismodule.c'],
903 # Curses support, requiring the System V version of curses, often
904 # provided by the ncurses library.
905 if (self
.compiler
.find_library_file(lib_dirs
, 'ncursesw')):
906 curses_libs
= ['ncursesw']
907 exts
.append( Extension('_curses', ['_cursesmodule.c'],
908 libraries
= curses_libs
) )
909 elif (self
.compiler
.find_library_file(lib_dirs
, 'ncurses')):
910 curses_libs
= ['ncurses']
911 exts
.append( Extension('_curses', ['_cursesmodule.c'],
912 libraries
= curses_libs
) )
913 elif (self
.compiler
.find_library_file(lib_dirs
, 'curses')
914 and platform
!= 'darwin'):
915 # OSX has an old Berkeley curses, not good enough for
916 # the _curses module.
917 if (self
.compiler
.find_library_file(lib_dirs
, 'terminfo')):
918 curses_libs
= ['curses', 'terminfo']
919 elif (self
.compiler
.find_library_file(lib_dirs
, 'termcap')):
920 curses_libs
= ['curses', 'termcap']
922 curses_libs
= ['curses']
924 exts
.append( Extension('_curses', ['_cursesmodule.c'],
925 libraries
= curses_libs
) )
927 # If the curses module is enabled, check for the panel module
928 if (module_enabled(exts
, '_curses') and
929 self
.compiler
.find_library_file(lib_dirs
, 'panel')):
930 exts
.append( Extension('_curses_panel', ['_curses_panel.c'],
931 libraries
= ['panel'] + curses_libs
) )
934 # Andrew Kuchling's zlib module. Note that some versions of zlib
935 # 1.1.3 have security problems. See CERT Advisory CA-2002-07:
936 # http://www.cert.org/advisories/CA-2002-07.html
938 # zlib 1.1.4 is fixed, but at least one vendor (RedHat) has decided to
939 # patch its zlib 1.1.3 package instead of upgrading to 1.1.4. For
940 # now, we still accept 1.1.3, because we think it's difficult to
941 # exploit this in Python, and we'd rather make it RedHat's problem
942 # than our problem <wink>.
944 # You can upgrade zlib to version 1.1.4 yourself by going to
945 # http://www.gzip.org/zlib/
946 zlib_inc
= find_file('zlib.h', [], inc_dirs
)
947 if zlib_inc
is not None:
948 zlib_h
= zlib_inc
[0] + '/zlib.h'
950 version_req
= '"1.1.3"'
956 if line
.startswith('#define ZLIB_VERSION'):
957 version
= line
.split()[2]
959 if version
>= version_req
:
960 if (self
.compiler
.find_library_file(lib_dirs
, 'z')):
961 if sys
.platform
== "darwin":
962 zlib_extra_link_args
= ('-Wl,-search_paths_first',)
964 zlib_extra_link_args
= ()
965 exts
.append( Extension('zlib', ['zlibmodule.c'],
967 extra_link_args
= zlib_extra_link_args
))
969 # Gustavo Niemeyer's bz2 module.
970 if (self
.compiler
.find_library_file(lib_dirs
, 'bz2')):
971 if sys
.platform
== "darwin":
972 bz2_extra_link_args
= ('-Wl,-search_paths_first',)
974 bz2_extra_link_args
= ()
975 exts
.append( Extension('bz2', ['bz2module.c'],
977 extra_link_args
= bz2_extra_link_args
) )
979 # Interface to the Expat XML parser
981 # Expat was written by James Clark and is now maintained by a
982 # group of developers on SourceForge; see www.libexpat.org for
983 # more information. The pyexpat module was written by Paul
984 # Prescod after a prototype by Jack Jansen. The Expat source
985 # is included in Modules/expat/. Usage of a system
986 # shared libexpat.so/expat.dll is not advised.
988 # More information on Expat can be found at www.libexpat.org.
990 expatinc
= os
.path
.join(os
.getcwd(), srcdir
, 'Modules', 'expat')
992 ('HAVE_EXPAT_CONFIG_H', '1'),
995 exts
.append(Extension('pyexpat',
996 define_macros
= define_macros
,
997 include_dirs
= [expatinc
],
998 sources
= ['pyexpat.c',
1005 # Fredrik Lundh's cElementTree module. Note that this also
1006 # uses expat (via the CAPI hook in pyexpat).
1008 if os
.path
.isfile(os
.path
.join(srcdir
, 'Modules', '_elementtree.c')):
1009 define_macros
.append(('USE_PYEXPAT_CAPI', None))
1010 exts
.append(Extension('_elementtree',
1011 define_macros
= define_macros
,
1012 include_dirs
= [expatinc
],
1013 sources
= ['_elementtree.c'],
1016 # Hye-Shik Chang's CJKCodecs modules.
1018 exts
.append(Extension('_multibytecodec',
1019 ['cjkcodecs/multibytecodec.c']))
1020 for loc
in ('kr', 'jp', 'cn', 'tw', 'hk', 'iso2022'):
1021 exts
.append(Extension('_codecs_' + loc
,
1022 ['cjkcodecs/_codecs_%s.c' % loc
]))
1024 # Dynamic loading module
1025 if sys
.maxint
== 0x7fffffff:
1026 # This requires sizeof(int) == sizeof(long) == sizeof(char*)
1027 dl_inc
= find_file('dlfcn.h', [], inc_dirs
)
1028 if (dl_inc
is not None) and (platform
not in ['atheos']):
1029 exts
.append( Extension('dl', ['dlmodule.c']) )
1031 # Thomas Heller's _ctypes module
1032 self
.detect_ctypes(inc_dirs
, lib_dirs
)
1034 # Platform-specific libraries
1035 if platform
== 'linux2':
1036 # Linux-specific modules
1037 exts
.append( Extension('linuxaudiodev', ['linuxaudiodev.c']) )
1039 if platform
in ('linux2', 'freebsd4', 'freebsd5', 'freebsd6',
1041 exts
.append( Extension('ossaudiodev', ['ossaudiodev.c']) )
1043 if platform
== 'sunos5':
1044 # SunOS specific modules
1045 exts
.append( Extension('sunaudiodev', ['sunaudiodev.c']) )
1047 if platform
== 'darwin' and ("--disable-toolbox-glue" not in
1048 sysconfig
.get_config_var("CONFIG_ARGS")):
1050 if os
.uname()[2] > '8.':
1051 # We're on Mac OS X 10.4 or later, the compiler should
1052 # support '-Wno-deprecated-declarations'. This will
1053 # surpress deprecation warnings for the Carbon extensions,
1054 # these extensions wrap the Carbon APIs and even those
1055 # parts that are deprecated.
1056 carbon_extra_compile_args
= ['-Wno-deprecated-declarations']
1058 carbon_extra_compile_args
= []
1060 # Mac OS X specific modules.
1061 def macSrcExists(name1
, name2
=''):
1066 names
= (name1
, name2
)
1067 path
= os
.path
.join(srcdir
, 'Mac', 'Modules', *names
)
1068 return os
.path
.exists(path
)
1070 def addMacExtension(name
, kwds
, extra_srcs
=[]):
1073 dirname
= name
[1:].lower()
1075 cmodulename
= name
+ 'module.c'
1076 # Check for NNN.c, NNNmodule.c, _nnn/NNN.c, _nnn/NNNmodule.c
1077 if macSrcExists(cname
):
1079 elif macSrcExists(cmodulename
):
1080 srcs
= [cmodulename
]
1081 elif macSrcExists(dirname
, cname
):
1082 # XXX(nnorwitz): If all the names ended with module, we
1083 # wouldn't need this condition. ibcarbon is the only one.
1084 srcs
= [os
.path
.join(dirname
, cname
)]
1085 elif macSrcExists(dirname
, cmodulename
):
1086 srcs
= [os
.path
.join(dirname
, cmodulename
)]
1088 raise RuntimeError("%s not found" % name
)
1090 # Here's the whole point: add the extension with sources
1091 exts
.append(Extension(name
, srcs
+ extra_srcs
, **kwds
))
1094 core_kwds
= {'extra_compile_args': carbon_extra_compile_args
,
1095 'extra_link_args': ['-framework', 'CoreFoundation'],
1097 addMacExtension('_CF', core_kwds
, ['cf/pycfbridge.c'])
1098 addMacExtension('autoGIL', core_kwds
)
1101 carbon_kwds
= {'extra_compile_args': carbon_extra_compile_args
,
1102 'extra_link_args': ['-framework', 'Carbon'],
1104 CARBON_EXTS
= ['ColorPicker', 'gestalt', 'MacOS', 'Nav',
1105 'OSATerminology', 'icglue',
1106 # All these are in subdirs
1107 '_AE', '_AH', '_App', '_CarbonEvt', '_Cm', '_Ctl',
1108 '_Dlg', '_Drag', '_Evt', '_File', '_Folder', '_Fm',
1109 '_Help', '_Icn', '_IBCarbon', '_List',
1110 '_Menu', '_Mlte', '_OSA', '_Res', '_Qd', '_Qdoffs',
1111 '_Scrap', '_Snd', '_TE', '_Win',
1113 for name
in CARBON_EXTS
:
1114 addMacExtension(name
, carbon_kwds
)
1116 # Application Services & QuickTime
1117 app_kwds
= {'extra_compile_args': carbon_extra_compile_args
,
1118 'extra_link_args': ['-framework','ApplicationServices'],
1120 addMacExtension('_Launch', app_kwds
)
1121 addMacExtension('_CG', app_kwds
)
1123 exts
.append( Extension('_Qt', ['qt/_Qtmodule.c'],
1124 extra_compile_args
=carbon_extra_compile_args
,
1125 extra_link_args
=['-framework', 'QuickTime',
1126 '-framework', 'Carbon']) )
1129 self
.extensions
.extend(exts
)
1131 # Call the method for detecting whether _tkinter can be compiled
1132 self
.detect_tkinter(inc_dirs
, lib_dirs
)
1134 def detect_tkinter_darwin(self
, inc_dirs
, lib_dirs
):
1135 # The _tkinter module, using frameworks. Since frameworks are quite
1136 # different the UNIX search logic is not sharable.
1137 from os
.path
import join
, exists
1139 '/System/Library/Frameworks/',
1140 '/Library/Frameworks',
1141 join(os
.getenv('HOME'), '/Library/Frameworks')
1144 # Find the directory that contains the Tcl.framework and Tk.framework
1146 # XXX distutils should support -F!
1147 for F
in framework_dirs
:
1148 # both Tcl.framework and Tk.framework should be present
1149 for fw
in 'Tcl', 'Tk':
1150 if not exists(join(F
, fw
+ '.framework')):
1153 # ok, F is now directory with both frameworks. Continure
1157 # Tk and Tcl frameworks not found. Normal "unix" tkinter search
1161 # For 8.4a2, we must add -I options that point inside the Tcl and Tk
1162 # frameworks. In later release we should hopefully be able to pass
1163 # the -F option to gcc, which specifies a framework lookup path.
1166 join(F
, fw
+ '.framework', H
)
1167 for fw
in 'Tcl', 'Tk'
1168 for H
in 'Headers', 'Versions/Current/PrivateHeaders'
1171 # For 8.4a2, the X11 headers are not included. Rather than include a
1172 # complicated search, this is a hard-coded path. It could bail out
1173 # if X11 libs are not found...
1174 include_dirs
.append('/usr/X11R6/include')
1175 frameworks
= ['-framework', 'Tcl', '-framework', 'Tk']
1177 ext
= Extension('_tkinter', ['_tkinter.c', 'tkappinit.c'],
1178 define_macros
=[('WITH_APPINIT', 1)],
1179 include_dirs
= include_dirs
,
1181 extra_compile_args
= frameworks
,
1182 extra_link_args
= frameworks
,
1184 self
.extensions
.append(ext
)
1188 def detect_tkinter(self
, inc_dirs
, lib_dirs
):
1189 # The _tkinter module.
1191 # Rather than complicate the code below, detecting and building
1192 # AquaTk is a separate method. Only one Tkinter will be built on
1193 # Darwin - either AquaTk, if it is found, or X11 based Tk.
1194 platform
= self
.get_platform()
1195 if (platform
== 'darwin' and
1196 self
.detect_tkinter_darwin(inc_dirs
, lib_dirs
)):
1199 # Assume we haven't found any of the libraries or include files
1200 # The versions with dots are used on Unix, and the versions without
1201 # dots on Windows, for detection by cygwin.
1202 tcllib
= tklib
= tcl_includes
= tk_includes
= None
1203 for version
in ['8.5', '85', '8.4', '84', '8.3', '83', '8.2',
1204 '82', '8.1', '81', '8.0', '80']:
1205 tklib
= self
.compiler
.find_library_file(lib_dirs
, 'tk' + version
)
1206 tcllib
= self
.compiler
.find_library_file(lib_dirs
, 'tcl' + version
)
1207 if tklib
and tcllib
:
1208 # Exit the loop when we've found the Tcl/Tk libraries
1211 # Now check for the header files
1212 if tklib
and tcllib
:
1213 # Check for the include files on Debian and {Free,Open}BSD, where
1214 # they're put in /usr/include/{tcl,tk}X.Y
1215 dotversion
= version
1216 if '.' not in dotversion
and "bsd" in sys
.platform
.lower():
1217 # OpenBSD and FreeBSD use Tcl/Tk library names like libtcl83.a,
1218 # but the include subdirs are named like .../include/tcl8.3.
1219 dotversion
= dotversion
[:-1] + '.' + dotversion
[-1]
1220 tcl_include_sub
= []
1222 for dir in inc_dirs
:
1223 tcl_include_sub
+= [dir + os
.sep
+ "tcl" + dotversion
]
1224 tk_include_sub
+= [dir + os
.sep
+ "tk" + dotversion
]
1225 tk_include_sub
+= tcl_include_sub
1226 tcl_includes
= find_file('tcl.h', inc_dirs
, tcl_include_sub
)
1227 tk_includes
= find_file('tk.h', inc_dirs
, tk_include_sub
)
1229 if (tcllib
is None or tklib
is None or
1230 tcl_includes
is None or tk_includes
is None):
1231 self
.announce("INFO: Can't locate Tcl/Tk libs and/or headers", 2)
1234 # OK... everything seems to be present for Tcl/Tk.
1236 include_dirs
= [] ; libs
= [] ; defs
= [] ; added_lib_dirs
= []
1237 for dir in tcl_includes
+ tk_includes
:
1238 if dir not in include_dirs
:
1239 include_dirs
.append(dir)
1241 # Check for various platform-specific directories
1242 if platform
== 'sunos5':
1243 include_dirs
.append('/usr/openwin/include')
1244 added_lib_dirs
.append('/usr/openwin/lib')
1245 elif os
.path
.exists('/usr/X11R6/include'):
1246 include_dirs
.append('/usr/X11R6/include')
1247 added_lib_dirs
.append('/usr/X11R6/lib64')
1248 added_lib_dirs
.append('/usr/X11R6/lib')
1249 elif os
.path
.exists('/usr/X11R5/include'):
1250 include_dirs
.append('/usr/X11R5/include')
1251 added_lib_dirs
.append('/usr/X11R5/lib')
1253 # Assume default location for X11
1254 include_dirs
.append('/usr/X11/include')
1255 added_lib_dirs
.append('/usr/X11/lib')
1257 # If Cygwin, then verify that X is installed before proceeding
1258 if platform
== 'cygwin':
1259 x11_inc
= find_file('X11/Xlib.h', [], include_dirs
)
1263 # Check for BLT extension
1264 if self
.compiler
.find_library_file(lib_dirs
+ added_lib_dirs
,
1266 defs
.append( ('WITH_BLT', 1) )
1267 libs
.append('BLT8.0')
1268 elif self
.compiler
.find_library_file(lib_dirs
+ added_lib_dirs
,
1270 defs
.append( ('WITH_BLT', 1) )
1273 # Add the Tcl/Tk libraries
1274 libs
.append('tk'+ version
)
1275 libs
.append('tcl'+ version
)
1277 if platform
in ['aix3', 'aix4']:
1280 # Finally, link with the X11 libraries (not appropriate on cygwin)
1281 if platform
!= "cygwin":
1284 ext
= Extension('_tkinter', ['_tkinter.c', 'tkappinit.c'],
1285 define_macros
=[('WITH_APPINIT', 1)] + defs
,
1286 include_dirs
= include_dirs
,
1288 library_dirs
= added_lib_dirs
,
1290 self
.extensions
.append(ext
)
1292 ## # Uncomment these lines if you want to play with xxmodule.c
1293 ## ext = Extension('xx', ['xxmodule.c'])
1294 ## self.extensions.append(ext)
1296 # XXX handle these, but how to detect?
1297 # *** Uncomment and edit for PIL (TkImaging) extension only:
1298 # -DWITH_PIL -I../Extensions/Imaging/libImaging tkImaging.c \
1299 # *** Uncomment and edit for TOGL extension only:
1300 # -DWITH_TOGL togl.c \
1301 # *** Uncomment these for TOGL extension only:
1302 # -lGL -lGLU -lXext -lXmu \
1304 def configure_ctypes(self
, ext
):
1305 if not self
.use_system_libffi
:
1306 (srcdir
,) = sysconfig
.get_config_vars('srcdir')
1307 ffi_builddir
= os
.path
.join(self
.build_temp
, 'libffi')
1308 ffi_srcdir
= os
.path
.abspath(os
.path
.join(srcdir
, 'Modules',
1309 '_ctypes', 'libffi'))
1310 ffi_configfile
= os
.path
.join(ffi_builddir
, 'fficonfig.py')
1312 from distutils
.dep_util
import newer_group
1314 config_sources
= [os
.path
.join(ffi_srcdir
, fname
)
1315 for fname
in os
.listdir(ffi_srcdir
)]
1316 if self
.force
or newer_group(config_sources
,
1318 from distutils
.dir_util
import mkpath
1319 mkpath(ffi_builddir
)
1322 # Pass empty CFLAGS because we'll just append the resulting
1323 # CFLAGS to Python's; -g or -O2 is to be avoided.
1324 cmd
= "cd %s && env CFLAGS='' '%s/configure' %s" \
1325 % (ffi_builddir
, ffi_srcdir
, " ".join(config_args
))
1327 res
= os
.system(cmd
)
1328 if res
or not os
.path
.exists(ffi_configfile
):
1329 print "Failed to configure _ctypes module"
1333 execfile(ffi_configfile
, globals(), fficonfig
)
1334 ffi_srcdir
= os
.path
.join(fficonfig
['ffi_srcdir'], 'src')
1336 # Add .S (preprocessed assembly) to C compiler source extensions.
1337 self
.compiler
.src_extensions
.append('.S')
1339 include_dirs
= [os
.path
.join(ffi_builddir
, 'include'),
1340 ffi_builddir
, ffi_srcdir
]
1341 extra_compile_args
= fficonfig
['ffi_cflags'].split()
1343 ext
.sources
.extend(fficonfig
['ffi_sources'])
1344 ext
.include_dirs
.extend(include_dirs
)
1345 ext
.extra_compile_args
.extend(extra_compile_args
)
1348 def detect_ctypes(self
, inc_dirs
, lib_dirs
):
1349 self
.use_system_libffi
= False
1351 extra_compile_args
= []
1352 sources
= ['_ctypes/_ctypes.c',
1353 '_ctypes/callbacks.c',
1354 '_ctypes/callproc.c',
1355 '_ctypes/stgdict.c',
1357 '_ctypes/malloc_closure.c']
1358 depends
= ['_ctypes/ctypes.h']
1360 if sys
.platform
== 'darwin':
1361 sources
.append('_ctypes/darwin/dlfcn_simple.c')
1362 include_dirs
.append('_ctypes/darwin')
1363 # XXX Is this still needed?
1364 ## extra_link_args.extend(['-read_only_relocs', 'warning'])
1366 ext
= Extension('_ctypes',
1367 include_dirs
=include_dirs
,
1368 extra_compile_args
=extra_compile_args
,
1372 ext_test
= Extension('_ctypes_test',
1373 sources
=['_ctypes/_ctypes_test.c'])
1374 self
.extensions
.extend([ext
, ext_test
])
1376 if not '--with-system-ffi' in sysconfig
.get_config_var("CONFIG_ARGS"):
1379 ffi_inc
= find_file('ffi.h', [], inc_dirs
)
1380 if ffi_inc
is not None:
1381 ffi_h
= ffi_inc
[0] + '/ffi.h'
1384 line
= fp
.readline()
1388 if line
.startswith('#define LIBFFI_H'):
1391 if ffi_inc
is not None:
1392 for lib_name
in ('ffi_convenience', 'ffi_pic', 'ffi'):
1393 if (self
.compiler
.find_library_file(lib_dirs
, lib_name
)):
1397 if ffi_inc
and ffi_lib
:
1398 ext
.include_dirs
.extend(ffi_inc
)
1399 ext
.libraries
.append(ffi_lib
)
1400 self
.use_system_libffi
= True
1403 class PyBuildInstall(install
):
1404 # Suppress the warning about installation into the lib_dynload
1405 # directory, which is not in sys.path when running Python during
1407 def initialize_options (self
):
1408 install
.initialize_options(self
)
1411 class PyBuildInstallLib(install_lib
):
1412 # Do exactly what install_lib does but make sure correct access modes get
1413 # set on installed directories and files. All installed files with get
1414 # mode 644 unless they are a shared library in which case they will get
1415 # mode 755. All installed directories will get mode 755.
1417 so_ext
= sysconfig
.get_config_var("SO")
1420 outfiles
= install_lib
.install(self
)
1421 self
.set_file_modes(outfiles
, 0644, 0755)
1422 self
.set_dir_modes(self
.install_dir
, 0755)
1425 def set_file_modes(self
, files
, defaultMode
, sharedLibMode
):
1426 if not self
.is_chmod_supported(): return
1427 if not files
: return
1429 for filename
in files
:
1430 if os
.path
.islink(filename
): continue
1432 if filename
.endswith(self
.so_ext
): mode
= sharedLibMode
1433 log
.info("changing mode of %s to %o", filename
, mode
)
1434 if not self
.dry_run
: os
.chmod(filename
, mode
)
1436 def set_dir_modes(self
, dirname
, mode
):
1437 if not self
.is_chmod_supported(): return
1438 os
.path
.walk(dirname
, self
.set_dir_modes_visitor
, mode
)
1440 def set_dir_modes_visitor(self
, mode
, dirname
, names
):
1441 if os
.path
.islink(dirname
): return
1442 log
.info("changing mode of %s to %o", dirname
, mode
)
1443 if not self
.dry_run
: os
.chmod(dirname
, mode
)
1445 def is_chmod_supported(self
):
1446 return hasattr(os
, 'chmod')
1449 Python is an interpreted, interactive, object-oriented programming
1450 language. It is often compared to Tcl, Perl, Scheme or Java.
1452 Python combines remarkable power with very clear syntax. It has
1453 modules, classes, exceptions, very high level dynamic data types, and
1454 dynamic typing. There are interfaces to many system calls and
1455 libraries, as well as to various windowing systems (X11, Motif, Tk,
1456 Mac, MFC). New built-in modules are easily written in C or C++. Python
1457 is also usable as an extension language for applications that need a
1458 programmable interface.
1460 The Python implementation is portable: it runs on many brands of UNIX,
1461 on Windows, DOS, OS/2, Mac, Amiga... If your favorite system isn't
1462 listed here, it may still be supported, if there's a C compiler for
1463 it. Ask around on comp.lang.python -- or just try compiling Python
1468 Development Status :: 3 - Alpha
1469 Development Status :: 6 - Mature
1470 License :: OSI Approved :: Python Software Foundation License
1471 Natural Language :: English
1472 Programming Language :: C
1473 Programming Language :: Python
1474 Topic :: Software Development
1478 # turn off warnings when deprecated modules are imported
1480 warnings
.filterwarnings("ignore",category
=DeprecationWarning)
1481 setup(# PyPI Metadata (PEP 301)
1483 version
= sys
.version
.split()[0],
1484 url
= "http://www.python.org/%s" % sys
.version
[:3],
1485 maintainer
= "Guido van Rossum and the Python community",
1486 maintainer_email
= "python-dev@python.org",
1487 description
= "A high-level object-oriented programming language",
1488 long_description
= SUMMARY
.strip(),
1489 license
= "PSF license",
1490 classifiers
= filter(None, CLASSIFIERS
.split("\n")),
1491 platforms
= ["Many"],
1494 cmdclass
= {'build_ext':PyBuildExt
, 'install':PyBuildInstall
,
1495 'install_lib':PyBuildInstallLib
},
1496 # The struct module is defined here, because build_ext won't be
1497 # called unless there's at least one extension module defined.
1498 ext_modules
=[Extension('_struct', ['_struct.c'])],
1500 # Scripts to install
1501 scripts
= ['Tools/scripts/pydoc', 'Tools/scripts/idle',
1506 if __name__
== '__main__':