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
17 from distutils
.spawn
import find_executable
19 # This global variable is used to hold the list of modules to be disabled.
20 disabled_module_list
= []
22 def add_dir_to_list(dirlist
, dir):
23 """Add the directory 'dir' to the list 'dirlist' (at the front) if
24 1) 'dir' is not already in 'dirlist'
25 2) 'dir' actually exists, and is a directory."""
26 if dir is not None and os
.path
.isdir(dir) and dir not in dirlist
:
27 dirlist
.insert(0, dir)
29 def macosx_sdk_root():
31 Return the directory of the current OSX SDK,
32 or '/' if no SDK was specified.
34 cflags
= sysconfig
.get_config_var('CFLAGS')
35 m
= re
.search(r
'-isysroot\s+(\S+)', cflags
)
42 def is_macosx_sdk_path(path
):
44 Returns True if 'path' can be located in an OSX SDK
46 return (path
.startswith('/usr/') and not path
.startswith('/usr/local')) or path
.startswith('/System/')
48 def find_file(filename
, std_dirs
, paths
):
49 """Searches for the directory where a given file is located,
50 and returns a possibly-empty list of additional directories, or None
51 if the file couldn't be found at all.
53 'filename' is the name of a file, such as readline.h or libcrypto.a.
54 'std_dirs' is the list of standard system directories; if the
55 file is found in one of them, no additional directives are needed.
56 'paths' is a list of additional locations to check; if the file is
57 found in one of them, the resulting list will contain the directory.
59 if sys
.platform
== 'darwin':
60 # Honor the MacOSX SDK setting when one was specified.
61 # An SDK is a directory with the same structure as a real
62 # system, but with only header files and libraries.
63 sysroot
= macosx_sdk_root()
65 # Check the standard locations
67 f
= os
.path
.join(dir, filename
)
69 if sys
.platform
== 'darwin' and is_macosx_sdk_path(dir):
70 f
= os
.path
.join(sysroot
, dir[1:], filename
)
72 if os
.path
.exists(f
): return []
74 # Check the additional directories
76 f
= os
.path
.join(dir, filename
)
78 if sys
.platform
== 'darwin' and is_macosx_sdk_path(dir):
79 f
= os
.path
.join(sysroot
, dir[1:], filename
)
87 def find_library_file(compiler
, libname
, std_dirs
, paths
):
88 result
= compiler
.find_library_file(std_dirs
+ paths
, libname
)
92 if sys
.platform
== 'darwin':
93 sysroot
= macosx_sdk_root()
95 # Check whether the found file is in one of the standard directories
96 dirname
= os
.path
.dirname(result
)
98 # Ensure path doesn't end with path separator
101 if sys
.platform
== 'darwin' and is_macosx_sdk_path(p
):
102 if os
.path
.join(sysroot
, p
[1:]) == dirname
:
108 # Otherwise, it must have been in one of the additional directories,
109 # so we have to figure out which one.
111 # Ensure path doesn't end with path separator
114 if sys
.platform
== 'darwin' and is_macosx_sdk_path(p
):
115 if os
.path
.join(sysroot
, p
[1:]) == dirname
:
121 assert False, "Internal error: Path not found in std_dirs or paths"
123 def module_enabled(extlist
, modname
):
124 """Returns whether the module 'modname' is present in the list
125 of extensions 'extlist'."""
126 extlist
= [ext
for ext
in extlist
if ext
.name
== modname
]
129 def find_module_file(module
, dirlist
):
130 """Find a module in a set of possible folders. If it is not found
131 return the unadorned filename"""
132 list = find_file(module
, [], dirlist
)
136 log
.info("WARNING: multiple copies of %s found"%module
)
137 return os
.path
.join(list[0], module
)
139 class PyBuildExt(build_ext
):
141 def __init__(self
, dist
):
142 build_ext
.__init
__(self
, dist
)
145 def build_extensions(self
):
147 # Detect which modules should be compiled
148 missing
= self
.detect_modules()
150 # Remove modules that are present on the disabled list
151 extensions
= [ext
for ext
in self
.extensions
152 if ext
.name
not in disabled_module_list
]
153 # move ctypes to the end, it depends on other modules
154 ext_map
= dict((ext
.name
, i
) for i
, ext
in enumerate(extensions
))
155 if "_ctypes" in ext_map
:
156 ctypes
= extensions
.pop(ext_map
["_ctypes"])
157 extensions
.append(ctypes
)
158 self
.extensions
= extensions
160 # Fix up the autodetected modules, prefixing all the source files
162 srcdir
= sysconfig
.get_config_var('srcdir')
164 # Maybe running on Windows but not using CYGWIN?
165 raise ValueError("No source directory; cannot proceed.")
166 srcdir
= os
.path
.abspath(srcdir
)
167 moddirlist
= [os
.path
.join(srcdir
, 'Modules')]
169 # Platform-dependent module source and include directories
170 platform
= self
.get_platform()
172 # Fix up the paths for scripts, too
173 self
.distribution
.scripts
= [os
.path
.join(srcdir
, filename
)
174 for filename
in self
.distribution
.scripts
]
176 # Python header files
177 headers
= [sysconfig
.get_config_h_filename()]
178 headers
+= glob(os
.path
.join(sysconfig
.get_python_inc(), "*.h"))
180 for ext
in self
.extensions
[:]:
181 ext
.sources
= [ find_module_file(filename
, moddirlist
)
182 for filename
in ext
.sources
]
183 if ext
.depends
is not None:
184 ext
.depends
= [find_module_file(filename
, moddirlist
)
185 for filename
in ext
.depends
]
188 # re-compile extensions if a header file has been changed
189 ext
.depends
.extend(headers
)
191 # If a module has already been built statically,
192 # don't build it here
193 if ext
.name
in sys
.builtin_module_names
:
194 self
.extensions
.remove(ext
)
196 if platform
!= 'mac':
197 # Parse Modules/Setup and Modules/Setup.local to figure out which
198 # modules are turned on in the file.
200 for filename
in ('Modules/Setup', 'Modules/Setup.local'):
201 input = text_file
.TextFile(filename
, join_lines
=1)
203 line
= input.readline()
206 remove_modules
.append(line
[0])
209 for ext
in self
.extensions
[:]:
210 if ext
.name
in remove_modules
:
211 self
.extensions
.remove(ext
)
213 # When you run "make CC=altcc" or something similar, you really want
214 # those environment variables passed into the setup.py phase. Here's
215 # a small set of useful ones.
216 compiler
= os
.environ
.get('CC')
218 # unfortunately, distutils doesn't let us provide separate C and C++
220 if compiler
is not None:
221 (ccshared
,cflags
) = sysconfig
.get_config_vars('CCSHARED','CFLAGS')
222 args
['compiler_so'] = compiler
+ ' ' + ccshared
+ ' ' + cflags
223 self
.compiler
.set_executables(**args
)
225 build_ext
.build_extensions(self
)
227 longest
= max([len(e
.name
) for e
in self
.extensions
])
229 longest
= max(longest
, max([len(name
) for name
in self
.failed
]))
231 def print_three_column(lst
):
232 lst
.sort(key
=str.lower
)
233 # guarantee zip() doesn't drop anything
236 for e
, f
, g
in zip(lst
[::3], lst
[1::3], lst
[2::3]):
237 print("%-*s %-*s %-*s" % (longest
, e
, longest
, f
,
242 print("Python build finished, but the necessary bits to build "
243 "these modules were not found:")
244 print_three_column(missing
)
245 print("To find the necessary bits, look in setup.py in"
246 " detect_modules() for the module's name.")
250 failed
= self
.failed
[:]
252 print("Failed to build these modules:")
253 print_three_column(failed
)
256 def build_extension(self
, ext
):
258 if ext
.name
== '_ctypes':
259 if not self
.configure_ctypes(ext
):
263 build_ext
.build_extension(self
, ext
)
264 except (CCompilerError
, DistutilsError
) as why
:
265 self
.announce('WARNING: building of extension "%s" failed: %s' %
266 (ext
.name
, sys
.exc_info()[1]))
267 self
.failed
.append(ext
.name
)
269 # Workaround for Mac OS X: The Carbon-based modules cannot be
270 # reliably imported into a command-line Python
271 if 'Carbon' in ext
.extra_link_args
:
273 'WARNING: skipping import check for Carbon-based "%s"' %
277 if self
.get_platform() == 'darwin' and (
278 sys
.maxsize
> 2**32 and '-arch' in ext
.extra_link_args
):
279 # Don't bother doing an import check when an extension was
280 # build with an explicit '-arch' flag on OSX. That's currently
281 # only used to build 32-bit only extensions in a 4-way
282 # universal build and loading 32-bit code into a 64-bit
285 'WARNING: skipping import check for "%s"' %
289 # Workaround for Cygwin: Cygwin currently has fork issues when many
290 # modules have been imported
291 if self
.get_platform() == 'cygwin':
292 self
.announce('WARNING: skipping import check for Cygwin-based "%s"'
295 ext_filename
= os
.path
.join(
297 self
.get_ext_filename(self
.get_ext_fullname(ext
.name
)))
299 # If the build directory didn't exist when setup.py was
300 # started, sys.path_importer_cache has a negative result
301 # cached. Clear that cache before trying to import.
302 sys
.path_importer_cache
.clear()
305 imp
.load_dynamic(ext
.name
, ext_filename
)
306 except ImportError as why
:
307 self
.failed
.append(ext
.name
)
308 self
.announce('*** WARNING: renaming "%s" since importing it'
309 ' failed: %s' % (ext
.name
, why
), level
=3)
310 assert not self
.inplace
311 basename
, tail
= os
.path
.splitext(ext_filename
)
312 newname
= basename
+ "_failed" + tail
313 if os
.path
.exists(newname
):
315 os
.rename(ext_filename
, newname
)
317 # XXX -- This relies on a Vile HACK in
318 # distutils.command.build_ext.build_extension(). The
319 # _built_objects attribute is stored there strictly for
321 # If there is a failure, _built_objects may not be there,
322 # so catch the AttributeError and move on.
324 for filename
in self
._built
_objects
:
326 except AttributeError:
327 self
.announce('unable to remove files (ignored)')
329 exc_type
, why
, tb
= sys
.exc_info()
330 self
.announce('*** WARNING: importing extension "%s" '
331 'failed with %s: %s' % (ext
.name
, exc_type
, why
),
333 self
.failed
.append(ext
.name
)
335 def get_platform(self
):
336 # Get value of sys.platform
337 for platform
in ['cygwin', 'darwin', 'atheos', 'osf1']:
338 if sys
.platform
.startswith(platform
):
342 def detect_modules(self
):
343 # Ensure that /usr/local is always used
344 add_dir_to_list(self
.compiler
.library_dirs
, '/usr/local/lib')
345 add_dir_to_list(self
.compiler
.include_dirs
, '/usr/local/include')
347 # Add paths specified in the environment variables LDFLAGS and
348 # CPPFLAGS for header and library files.
349 # We must get the values from the Makefile and not the environment
350 # directly since an inconsistently reproducible issue comes up where
351 # the environment variable is not set even though the value were passed
352 # into configure and stored in the Makefile (issue found on OS X 10.3).
353 for env_var
, arg_name
, dir_list
in (
354 ('LDFLAGS', '-R', self
.compiler
.runtime_library_dirs
),
355 ('LDFLAGS', '-L', self
.compiler
.library_dirs
),
356 ('CPPFLAGS', '-I', self
.compiler
.include_dirs
)):
357 env_val
= sysconfig
.get_config_var(env_var
)
359 # To prevent optparse from raising an exception about any
360 # options in env_val that it doesn't know about we strip out
361 # all double dashes and any dashes followed by a character
362 # that is not for the option we are dealing with.
364 # Please note that order of the regex is important! We must
365 # strip out double-dashes first so that we don't end up with
366 # substituting "--Long" to "-Long" and thus lead to "ong" being
367 # used for a library directory.
368 env_val
= re
.sub(r
'(^|\s+)-(-|(?!%s))' % arg_name
[1],
370 parser
= optparse
.OptionParser()
371 # Make sure that allowing args interspersed with options is
373 parser
.allow_interspersed_args
= True
374 parser
.error
= lambda msg
: None
375 parser
.add_option(arg_name
, dest
="dirs", action
="append")
376 options
= parser
.parse_args(env_val
.split())[0]
378 for directory
in reversed(options
.dirs
):
379 add_dir_to_list(dir_list
, directory
)
381 if os
.path
.normpath(sys
.prefix
) != '/usr':
382 add_dir_to_list(self
.compiler
.library_dirs
,
383 sysconfig
.get_config_var("LIBDIR"))
384 add_dir_to_list(self
.compiler
.include_dirs
,
385 sysconfig
.get_config_var("INCLUDEDIR"))
387 # lib_dirs and inc_dirs are used to search for files;
388 # if a file is found in one of those directories, it can
389 # be assumed that no additional -I,-L directives are needed.
390 lib_dirs
= self
.compiler
.library_dirs
+ [
391 '/lib64', '/usr/lib64',
394 inc_dirs
= self
.compiler
.include_dirs
+ ['/usr/include']
398 config_h
= sysconfig
.get_config_h_filename()
399 config_h_vars
= sysconfig
.parse_config_h(open(config_h
))
401 platform
= self
.get_platform()
402 srcdir
= sysconfig
.get_config_var('srcdir')
404 # Check for AtheOS which has libraries in non-standard locations
405 if platform
== 'atheos':
406 lib_dirs
+= ['/system/libs', '/atheos/autolnk/lib']
407 lib_dirs
+= os
.getenv('LIBRARY_PATH', '').split(os
.pathsep
)
408 inc_dirs
+= ['/system/include', '/atheos/autolnk/include']
409 inc_dirs
+= os
.getenv('C_INCLUDE_PATH', '').split(os
.pathsep
)
411 # OSF/1 and Unixware have some stuff in /usr/ccs/lib (like -ldb)
412 if platform
in ['osf1', 'unixware7', 'openunix8']:
413 lib_dirs
+= ['/usr/ccs/lib']
415 if platform
== 'darwin':
416 # This should work on any unixy platform ;-)
417 # If the user has bothered specifying additional -I and -L flags
418 # in OPT and LDFLAGS we might as well use them here.
419 # NOTE: using shlex.split would technically be more correct, but
420 # also gives a bootstrap problem. Let's hope nobody uses directories
421 # with whitespace in the name to store libraries.
422 cflags
, ldflags
= sysconfig
.get_config_vars(
424 for item
in cflags
.split():
425 if item
.startswith('-I'):
426 inc_dirs
.append(item
[2:])
428 for item
in ldflags
.split():
429 if item
.startswith('-L'):
430 lib_dirs
.append(item
[2:])
432 # Check for MacOS X, which doesn't need libm.a at all
434 if platform
in ['darwin', 'mac']:
437 # XXX Omitted modules: gl, pure, dl, SGI-specific modules
440 # The following modules are all pretty straightforward, and compile
441 # on pretty much any POSIXish platform.
444 # Some modules that are normally always on:
445 exts
.append( Extension('_weakref', ['_weakref.c']) )
448 exts
.append( Extension('array', ['arraymodule.c']) )
449 # complex math library functions
450 exts
.append( Extension('cmath', ['cmathmodule.c'],
451 libraries
=math_libs
) )
453 # math library functions, e.g. sin()
454 exts
.append( Extension('math', ['mathmodule.c'],
455 libraries
=math_libs
) )
456 # time operations and variables
457 exts
.append( Extension('time', ['timemodule.c'],
458 libraries
=math_libs
) )
459 exts
.append( Extension('datetime', ['datetimemodule.c', 'timemodule.c'],
460 libraries
=math_libs
) )
461 # fast iterator tools implemented in C
462 exts
.append( Extension("itertools", ["itertoolsmodule.c"]) )
463 # random number generator implemented in C
464 exts
.append( Extension("_random", ["_randommodule.c"]) )
465 # high-performance collections
466 exts
.append( Extension("_collections", ["_collectionsmodule.c"]) )
468 exts
.append( Extension("_bisect", ["_bisectmodule.c"]) )
470 exts
.append( Extension("_heapq", ["_heapqmodule.c"]) )
471 # operator.add() and similar goodies
472 exts
.append( Extension('operator', ['operator.c']) )
473 # C-optimized pickle replacement
474 exts
.append( Extension("_pickle", ["_pickle.c"]) )
476 exts
.append( Extension("atexit", ["atexitmodule.c"]) )
478 exts
.append( Extension("_json", ["_json.c"]) )
479 # Python C API test module
480 exts
.append( Extension('_testcapi', ['_testcapimodule.c'],
481 depends
=['testcapi_long.h']) )
482 # profiler (_lsprof is for cProfile.py)
483 exts
.append( Extension('_lsprof', ['_lsprof.c', 'rotatingtree.c']) )
484 # static Unicode character database
485 exts
.append( Extension('unicodedata', ['unicodedata.c']) )
487 # Modules with some UNIX dependencies -- on by default:
488 # (If you have a really backward UNIX, select and socket may not be
491 # fcntl(2) and ioctl(2)
492 exts
.append( Extension('fcntl', ['fcntlmodule.c']) )
493 if platform
not in ['mac']:
495 exts
.append( Extension('pwd', ['pwdmodule.c']) )
497 exts
.append( Extension('grp', ['grpmodule.c']) )
498 # spwd, shadow passwords
499 if (config_h_vars
.get('HAVE_GETSPNAM', False) or
500 config_h_vars
.get('HAVE_GETSPENT', False)):
501 exts
.append( Extension('spwd', ['spwdmodule.c']) )
503 missing
.append('spwd')
505 missing
.extend(['pwd', 'grp', 'spwd'])
507 # select(2); not on ancient System V
508 exts
.append( Extension('select', ['selectmodule.c']) )
510 # Fred Drake's interface to the Python parser
511 exts
.append( Extension('parser', ['parsermodule.c']) )
513 # Memory-mapped files (also works on Win32).
514 if platform
not in ['atheos', 'mac']:
515 exts
.append( Extension('mmap', ['mmapmodule.c']) )
517 missing
.append('mmap')
519 # Lance Ellinghaus's syslog module
520 if platform
not in ['mac']:
521 # syslog daemon interface
522 exts
.append( Extension('syslog', ['syslogmodule.c']) )
524 missing
.append('syslog')
527 # Here ends the simple stuff. From here on, modules need certain
528 # libraries, are platform-specific, or present other surprises.
532 # These don't work for 64-bit platforms!!!
533 # These represent audio samples or images as strings:
535 # Operations on audio samples
536 # According to #993173, this one should actually work fine on
538 exts
.append( Extension('audioop', ['audioop.c']) )
541 do_readline
= self
.compiler
.find_library_file(lib_dirs
, 'readline')
542 readline_termcap_library
= ""
544 # Determine if readline is already linked against curses or tinfo.
545 if do_readline
and find_executable('ldd'):
546 # Cannot use os.popen here in py3k.
547 tmpfile
= os
.path
.join(self
.build_temp
, 'readline_termcap_lib')
548 if not os
.path
.exists(self
.build_temp
):
549 os
.makedirs(self
.build_temp
)
550 ret
= os
.system("ldd %s > %s" % (do_readline
, tmpfile
))
555 readline_termcap_library
= re
.sub(
556 r
'.*lib(n?cursesw?)\.so.*', r
'\1', ln
559 if 'tinfo' in ln
: # termcap interface split out from ncurses
560 readline_termcap_library
= 'tinfo'
564 # Issue 7384: If readline is already linked against curses,
565 # use the same library for the readline and curses modules.
566 # Disabled since applications relying on ncursesw might break.
568 # if 'curses' in readline_termcap_library:
569 # curses_library = readline_termcap_library
570 # elif self.compiler.find_library_file(lib_dirs, 'ncursesw'):
572 if self
.compiler
.find_library_file(lib_dirs
, 'ncursesw'):
573 curses_library
= 'ncursesw'
574 elif self
.compiler
.find_library_file(lib_dirs
, 'ncurses'):
575 curses_library
= 'ncurses'
576 elif self
.compiler
.find_library_file(lib_dirs
, 'curses'):
577 curses_library
= 'curses'
579 if platform
== 'darwin': # and os.uname()[2] < '9.':
580 # MacOSX 10.4 has a broken readline. Don't try to build
581 # the readline module unless the user has installed a fixed
583 # FIXME: The readline emulation on 10.5 is better, but the
584 # readline module doesn't compile out of the box.
585 if find_file('readline/rlconf.h', inc_dirs
, []) is None:
588 if sys
.platform
== 'darwin':
589 # In every directory on the search path search for a dynamic
590 # library and then a static library, instead of first looking
591 # for dynamic libraries on the entire path.
592 # This way a staticly linked custom readline gets picked up
593 # before the (possibly broken) dynamic library in /usr/lib.
594 readline_extra_link_args
= ('-Wl,-search_paths_first',)
596 readline_extra_link_args
= ()
598 readline_libs
= ['readline']
599 if readline_termcap_library
:
600 pass # Issue 7384: Already linked against curses or tinfo.
602 readline_libs
.append(curses_library
)
603 elif self
.compiler
.find_library_file(lib_dirs
+
604 ['/usr/lib/termcap'],
606 readline_libs
.append('termcap')
607 exts
.append( Extension('readline', ['readline.c'],
608 library_dirs
=['/usr/lib/termcap'],
609 extra_link_args
=readline_extra_link_args
,
610 libraries
=readline_libs
) )
612 missing
.append('readline')
614 if platform
not in ['mac']:
617 if self
.compiler
.find_library_file(lib_dirs
, 'crypt'):
621 exts
.append( Extension('crypt', ['cryptmodule.c'], libraries
=libs
) )
623 missing
.append('crypt')
626 exts
.append( Extension('_csv', ['_csv.c']) )
629 exts
.append( Extension('_socket', ['socketmodule.c'],
630 depends
= ['socketmodule.h']) )
631 # Detect SSL support for the socket module (via _ssl)
632 search_for_ssl_incs_in
= [
633 '/usr/local/ssl/include',
634 '/usr/contrib/ssl/include/'
636 ssl_incs
= find_file('openssl/ssl.h', inc_dirs
,
637 search_for_ssl_incs_in
639 if ssl_incs
is not None:
640 krb5_h
= find_file('krb5.h', inc_dirs
,
641 ['/usr/kerberos/include'])
644 ssl_libs
= find_library_file(self
.compiler
, 'ssl',lib_dirs
,
645 ['/usr/local/ssl/lib',
646 '/usr/contrib/ssl/lib/'
649 if (ssl_incs
is not None and
650 ssl_libs
is not None):
651 exts
.append( Extension('_ssl', ['_ssl.c'],
652 include_dirs
= ssl_incs
,
653 library_dirs
= ssl_libs
,
654 libraries
= ['ssl', 'crypto'],
655 depends
= ['socketmodule.h']), )
657 missing
.append('_ssl')
659 # find out which version of OpenSSL we have
661 openssl_ver_re
= re
.compile(
662 '^\s*#\s*define\s+OPENSSL_VERSION_NUMBER\s+(0x[0-9a-fA-F]+)' )
664 # look for the openssl version header on the compiler search path.
665 opensslv_h
= find_file('openssl/opensslv.h', [],
666 inc_dirs
+ search_for_ssl_incs_in
)
668 name
= os
.path
.join(opensslv_h
[0], 'openssl/opensslv.h')
669 if sys
.platform
== 'darwin' and is_macosx_sdk_path(name
):
670 name
= os
.path
.join(macosx_sdk_root(), name
[1:])
672 incfile
= open(name
, 'r')
674 m
= openssl_ver_re
.match(line
)
676 openssl_ver
= eval(m
.group(1))
677 except IOError as msg
:
678 print("IOError while reading opensshv.h:", msg
)
681 #print('openssl_ver = 0x%08x' % openssl_ver)
683 if ssl_incs
is not None and ssl_libs
is not None:
684 if openssl_ver
>= 0x00907000:
685 # The _hashlib module wraps optimized implementations
686 # of hash functions from the OpenSSL library.
687 exts
.append( Extension('_hashlib', ['_hashopenssl.c'],
688 include_dirs
= ssl_incs
,
689 library_dirs
= ssl_libs
,
690 libraries
= ['ssl', 'crypto']) )
692 print("warning: openssl 0x%08x is too old for _hashlib" %
694 missing
.append('_hashlib')
696 missing
.append('_hashlib')
698 if openssl_ver
< 0x00908000:
699 # OpenSSL doesn't do these until 0.9.8 so we'll bring our own hash
700 exts
.append( Extension('_sha256', ['sha256module.c']) )
701 exts
.append( Extension('_sha512', ['sha512module.c']) )
703 if openssl_ver
< 0x00907000:
704 # no openssl at all, use our own md5 and sha1
705 exts
.append( Extension('_md5', ['md5module.c']) )
706 exts
.append( Extension('_sha1', ['sha1module.c']) )
708 # Modules that provide persistent dictionary-like semantics. You will
709 # probably want to arrange for at least one of them to be available on
710 # your machine, though none are defined by default because of library
711 # dependencies. The Python module dbm/__init__.py provides an
712 # implementation independent wrapper for these; dbm/dumb.py provides
713 # similar functionality (but slower of course) implemented in Python.
715 # Sleepycat^WOracle Berkeley DB interface.
716 # http://www.oracle.com/database/berkeley-db/db/index.html
718 # This requires the Sleepycat^WOracle DB code. The supported versions
719 # are set below. Visit the URL above to download
720 # a release. Most open source OSes come with one or more
721 # versions of BerkeleyDB already installed.
725 db_setup_debug
= False # verbose debug prints from this script?
727 def allow_db_ver(db_ver
):
728 """Returns a boolean if the given BerkeleyDB version is acceptable.
731 db_ver: A tuple of the version to verify.
733 if not (min_db_ver
<= db_ver
<= max_db_ver
):
737 def gen_db_minor_ver_nums(major
):
739 for x
in range(max_db_ver
[1]+1):
740 if allow_db_ver((4, x
)):
744 if allow_db_ver((3, x
)):
747 raise ValueError("unknown major BerkeleyDB version", major
)
749 # construct a list of paths to look for the header file in on
750 # top of the normal inc_dirs.
753 '/usr/local/include/db4',
754 '/opt/sfw/include/db4',
756 '/usr/local/include/db3',
757 '/opt/sfw/include/db3',
758 # Fink defaults (http://fink.sourceforge.net/)
762 # 4.x minor number specific paths
763 for x
in gen_db_minor_ver_nums(4):
764 db_inc_paths
.append('/usr/include/db4%d' % x
)
765 db_inc_paths
.append('/usr/include/db4.%d' % x
)
766 db_inc_paths
.append('/usr/local/BerkeleyDB.4.%d/include' % x
)
767 db_inc_paths
.append('/usr/local/include/db4%d' % x
)
768 db_inc_paths
.append('/pkg/db-4.%d/include' % x
)
769 db_inc_paths
.append('/opt/db-4.%d/include' % x
)
770 # MacPorts default (http://www.macports.org/)
771 db_inc_paths
.append('/opt/local/include/db4%d' % x
)
772 # 3.x minor number specific paths
773 for x
in gen_db_minor_ver_nums(3):
774 db_inc_paths
.append('/usr/include/db3%d' % x
)
775 db_inc_paths
.append('/usr/local/BerkeleyDB.3.%d/include' % x
)
776 db_inc_paths
.append('/usr/local/include/db3%d' % x
)
777 db_inc_paths
.append('/pkg/db-3.%d/include' % x
)
778 db_inc_paths
.append('/opt/db-3.%d/include' % x
)
780 # Add some common subdirectories for Sleepycat DB to the list,
781 # based on the standard include directories. This way DB3/4 gets
782 # picked up when it is installed in a non-standard prefix and
783 # the user has added that prefix into inc_dirs.
786 std_variants
.append(os
.path
.join(dn
, 'db3'))
787 std_variants
.append(os
.path
.join(dn
, 'db4'))
788 for x
in gen_db_minor_ver_nums(4):
789 std_variants
.append(os
.path
.join(dn
, "db4%d"%x))
790 std_variants
.append(os
.path
.join(dn
, "db4.%d"%x))
791 for x
in gen_db_minor_ver_nums(3):
792 std_variants
.append(os
.path
.join(dn
, "db3%d"%x))
793 std_variants
.append(os
.path
.join(dn
, "db3.%d"%x))
795 db_inc_paths
= std_variants
+ db_inc_paths
796 db_inc_paths
= [p
for p
in db_inc_paths
if os
.path
.exists(p
)]
800 if sys
.platform
== 'darwin':
801 sysroot
= macosx_sdk_root()
803 class db_found(Exception): pass
805 # See whether there is a Sleepycat header in the standard
807 for d
in inc_dirs
+ db_inc_paths
:
808 f
= os
.path
.join(d
, "db.h")
809 if sys
.platform
== 'darwin' and is_macosx_sdk_path(d
):
810 f
= os
.path
.join(sysroot
, d
[1:], "db.h")
812 if db_setup_debug
: print("db: looking for db.h in", f
)
813 if os
.path
.exists(f
):
814 f
= open(f
, "rb").read()
815 m
= re
.search(br
"#define\WDB_VERSION_MAJOR\W(\d+)", f
)
817 db_major
= int(m
.group(1))
818 m
= re
.search(br
"#define\WDB_VERSION_MINOR\W(\d+)", f
)
819 db_minor
= int(m
.group(1))
820 db_ver
= (db_major
, db_minor
)
822 # Avoid 4.6 prior to 4.6.21 due to a BerkeleyDB bug
824 m
= re
.search(br
"#define\WDB_VERSION_PATCH\W(\d+)", f
)
825 db_patch
= int(m
.group(1))
827 print("db.h:", db_ver
, "patch", db_patch
,
828 "being ignored (4.6.x must be >= 4.6.21)")
831 if ( (db_ver
not in db_ver_inc_map
) and
832 allow_db_ver(db_ver
) ):
833 # save the include directory with the db.h version
834 # (first occurrence only)
835 db_ver_inc_map
[db_ver
] = d
837 print("db.h: found", db_ver
, "in", d
)
839 # we already found a header for this library version
840 if db_setup_debug
: print("db.h: ignoring", d
)
842 # ignore this header, it didn't contain a version number
844 print("db.h: no version number version in", d
)
846 db_found_vers
= list(db_ver_inc_map
.keys())
850 db_ver
= db_found_vers
.pop()
851 db_incdir
= db_ver_inc_map
[db_ver
]
853 # check lib directories parallel to the location of the header
855 db_incdir
.replace("include", 'lib64'),
856 db_incdir
.replace("include", 'lib'),
859 if sys
.platform
!= 'darwin':
860 db_dirs_to_check
= list(filter(os
.path
.isdir
, db_dirs_to_check
))
863 # Same as other branch, but takes OSX SDK into account
865 for dn
in db_dirs_to_check
:
866 if is_macosx_sdk_path(dn
):
867 if os
.path
.isdir(os
.path
.join(sysroot
, dn
[1:])):
870 if os
.path
.isdir(dn
):
872 db_dirs_to_check
= tmp
874 db_dirs_to_check
= tmp
876 # Look for a version specific db-X.Y before an ambiguoius dbX
877 # XXX should we -ever- look for a dbX name? Do any
878 # systems really not name their library by version and
879 # symlink to more general names?
880 for dblib
in (('db-%d.%d' % db_ver
),
882 ('db%d' % db_ver
[0])):
883 dblib_file
= self
.compiler
.find_library_file(
884 db_dirs_to_check
+ lib_dirs
, dblib
)
886 dblib_dir
= [ os
.path
.abspath(os
.path
.dirname(dblib_file
)) ]
889 if db_setup_debug
: print("db lib: ", dblib
, "not found")
893 print("bsddb using BerkeleyDB lib:", db_ver
, dblib
)
894 print("bsddb lib dir:", dblib_dir
, " inc dir:", db_incdir
)
895 db_incs
= [db_incdir
]
898 if db_setup_debug
: print("db: no appropriate library found")
903 # The sqlite interface
904 sqlite_setup_debug
= False # verbose debug prints from this script?
906 # We hunt for #define SQLITE_VERSION "n.n.n"
907 # We need to find >= sqlite version 3.0.8
908 sqlite_incdir
= sqlite_libdir
= None
909 sqlite_inc_paths
= [ '/usr/include',
910 '/usr/include/sqlite',
911 '/usr/include/sqlite3',
912 '/usr/local/include',
913 '/usr/local/include/sqlite',
914 '/usr/local/include/sqlite3',
916 MIN_SQLITE_VERSION_NUMBER
= (3, 0, 8)
917 MIN_SQLITE_VERSION
= ".".join([str(x
)
918 for x
in MIN_SQLITE_VERSION_NUMBER
])
920 # Scan the default include directories before the SQLite specific
921 # ones. This allows one to override the copy of sqlite on OSX,
922 # where /usr/include contains an old version of sqlite.
923 if sys
.platform
== 'darwin':
924 sysroot
= macosx_sdk_root()
926 for d
in inc_dirs
+ sqlite_inc_paths
:
927 f
= os
.path
.join(d
, "sqlite3.h")
929 if sys
.platform
== 'darwin' and is_macosx_sdk_path(d
):
930 f
= os
.path
.join(sysroot
, d
[1:], "sqlite3.h")
932 if os
.path
.exists(f
):
933 if sqlite_setup_debug
: print("sqlite: found %s"%f)
934 incf
= open(f
).read()
936 r
'\s*.*#\s*.*define\s.*SQLITE_VERSION\W*"(.*)"', incf
)
938 sqlite_version
= m
.group(1)
939 sqlite_version_tuple
= tuple([int(x
)
940 for x
in sqlite_version
.split(".")])
941 if sqlite_version_tuple
>= MIN_SQLITE_VERSION_NUMBER
:
943 if sqlite_setup_debug
:
944 print("%s/sqlite3.h: version %s"%(d
, sqlite_version
))
948 if sqlite_setup_debug
:
949 print("%s: version %d is too old, need >= %s"%(d
,
950 sqlite_version
, MIN_SQLITE_VERSION
))
951 elif sqlite_setup_debug
:
952 print("sqlite: %s had no SQLITE_VERSION"%(f
,))
955 sqlite_dirs_to_check
= [
956 os
.path
.join(sqlite_incdir
, '..', 'lib64'),
957 os
.path
.join(sqlite_incdir
, '..', 'lib'),
958 os
.path
.join(sqlite_incdir
, '..', '..', 'lib64'),
959 os
.path
.join(sqlite_incdir
, '..', '..', 'lib'),
961 sqlite_libfile
= self
.compiler
.find_library_file(
962 sqlite_dirs_to_check
+ lib_dirs
, 'sqlite3')
964 sqlite_libdir
= [os
.path
.abspath(os
.path
.dirname(sqlite_libfile
))]
966 if sqlite_incdir
and sqlite_libdir
:
967 sqlite_srcs
= ['_sqlite/cache.c',
968 '_sqlite/connection.c',
970 '_sqlite/microprotocols.c',
972 '_sqlite/prepare_protocol.c',
974 '_sqlite/statement.c',
978 if sys
.platform
!= "win32":
979 sqlite_defines
.append(('MODULE_NAME', '"sqlite3"'))
981 sqlite_defines
.append(('MODULE_NAME', '\\"sqlite3\\"'))
984 if sys
.platform
== 'darwin':
985 # In every directory on the search path search for a dynamic
986 # library and then a static library, instead of first looking
987 # for dynamic libraries on the entiry path.
988 # This way a staticly linked custom sqlite gets picked up
989 # before the dynamic library in /usr/lib.
990 sqlite_extra_link_args
= ('-Wl,-search_paths_first',)
992 sqlite_extra_link_args
= ()
994 exts
.append(Extension('_sqlite3', sqlite_srcs
,
995 define_macros
=sqlite_defines
,
996 include_dirs
=["Modules/_sqlite",
998 library_dirs
=sqlite_libdir
,
999 runtime_library_dirs
=sqlite_libdir
,
1000 extra_link_args
=sqlite_extra_link_args
,
1001 libraries
=["sqlite3",]))
1003 missing
.append('_sqlite3')
1005 dbm_order
= ['gdbm']
1006 # The standard Unix dbm module:
1007 if platform
not in ['cygwin']:
1008 config_args
= [arg
.strip("'")
1009 for arg
in sysconfig
.get_config_var("CONFIG_ARGS").split()]
1010 dbm_args
= [arg
for arg
in config_args
1011 if arg
.startswith('--with-dbmliborder=')]
1013 dbm_order
= [arg
.split('=')[-1] for arg
in dbm_args
][-1].split(":")
1015 dbm_order
= "ndbm:gdbm:bdb".split(":")
1017 for cand
in dbm_order
:
1019 if find_file("ndbm.h", inc_dirs
, []) is not None:
1020 # Some systems have -lndbm, others don't
1021 if self
.compiler
.find_library_file(lib_dirs
, 'ndbm'):
1022 ndbm_libs
= ['ndbm']
1025 print("building dbm using ndbm")
1026 dbmext
= Extension('_dbm', ['_dbmmodule.c'],
1028 ('HAVE_NDBM_H',None),
1030 libraries
=ndbm_libs
)
1033 elif cand
== "gdbm":
1034 if self
.compiler
.find_library_file(lib_dirs
, 'gdbm'):
1035 gdbm_libs
= ['gdbm']
1036 if self
.compiler
.find_library_file(lib_dirs
, 'gdbm_compat'):
1037 gdbm_libs
.append('gdbm_compat')
1038 if find_file("gdbm/ndbm.h", inc_dirs
, []) is not None:
1039 print("building dbm using gdbm")
1041 '_dbm', ['_dbmmodule.c'],
1043 ('HAVE_GDBM_NDBM_H', None),
1045 libraries
= gdbm_libs
)
1047 if find_file("gdbm-ndbm.h", inc_dirs
, []) is not None:
1048 print("building dbm using gdbm")
1050 '_dbm', ['_dbmmodule.c'],
1052 ('HAVE_GDBM_DASH_NDBM_H', None),
1054 libraries
= gdbm_libs
)
1057 if db_incs
is not None:
1058 print("building dbm using bdb")
1059 dbmext
= Extension('_dbm', ['_dbmmodule.c'],
1060 library_dirs
=dblib_dir
,
1061 runtime_library_dirs
=dblib_dir
,
1062 include_dirs
=db_incs
,
1064 ('HAVE_BERKDB_H', None),
1065 ('DB_DBM_HSEARCH', None),
1069 if dbmext
is not None:
1072 missing
.append('_dbm')
1074 # Anthony Baxter's gdbm module. GNU dbm(3) will require -lgdbm:
1075 if ('gdbm' in dbm_order
and
1076 self
.compiler
.find_library_file(lib_dirs
, 'gdbm')):
1077 exts
.append( Extension('_gdbm', ['_gdbmmodule.c'],
1078 libraries
= ['gdbm'] ) )
1080 missing
.append('_gdbm')
1083 if platform
not in ['mac', 'win32']:
1084 # Steen Lumholt's termios module
1085 exts
.append( Extension('termios', ['termios.c']) )
1086 # Jeremy Hylton's rlimit interface
1087 if platform
not in ['atheos']:
1088 exts
.append( Extension('resource', ['resource.c']) )
1090 missing
.append('resource')
1092 # Sun yellow pages. Some systems have the functions in libc.
1093 if (platform
not in ['cygwin', 'qnx6'] and
1094 find_file('rpcsvc/yp_prot.h', inc_dirs
, []) is not None):
1095 if (self
.compiler
.find_library_file(lib_dirs
, 'nsl')):
1099 exts
.append( Extension('nis', ['nismodule.c'],
1102 missing
.append('nis')
1104 missing
.extend(['nis', 'resource', 'termios'])
1106 # Curses support, requiring the System V version of curses, often
1107 # provided by the ncurses library.
1108 panel_library
= 'panel'
1109 if curses_library
.startswith('ncurses'):
1110 if curses_library
== 'ncursesw':
1111 # Bug 1464056: If _curses.so links with ncursesw,
1112 # _curses_panel.so must link with panelw.
1113 panel_library
= 'panelw'
1114 curses_libs
= [curses_library
]
1115 exts
.append( Extension('_curses', ['_cursesmodule.c'],
1116 libraries
= curses_libs
) )
1117 elif curses_library
== 'curses' and platform
!= 'darwin':
1118 # OSX has an old Berkeley curses, not good enough for
1119 # the _curses module.
1120 if (self
.compiler
.find_library_file(lib_dirs
, 'terminfo')):
1121 curses_libs
= ['curses', 'terminfo']
1122 elif (self
.compiler
.find_library_file(lib_dirs
, 'termcap')):
1123 curses_libs
= ['curses', 'termcap']
1125 curses_libs
= ['curses']
1127 exts
.append( Extension('_curses', ['_cursesmodule.c'],
1128 libraries
= curses_libs
) )
1130 missing
.append('_curses')
1132 # If the curses module is enabled, check for the panel module
1133 if (module_enabled(exts
, '_curses') and
1134 self
.compiler
.find_library_file(lib_dirs
, panel_library
)):
1135 exts
.append( Extension('_curses_panel', ['_curses_panel.c'],
1136 libraries
= [panel_library
] + curses_libs
) )
1138 missing
.append('_curses_panel')
1140 # Andrew Kuchling's zlib module. Note that some versions of zlib
1141 # 1.1.3 have security problems. See CERT Advisory CA-2002-07:
1142 # http://www.cert.org/advisories/CA-2002-07.html
1144 # zlib 1.1.4 is fixed, but at least one vendor (RedHat) has decided to
1145 # patch its zlib 1.1.3 package instead of upgrading to 1.1.4. For
1146 # now, we still accept 1.1.3, because we think it's difficult to
1147 # exploit this in Python, and we'd rather make it RedHat's problem
1148 # than our problem <wink>.
1150 # You can upgrade zlib to version 1.1.4 yourself by going to
1151 # http://www.gzip.org/zlib/
1152 zlib_inc
= find_file('zlib.h', [], inc_dirs
)
1154 if zlib_inc
is not None:
1155 zlib_h
= zlib_inc
[0] + '/zlib.h'
1157 version_req
= '"1.1.3"'
1160 line
= fp
.readline()
1163 if line
.startswith('#define ZLIB_VERSION'):
1164 version
= line
.split()[2]
1166 if version
>= version_req
:
1167 if (self
.compiler
.find_library_file(lib_dirs
, 'z')):
1168 if sys
.platform
== "darwin":
1169 zlib_extra_link_args
= ('-Wl,-search_paths_first',)
1171 zlib_extra_link_args
= ()
1172 exts
.append( Extension('zlib', ['zlibmodule.c'],
1174 extra_link_args
= zlib_extra_link_args
))
1177 missing
.append('zlib')
1179 missing
.append('zlib')
1181 missing
.append('zlib')
1183 # Helper module for various ascii-encoders. Uses zlib for an optimized
1184 # crc32 if we have it. Otherwise binascii uses its own.
1186 extra_compile_args
= ['-DUSE_ZLIB_CRC32']
1188 extra_link_args
= zlib_extra_link_args
1190 extra_compile_args
= []
1192 extra_link_args
= []
1193 exts
.append( Extension('binascii', ['binascii.c'],
1194 extra_compile_args
= extra_compile_args
,
1195 libraries
= libraries
,
1196 extra_link_args
= extra_link_args
) )
1198 # Gustavo Niemeyer's bz2 module.
1199 if (self
.compiler
.find_library_file(lib_dirs
, 'bz2')):
1200 if sys
.platform
== "darwin":
1201 bz2_extra_link_args
= ('-Wl,-search_paths_first',)
1203 bz2_extra_link_args
= ()
1204 exts
.append( Extension('bz2', ['bz2module.c'],
1205 libraries
= ['bz2'],
1206 extra_link_args
= bz2_extra_link_args
) )
1208 missing
.append('bz2')
1210 # Interface to the Expat XML parser
1212 # Expat was written by James Clark and is now maintained by a
1213 # group of developers on SourceForge; see www.libexpat.org for
1214 # more information. The pyexpat module was written by Paul
1215 # Prescod after a prototype by Jack Jansen. The Expat source
1216 # is included in Modules/expat/. Usage of a system
1217 # shared libexpat.so/expat.dll is not advised.
1219 # More information on Expat can be found at www.libexpat.org.
1221 expatinc
= os
.path
.join(os
.getcwd(), srcdir
, 'Modules', 'expat')
1223 ('HAVE_EXPAT_CONFIG_H', '1'),
1226 exts
.append(Extension('pyexpat',
1227 define_macros
= define_macros
,
1228 include_dirs
= [expatinc
],
1229 sources
= ['pyexpat.c',
1236 # Fredrik Lundh's cElementTree module. Note that this also
1237 # uses expat (via the CAPI hook in pyexpat).
1239 if os
.path
.isfile(os
.path
.join(srcdir
, 'Modules', '_elementtree.c')):
1240 define_macros
.append(('USE_PYEXPAT_CAPI', None))
1241 exts
.append(Extension('_elementtree',
1242 define_macros
= define_macros
,
1243 include_dirs
= [expatinc
],
1244 sources
= ['_elementtree.c'],
1247 missing
.append('_elementtree')
1249 # Hye-Shik Chang's CJKCodecs modules.
1250 exts
.append(Extension('_multibytecodec',
1251 ['cjkcodecs/multibytecodec.c']))
1252 for loc
in ('kr', 'jp', 'cn', 'tw', 'hk', 'iso2022'):
1253 exts
.append(Extension('_codecs_%s' % loc
,
1254 ['cjkcodecs/_codecs_%s.c' % loc
]))
1256 # Thomas Heller's _ctypes module
1257 self
.detect_ctypes(inc_dirs
, lib_dirs
)
1259 # Richard Oudkerk's multiprocessing module
1260 if platform
== 'win32': # Windows
1262 libraries
= ['ws2_32']
1264 elif platform
== 'darwin': # Mac OSX
1268 elif platform
== 'cygwin': # Cygwin
1272 elif platform
in ('freebsd4', 'freebsd5', 'freebsd6', 'freebsd7', 'freebsd8'):
1273 # FreeBSD's P1003.1b semaphore support is very experimental
1274 # and has many known problems. (as of June 2008)
1278 elif platform
.startswith('openbsd'):
1282 elif platform
.startswith('netbsd'):
1286 else: # Linux and other unices
1290 if platform
== 'win32':
1291 multiprocessing_srcs
= [ '_multiprocessing/multiprocessing.c',
1292 '_multiprocessing/semaphore.c',
1293 '_multiprocessing/pipe_connection.c',
1294 '_multiprocessing/socket_connection.c',
1295 '_multiprocessing/win32_functions.c'
1299 multiprocessing_srcs
= [ '_multiprocessing/multiprocessing.c',
1300 '_multiprocessing/socket_connection.c'
1302 if (sysconfig
.get_config_var('HAVE_SEM_OPEN') and not
1303 sysconfig
.get_config_var('POSIX_SEMAPHORES_NOT_ENABLED')):
1304 multiprocessing_srcs
.append('_multiprocessing/semaphore.c')
1306 if sysconfig
.get_config_var('WITH_THREAD'):
1307 exts
.append ( Extension('_multiprocessing', multiprocessing_srcs
,
1308 define_macros
=list(macros
.items()),
1309 include_dirs
=["Modules/_multiprocessing"]))
1311 missing
.append('_multiprocessing')
1312 # End multiprocessing
1314 # Platform-specific libraries
1315 if platform
in ('linux2', 'freebsd4', 'freebsd5', 'freebsd6',
1316 'freebsd7', 'freebsd8'):
1317 exts
.append( Extension('ossaudiodev', ['ossaudiodev.c']) )
1319 missing
.append('ossaudiodev')
1321 if sys
.platform
== 'darwin':
1323 Extension('_gestalt', ['_gestalt.c'],
1324 extra_link_args
=['-framework', 'Carbon'])
1327 Extension('_scproxy', ['_scproxy.c'],
1329 '-framework', 'SystemConfiguration',
1330 '-framework', 'CoreFoundation',
1333 self
.extensions
.extend(exts
)
1335 # Call the method for detecting whether _tkinter can be compiled
1336 self
.detect_tkinter(inc_dirs
, lib_dirs
)
1338 if '_tkinter' not in [e
.name
for e
in self
.extensions
]:
1339 missing
.append('_tkinter')
1343 def detect_tkinter_darwin(self
, inc_dirs
, lib_dirs
):
1344 # The _tkinter module, using frameworks. Since frameworks are quite
1345 # different the UNIX search logic is not sharable.
1346 from os
.path
import join
, exists
1348 '/Library/Frameworks',
1349 '/System/Library/Frameworks/',
1350 join(os
.getenv('HOME'), '/Library/Frameworks')
1353 sysroot
= macosx_sdk_root()
1355 # Find the directory that contains the Tcl.framework and Tk.framework
1357 # XXX distutils should support -F!
1358 for F
in framework_dirs
:
1359 # both Tcl.framework and Tk.framework should be present
1362 for fw
in 'Tcl', 'Tk':
1363 if is_macosx_sdk_path(F
):
1364 if not exists(join(sysroot
, F
[1:], fw
+ '.framework')):
1367 if not exists(join(F
, fw
+ '.framework')):
1370 # ok, F is now directory with both frameworks. Continure
1374 # Tk and Tcl frameworks not found. Normal "unix" tkinter search
1378 # For 8.4a2, we must add -I options that point inside the Tcl and Tk
1379 # frameworks. In later release we should hopefully be able to pass
1380 # the -F option to gcc, which specifies a framework lookup path.
1383 join(F
, fw
+ '.framework', H
)
1384 for fw
in ('Tcl', 'Tk')
1385 for H
in ('Headers', 'Versions/Current/PrivateHeaders')
1388 # For 8.4a2, the X11 headers are not included. Rather than include a
1389 # complicated search, this is a hard-coded path. It could bail out
1390 # if X11 libs are not found...
1391 include_dirs
.append('/usr/X11R6/include')
1392 frameworks
= ['-framework', 'Tcl', '-framework', 'Tk']
1394 # All existing framework builds of Tcl/Tk don't support 64-bit
1396 cflags
= sysconfig
.get_config_vars('CFLAGS')[0]
1397 archs
= re
.findall('-arch\s+(\w+)', cflags
)
1399 tmpfile
= os
.path
.join(self
.build_temp
, 'tk.arch')
1400 if not os
.path
.exists(self
.build_temp
):
1401 os
.makedirs(self
.build_temp
)
1403 # Note: cannot use os.popen or subprocess here, that
1404 # requires extensions that are not available here.
1405 if is_macosx_sdk_path(F
):
1406 os
.system("file %s/Tk.framework/Tk | grep 'for architecture' > %s"%(os
.path
.join(sysroot
, F
[1:]), tmpfile
))
1408 os
.system("file %s/Tk.framework/Tk | grep 'for architecture' > %s"%(F
, tmpfile
))
1415 detected_archs
.append(ln
.split()[-1])
1419 for a
in detected_archs
:
1420 frameworks
.append('-arch')
1421 frameworks
.append(a
)
1423 ext
= Extension('_tkinter', ['_tkinter.c', 'tkappinit.c'],
1424 define_macros
=[('WITH_APPINIT', 1)],
1425 include_dirs
= include_dirs
,
1427 extra_compile_args
= frameworks
[2:],
1428 extra_link_args
= frameworks
,
1430 self
.extensions
.append(ext
)
1434 def detect_tkinter(self
, inc_dirs
, lib_dirs
):
1435 # The _tkinter module.
1437 # Rather than complicate the code below, detecting and building
1438 # AquaTk is a separate method. Only one Tkinter will be built on
1439 # Darwin - either AquaTk, if it is found, or X11 based Tk.
1440 platform
= self
.get_platform()
1441 if (platform
== 'darwin' and
1442 self
.detect_tkinter_darwin(inc_dirs
, lib_dirs
)):
1445 # Assume we haven't found any of the libraries or include files
1446 # The versions with dots are used on Unix, and the versions without
1447 # dots on Windows, for detection by cygwin.
1448 tcllib
= tklib
= tcl_includes
= tk_includes
= None
1449 for version
in ['8.5', '85', '8.4', '84', '8.3', '83', '8.2',
1450 '82', '8.1', '81', '8.0', '80']:
1451 tklib
= self
.compiler
.find_library_file(lib_dirs
, 'tk' + version
)
1452 tcllib
= self
.compiler
.find_library_file(lib_dirs
, 'tcl' + version
)
1453 if tklib
and tcllib
:
1454 # Exit the loop when we've found the Tcl/Tk libraries
1457 # Now check for the header files
1458 if tklib
and tcllib
:
1459 # Check for the include files on Debian and {Free,Open}BSD, where
1460 # they're put in /usr/include/{tcl,tk}X.Y
1461 dotversion
= version
1462 if '.' not in dotversion
and "bsd" in sys
.platform
.lower():
1463 # OpenBSD and FreeBSD use Tcl/Tk library names like libtcl83.a,
1464 # but the include subdirs are named like .../include/tcl8.3.
1465 dotversion
= dotversion
[:-1] + '.' + dotversion
[-1]
1466 tcl_include_sub
= []
1468 for dir in inc_dirs
:
1469 tcl_include_sub
+= [dir + os
.sep
+ "tcl" + dotversion
]
1470 tk_include_sub
+= [dir + os
.sep
+ "tk" + dotversion
]
1471 tk_include_sub
+= tcl_include_sub
1472 tcl_includes
= find_file('tcl.h', inc_dirs
, tcl_include_sub
)
1473 tk_includes
= find_file('tk.h', inc_dirs
, tk_include_sub
)
1475 if (tcllib
is None or tklib
is None or
1476 tcl_includes
is None or tk_includes
is None):
1477 self
.announce("INFO: Can't locate Tcl/Tk libs and/or headers", 2)
1480 # OK... everything seems to be present for Tcl/Tk.
1482 include_dirs
= [] ; libs
= [] ; defs
= [] ; added_lib_dirs
= []
1483 for dir in tcl_includes
+ tk_includes
:
1484 if dir not in include_dirs
:
1485 include_dirs
.append(dir)
1487 # Check for various platform-specific directories
1488 if platform
== 'sunos5':
1489 include_dirs
.append('/usr/openwin/include')
1490 added_lib_dirs
.append('/usr/openwin/lib')
1491 elif os
.path
.exists('/usr/X11R6/include'):
1492 include_dirs
.append('/usr/X11R6/include')
1493 added_lib_dirs
.append('/usr/X11R6/lib64')
1494 added_lib_dirs
.append('/usr/X11R6/lib')
1495 elif os
.path
.exists('/usr/X11R5/include'):
1496 include_dirs
.append('/usr/X11R5/include')
1497 added_lib_dirs
.append('/usr/X11R5/lib')
1499 # Assume default location for X11
1500 include_dirs
.append('/usr/X11/include')
1501 added_lib_dirs
.append('/usr/X11/lib')
1503 # If Cygwin, then verify that X is installed before proceeding
1504 if platform
== 'cygwin':
1505 x11_inc
= find_file('X11/Xlib.h', [], include_dirs
)
1509 # Check for BLT extension
1510 if self
.compiler
.find_library_file(lib_dirs
+ added_lib_dirs
,
1512 defs
.append( ('WITH_BLT', 1) )
1513 libs
.append('BLT8.0')
1514 elif self
.compiler
.find_library_file(lib_dirs
+ added_lib_dirs
,
1516 defs
.append( ('WITH_BLT', 1) )
1519 # Add the Tcl/Tk libraries
1520 libs
.append('tk'+ version
)
1521 libs
.append('tcl'+ version
)
1523 if platform
in ['aix3', 'aix4']:
1526 # Finally, link with the X11 libraries (not appropriate on cygwin)
1527 if platform
!= "cygwin":
1530 ext
= Extension('_tkinter', ['_tkinter.c', 'tkappinit.c'],
1531 define_macros
=[('WITH_APPINIT', 1)] + defs
,
1532 include_dirs
= include_dirs
,
1534 library_dirs
= added_lib_dirs
,
1536 self
.extensions
.append(ext
)
1538 ## # Uncomment these lines if you want to play with xxmodule.c
1539 ## ext = Extension('xx', ['xxmodule.c'])
1540 ## self.extensions.append(ext)
1542 # XXX handle these, but how to detect?
1543 # *** Uncomment and edit for PIL (TkImaging) extension only:
1544 # -DWITH_PIL -I../Extensions/Imaging/libImaging tkImaging.c \
1545 # *** Uncomment and edit for TOGL extension only:
1546 # -DWITH_TOGL togl.c \
1547 # *** Uncomment these for TOGL extension only:
1548 # -lGL -lGLU -lXext -lXmu \
1550 def configure_ctypes_darwin(self
, ext
):
1551 # Darwin (OS X) uses preconfigured files, in
1552 # the Modules/_ctypes/libffi_osx directory.
1553 srcdir
= sysconfig
.get_config_var('srcdir')
1554 ffi_srcdir
= os
.path
.abspath(os
.path
.join(srcdir
, 'Modules',
1555 '_ctypes', 'libffi_osx'))
1556 sources
= [os
.path
.join(ffi_srcdir
, p
)
1560 'x86/x86-ffi_darwin.c',
1562 'powerpc/ppc-darwin.S',
1563 'powerpc/ppc-darwin_closure.S',
1564 'powerpc/ppc-ffi_darwin.c',
1565 'powerpc/ppc64-darwin_closure.S',
1568 # Add .S (preprocessed assembly) to C compiler source extensions.
1569 self
.compiler
.src_extensions
.append('.S')
1571 include_dirs
= [os
.path
.join(ffi_srcdir
, 'include'),
1572 os
.path
.join(ffi_srcdir
, 'powerpc')]
1573 ext
.include_dirs
.extend(include_dirs
)
1574 ext
.sources
.extend(sources
)
1577 def configure_ctypes(self
, ext
):
1578 if not self
.use_system_libffi
:
1579 if sys
.platform
== 'darwin':
1580 return self
.configure_ctypes_darwin(ext
)
1582 srcdir
= sysconfig
.get_config_var('srcdir')
1583 ffi_builddir
= os
.path
.join(self
.build_temp
, 'libffi')
1584 ffi_srcdir
= os
.path
.abspath(os
.path
.join(srcdir
, 'Modules',
1585 '_ctypes', 'libffi'))
1586 ffi_configfile
= os
.path
.join(ffi_builddir
, 'fficonfig.py')
1588 from distutils
.dep_util
import newer_group
1590 config_sources
= [os
.path
.join(ffi_srcdir
, fname
)
1591 for fname
in os
.listdir(ffi_srcdir
)
1592 if os
.path
.isfile(os
.path
.join(ffi_srcdir
, fname
))]
1593 if self
.force
or newer_group(config_sources
,
1595 from distutils
.dir_util
import mkpath
1596 mkpath(ffi_builddir
)
1599 # Pass empty CFLAGS because we'll just append the resulting
1600 # CFLAGS to Python's; -g or -O2 is to be avoided.
1601 cmd
= "cd %s && env CFLAGS='' '%s/configure' %s" \
1602 % (ffi_builddir
, ffi_srcdir
, " ".join(config_args
))
1604 res
= os
.system(cmd
)
1605 if res
or not os
.path
.exists(ffi_configfile
):
1606 print("Failed to configure _ctypes module")
1610 fp
= open(ffi_configfile
)
1615 exec(script
, globals(), fficonfig
)
1616 ffi_srcdir
= os
.path
.join(fficonfig
['ffi_srcdir'], 'src')
1618 # Add .S (preprocessed assembly) to C compiler source extensions.
1619 self
.compiler
.src_extensions
.append('.S')
1621 include_dirs
= [os
.path
.join(ffi_builddir
, 'include'),
1622 ffi_builddir
, ffi_srcdir
]
1623 extra_compile_args
= fficonfig
['ffi_cflags'].split()
1625 ext
.sources
.extend(fficonfig
['ffi_sources'])
1626 ext
.include_dirs
.extend(include_dirs
)
1627 ext
.extra_compile_args
.extend(extra_compile_args
)
1630 def detect_ctypes(self
, inc_dirs
, lib_dirs
):
1631 self
.use_system_libffi
= False
1633 extra_compile_args
= []
1634 extra_link_args
= []
1635 sources
= ['_ctypes/_ctypes.c',
1636 '_ctypes/callbacks.c',
1637 '_ctypes/callproc.c',
1638 '_ctypes/stgdict.c',
1640 '_ctypes/malloc_closure.c']
1641 depends
= ['_ctypes/ctypes.h']
1643 if sys
.platform
== 'darwin':
1644 sources
.append('_ctypes/darwin/dlfcn_simple.c')
1645 extra_compile_args
.append('-DMACOSX')
1646 include_dirs
.append('_ctypes/darwin')
1647 # XXX Is this still needed?
1648 ## extra_link_args.extend(['-read_only_relocs', 'warning'])
1650 elif sys
.platform
== 'sunos5':
1651 # XXX This shouldn't be necessary; it appears that some
1652 # of the assembler code is non-PIC (i.e. it has relocations
1653 # when it shouldn't. The proper fix would be to rewrite
1654 # the assembler code to be PIC.
1655 # This only works with GCC; the Sun compiler likely refuses
1656 # this option. If you want to compile ctypes with the Sun
1657 # compiler, please research a proper solution, instead of
1658 # finding some -z option for the Sun compiler.
1659 extra_link_args
.append('-mimpure-text')
1661 elif sys
.platform
.startswith('hp-ux'):
1662 extra_link_args
.append('-fPIC')
1664 ext
= Extension('_ctypes',
1665 include_dirs
=include_dirs
,
1666 extra_compile_args
=extra_compile_args
,
1667 extra_link_args
=extra_link_args
,
1671 ext_test
= Extension('_ctypes_test',
1672 sources
=['_ctypes/_ctypes_test.c'])
1673 self
.extensions
.extend([ext
, ext_test
])
1675 if not '--with-system-ffi' in sysconfig
.get_config_var("CONFIG_ARGS"):
1678 if sys
.platform
== 'darwin':
1679 # OS X 10.5 comes with libffi.dylib; the include files are
1680 # in /usr/include/ffi
1681 inc_dirs
.append('/usr/include/ffi')
1683 ffi_inc
= find_file('ffi.h', [], inc_dirs
)
1684 if ffi_inc
is not None:
1685 ffi_h
= ffi_inc
[0] + '/ffi.h'
1688 line
= fp
.readline()
1692 if line
.startswith('#define LIBFFI_H'):
1695 if ffi_inc
is not None:
1696 for lib_name
in ('ffi_convenience', 'ffi_pic', 'ffi'):
1697 if (self
.compiler
.find_library_file(lib_dirs
, lib_name
)):
1701 if ffi_inc
and ffi_lib
:
1702 ext
.include_dirs
.extend(ffi_inc
)
1703 ext
.libraries
.append(ffi_lib
)
1704 self
.use_system_libffi
= True
1707 class PyBuildInstall(install
):
1708 # Suppress the warning about installation into the lib_dynload
1709 # directory, which is not in sys.path when running Python during
1711 def initialize_options (self
):
1712 install
.initialize_options(self
)
1715 class PyBuildInstallLib(install_lib
):
1716 # Do exactly what install_lib does but make sure correct access modes get
1717 # set on installed directories and files. All installed files with get
1718 # mode 644 unless they are a shared library in which case they will get
1719 # mode 755. All installed directories will get mode 755.
1721 so_ext
= sysconfig
.get_config_var("SO")
1724 outfiles
= install_lib
.install(self
)
1725 self
.set_file_modes(outfiles
, 0o644, 0o755)
1726 self
.set_dir_modes(self
.install_dir
, 0o755)
1729 def set_file_modes(self
, files
, defaultMode
, sharedLibMode
):
1730 if not self
.is_chmod_supported(): return
1731 if not files
: return
1733 for filename
in files
:
1734 if os
.path
.islink(filename
): continue
1736 if filename
.endswith(self
.so_ext
): mode
= sharedLibMode
1737 log
.info("changing mode of %s to %o", filename
, mode
)
1738 if not self
.dry_run
: os
.chmod(filename
, mode
)
1740 def set_dir_modes(self
, dirname
, mode
):
1741 if not self
.is_chmod_supported(): return
1742 for dirpath
, dirnames
, fnames
in os
.walk(dirname
):
1743 if os
.path
.islink(dirpath
):
1745 log
.info("changing mode of %s to %o", dirpath
, mode
)
1746 if not self
.dry_run
: os
.chmod(dirpath
, mode
)
1748 def is_chmod_supported(self
):
1749 return hasattr(os
, 'chmod')
1752 Python is an interpreted, interactive, object-oriented programming
1753 language. It is often compared to Tcl, Perl, Scheme or Java.
1755 Python combines remarkable power with very clear syntax. It has
1756 modules, classes, exceptions, very high level dynamic data types, and
1757 dynamic typing. There are interfaces to many system calls and
1758 libraries, as well as to various windowing systems (X11, Motif, Tk,
1759 Mac, MFC). New built-in modules are easily written in C or C++. Python
1760 is also usable as an extension language for applications that need a
1761 programmable interface.
1763 The Python implementation is portable: it runs on many brands of UNIX,
1764 on Windows, DOS, OS/2, Mac, Amiga... If your favorite system isn't
1765 listed here, it may still be supported, if there's a C compiler for
1766 it. Ask around on comp.lang.python -- or just try compiling Python
1771 Development Status :: 6 - Mature
1772 License :: OSI Approved :: Python Software Foundation License
1773 Natural Language :: English
1774 Programming Language :: C
1775 Programming Language :: Python
1776 Topic :: Software Development
1780 # turn off warnings when deprecated modules are imported
1782 warnings
.filterwarnings("ignore",category
=DeprecationWarning)
1783 setup(# PyPI Metadata (PEP 301)
1785 version
= sys
.version
.split()[0],
1786 url
= "http://www.python.org/%s" % sys
.version
[:3],
1787 maintainer
= "Guido van Rossum and the Python community",
1788 maintainer_email
= "python-dev@python.org",
1789 description
= "A high-level object-oriented programming language",
1790 long_description
= SUMMARY
.strip(),
1791 license
= "PSF license",
1792 classifiers
= [x
for x
in CLASSIFIERS
.split("\n") if x
],
1793 platforms
= ["Many"],
1796 cmdclass
= {'build_ext':PyBuildExt
, 'install':PyBuildInstall
,
1797 'install_lib':PyBuildInstallLib
},
1798 # The struct module is defined here, because build_ext won't be
1799 # called unless there's at least one extension module defined.
1800 ext_modules
=[Extension('_struct', ['_struct.c'])],
1802 scripts
= ["Tools/scripts/pydoc3", "Tools/scripts/idle3",
1803 "Tools/scripts/2to3"]
1807 if __name__
== '__main__':