1 # Autodetecting setup.py script for building the Python extensions
4 __version__
= "$Revision$"
6 import sys
, os
, imp
, re
, optparse
9 from distutils
import log
10 from distutils
import sysconfig
11 from distutils
import text_file
12 from distutils
.errors
import *
13 from distutils
.core
import Extension
, setup
14 from distutils
.command
.build_ext
import build_ext
15 from distutils
.command
.install
import install
16 from distutils
.command
.install_lib
import install_lib
18 # This global variable is used to hold the list of modules to be disabled.
19 disabled_module_list
= []
21 def add_dir_to_list(dirlist
, dir):
22 """Add the directory 'dir' to the list 'dirlist' (at the front) if
23 1) 'dir' is not already in 'dirlist'
24 2) 'dir' actually exists, and is a directory."""
25 if dir is not None and os
.path
.isdir(dir) and dir not in dirlist
:
26 dirlist
.insert(0, dir)
28 def find_file(filename
, std_dirs
, paths
):
29 """Searches for the directory where a given file is located,
30 and returns a possibly-empty list of additional directories, or None
31 if the file couldn't be found at all.
33 'filename' is the name of a file, such as readline.h or libcrypto.a.
34 'std_dirs' is the list of standard system directories; if the
35 file is found in one of them, no additional directives are needed.
36 'paths' is a list of additional locations to check; if the file is
37 found in one of them, the resulting list will contain the directory.
40 # Check the standard locations
42 f
= os
.path
.join(dir, filename
)
43 if os
.path
.exists(f
): return []
45 # Check the additional directories
47 f
= os
.path
.join(dir, filename
)
54 def find_library_file(compiler
, libname
, std_dirs
, paths
):
55 result
= compiler
.find_library_file(std_dirs
+ paths
, libname
)
59 # Check whether the found file is in one of the standard directories
60 dirname
= os
.path
.dirname(result
)
62 # Ensure path doesn't end with path separator
67 # Otherwise, it must have been in one of the additional directories,
68 # so we have to figure out which one.
70 # Ensure path doesn't end with path separator
75 assert False, "Internal error: Path not found in std_dirs or paths"
77 def module_enabled(extlist
, modname
):
78 """Returns whether the module 'modname' is present in the list
79 of extensions 'extlist'."""
80 extlist
= [ext
for ext
in extlist
if ext
.name
== modname
]
83 def find_module_file(module
, dirlist
):
84 """Find a module in a set of possible folders. If it is not found
85 return the unadorned filename"""
86 list = find_file(module
, [], dirlist
)
90 log
.info("WARNING: multiple copies of %s found"%module
)
91 return os
.path
.join(list[0], module
)
93 class PyBuildExt(build_ext
):
95 def __init__(self
, dist
):
96 build_ext
.__init
__(self
, dist
)
99 def build_extensions(self
):
101 # Detect which modules should be compiled
102 missing
= self
.detect_modules()
104 # Remove modules that are present on the disabled list
105 extensions
= [ext
for ext
in self
.extensions
106 if ext
.name
not in disabled_module_list
]
107 # move ctypes to the end, it depends on other modules
108 ext_map
= dict((ext
.name
, i
) for i
, ext
in enumerate(extensions
))
109 if "_ctypes" in ext_map
:
110 ctypes
= extensions
.pop(ext_map
["_ctypes"])
111 extensions
.append(ctypes
)
112 self
.extensions
= extensions
114 # Fix up the autodetected modules, prefixing all the source files
116 srcdir
= sysconfig
.get_config_var('srcdir')
118 # Maybe running on Windows but not using CYGWIN?
119 raise ValueError("No source directory; cannot proceed.")
120 srcdir
= os
.path
.abspath(srcdir
)
121 moddirlist
= [os
.path
.join(srcdir
, 'Modules')]
123 # Platform-dependent module source and include directories
124 platform
= self
.get_platform()
126 # Fix up the paths for scripts, too
127 self
.distribution
.scripts
= [os
.path
.join(srcdir
, filename
)
128 for filename
in self
.distribution
.scripts
]
130 # Python header files
131 headers
= [sysconfig
.get_config_h_filename()]
132 headers
+= glob(os
.path
.join(sysconfig
.get_python_inc(), "*.h"))
134 for ext
in self
.extensions
[:]:
135 ext
.sources
= [ find_module_file(filename
, moddirlist
)
136 for filename
in ext
.sources
]
137 if ext
.depends
is not None:
138 ext
.depends
= [find_module_file(filename
, moddirlist
)
139 for filename
in ext
.depends
]
142 # re-compile extensions if a header file has been changed
143 ext
.depends
.extend(headers
)
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 longest
= max([len(e
.name
) for e
in self
.extensions
])
183 longest
= max(longest
, max([len(name
) for name
in self
.failed
]))
185 def print_three_column(lst
):
186 lst
.sort(key
=str.lower
)
187 # guarantee zip() doesn't drop anything
190 for e
, f
, g
in zip(lst
[::3], lst
[1::3], lst
[2::3]):
191 print("%-*s %-*s %-*s" % (longest
, e
, longest
, f
,
196 print("Python build finished, but the necessary bits to build "
197 "these modules were not found:")
198 print_three_column(missing
)
199 print("To find the necessary bits, look in setup.py in"
200 " detect_modules() for the module's name.")
204 failed
= self
.failed
[:]
206 print("Failed to build these modules:")
207 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
) as 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"' %
231 if self
.get_platform() == 'darwin' and (
232 sys
.maxsize
> 2**32 and '-arch' in ext
.extra_link_args
):
233 # Don't bother doing an import check when an extension was
234 # build with an explicit '-arch' flag on OSX. That's currently
235 # only used to build 32-bit only extensions in a 4-way
236 # universal build and loading 32-bit code into a 64-bit
239 'WARNING: skipping import check for "%s"' %
243 # Workaround for Cygwin: Cygwin currently has fork issues when many
244 # modules have been imported
245 if self
.get_platform() == 'cygwin':
246 self
.announce('WARNING: skipping import check for Cygwin-based "%s"'
249 ext_filename
= os
.path
.join(
251 self
.get_ext_filename(self
.get_ext_fullname(ext
.name
)))
253 # If the build directory didn't exist when setup.py was
254 # started, sys.path_importer_cache has a negative result
255 # cached. Clear that cache before trying to import.
256 sys
.path_importer_cache
.clear()
259 imp
.load_dynamic(ext
.name
, ext_filename
)
260 except ImportError as why
:
261 self
.failed
.append(ext
.name
)
262 self
.announce('*** WARNING: renaming "%s" since importing it'
263 ' failed: %s' % (ext
.name
, why
), level
=3)
264 assert not self
.inplace
265 basename
, tail
= os
.path
.splitext(ext_filename
)
266 newname
= basename
+ "_failed" + tail
267 if os
.path
.exists(newname
):
269 os
.rename(ext_filename
, newname
)
271 # XXX -- This relies on a Vile HACK in
272 # distutils.command.build_ext.build_extension(). The
273 # _built_objects attribute is stored there strictly for
275 # If there is a failure, _built_objects may not be there,
276 # so catch the AttributeError and move on.
278 for filename
in self
._built
_objects
:
280 except AttributeError:
281 self
.announce('unable to remove files (ignored)')
283 exc_type
, why
, tb
= sys
.exc_info()
284 self
.announce('*** WARNING: importing extension "%s" '
285 'failed with %s: %s' % (ext
.name
, exc_type
, why
),
287 self
.failed
.append(ext
.name
)
289 def get_platform(self
):
290 # Get value of sys.platform
291 for platform
in ['cygwin', 'darwin', 'atheos', 'osf1']:
292 if sys
.platform
.startswith(platform
):
296 def detect_modules(self
):
297 # Ensure that /usr/local is always used
298 add_dir_to_list(self
.compiler
.library_dirs
, '/usr/local/lib')
299 add_dir_to_list(self
.compiler
.include_dirs
, '/usr/local/include')
301 # Add paths specified in the environment variables LDFLAGS and
302 # CPPFLAGS for header and library files.
303 # We must get the values from the Makefile and not the environment
304 # directly since an inconsistently reproducible issue comes up where
305 # the environment variable is not set even though the value were passed
306 # into configure and stored in the Makefile (issue found on OS X 10.3).
307 for env_var
, arg_name
, dir_list
in (
308 ('LDFLAGS', '-R', self
.compiler
.runtime_library_dirs
),
309 ('LDFLAGS', '-L', self
.compiler
.library_dirs
),
310 ('CPPFLAGS', '-I', self
.compiler
.include_dirs
)):
311 env_val
= sysconfig
.get_config_var(env_var
)
313 # To prevent optparse from raising an exception about any
314 # options in env_val that it doesn't know about we strip out
315 # all double dashes and any dashes followed by a character
316 # that is not for the option we are dealing with.
318 # Please note that order of the regex is important! We must
319 # strip out double-dashes first so that we don't end up with
320 # substituting "--Long" to "-Long" and thus lead to "ong" being
321 # used for a library directory.
322 env_val
= re
.sub(r
'(^|\s+)-(-|(?!%s))' % arg_name
[1],
324 parser
= optparse
.OptionParser()
325 # Make sure that allowing args interspersed with options is
327 parser
.allow_interspersed_args
= True
328 parser
.error
= lambda msg
: None
329 parser
.add_option(arg_name
, dest
="dirs", action
="append")
330 options
= parser
.parse_args(env_val
.split())[0]
332 for directory
in reversed(options
.dirs
):
333 add_dir_to_list(dir_list
, directory
)
335 if os
.path
.normpath(sys
.prefix
) != '/usr':
336 add_dir_to_list(self
.compiler
.library_dirs
,
337 sysconfig
.get_config_var("LIBDIR"))
338 add_dir_to_list(self
.compiler
.include_dirs
,
339 sysconfig
.get_config_var("INCLUDEDIR"))
341 # lib_dirs and inc_dirs are used to search for files;
342 # if a file is found in one of those directories, it can
343 # be assumed that no additional -I,-L directives are needed.
344 lib_dirs
= self
.compiler
.library_dirs
+ [
345 '/lib64', '/usr/lib64',
348 inc_dirs
= self
.compiler
.include_dirs
+ ['/usr/include']
352 config_h
= sysconfig
.get_config_h_filename()
353 config_h_vars
= sysconfig
.parse_config_h(open(config_h
))
355 platform
= self
.get_platform()
356 srcdir
= sysconfig
.get_config_var('srcdir')
358 # Check for AtheOS which has libraries in non-standard locations
359 if platform
== 'atheos':
360 lib_dirs
+= ['/system/libs', '/atheos/autolnk/lib']
361 lib_dirs
+= os
.getenv('LIBRARY_PATH', '').split(os
.pathsep
)
362 inc_dirs
+= ['/system/include', '/atheos/autolnk/include']
363 inc_dirs
+= os
.getenv('C_INCLUDE_PATH', '').split(os
.pathsep
)
365 # OSF/1 and Unixware have some stuff in /usr/ccs/lib (like -ldb)
366 if platform
in ['osf1', 'unixware7', 'openunix8']:
367 lib_dirs
+= ['/usr/ccs/lib']
369 if platform
== 'darwin':
370 # This should work on any unixy platform ;-)
371 # If the user has bothered specifying additional -I and -L flags
372 # in OPT and LDFLAGS we might as well use them here.
373 # NOTE: using shlex.split would technically be more correct, but
374 # also gives a bootstrap problem. Let's hope nobody uses directories
375 # with whitespace in the name to store libraries.
376 cflags
, ldflags
= sysconfig
.get_config_vars(
378 for item
in cflags
.split():
379 if item
.startswith('-I'):
380 inc_dirs
.append(item
[2:])
382 for item
in ldflags
.split():
383 if item
.startswith('-L'):
384 lib_dirs
.append(item
[2:])
386 # Check for MacOS X, which doesn't need libm.a at all
388 if platform
in ['darwin', 'mac']:
391 # XXX Omitted modules: gl, pure, dl, SGI-specific modules
394 # The following modules are all pretty straightforward, and compile
395 # on pretty much any POSIXish platform.
398 # Some modules that are normally always on:
399 exts
.append( Extension('_weakref', ['_weakref.c']) )
402 exts
.append( Extension('array', ['arraymodule.c']) )
403 # complex math library functions
404 exts
.append( Extension('cmath', ['cmathmodule.c'],
405 libraries
=math_libs
) )
407 # math library functions, e.g. sin()
408 exts
.append( Extension('math', ['mathmodule.c'],
409 libraries
=math_libs
) )
410 # time operations and variables
411 exts
.append( Extension('time', ['timemodule.c'],
412 libraries
=math_libs
) )
413 exts
.append( Extension('datetime', ['datetimemodule.c', 'timemodule.c'],
414 libraries
=math_libs
) )
415 # fast iterator tools implemented in C
416 exts
.append( Extension("itertools", ["itertoolsmodule.c"]) )
417 # random number generator implemented in C
418 exts
.append( Extension("_random", ["_randommodule.c"]) )
419 # high-performance collections
420 exts
.append( Extension("_collections", ["_collectionsmodule.c"]) )
422 exts
.append( Extension("_bisect", ["_bisectmodule.c"]) )
424 exts
.append( Extension("_heapq", ["_heapqmodule.c"]) )
425 # operator.add() and similar goodies
426 exts
.append( Extension('operator', ['operator.c']) )
427 # C-optimized pickle replacement
428 exts
.append( Extension("_pickle", ["_pickle.c"]) )
430 exts
.append( Extension("atexit", ["atexitmodule.c"]) )
432 exts
.append( Extension("_json", ["_json.c"]) )
433 # Python C API test module
434 exts
.append( Extension('_testcapi', ['_testcapimodule.c'],
435 depends
=['testcapi_long.h']) )
436 # profiler (_lsprof is for cProfile.py)
437 exts
.append( Extension('_lsprof', ['_lsprof.c', 'rotatingtree.c']) )
438 # static Unicode character database
439 exts
.append( Extension('unicodedata', ['unicodedata.c']) )
441 # Modules with some UNIX dependencies -- on by default:
442 # (If you have a really backward UNIX, select and socket may not be
445 # fcntl(2) and ioctl(2)
446 exts
.append( Extension('fcntl', ['fcntlmodule.c']) )
447 if platform
not in ['mac']:
449 exts
.append( Extension('pwd', ['pwdmodule.c']) )
451 exts
.append( Extension('grp', ['grpmodule.c']) )
452 # spwd, shadow passwords
453 if (config_h_vars
.get('HAVE_GETSPNAM', False) or
454 config_h_vars
.get('HAVE_GETSPENT', False)):
455 exts
.append( Extension('spwd', ['spwdmodule.c']) )
457 missing
.append('spwd')
459 missing
.extend(['pwd', 'grp', 'spwd'])
461 # select(2); not on ancient System V
462 exts
.append( Extension('select', ['selectmodule.c']) )
464 # Fred Drake's interface to the Python parser
465 exts
.append( Extension('parser', ['parsermodule.c']) )
467 # Memory-mapped files (also works on Win32).
468 if platform
not in ['atheos', 'mac']:
469 exts
.append( Extension('mmap', ['mmapmodule.c']) )
471 missing
.append('mmap')
473 # Lance Ellinghaus's syslog module
474 if platform
not in ['mac']:
475 # syslog daemon interface
476 exts
.append( Extension('syslog', ['syslogmodule.c']) )
478 missing
.append('syslog')
481 # Here ends the simple stuff. From here on, modules need certain
482 # libraries, are platform-specific, or present other surprises.
486 # These don't work for 64-bit platforms!!!
487 # These represent audio samples or images as strings:
489 # Operations on audio samples
490 # According to #993173, this one should actually work fine on
492 exts
.append( Extension('audioop', ['audioop.c']) )
495 do_readline
= self
.compiler
.find_library_file(lib_dirs
, 'readline')
496 if platform
== 'darwin': # and os.uname()[2] < '9.':
497 # MacOSX 10.4 has a broken readline. Don't try to build
498 # the readline module unless the user has installed a fixed
500 # FIXME: The readline emulation on 10.5 is better, but the
501 # readline module doesn't compile out of the box.
502 if find_file('readline/rlconf.h', inc_dirs
, []) is None:
505 if sys
.platform
== 'darwin':
506 # In every directory on the search path search for a dynamic
507 # library and then a static library, instead of first looking
508 # for dynamic libraries on the entire path.
509 # This way a staticly linked custom readline gets picked up
510 # before the (broken) dynamic library in /usr/lib.
511 readline_extra_link_args
= ('-Wl,-search_paths_first',)
513 readline_extra_link_args
= ()
515 readline_libs
= ['readline']
516 if self
.compiler
.find_library_file(lib_dirs
,
518 readline_libs
.append('ncursesw')
519 elif self
.compiler
.find_library_file(lib_dirs
,
521 readline_libs
.append('ncurses')
522 elif self
.compiler
.find_library_file(lib_dirs
, 'curses'):
523 readline_libs
.append('curses')
524 elif self
.compiler
.find_library_file(lib_dirs
+
525 ['/usr/lib/termcap'],
527 readline_libs
.append('termcap')
528 exts
.append( Extension('readline', ['readline.c'],
529 library_dirs
=['/usr/lib/termcap'],
530 extra_link_args
=readline_extra_link_args
,
531 libraries
=readline_libs
) )
533 missing
.append('readline')
535 if platform
not in ['mac']:
538 if self
.compiler
.find_library_file(lib_dirs
, 'crypt'):
542 exts
.append( Extension('crypt', ['cryptmodule.c'], libraries
=libs
) )
544 missing
.append('crypt')
547 exts
.append( Extension('_csv', ['_csv.c']) )
550 exts
.append( Extension('_socket', ['socketmodule.c'],
551 depends
= ['socketmodule.h']) )
552 # Detect SSL support for the socket module (via _ssl)
553 search_for_ssl_incs_in
= [
554 '/usr/local/ssl/include',
555 '/usr/contrib/ssl/include/'
557 ssl_incs
= find_file('openssl/ssl.h', inc_dirs
,
558 search_for_ssl_incs_in
560 if ssl_incs
is not None:
561 krb5_h
= find_file('krb5.h', inc_dirs
,
562 ['/usr/kerberos/include'])
565 ssl_libs
= find_library_file(self
.compiler
, 'ssl',lib_dirs
,
566 ['/usr/local/ssl/lib',
567 '/usr/contrib/ssl/lib/'
570 if (ssl_incs
is not None and
571 ssl_libs
is not None):
572 exts
.append( Extension('_ssl', ['_ssl.c'],
573 include_dirs
= ssl_incs
,
574 library_dirs
= ssl_libs
,
575 libraries
= ['ssl', 'crypto'],
576 depends
= ['socketmodule.h']), )
578 missing
.append('_ssl')
580 # find out which version of OpenSSL we have
582 openssl_ver_re
= re
.compile(
583 '^\s*#\s*define\s+OPENSSL_VERSION_NUMBER\s+(0x[0-9a-fA-F]+)' )
584 for ssl_inc_dir
in inc_dirs
+ search_for_ssl_incs_in
:
585 name
= os
.path
.join(ssl_inc_dir
, 'openssl', 'opensslv.h')
586 if os
.path
.isfile(name
):
588 incfile
= open(name
, 'r')
590 m
= openssl_ver_re
.match(line
)
592 openssl_ver
= eval(m
.group(1))
597 # first version found is what we'll use (as the compiler should)
601 #print('openssl_ver = 0x%08x' % openssl_ver)
603 if ssl_incs
is not None and ssl_libs
is not None:
604 if openssl_ver
>= 0x00907000:
605 # The _hashlib module wraps optimized implementations
606 # of hash functions from the OpenSSL library.
607 exts
.append( Extension('_hashlib', ['_hashopenssl.c'],
608 include_dirs
= ssl_incs
,
609 library_dirs
= ssl_libs
,
610 libraries
= ['ssl', 'crypto']) )
612 print("warning: openssl 0x%08x is too old for _hashlib" %
614 missing
.append('_hashlib')
616 missing
.append('_hashlib')
618 if openssl_ver
< 0x00908000:
619 # OpenSSL doesn't do these until 0.9.8 so we'll bring our own hash
620 exts
.append( Extension('_sha256', ['sha256module.c']) )
621 exts
.append( Extension('_sha512', ['sha512module.c']) )
623 if openssl_ver
< 0x00907000:
624 # no openssl at all, use our own md5 and sha1
625 exts
.append( Extension('_md5', ['md5module.c']) )
626 exts
.append( Extension('_sha1', ['sha1module.c']) )
628 # Modules that provide persistent dictionary-like semantics. You will
629 # probably want to arrange for at least one of them to be available on
630 # your machine, though none are defined by default because of library
631 # dependencies. The Python module dbm/__init__.py provides an
632 # implementation independent wrapper for these; dbm/dumb.py provides
633 # similar functionality (but slower of course) implemented in Python.
635 # Sleepycat^WOracle Berkeley DB interface.
636 # http://www.oracle.com/database/berkeley-db/db/index.html
638 # This requires the Sleepycat^WOracle DB code. The supported versions
639 # are set below. Visit the URL above to download
640 # a release. Most open source OSes come with one or more
641 # versions of BerkeleyDB already installed.
645 db_setup_debug
= False # verbose debug prints from this script?
647 def allow_db_ver(db_ver
):
648 """Returns a boolean if the given BerkeleyDB version is acceptable.
651 db_ver: A tuple of the version to verify.
653 if not (min_db_ver
<= db_ver
<= max_db_ver
):
657 def gen_db_minor_ver_nums(major
):
659 for x
in range(max_db_ver
[1]+1):
660 if allow_db_ver((4, x
)):
664 if allow_db_ver((3, x
)):
667 raise ValueError("unknown major BerkeleyDB version", major
)
669 # construct a list of paths to look for the header file in on
670 # top of the normal inc_dirs.
673 '/usr/local/include/db4',
674 '/opt/sfw/include/db4',
676 '/usr/local/include/db3',
677 '/opt/sfw/include/db3',
678 # Fink defaults (http://fink.sourceforge.net/)
682 # 4.x minor number specific paths
683 for x
in gen_db_minor_ver_nums(4):
684 db_inc_paths
.append('/usr/include/db4%d' % x
)
685 db_inc_paths
.append('/usr/include/db4.%d' % x
)
686 db_inc_paths
.append('/usr/local/BerkeleyDB.4.%d/include' % x
)
687 db_inc_paths
.append('/usr/local/include/db4%d' % x
)
688 db_inc_paths
.append('/pkg/db-4.%d/include' % x
)
689 db_inc_paths
.append('/opt/db-4.%d/include' % x
)
690 # MacPorts default (http://www.macports.org/)
691 db_inc_paths
.append('/opt/local/include/db4%d' % x
)
692 # 3.x minor number specific paths
693 for x
in gen_db_minor_ver_nums(3):
694 db_inc_paths
.append('/usr/include/db3%d' % x
)
695 db_inc_paths
.append('/usr/local/BerkeleyDB.3.%d/include' % x
)
696 db_inc_paths
.append('/usr/local/include/db3%d' % x
)
697 db_inc_paths
.append('/pkg/db-3.%d/include' % x
)
698 db_inc_paths
.append('/opt/db-3.%d/include' % x
)
700 # Add some common subdirectories for Sleepycat DB to the list,
701 # based on the standard include directories. This way DB3/4 gets
702 # picked up when it is installed in a non-standard prefix and
703 # the user has added that prefix into inc_dirs.
706 std_variants
.append(os
.path
.join(dn
, 'db3'))
707 std_variants
.append(os
.path
.join(dn
, 'db4'))
708 for x
in gen_db_minor_ver_nums(4):
709 std_variants
.append(os
.path
.join(dn
, "db4%d"%x))
710 std_variants
.append(os
.path
.join(dn
, "db4.%d"%x))
711 for x
in gen_db_minor_ver_nums(3):
712 std_variants
.append(os
.path
.join(dn
, "db3%d"%x))
713 std_variants
.append(os
.path
.join(dn
, "db3.%d"%x))
715 db_inc_paths
= std_variants
+ db_inc_paths
716 db_inc_paths
= [p
for p
in db_inc_paths
if os
.path
.exists(p
)]
720 class db_found(Exception): pass
722 # See whether there is a Sleepycat header in the standard
724 for d
in inc_dirs
+ db_inc_paths
:
725 f
= os
.path
.join(d
, "db.h")
726 if db_setup_debug
: print("db: looking for db.h in", f
)
727 if os
.path
.exists(f
):
728 f
= open(f
, "rb").read()
729 m
= re
.search(br
"#define\WDB_VERSION_MAJOR\W(\d+)", f
)
731 db_major
= int(m
.group(1))
732 m
= re
.search(br
"#define\WDB_VERSION_MINOR\W(\d+)", f
)
733 db_minor
= int(m
.group(1))
734 db_ver
= (db_major
, db_minor
)
736 # Avoid 4.6 prior to 4.6.21 due to a BerkeleyDB bug
738 m
= re
.search(br
"#define\WDB_VERSION_PATCH\W(\d+)", f
)
739 db_patch
= int(m
.group(1))
741 print("db.h:", db_ver
, "patch", db_patch
,
742 "being ignored (4.6.x must be >= 4.6.21)")
745 if ( (db_ver
not in db_ver_inc_map
) and
746 allow_db_ver(db_ver
) ):
747 # save the include directory with the db.h version
748 # (first occurrence only)
749 db_ver_inc_map
[db_ver
] = d
751 print("db.h: found", db_ver
, "in", d
)
753 # we already found a header for this library version
754 if db_setup_debug
: print("db.h: ignoring", d
)
756 # ignore this header, it didn't contain a version number
758 print("db.h: no version number version in", d
)
760 db_found_vers
= list(db_ver_inc_map
.keys())
764 db_ver
= db_found_vers
.pop()
765 db_incdir
= db_ver_inc_map
[db_ver
]
767 # check lib directories parallel to the location of the header
769 db_incdir
.replace("include", 'lib64'),
770 db_incdir
.replace("include", 'lib'),
772 db_dirs_to_check
= list(filter(os
.path
.isdir
, db_dirs_to_check
))
774 # Look for a version specific db-X.Y before an ambiguoius dbX
775 # XXX should we -ever- look for a dbX name? Do any
776 # systems really not name their library by version and
777 # symlink to more general names?
778 for dblib
in (('db-%d.%d' % db_ver
),
780 ('db%d' % db_ver
[0])):
781 dblib_file
= self
.compiler
.find_library_file(
782 db_dirs_to_check
+ lib_dirs
, dblib
)
784 dblib_dir
= [ os
.path
.abspath(os
.path
.dirname(dblib_file
)) ]
787 if db_setup_debug
: print("db lib: ", dblib
, "not found")
791 print("bsddb using BerkeleyDB lib:", db_ver
, dblib
)
792 print("bsddb lib dir:", dblib_dir
, " inc dir:", db_incdir
)
793 db_incs
= [db_incdir
]
796 if db_setup_debug
: print("db: no appropriate library found")
801 # The sqlite interface
802 sqlite_setup_debug
= False # verbose debug prints from this script?
804 # We hunt for #define SQLITE_VERSION "n.n.n"
805 # We need to find >= sqlite version 3.0.8
806 sqlite_incdir
= sqlite_libdir
= None
807 sqlite_inc_paths
= [ '/usr/include',
808 '/usr/include/sqlite',
809 '/usr/include/sqlite3',
810 '/usr/local/include',
811 '/usr/local/include/sqlite',
812 '/usr/local/include/sqlite3',
814 MIN_SQLITE_VERSION_NUMBER
= (3, 0, 8)
815 MIN_SQLITE_VERSION
= ".".join([str(x
)
816 for x
in MIN_SQLITE_VERSION_NUMBER
])
818 # Scan the default include directories before the SQLite specific
819 # ones. This allows one to override the copy of sqlite on OSX,
820 # where /usr/include contains an old version of sqlite.
821 for d
in inc_dirs
+ sqlite_inc_paths
:
822 f
= os
.path
.join(d
, "sqlite3.h")
823 if os
.path
.exists(f
):
824 if sqlite_setup_debug
: print("sqlite: found %s"%f)
825 incf
= open(f
).read()
827 r
'\s*.*#\s*.*define\s.*SQLITE_VERSION\W*"(.*)"', incf
)
829 sqlite_version
= m
.group(1)
830 sqlite_version_tuple
= tuple([int(x
)
831 for x
in sqlite_version
.split(".")])
832 if sqlite_version_tuple
>= MIN_SQLITE_VERSION_NUMBER
:
834 if sqlite_setup_debug
:
835 print("%s/sqlite3.h: version %s"%(d
, sqlite_version
))
839 if sqlite_setup_debug
:
840 print("%s: version %d is too old, need >= %s"%(d
,
841 sqlite_version
, MIN_SQLITE_VERSION
))
842 elif sqlite_setup_debug
:
843 print("sqlite: %s had no SQLITE_VERSION"%(f
,))
846 sqlite_dirs_to_check
= [
847 os
.path
.join(sqlite_incdir
, '..', 'lib64'),
848 os
.path
.join(sqlite_incdir
, '..', 'lib'),
849 os
.path
.join(sqlite_incdir
, '..', '..', 'lib64'),
850 os
.path
.join(sqlite_incdir
, '..', '..', 'lib'),
852 sqlite_libfile
= self
.compiler
.find_library_file(
853 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 # The standard Unix dbm module:
897 if platform
not in ['cygwin']:
898 config_args
= [arg
.strip("'")
899 for arg
in sysconfig
.get_config_var("CONFIG_ARGS").split()]
900 dbm_args
= [arg
.split('=')[-1] for arg
in config_args
901 if arg
.startswith('--with-dbmliborder=')]
903 dbm_order
= dbm_args
[-1].split(":")
905 dbm_order
= "ndbm:gdbm:bdb".split(":")
907 for cand
in dbm_order
:
909 if find_file("ndbm.h", inc_dirs
, []) is not None:
910 # Some systems have -lndbm, others don't
911 if self
.compiler
.find_library_file(lib_dirs
, 'ndbm'):
915 print("building dbm using ndbm")
916 dbmext
= Extension('_dbm', ['_dbmmodule.c'],
918 ('HAVE_NDBM_H',None),
924 if self
.compiler
.find_library_file(lib_dirs
, 'gdbm'):
926 if self
.compiler
.find_library_file(lib_dirs
, 'gdbm_compat'):
927 gdbm_libs
.append('gdbm_compat')
928 if find_file("gdbm/ndbm.h", inc_dirs
, []) is not None:
929 print("building dbm using gdbm")
931 '_dbm', ['_dbmmodule.c'],
933 ('HAVE_GDBM_NDBM_H', None),
935 libraries
= gdbm_libs
)
937 if find_file("gdbm-ndbm.h", inc_dirs
, []) is not None:
938 print("building dbm using gdbm")
940 '_dbm', ['_dbmmodule.c'],
942 ('HAVE_GDBM_DASH_NDBM_H', None),
944 libraries
= gdbm_libs
)
947 if db_incs
is not None:
948 print("building dbm using bdb")
949 dbmext
= Extension('_dbm', ['_dbmmodule.c'],
950 library_dirs
=dblib_dir
,
951 runtime_library_dirs
=dblib_dir
,
952 include_dirs
=db_incs
,
954 ('HAVE_BERKDB_H', None),
955 ('DB_DBM_HSEARCH', None),
959 if dbmext
is not None:
962 missing
.append('_dbm')
964 # Anthony Baxter's gdbm module. GNU dbm(3) will require -lgdbm:
965 if (self
.compiler
.find_library_file(lib_dirs
, 'gdbm')):
966 exts
.append( Extension('_gdbm', ['_gdbmmodule.c'],
967 libraries
= ['gdbm'] ) )
969 missing
.append('_gdbm')
972 if platform
not in ['mac', 'win32']:
973 # Steen Lumholt's termios module
974 exts
.append( Extension('termios', ['termios.c']) )
975 # Jeremy Hylton's rlimit interface
976 if platform
not in ['atheos']:
977 exts
.append( Extension('resource', ['resource.c']) )
979 missing
.append('resource')
981 # Sun yellow pages. Some systems have the functions in libc.
982 if platform
not in ['cygwin', 'atheos', 'qnx6']:
983 if (self
.compiler
.find_library_file(lib_dirs
, 'nsl')):
987 exts
.append( Extension('nis', ['nismodule.c'],
990 missing
.append('nis')
992 missing
.extend(['nis', 'resource', 'termios'])
994 # Curses support, requiring the System V version of curses, often
995 # provided by the ncurses library.
996 panel_library
= 'panel'
997 if (self
.compiler
.find_library_file(lib_dirs
, 'ncursesw')):
998 curses_libs
= ['ncursesw']
999 # Bug 1464056: If _curses.so links with ncursesw,
1000 # _curses_panel.so must link with panelw.
1001 panel_library
= 'panelw'
1002 exts
.append( Extension('_curses', ['_cursesmodule.c'],
1003 libraries
= curses_libs
) )
1004 elif (self
.compiler
.find_library_file(lib_dirs
, 'ncurses')):
1005 curses_libs
= ['ncurses']
1006 exts
.append( Extension('_curses', ['_cursesmodule.c'],
1007 libraries
= curses_libs
) )
1008 elif (self
.compiler
.find_library_file(lib_dirs
, 'curses')
1009 and platform
!= 'darwin'):
1010 # OSX has an old Berkeley curses, not good enough for
1011 # the _curses module.
1012 if (self
.compiler
.find_library_file(lib_dirs
, 'terminfo')):
1013 curses_libs
= ['curses', 'terminfo']
1014 elif (self
.compiler
.find_library_file(lib_dirs
, 'termcap')):
1015 curses_libs
= ['curses', 'termcap']
1017 curses_libs
= ['curses']
1019 exts
.append( Extension('_curses', ['_cursesmodule.c'],
1020 libraries
= curses_libs
) )
1022 missing
.append('_curses')
1024 # If the curses module is enabled, check for the panel module
1025 if (module_enabled(exts
, '_curses') and
1026 self
.compiler
.find_library_file(lib_dirs
, panel_library
)):
1027 exts
.append( Extension('_curses_panel', ['_curses_panel.c'],
1028 libraries
= [panel_library
] + curses_libs
) )
1030 missing
.append('_curses_panel')
1032 # Andrew Kuchling's zlib module. Note that some versions of zlib
1033 # 1.1.3 have security problems. See CERT Advisory CA-2002-07:
1034 # http://www.cert.org/advisories/CA-2002-07.html
1036 # zlib 1.1.4 is fixed, but at least one vendor (RedHat) has decided to
1037 # patch its zlib 1.1.3 package instead of upgrading to 1.1.4. For
1038 # now, we still accept 1.1.3, because we think it's difficult to
1039 # exploit this in Python, and we'd rather make it RedHat's problem
1040 # than our problem <wink>.
1042 # You can upgrade zlib to version 1.1.4 yourself by going to
1043 # http://www.gzip.org/zlib/
1044 zlib_inc
= find_file('zlib.h', [], inc_dirs
)
1046 if zlib_inc
is not None:
1047 zlib_h
= zlib_inc
[0] + '/zlib.h'
1049 version_req
= '"1.1.3"'
1052 line
= fp
.readline()
1055 if line
.startswith('#define ZLIB_VERSION'):
1056 version
= line
.split()[2]
1058 if version
>= version_req
:
1059 if (self
.compiler
.find_library_file(lib_dirs
, 'z')):
1060 if sys
.platform
== "darwin":
1061 zlib_extra_link_args
= ('-Wl,-search_paths_first',)
1063 zlib_extra_link_args
= ()
1064 exts
.append( Extension('zlib', ['zlibmodule.c'],
1066 extra_link_args
= zlib_extra_link_args
))
1069 missing
.append('zlib')
1071 missing
.append('zlib')
1073 missing
.append('zlib')
1075 # Helper module for various ascii-encoders. Uses zlib for an optimized
1076 # crc32 if we have it. Otherwise binascii uses its own.
1078 extra_compile_args
= ['-DUSE_ZLIB_CRC32']
1080 extra_link_args
= zlib_extra_link_args
1082 extra_compile_args
= []
1084 extra_link_args
= []
1085 exts
.append( Extension('binascii', ['binascii.c'],
1086 extra_compile_args
= extra_compile_args
,
1087 libraries
= libraries
,
1088 extra_link_args
= extra_link_args
) )
1090 # Gustavo Niemeyer's bz2 module.
1091 if (self
.compiler
.find_library_file(lib_dirs
, 'bz2')):
1092 if sys
.platform
== "darwin":
1093 bz2_extra_link_args
= ('-Wl,-search_paths_first',)
1095 bz2_extra_link_args
= ()
1096 exts
.append( Extension('bz2', ['bz2module.c'],
1097 libraries
= ['bz2'],
1098 extra_link_args
= bz2_extra_link_args
) )
1100 missing
.append('bz2')
1102 # Interface to the Expat XML parser
1104 # Expat was written by James Clark and is now maintained by a
1105 # group of developers on SourceForge; see www.libexpat.org for
1106 # more information. The pyexpat module was written by Paul
1107 # Prescod after a prototype by Jack Jansen. The Expat source
1108 # is included in Modules/expat/. Usage of a system
1109 # shared libexpat.so/expat.dll is not advised.
1111 # More information on Expat can be found at www.libexpat.org.
1113 expatinc
= os
.path
.join(os
.getcwd(), srcdir
, 'Modules', 'expat')
1115 ('HAVE_EXPAT_CONFIG_H', '1'),
1118 exts
.append(Extension('pyexpat',
1119 define_macros
= define_macros
,
1120 include_dirs
= [expatinc
],
1121 sources
= ['pyexpat.c',
1128 # Fredrik Lundh's cElementTree module. Note that this also
1129 # uses expat (via the CAPI hook in pyexpat).
1131 if os
.path
.isfile(os
.path
.join(srcdir
, 'Modules', '_elementtree.c')):
1132 define_macros
.append(('USE_PYEXPAT_CAPI', None))
1133 exts
.append(Extension('_elementtree',
1134 define_macros
= define_macros
,
1135 include_dirs
= [expatinc
],
1136 sources
= ['_elementtree.c'],
1139 missing
.append('_elementtree')
1141 # Hye-Shik Chang's CJKCodecs modules.
1142 exts
.append(Extension('_multibytecodec',
1143 ['cjkcodecs/multibytecodec.c']))
1144 for loc
in ('kr', 'jp', 'cn', 'tw', 'hk', 'iso2022'):
1145 exts
.append(Extension('_codecs_%s' % loc
,
1146 ['cjkcodecs/_codecs_%s.c' % loc
]))
1148 # Thomas Heller's _ctypes module
1149 self
.detect_ctypes(inc_dirs
, lib_dirs
)
1151 # Richard Oudkerk's multiprocessing module
1152 if platform
== 'win32': # Windows
1154 libraries
= ['ws2_32']
1156 elif platform
== 'darwin': # Mac OSX
1160 elif platform
== 'cygwin': # Cygwin
1164 elif platform
in ('freebsd4', 'freebsd5', 'freebsd6', 'freebsd7', 'freebsd8'):
1165 # FreeBSD's P1003.1b semaphore support is very experimental
1166 # and has many known problems. (as of June 2008)
1170 elif platform
.startswith('openbsd'):
1174 elif platform
.startswith('netbsd'):
1178 else: # Linux and other unices
1182 if platform
== 'win32':
1183 multiprocessing_srcs
= [ '_multiprocessing/multiprocessing.c',
1184 '_multiprocessing/semaphore.c',
1185 '_multiprocessing/pipe_connection.c',
1186 '_multiprocessing/socket_connection.c',
1187 '_multiprocessing/win32_functions.c'
1191 multiprocessing_srcs
= [ '_multiprocessing/multiprocessing.c',
1192 '_multiprocessing/socket_connection.c'
1194 if sysconfig
.get_config_var('HAVE_SEM_OPEN'):
1195 multiprocessing_srcs
.append('_multiprocessing/semaphore.c')
1197 if sysconfig
.get_config_var('WITH_THREAD'):
1198 exts
.append ( Extension('_multiprocessing', multiprocessing_srcs
,
1199 define_macros
=list(macros
.items()),
1200 include_dirs
=["Modules/_multiprocessing"]))
1202 missing
.append('_multiprocessing')
1203 # End multiprocessing
1205 # Platform-specific libraries
1206 if platform
in ('linux2', 'freebsd4', 'freebsd5', 'freebsd6',
1207 'freebsd7', 'freebsd8'):
1208 exts
.append( Extension('ossaudiodev', ['ossaudiodev.c']) )
1210 missing
.append('ossaudiodev')
1212 if sys
.platform
== 'darwin':
1214 Extension('_gestalt', ['_gestalt.c'],
1215 extra_link_args
=['-framework', 'Carbon'])
1218 self
.extensions
.extend(exts
)
1220 # Call the method for detecting whether _tkinter can be compiled
1221 self
.detect_tkinter(inc_dirs
, lib_dirs
)
1223 if '_tkinter' not in [e
.name
for e
in self
.extensions
]:
1224 missing
.append('_tkinter')
1228 def detect_tkinter_darwin(self
, inc_dirs
, lib_dirs
):
1229 # The _tkinter module, using frameworks. Since frameworks are quite
1230 # different the UNIX search logic is not sharable.
1231 from os
.path
import join
, exists
1233 '/Library/Frameworks',
1234 '/System/Library/Frameworks/',
1235 join(os
.getenv('HOME'), '/Library/Frameworks')
1238 # Find the directory that contains the Tcl.framework and Tk.framework
1240 # XXX distutils should support -F!
1241 for F
in framework_dirs
:
1242 # both Tcl.framework and Tk.framework should be present
1243 for fw
in 'Tcl', 'Tk':
1244 if not exists(join(F
, fw
+ '.framework')):
1247 # ok, F is now directory with both frameworks. Continure
1251 # Tk and Tcl frameworks not found. Normal "unix" tkinter search
1255 # For 8.4a2, we must add -I options that point inside the Tcl and Tk
1256 # frameworks. In later release we should hopefully be able to pass
1257 # the -F option to gcc, which specifies a framework lookup path.
1260 join(F
, fw
+ '.framework', H
)
1261 for fw
in ('Tcl', 'Tk')
1262 for H
in ('Headers', 'Versions/Current/PrivateHeaders')
1265 # For 8.4a2, the X11 headers are not included. Rather than include a
1266 # complicated search, this is a hard-coded path. It could bail out
1267 # if X11 libs are not found...
1268 include_dirs
.append('/usr/X11R6/include')
1269 frameworks
= ['-framework', 'Tcl', '-framework', 'Tk']
1271 # All existing framework builds of Tcl/Tk don't support 64-bit
1273 cflags
= sysconfig
.get_config_vars('CFLAGS')[0]
1274 archs
= re
.findall('-arch\s+(\w+)', cflags
)
1276 tmpfile
= os
.path
.join(self
.build_temp
, 'tk.arch')
1277 if not os
.path
.exists(self
.build_temp
):
1278 os
.makedirs(self
.build_temp
)
1280 # Note: cannot use os.popen or subprocess here, that
1281 # requires extensions that are not available here.
1282 os
.system("file %s/Tk.framework/Tk | grep 'for architecture' > %s"%(F
, tmpfile
))
1288 detected_archs
.append(ln
.split()[-1])
1292 for a
in detected_archs
:
1293 frameworks
.append('-arch')
1294 frameworks
.append(a
)
1296 ext
= Extension('_tkinter', ['_tkinter.c', 'tkappinit.c'],
1297 define_macros
=[('WITH_APPINIT', 1)],
1298 include_dirs
= include_dirs
,
1300 extra_compile_args
= frameworks
[2:],
1301 extra_link_args
= frameworks
,
1303 self
.extensions
.append(ext
)
1307 def detect_tkinter(self
, inc_dirs
, lib_dirs
):
1308 # The _tkinter module.
1310 # Rather than complicate the code below, detecting and building
1311 # AquaTk is a separate method. Only one Tkinter will be built on
1312 # Darwin - either AquaTk, if it is found, or X11 based Tk.
1313 platform
= self
.get_platform()
1314 if (platform
== 'darwin' and
1315 self
.detect_tkinter_darwin(inc_dirs
, lib_dirs
)):
1318 # Assume we haven't found any of the libraries or include files
1319 # The versions with dots are used on Unix, and the versions without
1320 # dots on Windows, for detection by cygwin.
1321 tcllib
= tklib
= tcl_includes
= tk_includes
= None
1322 for version
in ['8.5', '85', '8.4', '84', '8.3', '83', '8.2',
1323 '82', '8.1', '81', '8.0', '80']:
1324 tklib
= self
.compiler
.find_library_file(lib_dirs
, 'tk' + version
)
1325 tcllib
= self
.compiler
.find_library_file(lib_dirs
, 'tcl' + version
)
1326 if tklib
and tcllib
:
1327 # Exit the loop when we've found the Tcl/Tk libraries
1330 # Now check for the header files
1331 if tklib
and tcllib
:
1332 # Check for the include files on Debian and {Free,Open}BSD, where
1333 # they're put in /usr/include/{tcl,tk}X.Y
1334 dotversion
= version
1335 if '.' not in dotversion
and "bsd" in sys
.platform
.lower():
1336 # OpenBSD and FreeBSD use Tcl/Tk library names like libtcl83.a,
1337 # but the include subdirs are named like .../include/tcl8.3.
1338 dotversion
= dotversion
[:-1] + '.' + dotversion
[-1]
1339 tcl_include_sub
= []
1341 for dir in inc_dirs
:
1342 tcl_include_sub
+= [dir + os
.sep
+ "tcl" + dotversion
]
1343 tk_include_sub
+= [dir + os
.sep
+ "tk" + dotversion
]
1344 tk_include_sub
+= tcl_include_sub
1345 tcl_includes
= find_file('tcl.h', inc_dirs
, tcl_include_sub
)
1346 tk_includes
= find_file('tk.h', inc_dirs
, tk_include_sub
)
1348 if (tcllib
is None or tklib
is None or
1349 tcl_includes
is None or tk_includes
is None):
1350 self
.announce("INFO: Can't locate Tcl/Tk libs and/or headers", 2)
1353 # OK... everything seems to be present for Tcl/Tk.
1355 include_dirs
= [] ; libs
= [] ; defs
= [] ; added_lib_dirs
= []
1356 for dir in tcl_includes
+ tk_includes
:
1357 if dir not in include_dirs
:
1358 include_dirs
.append(dir)
1360 # Check for various platform-specific directories
1361 if platform
== 'sunos5':
1362 include_dirs
.append('/usr/openwin/include')
1363 added_lib_dirs
.append('/usr/openwin/lib')
1364 elif os
.path
.exists('/usr/X11R6/include'):
1365 include_dirs
.append('/usr/X11R6/include')
1366 added_lib_dirs
.append('/usr/X11R6/lib64')
1367 added_lib_dirs
.append('/usr/X11R6/lib')
1368 elif os
.path
.exists('/usr/X11R5/include'):
1369 include_dirs
.append('/usr/X11R5/include')
1370 added_lib_dirs
.append('/usr/X11R5/lib')
1372 # Assume default location for X11
1373 include_dirs
.append('/usr/X11/include')
1374 added_lib_dirs
.append('/usr/X11/lib')
1376 # If Cygwin, then verify that X is installed before proceeding
1377 if platform
== 'cygwin':
1378 x11_inc
= find_file('X11/Xlib.h', [], include_dirs
)
1382 # Check for BLT extension
1383 if self
.compiler
.find_library_file(lib_dirs
+ added_lib_dirs
,
1385 defs
.append( ('WITH_BLT', 1) )
1386 libs
.append('BLT8.0')
1387 elif self
.compiler
.find_library_file(lib_dirs
+ added_lib_dirs
,
1389 defs
.append( ('WITH_BLT', 1) )
1392 # Add the Tcl/Tk libraries
1393 libs
.append('tk'+ version
)
1394 libs
.append('tcl'+ version
)
1396 if platform
in ['aix3', 'aix4']:
1399 # Finally, link with the X11 libraries (not appropriate on cygwin)
1400 if platform
!= "cygwin":
1403 ext
= Extension('_tkinter', ['_tkinter.c', 'tkappinit.c'],
1404 define_macros
=[('WITH_APPINIT', 1)] + defs
,
1405 include_dirs
= include_dirs
,
1407 library_dirs
= added_lib_dirs
,
1409 self
.extensions
.append(ext
)
1411 ## # Uncomment these lines if you want to play with xxmodule.c
1412 ## ext = Extension('xx', ['xxmodule.c'])
1413 ## self.extensions.append(ext)
1415 # XXX handle these, but how to detect?
1416 # *** Uncomment and edit for PIL (TkImaging) extension only:
1417 # -DWITH_PIL -I../Extensions/Imaging/libImaging tkImaging.c \
1418 # *** Uncomment and edit for TOGL extension only:
1419 # -DWITH_TOGL togl.c \
1420 # *** Uncomment these for TOGL extension only:
1421 # -lGL -lGLU -lXext -lXmu \
1423 def configure_ctypes_darwin(self
, ext
):
1424 # Darwin (OS X) uses preconfigured files, in
1425 # the Modules/_ctypes/libffi_osx directory.
1426 srcdir
= sysconfig
.get_config_var('srcdir')
1427 ffi_srcdir
= os
.path
.abspath(os
.path
.join(srcdir
, 'Modules',
1428 '_ctypes', 'libffi_osx'))
1429 sources
= [os
.path
.join(ffi_srcdir
, p
)
1433 'x86/x86-ffi_darwin.c',
1435 'powerpc/ppc-darwin.S',
1436 'powerpc/ppc-darwin_closure.S',
1437 'powerpc/ppc-ffi_darwin.c',
1438 'powerpc/ppc64-darwin_closure.S',
1441 # Add .S (preprocessed assembly) to C compiler source extensions.
1442 self
.compiler
.src_extensions
.append('.S')
1444 include_dirs
= [os
.path
.join(ffi_srcdir
, 'include'),
1445 os
.path
.join(ffi_srcdir
, 'powerpc')]
1446 ext
.include_dirs
.extend(include_dirs
)
1447 ext
.sources
.extend(sources
)
1450 def configure_ctypes(self
, ext
):
1451 if not self
.use_system_libffi
:
1452 if sys
.platform
== 'darwin':
1453 return self
.configure_ctypes_darwin(ext
)
1455 srcdir
= sysconfig
.get_config_var('srcdir')
1456 ffi_builddir
= os
.path
.join(self
.build_temp
, 'libffi')
1457 ffi_srcdir
= os
.path
.abspath(os
.path
.join(srcdir
, 'Modules',
1458 '_ctypes', 'libffi'))
1459 ffi_configfile
= os
.path
.join(ffi_builddir
, 'fficonfig.py')
1461 from distutils
.dep_util
import newer_group
1463 config_sources
= [os
.path
.join(ffi_srcdir
, fname
)
1464 for fname
in os
.listdir(ffi_srcdir
)
1465 if os
.path
.isfile(os
.path
.join(ffi_srcdir
, fname
))]
1466 if self
.force
or newer_group(config_sources
,
1468 from distutils
.dir_util
import mkpath
1469 mkpath(ffi_builddir
)
1472 # Pass empty CFLAGS because we'll just append the resulting
1473 # CFLAGS to Python's; -g or -O2 is to be avoided.
1474 cmd
= "cd %s && env CFLAGS='' '%s/configure' %s" \
1475 % (ffi_builddir
, ffi_srcdir
, " ".join(config_args
))
1477 res
= os
.system(cmd
)
1478 if res
or not os
.path
.exists(ffi_configfile
):
1479 print("Failed to configure _ctypes module")
1483 fp
= open(ffi_configfile
)
1488 exec(script
, globals(), fficonfig
)
1489 ffi_srcdir
= os
.path
.join(fficonfig
['ffi_srcdir'], 'src')
1491 # Add .S (preprocessed assembly) to C compiler source extensions.
1492 self
.compiler
.src_extensions
.append('.S')
1494 include_dirs
= [os
.path
.join(ffi_builddir
, 'include'),
1495 ffi_builddir
, ffi_srcdir
]
1496 extra_compile_args
= fficonfig
['ffi_cflags'].split()
1498 ext
.sources
.extend(fficonfig
['ffi_sources'])
1499 ext
.include_dirs
.extend(include_dirs
)
1500 ext
.extra_compile_args
.extend(extra_compile_args
)
1503 def detect_ctypes(self
, inc_dirs
, lib_dirs
):
1504 self
.use_system_libffi
= False
1506 extra_compile_args
= []
1507 extra_link_args
= []
1508 sources
= ['_ctypes/_ctypes.c',
1509 '_ctypes/callbacks.c',
1510 '_ctypes/callproc.c',
1511 '_ctypes/stgdict.c',
1513 '_ctypes/malloc_closure.c']
1514 depends
= ['_ctypes/ctypes.h']
1516 if sys
.platform
== 'darwin':
1517 sources
.append('_ctypes/darwin/dlfcn_simple.c')
1518 extra_compile_args
.append('-DMACOSX')
1519 include_dirs
.append('_ctypes/darwin')
1520 # XXX Is this still needed?
1521 ## extra_link_args.extend(['-read_only_relocs', 'warning'])
1523 elif sys
.platform
== 'sunos5':
1524 # XXX This shouldn't be necessary; it appears that some
1525 # of the assembler code is non-PIC (i.e. it has relocations
1526 # when it shouldn't. The proper fix would be to rewrite
1527 # the assembler code to be PIC.
1528 # This only works with GCC; the Sun compiler likely refuses
1529 # this option. If you want to compile ctypes with the Sun
1530 # compiler, please research a proper solution, instead of
1531 # finding some -z option for the Sun compiler.
1532 extra_link_args
.append('-mimpure-text')
1534 elif sys
.platform
.startswith('hp-ux'):
1535 extra_link_args
.append('-fPIC')
1537 ext
= Extension('_ctypes',
1538 include_dirs
=include_dirs
,
1539 extra_compile_args
=extra_compile_args
,
1540 extra_link_args
=extra_link_args
,
1544 ext_test
= Extension('_ctypes_test',
1545 sources
=['_ctypes/_ctypes_test.c'])
1546 self
.extensions
.extend([ext
, ext_test
])
1548 if not '--with-system-ffi' in sysconfig
.get_config_var("CONFIG_ARGS"):
1551 if sys
.platform
== 'darwin':
1552 # OS X 10.5 comes with libffi.dylib; the include files are
1553 # in /usr/include/ffi
1554 inc_dirs
.append('/usr/include/ffi')
1556 ffi_inc
= find_file('ffi.h', [], inc_dirs
)
1557 if ffi_inc
is not None:
1558 ffi_h
= ffi_inc
[0] + '/ffi.h'
1561 line
= fp
.readline()
1565 if line
.startswith('#define LIBFFI_H'):
1568 if ffi_inc
is not None:
1569 for lib_name
in ('ffi_convenience', 'ffi_pic', 'ffi'):
1570 if (self
.compiler
.find_library_file(lib_dirs
, lib_name
)):
1574 if ffi_inc
and ffi_lib
:
1575 ext
.include_dirs
.extend(ffi_inc
)
1576 ext
.libraries
.append(ffi_lib
)
1577 self
.use_system_libffi
= True
1580 class PyBuildInstall(install
):
1581 # Suppress the warning about installation into the lib_dynload
1582 # directory, which is not in sys.path when running Python during
1584 def initialize_options (self
):
1585 install
.initialize_options(self
)
1588 class PyBuildInstallLib(install_lib
):
1589 # Do exactly what install_lib does but make sure correct access modes get
1590 # set on installed directories and files. All installed files with get
1591 # mode 644 unless they are a shared library in which case they will get
1592 # mode 755. All installed directories will get mode 755.
1594 so_ext
= sysconfig
.get_config_var("SO")
1597 outfiles
= install_lib
.install(self
)
1598 self
.set_file_modes(outfiles
, 0o644, 0o755)
1599 self
.set_dir_modes(self
.install_dir
, 0o755)
1602 def set_file_modes(self
, files
, defaultMode
, sharedLibMode
):
1603 if not self
.is_chmod_supported(): return
1604 if not files
: return
1606 for filename
in files
:
1607 if os
.path
.islink(filename
): continue
1609 if filename
.endswith(self
.so_ext
): mode
= sharedLibMode
1610 log
.info("changing mode of %s to %o", filename
, mode
)
1611 if not self
.dry_run
: os
.chmod(filename
, mode
)
1613 def set_dir_modes(self
, dirname
, mode
):
1614 if not self
.is_chmod_supported(): return
1615 for dirpath
, dirnames
, fnames
in os
.walk(dirname
):
1616 if os
.path
.islink(dirpath
):
1618 log
.info("changing mode of %s to %o", dirpath
, mode
)
1619 if not self
.dry_run
: os
.chmod(dirpath
, mode
)
1621 def is_chmod_supported(self
):
1622 return hasattr(os
, 'chmod')
1625 Python is an interpreted, interactive, object-oriented programming
1626 language. It is often compared to Tcl, Perl, Scheme or Java.
1628 Python combines remarkable power with very clear syntax. It has
1629 modules, classes, exceptions, very high level dynamic data types, and
1630 dynamic typing. There are interfaces to many system calls and
1631 libraries, as well as to various windowing systems (X11, Motif, Tk,
1632 Mac, MFC). New built-in modules are easily written in C or C++. Python
1633 is also usable as an extension language for applications that need a
1634 programmable interface.
1636 The Python implementation is portable: it runs on many brands of UNIX,
1637 on Windows, DOS, OS/2, Mac, Amiga... If your favorite system isn't
1638 listed here, it may still be supported, if there's a C compiler for
1639 it. Ask around on comp.lang.python -- or just try compiling Python
1644 Development Status :: 6 - Mature
1645 License :: OSI Approved :: Python Software Foundation License
1646 Natural Language :: English
1647 Programming Language :: C
1648 Programming Language :: Python
1649 Topic :: Software Development
1653 # turn off warnings when deprecated modules are imported
1655 warnings
.filterwarnings("ignore",category
=DeprecationWarning)
1656 setup(# PyPI Metadata (PEP 301)
1658 version
= sys
.version
.split()[0],
1659 url
= "http://www.python.org/%s" % sys
.version
[:3],
1660 maintainer
= "Guido van Rossum and the Python community",
1661 maintainer_email
= "python-dev@python.org",
1662 description
= "A high-level object-oriented programming language",
1663 long_description
= SUMMARY
.strip(),
1664 license
= "PSF license",
1665 classifiers
= [x
for x
in CLASSIFIERS
.split("\n") if x
],
1666 platforms
= ["Many"],
1669 cmdclass
= {'build_ext':PyBuildExt
, 'install':PyBuildInstall
,
1670 'install_lib':PyBuildInstallLib
},
1671 # The struct module is defined here, because build_ext won't be
1672 # called unless there's at least one extension module defined.
1673 ext_modules
=[Extension('_struct', ['_struct.c'])],
1675 scripts
= ["Tools/scripts/pydoc3", "Tools/scripts/idle3",
1676 "Tools/scripts/2to3"]
1680 if __name__
== '__main__':