Add tests for issue #7458: str.rfind() would crash when called with an invalid
[python.git] / setup.py
blobfaf2c33386445467cc9743e8a08348fa598df06b
1 # Autodetecting setup.py script for building the Python extensions
4 __version__ = "$Revision$"
6 import sys, os, imp, re, optparse
7 from glob import glob
8 from platform import machine as platform_machine
10 from distutils import log
11 from distutils import sysconfig
12 from distutils import text_file
13 from distutils.errors import *
14 from distutils.core import Extension, setup
15 from distutils.command.build_ext import build_ext
16 from distutils.command.install import install
17 from distutils.command.install_lib import install_lib
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 find_file(filename, std_dirs, paths):
30 """Searches for the directory where a given file is located,
31 and returns a possibly-empty list of additional directories, or None
32 if the file couldn't be found at all.
34 'filename' is the name of a file, such as readline.h or libcrypto.a.
35 'std_dirs' is the list of standard system directories; if the
36 file is found in one of them, no additional directives are needed.
37 'paths' is a list of additional locations to check; if the file is
38 found in one of them, the resulting list will contain the directory.
39 """
41 # Check the standard locations
42 for dir in std_dirs:
43 f = os.path.join(dir, filename)
44 if os.path.exists(f): return []
46 # Check the additional directories
47 for dir in paths:
48 f = os.path.join(dir, filename)
49 if os.path.exists(f):
50 return [dir]
52 # Not found anywhere
53 return None
55 def find_library_file(compiler, libname, std_dirs, paths):
56 result = compiler.find_library_file(std_dirs + paths, libname)
57 if result is None:
58 return None
60 # Check whether the found file is in one of the standard directories
61 dirname = os.path.dirname(result)
62 for p in std_dirs:
63 # Ensure path doesn't end with path separator
64 p = p.rstrip(os.sep)
65 if p == dirname:
66 return [ ]
68 # Otherwise, it must have been in one of the additional directories,
69 # so we have to figure out which one.
70 for p in paths:
71 # Ensure path doesn't end with path separator
72 p = p.rstrip(os.sep)
73 if p == dirname:
74 return [p]
75 else:
76 assert False, "Internal error: Path not found in std_dirs or paths"
78 def module_enabled(extlist, modname):
79 """Returns whether the module 'modname' is present in the list
80 of extensions 'extlist'."""
81 extlist = [ext for ext in extlist if ext.name == modname]
82 return len(extlist)
84 def find_module_file(module, dirlist):
85 """Find a module in a set of possible folders. If it is not found
86 return the unadorned filename"""
87 list = find_file(module, [], dirlist)
88 if not list:
89 return module
90 if len(list) > 1:
91 log.info("WARNING: multiple copies of %s found"%module)
92 return os.path.join(list[0], module)
94 class PyBuildExt(build_ext):
96 def __init__(self, dist):
97 build_ext.__init__(self, dist)
98 self.failed = []
100 def build_extensions(self):
102 # Detect which modules should be compiled
103 missing = self.detect_modules()
105 # Remove modules that are present on the disabled list
106 extensions = [ext for ext in self.extensions
107 if ext.name not in disabled_module_list]
108 # move ctypes to the end, it depends on other modules
109 ext_map = dict((ext.name, i) for i, ext in enumerate(extensions))
110 if "_ctypes" in ext_map:
111 ctypes = extensions.pop(ext_map["_ctypes"])
112 extensions.append(ctypes)
113 self.extensions = extensions
115 # Fix up the autodetected modules, prefixing all the source files
116 # with Modules/ and adding Python's include directory to the path.
117 (srcdir,) = sysconfig.get_config_vars('srcdir')
118 if not srcdir:
119 # Maybe running on Windows but not using CYGWIN?
120 raise ValueError("No source directory; cannot proceed.")
121 srcdir = os.path.abspath(srcdir)
122 moddirlist = [os.path.join(srcdir, 'Modules')]
124 # Platform-dependent module source and include directories
125 incdirlist = []
126 platform = self.get_platform()
127 if platform in ('darwin', 'mac') and ("--disable-toolbox-glue" not in
128 sysconfig.get_config_var("CONFIG_ARGS")):
129 # Mac OS X also includes some mac-specific modules
130 macmoddir = os.path.join(srcdir, 'Mac/Modules')
131 moddirlist.append(macmoddir)
132 incdirlist.append(os.path.join(srcdir, 'Mac/Include'))
134 # Fix up the paths for scripts, too
135 self.distribution.scripts = [os.path.join(srcdir, filename)
136 for filename in self.distribution.scripts]
138 # Python header files
139 headers = [sysconfig.get_config_h_filename()]
140 headers += glob(os.path.join(sysconfig.get_python_inc(), "*.h"))
141 for ext in self.extensions[:]:
142 ext.sources = [ find_module_file(filename, moddirlist)
143 for filename in ext.sources ]
144 if ext.depends is not None:
145 ext.depends = [find_module_file(filename, moddirlist)
146 for filename in ext.depends]
147 else:
148 ext.depends = []
149 # re-compile extensions if a header file has been changed
150 ext.depends.extend(headers)
152 # platform specific include directories
153 ext.include_dirs.extend(incdirlist)
155 # If a module has already been built statically,
156 # don't build it here
157 if ext.name in sys.builtin_module_names:
158 self.extensions.remove(ext)
160 if platform != 'mac':
161 # Parse Modules/Setup and Modules/Setup.local to figure out which
162 # modules are turned on in the file.
163 remove_modules = []
164 for filename in ('Modules/Setup', 'Modules/Setup.local'):
165 input = text_file.TextFile(filename, join_lines=1)
166 while 1:
167 line = input.readline()
168 if not line: break
169 line = line.split()
170 remove_modules.append(line[0])
171 input.close()
173 for ext in self.extensions[:]:
174 if ext.name in remove_modules:
175 self.extensions.remove(ext)
177 # When you run "make CC=altcc" or something similar, you really want
178 # those environment variables passed into the setup.py phase. Here's
179 # a small set of useful ones.
180 compiler = os.environ.get('CC')
181 args = {}
182 # unfortunately, distutils doesn't let us provide separate C and C++
183 # compilers
184 if compiler is not None:
185 (ccshared,cflags) = sysconfig.get_config_vars('CCSHARED','CFLAGS')
186 args['compiler_so'] = compiler + ' ' + ccshared + ' ' + cflags
187 self.compiler_obj.set_executables(**args)
189 build_ext.build_extensions(self)
191 longest = max([len(e.name) for e in self.extensions])
192 if self.failed:
193 longest = max(longest, max([len(name) for name in self.failed]))
195 def print_three_column(lst):
196 lst.sort(key=str.lower)
197 # guarantee zip() doesn't drop anything
198 while len(lst) % 3:
199 lst.append("")
200 for e, f, g in zip(lst[::3], lst[1::3], lst[2::3]):
201 print "%-*s %-*s %-*s" % (longest, e, longest, f,
202 longest, g)
204 if missing:
205 print
206 print ("Python build finished, but the necessary bits to build "
207 "these modules were not found:")
208 print_three_column(missing)
209 print ("To find the necessary bits, look in setup.py in"
210 " detect_modules() for the module's name.")
211 print
213 if self.failed:
214 failed = self.failed[:]
215 print
216 print "Failed to build these modules:"
217 print_three_column(failed)
218 print
220 def build_extension(self, ext):
222 if ext.name == '_ctypes':
223 if not self.configure_ctypes(ext):
224 return
226 try:
227 build_ext.build_extension(self, ext)
228 except (CCompilerError, DistutilsError), why:
229 self.announce('WARNING: building of extension "%s" failed: %s' %
230 (ext.name, sys.exc_info()[1]))
231 self.failed.append(ext.name)
232 return
233 # Workaround for Mac OS X: The Carbon-based modules cannot be
234 # reliably imported into a command-line Python
235 if 'Carbon' in ext.extra_link_args:
236 self.announce(
237 'WARNING: skipping import check for Carbon-based "%s"' %
238 ext.name)
239 return
241 if self.get_platform() == 'darwin' and (
242 sys.maxint > 2**32 and '-arch' in ext.extra_link_args):
243 # Don't bother doing an import check when an extension was
244 # build with an explicit '-arch' flag on OSX. That's currently
245 # only used to build 32-bit only extensions in a 4-way
246 # universal build and loading 32-bit code into a 64-bit
247 # process will fail.
248 self.announce(
249 'WARNING: skipping import check for "%s"' %
250 ext.name)
251 return
253 # Workaround for Cygwin: Cygwin currently has fork issues when many
254 # modules have been imported
255 if self.get_platform() == 'cygwin':
256 self.announce('WARNING: skipping import check for Cygwin-based "%s"'
257 % ext.name)
258 return
259 ext_filename = os.path.join(
260 self.build_lib,
261 self.get_ext_filename(self.get_ext_fullname(ext.name)))
262 try:
263 imp.load_dynamic(ext.name, ext_filename)
264 except ImportError, why:
265 self.failed.append(ext.name)
266 self.announce('*** WARNING: renaming "%s" since importing it'
267 ' failed: %s' % (ext.name, why), level=3)
268 assert not self.inplace
269 basename, tail = os.path.splitext(ext_filename)
270 newname = basename + "_failed" + tail
271 if os.path.exists(newname):
272 os.remove(newname)
273 os.rename(ext_filename, newname)
275 # XXX -- This relies on a Vile HACK in
276 # distutils.command.build_ext.build_extension(). The
277 # _built_objects attribute is stored there strictly for
278 # use here.
279 # If there is a failure, _built_objects may not be there,
280 # so catch the AttributeError and move on.
281 try:
282 for filename in self._built_objects:
283 os.remove(filename)
284 except AttributeError:
285 self.announce('unable to remove files (ignored)')
286 except:
287 exc_type, why, tb = sys.exc_info()
288 self.announce('*** WARNING: importing extension "%s" '
289 'failed with %s: %s' % (ext.name, exc_type, why),
290 level=3)
291 self.failed.append(ext.name)
293 def get_platform(self):
294 # Get value of sys.platform
295 for platform in ['cygwin', 'beos', 'darwin', 'atheos', 'osf1']:
296 if sys.platform.startswith(platform):
297 return platform
298 return sys.platform
300 def detect_modules(self):
301 # Ensure that /usr/local is always used
302 add_dir_to_list(self.compiler_obj.library_dirs, '/usr/local/lib')
303 add_dir_to_list(self.compiler_obj.include_dirs, '/usr/local/include')
305 # Add paths specified in the environment variables LDFLAGS and
306 # CPPFLAGS for header and library files.
307 # We must get the values from the Makefile and not the environment
308 # directly since an inconsistently reproducible issue comes up where
309 # the environment variable is not set even though the value were passed
310 # into configure and stored in the Makefile (issue found on OS X 10.3).
311 for env_var, arg_name, dir_list in (
312 ('LDFLAGS', '-R', self.compiler_obj.runtime_library_dirs),
313 ('LDFLAGS', '-L', self.compiler_obj.library_dirs),
314 ('CPPFLAGS', '-I', self.compiler_obj.include_dirs)):
315 env_val = sysconfig.get_config_var(env_var)
316 if env_val:
317 # To prevent optparse from raising an exception about any
318 # options in env_val that it doesn't know about we strip out
319 # all double dashes and any dashes followed by a character
320 # that is not for the option we are dealing with.
322 # Please note that order of the regex is important! We must
323 # strip out double-dashes first so that we don't end up with
324 # substituting "--Long" to "-Long" and thus lead to "ong" being
325 # used for a library directory.
326 env_val = re.sub(r'(^|\s+)-(-|(?!%s))' % arg_name[1],
327 ' ', env_val)
328 parser = optparse.OptionParser()
329 # Make sure that allowing args interspersed with options is
330 # allowed
331 parser.allow_interspersed_args = True
332 parser.error = lambda msg: None
333 parser.add_option(arg_name, dest="dirs", action="append")
334 options = parser.parse_args(env_val.split())[0]
335 if options.dirs:
336 for directory in reversed(options.dirs):
337 add_dir_to_list(dir_list, directory)
339 if os.path.normpath(sys.prefix) != '/usr':
340 add_dir_to_list(self.compiler_obj.library_dirs,
341 sysconfig.get_config_var("LIBDIR"))
342 add_dir_to_list(self.compiler_obj.include_dirs,
343 sysconfig.get_config_var("INCLUDEDIR"))
345 try:
346 have_unicode = unicode
347 except NameError:
348 have_unicode = 0
350 # lib_dirs and inc_dirs are used to search for files;
351 # if a file is found in one of those directories, it can
352 # be assumed that no additional -I,-L directives are needed.
353 lib_dirs = self.compiler_obj.library_dirs + [
354 '/lib64', '/usr/lib64',
355 '/lib', '/usr/lib',
357 inc_dirs = self.compiler_obj.include_dirs + ['/usr/include']
358 exts = []
359 missing = []
361 config_h = sysconfig.get_config_h_filename()
362 config_h_vars = sysconfig.parse_config_h(open(config_h))
364 platform = self.get_platform()
365 srcdir = sysconfig.get_config_var('srcdir')
367 # Check for AtheOS which has libraries in non-standard locations
368 if platform == 'atheos':
369 lib_dirs += ['/system/libs', '/atheos/autolnk/lib']
370 lib_dirs += os.getenv('LIBRARY_PATH', '').split(os.pathsep)
371 inc_dirs += ['/system/include', '/atheos/autolnk/include']
372 inc_dirs += os.getenv('C_INCLUDE_PATH', '').split(os.pathsep)
374 # OSF/1 and Unixware have some stuff in /usr/ccs/lib (like -ldb)
375 if platform in ['osf1', 'unixware7', 'openunix8']:
376 lib_dirs += ['/usr/ccs/lib']
378 if platform == 'darwin':
379 # This should work on any unixy platform ;-)
380 # If the user has bothered specifying additional -I and -L flags
381 # in OPT and LDFLAGS we might as well use them here.
382 # NOTE: using shlex.split would technically be more correct, but
383 # also gives a bootstrap problem. Let's hope nobody uses directories
384 # with whitespace in the name to store libraries.
385 cflags, ldflags = sysconfig.get_config_vars(
386 'CFLAGS', 'LDFLAGS')
387 for item in cflags.split():
388 if item.startswith('-I'):
389 inc_dirs.append(item[2:])
391 for item in ldflags.split():
392 if item.startswith('-L'):
393 lib_dirs.append(item[2:])
395 # Check for MacOS X, which doesn't need libm.a at all
396 math_libs = ['m']
397 if platform in ['darwin', 'beos', 'mac']:
398 math_libs = []
400 # XXX Omitted modules: gl, pure, dl, SGI-specific modules
403 # The following modules are all pretty straightforward, and compile
404 # on pretty much any POSIXish platform.
407 # Some modules that are normally always on:
408 exts.append( Extension('_weakref', ['_weakref.c']) )
410 # array objects
411 exts.append( Extension('array', ['arraymodule.c']) )
412 # complex math library functions
413 exts.append( Extension('cmath', ['cmathmodule.c', '_math.c'],
414 depends=['_math.h'],
415 libraries=math_libs) )
416 # math library functions, e.g. sin()
417 exts.append( Extension('math', ['mathmodule.c', '_math.c'],
418 depends=['_math.h'],
419 libraries=math_libs) )
420 # fast string operations implemented in C
421 exts.append( Extension('strop', ['stropmodule.c']) )
422 # time operations and variables
423 exts.append( Extension('time', ['timemodule.c'],
424 libraries=math_libs) )
425 exts.append( Extension('datetime', ['datetimemodule.c', 'timemodule.c'],
426 libraries=math_libs) )
427 # fast iterator tools implemented in C
428 exts.append( Extension("itertools", ["itertoolsmodule.c"]) )
429 # code that will be builtins in the future, but conflict with the
430 # current builtins
431 exts.append( Extension('future_builtins', ['future_builtins.c']) )
432 # random number generator implemented in C
433 exts.append( Extension("_random", ["_randommodule.c"]) )
434 # high-performance collections
435 exts.append( Extension("_collections", ["_collectionsmodule.c"]) )
436 # bisect
437 exts.append( Extension("_bisect", ["_bisectmodule.c"]) )
438 # heapq
439 exts.append( Extension("_heapq", ["_heapqmodule.c"]) )
440 # operator.add() and similar goodies
441 exts.append( Extension('operator', ['operator.c']) )
442 # Python 3.1 _io library
443 exts.append( Extension("_io",
444 ["_io/bufferedio.c", "_io/bytesio.c", "_io/fileio.c",
445 "_io/iobase.c", "_io/_iomodule.c", "_io/stringio.c", "_io/textio.c"],
446 depends=["_io/_iomodule.h"], include_dirs=["Modules/_io"]))
447 # _functools
448 exts.append( Extension("_functools", ["_functoolsmodule.c"]) )
449 # _json speedups
450 exts.append( Extension("_json", ["_json.c"]) )
451 # Python C API test module
452 exts.append( Extension('_testcapi', ['_testcapimodule.c'],
453 depends=['testcapi_long.h']) )
454 # profilers (_lsprof is for cProfile.py)
455 exts.append( Extension('_hotshot', ['_hotshot.c']) )
456 exts.append( Extension('_lsprof', ['_lsprof.c', 'rotatingtree.c']) )
457 # static Unicode character database
458 if have_unicode:
459 exts.append( Extension('unicodedata', ['unicodedata.c']) )
460 else:
461 missing.append('unicodedata')
462 # access to ISO C locale support
463 data = open('pyconfig.h').read()
464 m = re.search(r"#s*define\s+WITH_LIBINTL\s+1\s*", data)
465 if m is not None:
466 locale_libs = ['intl']
467 else:
468 locale_libs = []
469 if platform == 'darwin':
470 locale_extra_link_args = ['-framework', 'CoreFoundation']
471 else:
472 locale_extra_link_args = []
475 exts.append( Extension('_locale', ['_localemodule.c'],
476 libraries=locale_libs,
477 extra_link_args=locale_extra_link_args) )
479 # Modules with some UNIX dependencies -- on by default:
480 # (If you have a really backward UNIX, select and socket may not be
481 # supported...)
483 # fcntl(2) and ioctl(2)
484 exts.append( Extension('fcntl', ['fcntlmodule.c']) )
485 if platform not in ['mac']:
486 # pwd(3)
487 exts.append( Extension('pwd', ['pwdmodule.c']) )
488 # grp(3)
489 exts.append( Extension('grp', ['grpmodule.c']) )
490 # spwd, shadow passwords
491 if (config_h_vars.get('HAVE_GETSPNAM', False) or
492 config_h_vars.get('HAVE_GETSPENT', False)):
493 exts.append( Extension('spwd', ['spwdmodule.c']) )
494 else:
495 missing.append('spwd')
496 else:
497 missing.extend(['pwd', 'grp', 'spwd'])
499 # select(2); not on ancient System V
500 exts.append( Extension('select', ['selectmodule.c']) )
502 # Fred Drake's interface to the Python parser
503 exts.append( Extension('parser', ['parsermodule.c']) )
505 # cStringIO and cPickle
506 exts.append( Extension('cStringIO', ['cStringIO.c']) )
507 exts.append( Extension('cPickle', ['cPickle.c']) )
509 # Memory-mapped files (also works on Win32).
510 if platform not in ['atheos', 'mac']:
511 exts.append( Extension('mmap', ['mmapmodule.c']) )
512 else:
513 missing.append('mmap')
515 # Lance Ellinghaus's syslog module
516 if platform not in ['mac']:
517 # syslog daemon interface
518 exts.append( Extension('syslog', ['syslogmodule.c']) )
519 else:
520 missing.append('syslog')
522 # George Neville-Neil's timing module:
523 # Deprecated in PEP 4 http://www.python.org/peps/pep-0004.html
524 # http://mail.python.org/pipermail/python-dev/2006-January/060023.html
525 #exts.append( Extension('timing', ['timingmodule.c']) )
528 # Here ends the simple stuff. From here on, modules need certain
529 # libraries, are platform-specific, or present other surprises.
532 # Multimedia modules
533 # These don't work for 64-bit platforms!!!
534 # These represent audio samples or images as strings:
536 # Operations on audio samples
537 # According to #993173, this one should actually work fine on
538 # 64-bit platforms.
539 exts.append( Extension('audioop', ['audioop.c']) )
541 # Disabled on 64-bit platforms
542 if sys.maxint != 9223372036854775807L:
543 # Operations on images
544 exts.append( Extension('imageop', ['imageop.c']) )
545 else:
546 missing.extend(['imageop'])
548 # readline
549 do_readline = self.compiler_obj.find_library_file(lib_dirs, 'readline')
550 if platform == 'darwin':
551 os_release = int(os.uname()[2].split('.')[0])
552 if os_release < 9:
553 # MacOSX 10.4 has a broken readline. Don't try to build
554 # the readline module unless the user has installed a fixed
555 # readline package
556 if find_file('readline/rlconf.h', inc_dirs, []) is None:
557 do_readline = False
558 if do_readline:
559 if platform == 'darwin' and os_release < 9:
560 # In every directory on the search path search for a dynamic
561 # library and then a static library, instead of first looking
562 # for dynamic libraries on the entiry path.
563 # This way a staticly linked custom readline gets picked up
564 # before the (broken) dynamic library in /usr/lib.
565 readline_extra_link_args = ('-Wl,-search_paths_first',)
566 else:
567 readline_extra_link_args = ()
569 readline_libs = ['readline']
570 if self.compiler_obj.find_library_file(lib_dirs,
571 'ncursesw'):
572 readline_libs.append('ncursesw')
573 elif self.compiler_obj.find_library_file(lib_dirs,
574 'ncurses'):
575 readline_libs.append('ncurses')
576 elif self.compiler_obj.find_library_file(lib_dirs, 'curses'):
577 readline_libs.append('curses')
578 elif self.compiler_obj.find_library_file(lib_dirs +
579 ['/usr/lib/termcap'],
580 'termcap'):
581 readline_libs.append('termcap')
582 exts.append( Extension('readline', ['readline.c'],
583 library_dirs=['/usr/lib/termcap'],
584 extra_link_args=readline_extra_link_args,
585 libraries=readline_libs) )
586 else:
587 missing.append('readline')
589 if platform not in ['mac']:
590 # crypt module.
592 if self.compiler_obj.find_library_file(lib_dirs, 'crypt'):
593 libs = ['crypt']
594 else:
595 libs = []
596 exts.append( Extension('crypt', ['cryptmodule.c'], libraries=libs) )
597 else:
598 missing.append('crypt')
600 # CSV files
601 exts.append( Extension('_csv', ['_csv.c']) )
603 # socket(2)
604 exts.append( Extension('_socket', ['socketmodule.c'],
605 depends = ['socketmodule.h']) )
606 # Detect SSL support for the socket module (via _ssl)
607 search_for_ssl_incs_in = [
608 '/usr/local/ssl/include',
609 '/usr/contrib/ssl/include/'
611 ssl_incs = find_file('openssl/ssl.h', inc_dirs,
612 search_for_ssl_incs_in
614 if ssl_incs is not None:
615 krb5_h = find_file('krb5.h', inc_dirs,
616 ['/usr/kerberos/include'])
617 if krb5_h:
618 ssl_incs += krb5_h
619 ssl_libs = find_library_file(self.compiler_obj, 'ssl',lib_dirs,
620 ['/usr/local/ssl/lib',
621 '/usr/contrib/ssl/lib/'
624 if (ssl_incs is not None and
625 ssl_libs is not None):
626 exts.append( Extension('_ssl', ['_ssl.c'],
627 include_dirs = ssl_incs,
628 library_dirs = ssl_libs,
629 libraries = ['ssl', 'crypto'],
630 depends = ['socketmodule.h']), )
631 else:
632 missing.append('_ssl')
634 # find out which version of OpenSSL we have
635 openssl_ver = 0
636 openssl_ver_re = re.compile(
637 '^\s*#\s*define\s+OPENSSL_VERSION_NUMBER\s+(0x[0-9a-fA-F]+)' )
638 for ssl_inc_dir in inc_dirs + search_for_ssl_incs_in:
639 name = os.path.join(ssl_inc_dir, 'openssl', 'opensslv.h')
640 if os.path.isfile(name):
641 try:
642 incfile = open(name, 'r')
643 for line in incfile:
644 m = openssl_ver_re.match(line)
645 if m:
646 openssl_ver = eval(m.group(1))
647 break
648 except IOError:
649 pass
651 # first version found is what we'll use (as the compiler should)
652 if openssl_ver:
653 break
655 #print 'openssl_ver = 0x%08x' % openssl_ver
657 if (ssl_incs is not None and
658 ssl_libs is not None and
659 openssl_ver >= 0x00907000):
660 # The _hashlib module wraps optimized implementations
661 # of hash functions from the OpenSSL library.
662 exts.append( Extension('_hashlib', ['_hashopenssl.c'],
663 include_dirs = ssl_incs,
664 library_dirs = ssl_libs,
665 libraries = ['ssl', 'crypto']) )
666 # these aren't strictly missing since they are unneeded.
667 #missing.extend(['_sha', '_md5'])
668 else:
669 # The _sha module implements the SHA1 hash algorithm.
670 exts.append( Extension('_sha', ['shamodule.c']) )
671 # The _md5 module implements the RSA Data Security, Inc. MD5
672 # Message-Digest Algorithm, described in RFC 1321. The
673 # necessary files md5.c and md5.h are included here.
674 exts.append( Extension('_md5',
675 sources = ['md5module.c', 'md5.c'],
676 depends = ['md5.h']) )
677 missing.append('_hashlib')
679 if (openssl_ver < 0x00908000):
680 # OpenSSL doesn't do these until 0.9.8 so we'll bring our own hash
681 exts.append( Extension('_sha256', ['sha256module.c']) )
682 exts.append( Extension('_sha512', ['sha512module.c']) )
684 # Modules that provide persistent dictionary-like semantics. You will
685 # probably want to arrange for at least one of them to be available on
686 # your machine, though none are defined by default because of library
687 # dependencies. The Python module anydbm.py provides an
688 # implementation independent wrapper for these; dumbdbm.py provides
689 # similar functionality (but slower of course) implemented in Python.
691 # Sleepycat^WOracle Berkeley DB interface.
692 # http://www.oracle.com/database/berkeley-db/db/index.html
694 # This requires the Sleepycat^WOracle DB code. The supported versions
695 # are set below. Visit the URL above to download
696 # a release. Most open source OSes come with one or more
697 # versions of BerkeleyDB already installed.
699 max_db_ver = (4, 7)
700 min_db_ver = (3, 3)
701 db_setup_debug = False # verbose debug prints from this script?
703 def allow_db_ver(db_ver):
704 """Returns a boolean if the given BerkeleyDB version is acceptable.
706 Args:
707 db_ver: A tuple of the version to verify.
709 if not (min_db_ver <= db_ver <= max_db_ver):
710 return False
711 # Use this function to filter out known bad configurations.
712 if (4, 6) == db_ver[:2]:
713 # BerkeleyDB 4.6.x is not stable on many architectures.
714 arch = platform_machine()
715 if arch not in ('i386', 'i486', 'i586', 'i686',
716 'x86_64', 'ia64'):
717 return False
718 return True
720 def gen_db_minor_ver_nums(major):
721 if major == 4:
722 for x in range(max_db_ver[1]+1):
723 if allow_db_ver((4, x)):
724 yield x
725 elif major == 3:
726 for x in (3,):
727 if allow_db_ver((3, x)):
728 yield x
729 else:
730 raise ValueError("unknown major BerkeleyDB version", major)
732 # construct a list of paths to look for the header file in on
733 # top of the normal inc_dirs.
734 db_inc_paths = [
735 '/usr/include/db4',
736 '/usr/local/include/db4',
737 '/opt/sfw/include/db4',
738 '/usr/include/db3',
739 '/usr/local/include/db3',
740 '/opt/sfw/include/db3',
741 # Fink defaults (http://fink.sourceforge.net/)
742 '/sw/include/db4',
743 '/sw/include/db3',
745 # 4.x minor number specific paths
746 for x in gen_db_minor_ver_nums(4):
747 db_inc_paths.append('/usr/include/db4%d' % x)
748 db_inc_paths.append('/usr/include/db4.%d' % x)
749 db_inc_paths.append('/usr/local/BerkeleyDB.4.%d/include' % x)
750 db_inc_paths.append('/usr/local/include/db4%d' % x)
751 db_inc_paths.append('/pkg/db-4.%d/include' % x)
752 db_inc_paths.append('/opt/db-4.%d/include' % x)
753 # MacPorts default (http://www.macports.org/)
754 db_inc_paths.append('/opt/local/include/db4%d' % x)
755 # 3.x minor number specific paths
756 for x in gen_db_minor_ver_nums(3):
757 db_inc_paths.append('/usr/include/db3%d' % x)
758 db_inc_paths.append('/usr/local/BerkeleyDB.3.%d/include' % x)
759 db_inc_paths.append('/usr/local/include/db3%d' % x)
760 db_inc_paths.append('/pkg/db-3.%d/include' % x)
761 db_inc_paths.append('/opt/db-3.%d/include' % x)
763 # Add some common subdirectories for Sleepycat DB to the list,
764 # based on the standard include directories. This way DB3/4 gets
765 # picked up when it is installed in a non-standard prefix and
766 # the user has added that prefix into inc_dirs.
767 std_variants = []
768 for dn in inc_dirs:
769 std_variants.append(os.path.join(dn, 'db3'))
770 std_variants.append(os.path.join(dn, 'db4'))
771 for x in gen_db_minor_ver_nums(4):
772 std_variants.append(os.path.join(dn, "db4%d"%x))
773 std_variants.append(os.path.join(dn, "db4.%d"%x))
774 for x in gen_db_minor_ver_nums(3):
775 std_variants.append(os.path.join(dn, "db3%d"%x))
776 std_variants.append(os.path.join(dn, "db3.%d"%x))
778 db_inc_paths = std_variants + db_inc_paths
779 db_inc_paths = [p for p in db_inc_paths if os.path.exists(p)]
781 db_ver_inc_map = {}
783 class db_found(Exception): pass
784 try:
785 # See whether there is a Sleepycat header in the standard
786 # search path.
787 for d in inc_dirs + db_inc_paths:
788 f = os.path.join(d, "db.h")
789 if db_setup_debug: print "db: looking for db.h in", f
790 if os.path.exists(f):
791 f = open(f).read()
792 m = re.search(r"#define\WDB_VERSION_MAJOR\W(\d+)", f)
793 if m:
794 db_major = int(m.group(1))
795 m = re.search(r"#define\WDB_VERSION_MINOR\W(\d+)", f)
796 db_minor = int(m.group(1))
797 db_ver = (db_major, db_minor)
799 # Avoid 4.6 prior to 4.6.21 due to a BerkeleyDB bug
800 if db_ver == (4, 6):
801 m = re.search(r"#define\WDB_VERSION_PATCH\W(\d+)", f)
802 db_patch = int(m.group(1))
803 if db_patch < 21:
804 print "db.h:", db_ver, "patch", db_patch,
805 print "being ignored (4.6.x must be >= 4.6.21)"
806 continue
808 if ( (not db_ver_inc_map.has_key(db_ver)) and
809 allow_db_ver(db_ver) ):
810 # save the include directory with the db.h version
811 # (first occurrence only)
812 db_ver_inc_map[db_ver] = d
813 if db_setup_debug:
814 print "db.h: found", db_ver, "in", d
815 else:
816 # we already found a header for this library version
817 if db_setup_debug: print "db.h: ignoring", d
818 else:
819 # ignore this header, it didn't contain a version number
820 if db_setup_debug:
821 print "db.h: no version number version in", d
823 db_found_vers = db_ver_inc_map.keys()
824 db_found_vers.sort()
826 while db_found_vers:
827 db_ver = db_found_vers.pop()
828 db_incdir = db_ver_inc_map[db_ver]
830 # check lib directories parallel to the location of the header
831 db_dirs_to_check = [
832 db_incdir.replace("include", 'lib64'),
833 db_incdir.replace("include", 'lib'),
835 db_dirs_to_check = filter(os.path.isdir, db_dirs_to_check)
837 # Look for a version specific db-X.Y before an ambiguoius dbX
838 # XXX should we -ever- look for a dbX name? Do any
839 # systems really not name their library by version and
840 # symlink to more general names?
841 for dblib in (('db-%d.%d' % db_ver),
842 ('db%d%d' % db_ver),
843 ('db%d' % db_ver[0])):
844 dblib_file = self.compiler_obj.find_library_file(
845 db_dirs_to_check + lib_dirs, dblib )
846 if dblib_file:
847 dblib_dir = [ os.path.abspath(os.path.dirname(dblib_file)) ]
848 raise db_found
849 else:
850 if db_setup_debug: print "db lib: ", dblib, "not found"
852 except db_found:
853 if db_setup_debug:
854 print "bsddb using BerkeleyDB lib:", db_ver, dblib
855 print "bsddb lib dir:", dblib_dir, " inc dir:", db_incdir
856 db_incs = [db_incdir]
857 dblibs = [dblib]
858 # We add the runtime_library_dirs argument because the
859 # BerkeleyDB lib we're linking against often isn't in the
860 # system dynamic library search path. This is usually
861 # correct and most trouble free, but may cause problems in
862 # some unusual system configurations (e.g. the directory
863 # is on an NFS server that goes away).
864 exts.append(Extension('_bsddb', ['_bsddb.c'],
865 depends = ['bsddb.h'],
866 library_dirs=dblib_dir,
867 runtime_library_dirs=dblib_dir,
868 include_dirs=db_incs,
869 libraries=dblibs))
870 else:
871 if db_setup_debug: print "db: no appropriate library found"
872 db_incs = None
873 dblibs = []
874 dblib_dir = None
875 missing.append('_bsddb')
877 # The sqlite interface
878 sqlite_setup_debug = False # verbose debug prints from this script?
880 # We hunt for #define SQLITE_VERSION "n.n.n"
881 # We need to find >= sqlite version 3.0.8
882 sqlite_incdir = sqlite_libdir = None
883 sqlite_inc_paths = [ '/usr/include',
884 '/usr/include/sqlite',
885 '/usr/include/sqlite3',
886 '/usr/local/include',
887 '/usr/local/include/sqlite',
888 '/usr/local/include/sqlite3',
890 MIN_SQLITE_VERSION_NUMBER = (3, 0, 8)
891 MIN_SQLITE_VERSION = ".".join([str(x)
892 for x in MIN_SQLITE_VERSION_NUMBER])
894 # Scan the default include directories before the SQLite specific
895 # ones. This allows one to override the copy of sqlite on OSX,
896 # where /usr/include contains an old version of sqlite.
897 for d in inc_dirs + sqlite_inc_paths:
898 f = os.path.join(d, "sqlite3.h")
899 if os.path.exists(f):
900 if sqlite_setup_debug: print "sqlite: found %s"%f
901 incf = open(f).read()
902 m = re.search(
903 r'\s*.*#\s*.*define\s.*SQLITE_VERSION\W*"(.*)"', incf)
904 if m:
905 sqlite_version = m.group(1)
906 sqlite_version_tuple = tuple([int(x)
907 for x in sqlite_version.split(".")])
908 if sqlite_version_tuple >= MIN_SQLITE_VERSION_NUMBER:
909 # we win!
910 if sqlite_setup_debug:
911 print "%s/sqlite3.h: version %s"%(d, sqlite_version)
912 sqlite_incdir = d
913 break
914 else:
915 if sqlite_setup_debug:
916 print "%s: version %d is too old, need >= %s"%(d,
917 sqlite_version, MIN_SQLITE_VERSION)
918 elif sqlite_setup_debug:
919 print "sqlite: %s had no SQLITE_VERSION"%(f,)
921 if sqlite_incdir:
922 sqlite_dirs_to_check = [
923 os.path.join(sqlite_incdir, '..', 'lib64'),
924 os.path.join(sqlite_incdir, '..', 'lib'),
925 os.path.join(sqlite_incdir, '..', '..', 'lib64'),
926 os.path.join(sqlite_incdir, '..', '..', 'lib'),
928 sqlite_libfile = self.compiler_obj.find_library_file(
929 sqlite_dirs_to_check + lib_dirs, 'sqlite3')
930 if sqlite_libfile:
931 sqlite_libdir = [os.path.abspath(os.path.dirname(sqlite_libfile))]
933 if sqlite_incdir and sqlite_libdir:
934 sqlite_srcs = ['_sqlite/cache.c',
935 '_sqlite/connection.c',
936 '_sqlite/cursor.c',
937 '_sqlite/microprotocols.c',
938 '_sqlite/module.c',
939 '_sqlite/prepare_protocol.c',
940 '_sqlite/row.c',
941 '_sqlite/statement.c',
942 '_sqlite/util.c', ]
944 sqlite_defines = []
945 if sys.platform != "win32":
946 sqlite_defines.append(('MODULE_NAME', '"sqlite3"'))
947 else:
948 sqlite_defines.append(('MODULE_NAME', '\\"sqlite3\\"'))
951 if sys.platform == 'darwin':
952 # In every directory on the search path search for a dynamic
953 # library and then a static library, instead of first looking
954 # for dynamic libraries on the entiry path.
955 # This way a staticly linked custom sqlite gets picked up
956 # before the dynamic library in /usr/lib.
957 sqlite_extra_link_args = ('-Wl,-search_paths_first',)
958 else:
959 sqlite_extra_link_args = ()
961 exts.append(Extension('_sqlite3', sqlite_srcs,
962 define_macros=sqlite_defines,
963 include_dirs=["Modules/_sqlite",
964 sqlite_incdir],
965 library_dirs=sqlite_libdir,
966 runtime_library_dirs=sqlite_libdir,
967 extra_link_args=sqlite_extra_link_args,
968 libraries=["sqlite3",]))
969 else:
970 missing.append('_sqlite3')
972 # Look for Berkeley db 1.85. Note that it is built as a different
973 # module name so it can be included even when later versions are
974 # available. A very restrictive search is performed to avoid
975 # accidentally building this module with a later version of the
976 # underlying db library. May BSD-ish Unixes incorporate db 1.85
977 # symbols into libc and place the include file in /usr/include.
979 # If the better bsddb library can be built (db_incs is defined)
980 # we do not build this one. Otherwise this build will pick up
981 # the more recent berkeleydb's db.h file first in the include path
982 # when attempting to compile and it will fail.
983 f = "/usr/include/db.h"
984 if os.path.exists(f) and not db_incs:
985 data = open(f).read()
986 m = re.search(r"#s*define\s+HASHVERSION\s+2\s*", data)
987 if m is not None:
988 # bingo - old version used hash file format version 2
989 ### XXX this should be fixed to not be platform-dependent
990 ### but I don't have direct access to an osf1 platform and
991 ### seemed to be muffing the search somehow
992 libraries = platform == "osf1" and ['db'] or None
993 if libraries is not None:
994 exts.append(Extension('bsddb185', ['bsddbmodule.c'],
995 libraries=libraries))
996 else:
997 exts.append(Extension('bsddb185', ['bsddbmodule.c']))
998 else:
999 missing.append('bsddb185')
1000 else:
1001 missing.append('bsddb185')
1003 dbm_order = ['gdbm']
1004 # The standard Unix dbm module:
1005 if platform not in ['cygwin']:
1006 config_args = [arg.strip("'")
1007 for arg in sysconfig.get_config_var("CONFIG_ARGS").split()]
1008 dbm_args = [arg for arg in config_args
1009 if arg.startswith('--with-dbmliborder=')]
1010 if dbm_args:
1011 dbm_order = [arg.split('=')[-1] for arg in dbm_args][-1].split(":")
1012 else:
1013 dbm_order = "ndbm:gdbm:bdb".split(":")
1014 dbmext = None
1015 for cand in dbm_order:
1016 if cand == "ndbm":
1017 if find_file("ndbm.h", inc_dirs, []) is not None:
1018 # Some systems have -lndbm, others don't
1019 if self.compiler_obj.find_library_file(lib_dirs,
1020 'ndbm'):
1021 ndbm_libs = ['ndbm']
1022 else:
1023 ndbm_libs = []
1024 print "building dbm using ndbm"
1025 dbmext = Extension('dbm', ['dbmmodule.c'],
1026 define_macros=[
1027 ('HAVE_NDBM_H',None),
1029 libraries=ndbm_libs)
1030 break
1032 elif cand == "gdbm":
1033 if self.compiler_obj.find_library_file(lib_dirs, 'gdbm'):
1034 gdbm_libs = ['gdbm']
1035 if self.compiler_obj.find_library_file(lib_dirs,
1036 '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"
1040 dbmext = Extension(
1041 'dbm', ['dbmmodule.c'],
1042 define_macros=[
1043 ('HAVE_GDBM_NDBM_H', None),
1045 libraries = gdbm_libs)
1046 break
1047 if find_file("gdbm-ndbm.h", inc_dirs, []) is not None:
1048 print "building dbm using gdbm"
1049 dbmext = Extension(
1050 'dbm', ['dbmmodule.c'],
1051 define_macros=[
1052 ('HAVE_GDBM_DASH_NDBM_H', None),
1054 libraries = gdbm_libs)
1055 break
1056 elif cand == "bdb":
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,
1063 define_macros=[
1064 ('HAVE_BERKDB_H', None),
1065 ('DB_DBM_HSEARCH', None),
1067 libraries=dblibs)
1068 break
1069 if dbmext is not None:
1070 exts.append(dbmext)
1071 else:
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_obj.find_library_file(lib_dirs, 'gdbm')):
1077 exts.append( Extension('gdbm', ['gdbmmodule.c'],
1078 libraries = ['gdbm'] ) )
1079 else:
1080 missing.append('gdbm')
1082 # Unix-only modules
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']) )
1089 else:
1090 missing.append('resource')
1092 # Sun yellow pages. Some systems have the functions in libc.
1093 if (platform not in ['cygwin', 'atheos', 'qnx6'] and
1094 find_file('rpcsvc/yp_prot.h', inc_dirs, []) is not None):
1095 if (self.compiler_obj.find_library_file(lib_dirs, 'nsl')):
1096 libs = ['nsl']
1097 else:
1098 libs = []
1099 exts.append( Extension('nis', ['nismodule.c'],
1100 libraries = libs) )
1101 else:
1102 missing.append('nis')
1103 else:
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 (self.compiler_obj.find_library_file(lib_dirs, 'ncursesw')):
1110 curses_libs = ['ncursesw']
1111 # Bug 1464056: If _curses.so links with ncursesw,
1112 # _curses_panel.so must link with panelw.
1113 panel_library = 'panelw'
1114 exts.append( Extension('_curses', ['_cursesmodule.c'],
1115 libraries = curses_libs) )
1116 elif (self.compiler_obj.find_library_file(lib_dirs, 'ncurses')):
1117 curses_libs = ['ncurses']
1118 exts.append( Extension('_curses', ['_cursesmodule.c'],
1119 libraries = curses_libs) )
1120 elif (self.compiler_obj.find_library_file(lib_dirs, 'curses')
1121 and platform != 'darwin'):
1122 # OSX has an old Berkeley curses, not good enough for
1123 # the _curses module.
1124 if (self.compiler_obj.find_library_file(lib_dirs, 'terminfo')):
1125 curses_libs = ['curses', 'terminfo']
1126 elif (self.compiler_obj.find_library_file(lib_dirs, 'termcap')):
1127 curses_libs = ['curses', 'termcap']
1128 else:
1129 curses_libs = ['curses']
1131 exts.append( Extension('_curses', ['_cursesmodule.c'],
1132 libraries = curses_libs) )
1133 else:
1134 missing.append('_curses')
1136 # If the curses module is enabled, check for the panel module
1137 if (module_enabled(exts, '_curses') and
1138 self.compiler_obj.find_library_file(lib_dirs, panel_library)):
1139 exts.append( Extension('_curses_panel', ['_curses_panel.c'],
1140 libraries = [panel_library] + curses_libs) )
1141 else:
1142 missing.append('_curses_panel')
1144 # Andrew Kuchling's zlib module. Note that some versions of zlib
1145 # 1.1.3 have security problems. See CERT Advisory CA-2002-07:
1146 # http://www.cert.org/advisories/CA-2002-07.html
1148 # zlib 1.1.4 is fixed, but at least one vendor (RedHat) has decided to
1149 # patch its zlib 1.1.3 package instead of upgrading to 1.1.4. For
1150 # now, we still accept 1.1.3, because we think it's difficult to
1151 # exploit this in Python, and we'd rather make it RedHat's problem
1152 # than our problem <wink>.
1154 # You can upgrade zlib to version 1.1.4 yourself by going to
1155 # http://www.gzip.org/zlib/
1156 zlib_inc = find_file('zlib.h', [], inc_dirs)
1157 have_zlib = False
1158 if zlib_inc is not None:
1159 zlib_h = zlib_inc[0] + '/zlib.h'
1160 version = '"0.0.0"'
1161 version_req = '"1.1.3"'
1162 fp = open(zlib_h)
1163 while 1:
1164 line = fp.readline()
1165 if not line:
1166 break
1167 if line.startswith('#define ZLIB_VERSION'):
1168 version = line.split()[2]
1169 break
1170 if version >= version_req:
1171 if (self.compiler_obj.find_library_file(lib_dirs, 'z')):
1172 if sys.platform == "darwin":
1173 zlib_extra_link_args = ('-Wl,-search_paths_first',)
1174 else:
1175 zlib_extra_link_args = ()
1176 exts.append( Extension('zlib', ['zlibmodule.c'],
1177 libraries = ['z'],
1178 extra_link_args = zlib_extra_link_args))
1179 have_zlib = True
1180 else:
1181 missing.append('zlib')
1182 else:
1183 missing.append('zlib')
1184 else:
1185 missing.append('zlib')
1187 # Helper module for various ascii-encoders. Uses zlib for an optimized
1188 # crc32 if we have it. Otherwise binascii uses its own.
1189 if have_zlib:
1190 extra_compile_args = ['-DUSE_ZLIB_CRC32']
1191 libraries = ['z']
1192 extra_link_args = zlib_extra_link_args
1193 else:
1194 extra_compile_args = []
1195 libraries = []
1196 extra_link_args = []
1197 exts.append( Extension('binascii', ['binascii.c'],
1198 extra_compile_args = extra_compile_args,
1199 libraries = libraries,
1200 extra_link_args = extra_link_args) )
1202 # Gustavo Niemeyer's bz2 module.
1203 if (self.compiler_obj.find_library_file(lib_dirs, 'bz2')):
1204 if sys.platform == "darwin":
1205 bz2_extra_link_args = ('-Wl,-search_paths_first',)
1206 else:
1207 bz2_extra_link_args = ()
1208 exts.append( Extension('bz2', ['bz2module.c'],
1209 libraries = ['bz2'],
1210 extra_link_args = bz2_extra_link_args) )
1211 else:
1212 missing.append('bz2')
1214 # Interface to the Expat XML parser
1216 # Expat was written by James Clark and is now maintained by a group of
1217 # developers on SourceForge; see www.libexpat.org for more information.
1218 # The pyexpat module was written by Paul Prescod after a prototype by
1219 # Jack Jansen. The Expat source is included in Modules/expat/. Usage
1220 # of a system shared libexpat.so is possible with --with-system-expat
1221 # cofigure option.
1223 # More information on Expat can be found at www.libexpat.org.
1225 if '--with-system-expat' in sysconfig.get_config_var("CONFIG_ARGS"):
1226 expat_inc = []
1227 define_macros = []
1228 expat_lib = ['expat']
1229 expat_sources = []
1230 else:
1231 expat_inc = [os.path.join(os.getcwd(), srcdir, 'Modules', 'expat')]
1232 define_macros = [
1233 ('HAVE_EXPAT_CONFIG_H', '1'),
1235 expat_lib = []
1236 expat_sources = ['expat/xmlparse.c',
1237 'expat/xmlrole.c',
1238 'expat/xmltok.c']
1240 exts.append(Extension('pyexpat',
1241 define_macros = define_macros,
1242 include_dirs = expat_inc,
1243 libraries = expat_lib,
1244 sources = ['pyexpat.c'] + expat_sources
1247 # Fredrik Lundh's cElementTree module. Note that this also
1248 # uses expat (via the CAPI hook in pyexpat).
1250 if os.path.isfile(os.path.join(srcdir, 'Modules', '_elementtree.c')):
1251 define_macros.append(('USE_PYEXPAT_CAPI', None))
1252 exts.append(Extension('_elementtree',
1253 define_macros = define_macros,
1254 include_dirs = expat_inc,
1255 libraries = expat_lib,
1256 sources = ['_elementtree.c'],
1258 else:
1259 missing.append('_elementtree')
1261 # Hye-Shik Chang's CJKCodecs modules.
1262 if have_unicode:
1263 exts.append(Extension('_multibytecodec',
1264 ['cjkcodecs/multibytecodec.c']))
1265 for loc in ('kr', 'jp', 'cn', 'tw', 'hk', 'iso2022'):
1266 exts.append(Extension('_codecs_%s' % loc,
1267 ['cjkcodecs/_codecs_%s.c' % loc]))
1268 else:
1269 missing.append('_multibytecodec')
1270 for loc in ('kr', 'jp', 'cn', 'tw', 'hk', 'iso2022'):
1271 missing.append('_codecs_%s' % loc)
1273 # Dynamic loading module
1274 if sys.maxint == 0x7fffffff:
1275 # This requires sizeof(int) == sizeof(long) == sizeof(char*)
1276 dl_inc = find_file('dlfcn.h', [], inc_dirs)
1277 if (dl_inc is not None) and (platform not in ['atheos']):
1278 exts.append( Extension('dl', ['dlmodule.c']) )
1279 else:
1280 missing.append('dl')
1281 else:
1282 missing.append('dl')
1284 # Thomas Heller's _ctypes module
1285 self.detect_ctypes(inc_dirs, lib_dirs)
1287 # Richard Oudkerk's multiprocessing module
1288 if platform == 'win32': # Windows
1289 macros = dict()
1290 libraries = ['ws2_32']
1292 elif platform == 'darwin': # Mac OSX
1293 macros = dict()
1294 libraries = []
1296 elif platform == 'cygwin': # Cygwin
1297 macros = dict()
1298 libraries = []
1300 elif platform in ('freebsd4', 'freebsd5', 'freebsd6', 'freebsd7', 'freebsd8'):
1301 # FreeBSD's P1003.1b semaphore support is very experimental
1302 # and has many known problems. (as of June 2008)
1303 macros = dict()
1304 libraries = []
1306 elif platform.startswith('openbsd'):
1307 macros = dict()
1308 libraries = []
1310 elif platform.startswith('netbsd'):
1311 macros = dict()
1312 libraries = []
1314 else: # Linux and other unices
1315 macros = dict()
1316 libraries = ['rt']
1318 if platform == 'win32':
1319 multiprocessing_srcs = [ '_multiprocessing/multiprocessing.c',
1320 '_multiprocessing/semaphore.c',
1321 '_multiprocessing/pipe_connection.c',
1322 '_multiprocessing/socket_connection.c',
1323 '_multiprocessing/win32_functions.c'
1326 else:
1327 multiprocessing_srcs = [ '_multiprocessing/multiprocessing.c',
1328 '_multiprocessing/socket_connection.c'
1330 if (sysconfig.get_config_var('HAVE_SEM_OPEN') and not
1331 sysconfig.get_config_var('POSIX_SEMAPHORES_NOT_ENABLED')):
1332 multiprocessing_srcs.append('_multiprocessing/semaphore.c')
1334 if sysconfig.get_config_var('WITH_THREAD'):
1335 exts.append ( Extension('_multiprocessing', multiprocessing_srcs,
1336 define_macros=macros.items(),
1337 include_dirs=["Modules/_multiprocessing"]))
1338 else:
1339 missing.append('_multiprocessing')
1341 # End multiprocessing
1344 # Platform-specific libraries
1345 if platform == 'linux2':
1346 # Linux-specific modules
1347 exts.append( Extension('linuxaudiodev', ['linuxaudiodev.c']) )
1348 else:
1349 missing.append('linuxaudiodev')
1351 if platform in ('linux2', 'freebsd4', 'freebsd5', 'freebsd6',
1352 'freebsd7', 'freebsd8'):
1353 exts.append( Extension('ossaudiodev', ['ossaudiodev.c']) )
1354 else:
1355 missing.append('ossaudiodev')
1357 if platform == 'sunos5':
1358 # SunOS specific modules
1359 exts.append( Extension('sunaudiodev', ['sunaudiodev.c']) )
1360 else:
1361 missing.append('sunaudiodev')
1363 if platform == 'darwin':
1364 # _scproxy
1365 exts.append(Extension("_scproxy", [os.path.join(srcdir, "Mac/Modules/_scproxy.c")],
1366 extra_link_args= [
1367 '-framework', 'SystemConfiguration',
1368 '-framework', 'CoreFoundation'
1372 if platform == 'darwin' and ("--disable-toolbox-glue" not in
1373 sysconfig.get_config_var("CONFIG_ARGS")):
1375 if os.uname()[2] > '8.':
1376 # We're on Mac OS X 10.4 or later, the compiler should
1377 # support '-Wno-deprecated-declarations'. This will
1378 # surpress deprecation warnings for the Carbon extensions,
1379 # these extensions wrap the Carbon APIs and even those
1380 # parts that are deprecated.
1381 carbon_extra_compile_args = ['-Wno-deprecated-declarations']
1382 else:
1383 carbon_extra_compile_args = []
1385 # Mac OS X specific modules.
1386 def macSrcExists(name1, name2=''):
1387 if not name1:
1388 return None
1389 names = (name1,)
1390 if name2:
1391 names = (name1, name2)
1392 path = os.path.join(srcdir, 'Mac', 'Modules', *names)
1393 return os.path.exists(path)
1395 def addMacExtension(name, kwds, extra_srcs=[]):
1396 dirname = ''
1397 if name[0] == '_':
1398 dirname = name[1:].lower()
1399 cname = name + '.c'
1400 cmodulename = name + 'module.c'
1401 # Check for NNN.c, NNNmodule.c, _nnn/NNN.c, _nnn/NNNmodule.c
1402 if macSrcExists(cname):
1403 srcs = [cname]
1404 elif macSrcExists(cmodulename):
1405 srcs = [cmodulename]
1406 elif macSrcExists(dirname, cname):
1407 # XXX(nnorwitz): If all the names ended with module, we
1408 # wouldn't need this condition. ibcarbon is the only one.
1409 srcs = [os.path.join(dirname, cname)]
1410 elif macSrcExists(dirname, cmodulename):
1411 srcs = [os.path.join(dirname, cmodulename)]
1412 else:
1413 raise RuntimeError("%s not found" % name)
1415 # Here's the whole point: add the extension with sources
1416 exts.append(Extension(name, srcs + extra_srcs, **kwds))
1418 # Core Foundation
1419 core_kwds = {'extra_compile_args': carbon_extra_compile_args,
1420 'extra_link_args': ['-framework', 'CoreFoundation'],
1422 addMacExtension('_CF', core_kwds, ['cf/pycfbridge.c'])
1423 addMacExtension('autoGIL', core_kwds)
1427 # Carbon
1428 carbon_kwds = {'extra_compile_args': carbon_extra_compile_args,
1429 'extra_link_args': ['-framework', 'Carbon'],
1431 CARBON_EXTS = ['ColorPicker', 'gestalt', 'MacOS', 'Nav',
1432 'OSATerminology', 'icglue',
1433 # All these are in subdirs
1434 '_AE', '_AH', '_App', '_CarbonEvt', '_Cm', '_Ctl',
1435 '_Dlg', '_Drag', '_Evt', '_File', '_Folder', '_Fm',
1436 '_Help', '_Icn', '_IBCarbon', '_List',
1437 '_Menu', '_Mlte', '_OSA', '_Res', '_Qd', '_Qdoffs',
1438 '_Scrap', '_Snd', '_TE',
1440 for name in CARBON_EXTS:
1441 addMacExtension(name, carbon_kwds)
1443 # Workaround for a bug in the version of gcc shipped with Xcode 3.
1444 # The _Win extension should build just like the other Carbon extensions, but
1445 # this actually results in a hard crash of the linker.
1447 if '-arch ppc64' in cflags and '-arch ppc' in cflags:
1448 win_kwds = {'extra_compile_args': carbon_extra_compile_args + ['-arch', 'i386', '-arch', 'ppc'],
1449 'extra_link_args': ['-framework', 'Carbon', '-arch', 'i386', '-arch', 'ppc'],
1451 addMacExtension('_Win', win_kwds)
1452 else:
1453 addMacExtension('_Win', carbon_kwds)
1456 # Application Services & QuickTime
1457 app_kwds = {'extra_compile_args': carbon_extra_compile_args,
1458 'extra_link_args': ['-framework','ApplicationServices'],
1460 addMacExtension('_Launch', app_kwds)
1461 addMacExtension('_CG', app_kwds)
1463 exts.append( Extension('_Qt', ['qt/_Qtmodule.c'],
1464 extra_compile_args=carbon_extra_compile_args,
1465 extra_link_args=['-framework', 'QuickTime',
1466 '-framework', 'Carbon']) )
1469 self.extensions.extend(exts)
1471 # Call the method for detecting whether _tkinter can be compiled
1472 self.detect_tkinter(inc_dirs, lib_dirs)
1474 if '_tkinter' not in [e.name for e in self.extensions]:
1475 missing.append('_tkinter')
1477 return missing
1479 def detect_tkinter_darwin(self, inc_dirs, lib_dirs):
1480 # The _tkinter module, using frameworks. Since frameworks are quite
1481 # different the UNIX search logic is not sharable.
1482 from os.path import join, exists
1483 framework_dirs = [
1484 '/Library/Frameworks',
1485 '/System/Library/Frameworks/',
1486 join(os.getenv('HOME'), '/Library/Frameworks')
1489 # Find the directory that contains the Tcl.framework and Tk.framework
1490 # bundles.
1491 # XXX distutils should support -F!
1492 for F in framework_dirs:
1493 # both Tcl.framework and Tk.framework should be present
1494 for fw in 'Tcl', 'Tk':
1495 if not exists(join(F, fw + '.framework')):
1496 break
1497 else:
1498 # ok, F is now directory with both frameworks. Continure
1499 # building
1500 break
1501 else:
1502 # Tk and Tcl frameworks not found. Normal "unix" tkinter search
1503 # will now resume.
1504 return 0
1506 # For 8.4a2, we must add -I options that point inside the Tcl and Tk
1507 # frameworks. In later release we should hopefully be able to pass
1508 # the -F option to gcc, which specifies a framework lookup path.
1510 include_dirs = [
1511 join(F, fw + '.framework', H)
1512 for fw in 'Tcl', 'Tk'
1513 for H in 'Headers', 'Versions/Current/PrivateHeaders'
1516 # For 8.4a2, the X11 headers are not included. Rather than include a
1517 # complicated search, this is a hard-coded path. It could bail out
1518 # if X11 libs are not found...
1519 include_dirs.append('/usr/X11R6/include')
1520 frameworks = ['-framework', 'Tcl', '-framework', 'Tk']
1522 # All existing framework builds of Tcl/Tk don't support 64-bit
1523 # architectures.
1524 cflags = sysconfig.get_config_vars('CFLAGS')[0]
1525 archs = re.findall('-arch\s+(\w+)', cflags)
1526 fp = os.popen("file %s/Tk.framework/Tk | grep 'for architecture'"%(F,))
1527 detected_archs = []
1528 for ln in fp:
1529 a = ln.split()[-1]
1530 if a in archs:
1531 detected_archs.append(ln.split()[-1])
1532 fp.close()
1534 for a in detected_archs:
1535 frameworks.append('-arch')
1536 frameworks.append(a)
1538 ext = Extension('_tkinter', ['_tkinter.c', 'tkappinit.c'],
1539 define_macros=[('WITH_APPINIT', 1)],
1540 include_dirs = include_dirs,
1541 libraries = [],
1542 extra_compile_args = frameworks[2:],
1543 extra_link_args = frameworks,
1545 self.extensions.append(ext)
1546 return 1
1549 def detect_tkinter(self, inc_dirs, lib_dirs):
1550 # The _tkinter module.
1552 # Rather than complicate the code below, detecting and building
1553 # AquaTk is a separate method. Only one Tkinter will be built on
1554 # Darwin - either AquaTk, if it is found, or X11 based Tk.
1555 platform = self.get_platform()
1556 if (platform == 'darwin' and
1557 self.detect_tkinter_darwin(inc_dirs, lib_dirs)):
1558 return
1560 # Assume we haven't found any of the libraries or include files
1561 # The versions with dots are used on Unix, and the versions without
1562 # dots on Windows, for detection by cygwin.
1563 tcllib = tklib = tcl_includes = tk_includes = None
1564 for version in ['8.6', '86', '8.5', '85', '8.4', '84', '8.3', '83',
1565 '8.2', '82', '8.1', '81', '8.0', '80']:
1566 tklib = self.compiler_obj.find_library_file(lib_dirs,
1567 'tk' + version)
1568 tcllib = self.compiler_obj.find_library_file(lib_dirs,
1569 'tcl' + version)
1570 if tklib and tcllib:
1571 # Exit the loop when we've found the Tcl/Tk libraries
1572 break
1574 # Now check for the header files
1575 if tklib and tcllib:
1576 # Check for the include files on Debian and {Free,Open}BSD, where
1577 # they're put in /usr/include/{tcl,tk}X.Y
1578 dotversion = version
1579 if '.' not in dotversion and "bsd" in sys.platform.lower():
1580 # OpenBSD and FreeBSD use Tcl/Tk library names like libtcl83.a,
1581 # but the include subdirs are named like .../include/tcl8.3.
1582 dotversion = dotversion[:-1] + '.' + dotversion[-1]
1583 tcl_include_sub = []
1584 tk_include_sub = []
1585 for dir in inc_dirs:
1586 tcl_include_sub += [dir + os.sep + "tcl" + dotversion]
1587 tk_include_sub += [dir + os.sep + "tk" + dotversion]
1588 tk_include_sub += tcl_include_sub
1589 tcl_includes = find_file('tcl.h', inc_dirs, tcl_include_sub)
1590 tk_includes = find_file('tk.h', inc_dirs, tk_include_sub)
1592 if (tcllib is None or tklib is None or
1593 tcl_includes is None or tk_includes is None):
1594 self.announce("INFO: Can't locate Tcl/Tk libs and/or headers", 2)
1595 return
1597 # OK... everything seems to be present for Tcl/Tk.
1599 include_dirs = [] ; libs = [] ; defs = [] ; added_lib_dirs = []
1600 for dir in tcl_includes + tk_includes:
1601 if dir not in include_dirs:
1602 include_dirs.append(dir)
1604 # Check for various platform-specific directories
1605 if platform == 'sunos5':
1606 include_dirs.append('/usr/openwin/include')
1607 added_lib_dirs.append('/usr/openwin/lib')
1608 elif os.path.exists('/usr/X11R6/include'):
1609 include_dirs.append('/usr/X11R6/include')
1610 added_lib_dirs.append('/usr/X11R6/lib64')
1611 added_lib_dirs.append('/usr/X11R6/lib')
1612 elif os.path.exists('/usr/X11R5/include'):
1613 include_dirs.append('/usr/X11R5/include')
1614 added_lib_dirs.append('/usr/X11R5/lib')
1615 else:
1616 # Assume default location for X11
1617 include_dirs.append('/usr/X11/include')
1618 added_lib_dirs.append('/usr/X11/lib')
1620 # If Cygwin, then verify that X is installed before proceeding
1621 if platform == 'cygwin':
1622 x11_inc = find_file('X11/Xlib.h', [], include_dirs)
1623 if x11_inc is None:
1624 return
1626 # Check for BLT extension
1627 if self.compiler_obj.find_library_file(lib_dirs + added_lib_dirs,
1628 'BLT8.0'):
1629 defs.append( ('WITH_BLT', 1) )
1630 libs.append('BLT8.0')
1631 elif self.compiler_obj.find_library_file(lib_dirs + added_lib_dirs,
1632 'BLT'):
1633 defs.append( ('WITH_BLT', 1) )
1634 libs.append('BLT')
1636 # Add the Tcl/Tk libraries
1637 libs.append('tk'+ version)
1638 libs.append('tcl'+ version)
1640 if platform in ['aix3', 'aix4']:
1641 libs.append('ld')
1643 # Finally, link with the X11 libraries (not appropriate on cygwin)
1644 if platform != "cygwin":
1645 libs.append('X11')
1647 ext = Extension('_tkinter', ['_tkinter.c', 'tkappinit.c'],
1648 define_macros=[('WITH_APPINIT', 1)] + defs,
1649 include_dirs = include_dirs,
1650 libraries = libs,
1651 library_dirs = added_lib_dirs,
1653 self.extensions.append(ext)
1655 ## # Uncomment these lines if you want to play with xxmodule.c
1656 ## ext = Extension('xx', ['xxmodule.c'])
1657 ## self.extensions.append(ext)
1659 # XXX handle these, but how to detect?
1660 # *** Uncomment and edit for PIL (TkImaging) extension only:
1661 # -DWITH_PIL -I../Extensions/Imaging/libImaging tkImaging.c \
1662 # *** Uncomment and edit for TOGL extension only:
1663 # -DWITH_TOGL togl.c \
1664 # *** Uncomment these for TOGL extension only:
1665 # -lGL -lGLU -lXext -lXmu \
1667 def configure_ctypes_darwin(self, ext):
1668 # Darwin (OS X) uses preconfigured files, in
1669 # the Modules/_ctypes/libffi_osx directory.
1670 srcdir = sysconfig.get_config_var('srcdir')
1671 ffi_srcdir = os.path.abspath(os.path.join(srcdir, 'Modules',
1672 '_ctypes', 'libffi_osx'))
1673 sources = [os.path.join(ffi_srcdir, p)
1674 for p in ['ffi.c',
1675 'x86/darwin64.S',
1676 'x86/x86-darwin.S',
1677 'x86/x86-ffi_darwin.c',
1678 'x86/x86-ffi64.c',
1679 'powerpc/ppc-darwin.S',
1680 'powerpc/ppc-darwin_closure.S',
1681 'powerpc/ppc-ffi_darwin.c',
1682 'powerpc/ppc64-darwin_closure.S',
1685 # Add .S (preprocessed assembly) to C compiler source extensions.
1686 self.compiler_obj.src_extensions.append('.S')
1688 include_dirs = [os.path.join(ffi_srcdir, 'include'),
1689 os.path.join(ffi_srcdir, 'powerpc')]
1690 ext.include_dirs.extend(include_dirs)
1691 ext.sources.extend(sources)
1692 return True
1694 def configure_ctypes(self, ext):
1695 if not self.use_system_libffi:
1696 if sys.platform == 'darwin':
1697 return self.configure_ctypes_darwin(ext)
1699 srcdir = sysconfig.get_config_var('srcdir')
1700 ffi_builddir = os.path.join(self.build_temp, 'libffi')
1701 ffi_srcdir = os.path.abspath(os.path.join(srcdir, 'Modules',
1702 '_ctypes', 'libffi'))
1703 ffi_configfile = os.path.join(ffi_builddir, 'fficonfig.py')
1705 from distutils.dep_util import newer_group
1707 config_sources = [os.path.join(ffi_srcdir, fname)
1708 for fname in os.listdir(ffi_srcdir)
1709 if os.path.isfile(os.path.join(ffi_srcdir, fname))]
1710 if self.force or newer_group(config_sources,
1711 ffi_configfile):
1712 from distutils.dir_util import mkpath
1713 mkpath(ffi_builddir)
1714 config_args = []
1716 # Pass empty CFLAGS because we'll just append the resulting
1717 # CFLAGS to Python's; -g or -O2 is to be avoided.
1718 cmd = "cd %s && env CFLAGS='' '%s/configure' %s" \
1719 % (ffi_builddir, ffi_srcdir, " ".join(config_args))
1721 res = os.system(cmd)
1722 if res or not os.path.exists(ffi_configfile):
1723 print "Failed to configure _ctypes module"
1724 return False
1726 fficonfig = {}
1727 execfile(ffi_configfile, globals(), fficonfig)
1728 ffi_srcdir = os.path.join(fficonfig['ffi_srcdir'], 'src')
1730 # Add .S (preprocessed assembly) to C compiler source extensions.
1731 self.compiler_obj.src_extensions.append('.S')
1733 include_dirs = [os.path.join(ffi_builddir, 'include'),
1734 ffi_builddir, ffi_srcdir]
1735 extra_compile_args = fficonfig['ffi_cflags'].split()
1737 ext.sources.extend(fficonfig['ffi_sources'])
1738 ext.include_dirs.extend(include_dirs)
1739 ext.extra_compile_args.extend(extra_compile_args)
1740 return True
1742 def detect_ctypes(self, inc_dirs, lib_dirs):
1743 self.use_system_libffi = False
1744 include_dirs = []
1745 extra_compile_args = []
1746 extra_link_args = []
1747 sources = ['_ctypes/_ctypes.c',
1748 '_ctypes/callbacks.c',
1749 '_ctypes/callproc.c',
1750 '_ctypes/stgdict.c',
1751 '_ctypes/cfield.c',
1752 '_ctypes/malloc_closure.c']
1753 depends = ['_ctypes/ctypes.h']
1755 if sys.platform == 'darwin':
1756 sources.append('_ctypes/darwin/dlfcn_simple.c')
1757 extra_compile_args.append('-DMACOSX')
1758 include_dirs.append('_ctypes/darwin')
1759 # XXX Is this still needed?
1760 ## extra_link_args.extend(['-read_only_relocs', 'warning'])
1762 elif sys.platform == 'sunos5':
1763 # XXX This shouldn't be necessary; it appears that some
1764 # of the assembler code is non-PIC (i.e. it has relocations
1765 # when it shouldn't. The proper fix would be to rewrite
1766 # the assembler code to be PIC.
1767 # This only works with GCC; the Sun compiler likely refuses
1768 # this option. If you want to compile ctypes with the Sun
1769 # compiler, please research a proper solution, instead of
1770 # finding some -z option for the Sun compiler.
1771 extra_link_args.append('-mimpure-text')
1773 elif sys.platform.startswith('hp-ux'):
1774 extra_link_args.append('-fPIC')
1776 ext = Extension('_ctypes',
1777 include_dirs=include_dirs,
1778 extra_compile_args=extra_compile_args,
1779 extra_link_args=extra_link_args,
1780 libraries=[],
1781 sources=sources,
1782 depends=depends)
1783 ext_test = Extension('_ctypes_test',
1784 sources=['_ctypes/_ctypes_test.c'])
1785 self.extensions.extend([ext, ext_test])
1787 if not '--with-system-ffi' in sysconfig.get_config_var("CONFIG_ARGS"):
1788 return
1790 if sys.platform == 'darwin':
1791 # OS X 10.5 comes with libffi.dylib; the include files are
1792 # in /usr/include/ffi
1793 inc_dirs.append('/usr/include/ffi')
1795 ffi_inc = [sysconfig.get_config_var("LIBFFI_INCLUDEDIR")]
1796 if not ffi_inc:
1797 ffi_inc = find_file('ffi.h', [], inc_dirs)
1798 if ffi_inc is not None:
1799 ffi_h = ffi_inc[0] + '/ffi.h'
1800 fp = open(ffi_h)
1801 while 1:
1802 line = fp.readline()
1803 if not line:
1804 ffi_inc = None
1805 break
1806 if line.startswith('#define LIBFFI_H'):
1807 break
1808 ffi_lib = None
1809 if ffi_inc is not None:
1810 for lib_name in ('ffi_convenience', 'ffi_pic', 'ffi'):
1811 if (self.compiler_obj.find_library_file(lib_dirs, lib_name)):
1812 ffi_lib = lib_name
1813 break
1815 if ffi_inc and ffi_lib:
1816 ext.include_dirs.extend(ffi_inc)
1817 ext.libraries.append(ffi_lib)
1818 self.use_system_libffi = True
1821 class PyBuildInstall(install):
1822 # Suppress the warning about installation into the lib_dynload
1823 # directory, which is not in sys.path when running Python during
1824 # installation:
1825 def initialize_options (self):
1826 install.initialize_options(self)
1827 self.warn_dir=0
1829 class PyBuildInstallLib(install_lib):
1830 # Do exactly what install_lib does but make sure correct access modes get
1831 # set on installed directories and files. All installed files with get
1832 # mode 644 unless they are a shared library in which case they will get
1833 # mode 755. All installed directories will get mode 755.
1835 so_ext = sysconfig.get_config_var("SO")
1837 def install(self):
1838 outfiles = install_lib.install(self)
1839 self.set_file_modes(outfiles, 0644, 0755)
1840 self.set_dir_modes(self.install_dir, 0755)
1841 return outfiles
1843 def set_file_modes(self, files, defaultMode, sharedLibMode):
1844 if not self.is_chmod_supported(): return
1845 if not files: return
1847 for filename in files:
1848 if os.path.islink(filename): continue
1849 mode = defaultMode
1850 if filename.endswith(self.so_ext): mode = sharedLibMode
1851 log.info("changing mode of %s to %o", filename, mode)
1852 if not self.dry_run: os.chmod(filename, mode)
1854 def set_dir_modes(self, dirname, mode):
1855 if not self.is_chmod_supported(): return
1856 os.path.walk(dirname, self.set_dir_modes_visitor, mode)
1858 def set_dir_modes_visitor(self, mode, dirname, names):
1859 if os.path.islink(dirname): return
1860 log.info("changing mode of %s to %o", dirname, mode)
1861 if not self.dry_run: os.chmod(dirname, mode)
1863 def is_chmod_supported(self):
1864 return hasattr(os, 'chmod')
1866 SUMMARY = """
1867 Python is an interpreted, interactive, object-oriented programming
1868 language. It is often compared to Tcl, Perl, Scheme or Java.
1870 Python combines remarkable power with very clear syntax. It has
1871 modules, classes, exceptions, very high level dynamic data types, and
1872 dynamic typing. There are interfaces to many system calls and
1873 libraries, as well as to various windowing systems (X11, Motif, Tk,
1874 Mac, MFC). New built-in modules are easily written in C or C++. Python
1875 is also usable as an extension language for applications that need a
1876 programmable interface.
1878 The Python implementation is portable: it runs on many brands of UNIX,
1879 on Windows, DOS, OS/2, Mac, Amiga... If your favorite system isn't
1880 listed here, it may still be supported, if there's a C compiler for
1881 it. Ask around on comp.lang.python -- or just try compiling Python
1882 yourself.
1885 CLASSIFIERS = """
1886 Development Status :: 6 - Mature
1887 License :: OSI Approved :: Python Software Foundation License
1888 Natural Language :: English
1889 Programming Language :: C
1890 Programming Language :: Python
1891 Topic :: Software Development
1894 def main():
1895 # turn off warnings when deprecated modules are imported
1896 import warnings
1897 warnings.filterwarnings("ignore",category=DeprecationWarning)
1898 setup(# PyPI Metadata (PEP 301)
1899 name = "Python",
1900 version = sys.version.split()[0],
1901 url = "http://www.python.org/%s" % sys.version[:3],
1902 maintainer = "Guido van Rossum and the Python community",
1903 maintainer_email = "python-dev@python.org",
1904 description = "A high-level object-oriented programming language",
1905 long_description = SUMMARY.strip(),
1906 license = "PSF license",
1907 classifiers = filter(None, CLASSIFIERS.split("\n")),
1908 platforms = ["Many"],
1910 # Build info
1911 cmdclass = {'build_ext':PyBuildExt, 'install':PyBuildInstall,
1912 'install_lib':PyBuildInstallLib},
1913 # The struct module is defined here, because build_ext won't be
1914 # called unless there's at least one extension module defined.
1915 ext_modules=[Extension('_struct', ['_struct.c'])],
1917 # Scripts to install
1918 scripts = ['Tools/scripts/pydoc', 'Tools/scripts/idle',
1919 'Tools/scripts/2to3',
1920 'Lib/smtpd.py']
1923 # --install-platlib
1924 if __name__ == '__main__':
1925 main()