source: vendor/python/2.5/setup.py@ 3359

Last change on this file since 3359 was 3225, checked in by bird, 18 years ago

Python 2.5
File size: 66.3 KB
Line 
1# Autodetecting setup.py script for building the Python extensions
2#
3
4__version__ = "$Revision: 51184 $"
5
6import sys, os, imp, re, optparse
7
8from distutils import log
9from distutils import sysconfig
10from distutils import text_file
11from distutils.errors import *
12from distutils.core import Extension, setup
13from distutils.command.build_ext import build_ext
14from distutils.command.install import install
15from distutils.command.install_lib import install_lib
16
17# This global variable is used to hold the list of modules to be disabled.
18disabled_module_list = []
19
20def add_dir_to_list(dirlist, dir):
21 """Add the directory 'dir' to the list 'dirlist' (at the front) if
22 1) 'dir' is not already in 'dirlist'
23 2) 'dir' actually exists, and is a directory."""
24 if dir is not None and os.path.isdir(dir) and dir not in dirlist:
25 dirlist.insert(0, dir)
26
27def find_file(filename, std_dirs, paths):
28 """Searches for the directory where a given file is located,
29 and returns a possibly-empty list of additional directories, or None
30 if the file couldn't be found at all.
31
32 'filename' is the name of a file, such as readline.h or libcrypto.a.
33 'std_dirs' is the list of standard system directories; if the
34 file is found in one of them, no additional directives are needed.
35 'paths' is a list of additional locations to check; if the file is
36 found in one of them, the resulting list will contain the directory.
37 """
38
39 # Check the standard locations
40 for dir in std_dirs:
41 f = os.path.join(dir, filename)
42 if os.path.exists(f): return []
43
44 # Check the additional directories
45 for dir in paths:
46 f = os.path.join(dir, filename)
47 if os.path.exists(f):
48 return [dir]
49
50 # Not found anywhere
51 return None
52
53def find_library_file(compiler, libname, std_dirs, paths):
54 result = compiler.find_library_file(std_dirs + paths, libname)
55 if result is None:
56 return None
57
58 # Check whether the found file is in one of the standard directories
59 dirname = os.path.dirname(result)
60 for p in std_dirs:
61 # Ensure path doesn't end with path separator
62 p = p.rstrip(os.sep)
63 if p == dirname:
64 return [ ]
65
66 # Otherwise, it must have been in one of the additional directories,
67 # so we have to figure out which one.
68 for p in paths:
69 # Ensure path doesn't end with path separator
70 p = p.rstrip(os.sep)
71 if p == dirname:
72 return [p]
73 else:
74 assert False, "Internal error: Path not found in std_dirs or paths"
75
76def module_enabled(extlist, modname):
77 """Returns whether the module 'modname' is present in the list
78 of extensions 'extlist'."""
79 extlist = [ext for ext in extlist if ext.name == modname]
80 return len(extlist)
81
82def find_module_file(module, dirlist):
83 """Find a module in a set of possible folders. If it is not found
84 return the unadorned filename"""
85 list = find_file(module, [], dirlist)
86 if not list:
87 return module
88 if len(list) > 1:
89 log.info("WARNING: multiple copies of %s found"%module)
90 return os.path.join(list[0], module)
91
92class PyBuildExt(build_ext):
93
94 def build_extensions(self):
95
96 # Detect which modules should be compiled
97 self.detect_modules()
98
99 # Remove modules that are present on the disabled list
100 self.extensions = [ext for ext in self.extensions
101 if ext.name not in disabled_module_list]
102
103 # Fix up the autodetected modules, prefixing all the source files
104 # with Modules/ and adding Python's include directory to the path.
105 (srcdir,) = sysconfig.get_config_vars('srcdir')
106 if not srcdir:
107 # Maybe running on Windows but not using CYGWIN?
108 raise ValueError("No source directory; cannot proceed.")
109
110 # Figure out the location of the source code for extension modules
111 moddir = os.path.join(os.getcwd(), srcdir, 'Modules')
112 moddir = os.path.normpath(moddir)
113 srcdir, tail = os.path.split(moddir)
114 srcdir = os.path.normpath(srcdir)
115 moddir = os.path.normpath(moddir)
116
117 moddirlist = [moddir]
118 incdirlist = ['./Include']
119
120 # Platform-dependent module source and include directories
121 platform = self.get_platform()
122 if platform in ('darwin', 'mac') and ("--disable-toolbox-glue" not in
123 sysconfig.get_config_var("CONFIG_ARGS")):
124 # Mac OS X also includes some mac-specific modules
125 macmoddir = os.path.join(os.getcwd(), srcdir, 'Mac/Modules')
126 moddirlist.append(macmoddir)
127 incdirlist.append('./Mac/Include')
128
129 alldirlist = moddirlist + incdirlist
130
131 # Fix up the paths for scripts, too
132 self.distribution.scripts = [os.path.join(srcdir, filename)
133 for filename in self.distribution.scripts]
134
135 for ext in self.extensions[:]:
136 ext.sources = [ find_module_file(filename, moddirlist)
137 for filename in ext.sources ]
138 if ext.depends is not None:
139 ext.depends = [find_module_file(filename, alldirlist)
140 for filename in ext.depends]
141 ext.include_dirs.append( '.' ) # to get config.h
142 for incdir in incdirlist:
143 ext.include_dirs.append( os.path.join(srcdir, incdir) )
144
145 # If a module has already been built statically,
146 # don't build it here
147 if ext.name in sys.builtin_module_names:
148 self.extensions.remove(ext)
149
150 if platform != 'mac':
151 # Parse Modules/Setup and Modules/Setup.local to figure out which
152 # modules are turned on in the file.
153 remove_modules = []
154 for filename in ('Modules/Setup', 'Modules/Setup.local'):
155 input = text_file.TextFile(filename, join_lines=1)
156 while 1:
157 line = input.readline()
158 if not line: break
159 line = line.split()
160 remove_modules.append(line[0])
161 input.close()
162
163 for ext in self.extensions[:]:
164 if ext.name in remove_modules:
165 self.extensions.remove(ext)
166
167 # When you run "make CC=altcc" or something similar, you really want
168 # those environment variables passed into the setup.py phase. Here's
169 # a small set of useful ones.
170 compiler = os.environ.get('CC')
171 args = {}
172 # unfortunately, distutils doesn't let us provide separate C and C++
173 # compilers
174 if compiler is not None:
175 (ccshared,cflags) = sysconfig.get_config_vars('CCSHARED','CFLAGS')
176 args['compiler_so'] = compiler + ' ' + ccshared + ' ' + cflags
177 self.compiler.set_executables(**args)
178
179 build_ext.build_extensions(self)
180
181 def build_extension(self, ext):
182
183 if ext.name == '_ctypes':
184 if not self.configure_ctypes(ext):
185 return
186
187 try:
188 build_ext.build_extension(self, ext)
189 except (CCompilerError, DistutilsError), why:
190 self.announce('WARNING: building of extension "%s" failed: %s' %
191 (ext.name, sys.exc_info()[1]))
192 return
193 # Workaround for Mac OS X: The Carbon-based modules cannot be
194 # reliably imported into a command-line Python
195 if 'Carbon' in ext.extra_link_args:
196 self.announce(
197 'WARNING: skipping import check for Carbon-based "%s"' %
198 ext.name)
199 return
200 # Workaround for Cygwin: Cygwin currently has fork issues when many
201 # modules have been imported
202 if self.get_platform() == 'cygwin':
203 self.announce('WARNING: skipping import check for Cygwin-based "%s"'
204 % ext.name)
205 return
206 ext_filename = os.path.join(
207 self.build_lib,
208 self.get_ext_filename(self.get_ext_fullname(ext.name)))
209 try:
210 imp.load_dynamic(ext.name, ext_filename)
211 except ImportError, why:
212 self.announce('*** WARNING: renaming "%s" since importing it'
213 ' failed: %s' % (ext.name, why), level=3)
214 assert not self.inplace
215 basename, tail = os.path.splitext(ext_filename)
216 newname = basename + "_failed" + tail
217 if os.path.exists(newname):
218 os.remove(newname)
219 os.rename(ext_filename, newname)
220
221 # XXX -- This relies on a Vile HACK in
222 # distutils.command.build_ext.build_extension(). The
223 # _built_objects attribute is stored there strictly for
224 # use here.
225 # If there is a failure, _built_objects may not be there,
226 # so catch the AttributeError and move on.
227 try:
228 for filename in self._built_objects:
229 os.remove(filename)
230 except AttributeError:
231 self.announce('unable to remove files (ignored)')
232 except:
233 exc_type, why, tb = sys.exc_info()
234 self.announce('*** WARNING: importing extension "%s" '
235 'failed with %s: %s' % (ext.name, exc_type, why),
236 level=3)
237
238 def get_platform(self):
239 # Get value of sys.platform
240 for platform in ['cygwin', 'beos', 'darwin', 'atheos', 'osf1']:
241 if sys.platform.startswith(platform):
242 return platform
243 return sys.platform
244
245 def detect_modules(self):
246 # Ensure that /usr/local is always used
247 add_dir_to_list(self.compiler.library_dirs, '/usr/local/lib')
248 add_dir_to_list(self.compiler.include_dirs, '/usr/local/include')
249
250 # Add paths specified in the environment variables LDFLAGS and
251 # CPPFLAGS for header and library files.
252 # We must get the values from the Makefile and not the environment
253 # directly since an inconsistently reproducible issue comes up where
254 # the environment variable is not set even though the value were passed
255 # into configure and stored in the Makefile (issue found on OS X 10.3).
256 for env_var, arg_name, dir_list in (
257 ('LDFLAGS', '-L', self.compiler.library_dirs),
258 ('CPPFLAGS', '-I', self.compiler.include_dirs)):
259 env_val = sysconfig.get_config_var(env_var)
260 if env_val:
261 # To prevent optparse from raising an exception about any
262 # options in env_val that is doesn't know about we strip out
263 # all double dashes and any dashes followed by a character
264 # that is not for the option we are dealing with.
265 #
266 # Please note that order of the regex is important! We must
267 # strip out double-dashes first so that we don't end up with
268 # substituting "--Long" to "-Long" and thus lead to "ong" being
269 # used for a library directory.
270 env_val = re.sub(r'(^|\s+)-(-|(?!%s))' % arg_name[1], '', env_val)
271 parser = optparse.OptionParser()
272 # Make sure that allowing args interspersed with options is
273 # allowed
274 parser.allow_interspersed_args = True
275 parser.error = lambda msg: None
276 parser.add_option(arg_name, dest="dirs", action="append")
277 options = parser.parse_args(env_val.split())[0]
278 if options.dirs:
279 for directory in options.dirs:
280 add_dir_to_list(dir_list, directory)
281
282 if os.path.normpath(sys.prefix) != '/usr':
283 add_dir_to_list(self.compiler.library_dirs,
284 sysconfig.get_config_var("LIBDIR"))
285 add_dir_to_list(self.compiler.include_dirs,
286 sysconfig.get_config_var("INCLUDEDIR"))
287
288 try:
289 have_unicode = unicode
290 except NameError:
291 have_unicode = 0
292
293 # lib_dirs and inc_dirs are used to search for files;
294 # if a file is found in one of those directories, it can
295 # be assumed that no additional -I,-L directives are needed.
296 lib_dirs = self.compiler.library_dirs + [
297 '/lib64', '/usr/lib64',
298 '/lib', '/usr/lib',
299 ]
300 inc_dirs = self.compiler.include_dirs + ['/usr/include']
301 exts = []
302
303 config_h = sysconfig.get_config_h_filename()
304 config_h_vars = sysconfig.parse_config_h(open(config_h))
305
306 platform = self.get_platform()
307 (srcdir,) = sysconfig.get_config_vars('srcdir')
308
309 # Check for AtheOS which has libraries in non-standard locations
310 if platform == 'atheos':
311 lib_dirs += ['/system/libs', '/atheos/autolnk/lib']
312 lib_dirs += os.getenv('LIBRARY_PATH', '').split(os.pathsep)
313 inc_dirs += ['/system/include', '/atheos/autolnk/include']
314 inc_dirs += os.getenv('C_INCLUDE_PATH', '').split(os.pathsep)
315
316 # OSF/1 and Unixware have some stuff in /usr/ccs/lib (like -ldb)
317 if platform in ['osf1', 'unixware7', 'openunix8']:
318 lib_dirs += ['/usr/ccs/lib']
319
320 if platform == 'darwin':
321 # This should work on any unixy platform ;-)
322 # If the user has bothered specifying additional -I and -L flags
323 # in OPT and LDFLAGS we might as well use them here.
324 # NOTE: using shlex.split would technically be more correct, but
325 # also gives a bootstrap problem. Let's hope nobody uses directories
326 # with whitespace in the name to store libraries.
327 cflags, ldflags = sysconfig.get_config_vars(
328 'CFLAGS', 'LDFLAGS')
329 for item in cflags.split():
330 if item.startswith('-I'):
331 inc_dirs.append(item[2:])
332
333 for item in ldflags.split():
334 if item.startswith('-L'):
335 lib_dirs.append(item[2:])
336
337 # Check for MacOS X, which doesn't need libm.a at all
338 math_libs = ['m']
339 if platform in ['darwin', 'beos', 'mac']:
340 math_libs = []
341
342 # XXX Omitted modules: gl, pure, dl, SGI-specific modules
343
344 #
345 # The following modules are all pretty straightforward, and compile
346 # on pretty much any POSIXish platform.
347 #
348
349 # Some modules that are normally always on:
350 exts.append( Extension('_weakref', ['_weakref.c']) )
351
352 # array objects
353 exts.append( Extension('array', ['arraymodule.c']) )
354 # complex math library functions
355 exts.append( Extension('cmath', ['cmathmodule.c'],
356 libraries=math_libs) )
357
358 # math library functions, e.g. sin()
359 exts.append( Extension('math', ['mathmodule.c'],
360 libraries=math_libs) )
361 # fast string operations implemented in C
362 exts.append( Extension('strop', ['stropmodule.c']) )
363 # time operations and variables
364 exts.append( Extension('time', ['timemodule.c'],
365 libraries=math_libs) )
366 exts.append( Extension('datetime', ['datetimemodule.c', 'timemodule.c'],
367 libraries=math_libs) )
368 # random number generator implemented in C
369 exts.append( Extension("_random", ["_randommodule.c"]) )
370 # fast iterator tools implemented in C
371 exts.append( Extension("itertools", ["itertoolsmodule.c"]) )
372 # high-performance collections
373 exts.append( Extension("collections", ["collectionsmodule.c"]) )
374 # bisect
375 exts.append( Extension("_bisect", ["_bisectmodule.c"]) )
376 # heapq
377 exts.append( Extension("_heapq", ["_heapqmodule.c"]) )
378 # operator.add() and similar goodies
379 exts.append( Extension('operator', ['operator.c']) )
380 # _functools
381 exts.append( Extension("_functools", ["_functoolsmodule.c"]) )
382 # Python C API test module
383 exts.append( Extension('_testcapi', ['_testcapimodule.c']) )
384 # profilers (_lsprof is for cProfile.py)
385 exts.append( Extension('_hotshot', ['_hotshot.c']) )
386 exts.append( Extension('_lsprof', ['_lsprof.c', 'rotatingtree.c']) )
387 # static Unicode character database
388 if have_unicode:
389 exts.append( Extension('unicodedata', ['unicodedata.c']) )
390 # access to ISO C locale support
391 data = open('pyconfig.h').read()
392 m = re.search(r"#s*define\s+WITH_LIBINTL\s+1\s*", data)
393 if m is not None:
394 locale_libs = ['intl']
395 else:
396 locale_libs = []
397 if platform == 'darwin':
398 locale_extra_link_args = ['-framework', 'CoreFoundation']
399 else:
400 locale_extra_link_args = []
401
402
403 exts.append( Extension('_locale', ['_localemodule.c'],
404 libraries=locale_libs,
405 extra_link_args=locale_extra_link_args) )
406
407 # Modules with some UNIX dependencies -- on by default:
408 # (If you have a really backward UNIX, select and socket may not be
409 # supported...)
410
411 # fcntl(2) and ioctl(2)
412 exts.append( Extension('fcntl', ['fcntlmodule.c']) )
413 if platform not in ['mac']:
414 # pwd(3)
415 exts.append( Extension('pwd', ['pwdmodule.c']) )
416 # grp(3)
417 exts.append( Extension('grp', ['grpmodule.c']) )
418 # spwd, shadow passwords
419 if (config_h_vars.get('HAVE_GETSPNAM', False) or
420 config_h_vars.get('HAVE_GETSPENT', False)):
421 exts.append( Extension('spwd', ['spwdmodule.c']) )
422 # select(2); not on ancient System V
423 exts.append( Extension('select', ['selectmodule.c']) )
424
425 # Helper module for various ascii-encoders
426 exts.append( Extension('binascii', ['binascii.c']) )
427
428 # Fred Drake's interface to the Python parser
429 exts.append( Extension('parser', ['parsermodule.c']) )
430
431 # cStringIO and cPickle
432 exts.append( Extension('cStringIO', ['cStringIO.c']) )
433 exts.append( Extension('cPickle', ['cPickle.c']) )
434
435 # Memory-mapped files (also works on Win32).
436 if platform not in ['atheos', 'mac']:
437 exts.append( Extension('mmap', ['mmapmodule.c']) )
438
439 # Lance Ellinghaus's syslog module
440 if platform not in ['mac']:
441 # syslog daemon interface
442 exts.append( Extension('syslog', ['syslogmodule.c']) )
443
444 # George Neville-Neil's timing module:
445 # Deprecated in PEP 4 http://www.python.org/peps/pep-0004.html
446 # http://mail.python.org/pipermail/python-dev/2006-January/060023.html
447 #exts.append( Extension('timing', ['timingmodule.c']) )
448
449 #
450 # Here ends the simple stuff. From here on, modules need certain
451 # libraries, are platform-specific, or present other surprises.
452 #
453
454 # Multimedia modules
455 # These don't work for 64-bit platforms!!!
456 # These represent audio samples or images as strings:
457
458 # Operations on audio samples
459 # According to #993173, this one should actually work fine on
460 # 64-bit platforms.
461 exts.append( Extension('audioop', ['audioop.c']) )
462
463 # Disabled on 64-bit platforms
464 if sys.maxint != 9223372036854775807L:
465 # Operations on images
466 exts.append( Extension('imageop', ['imageop.c']) )
467 # Read SGI RGB image files (but coded portably)
468 exts.append( Extension('rgbimg', ['rgbimgmodule.c']) )
469
470 # readline
471 do_readline = self.compiler.find_library_file(lib_dirs, 'readline')
472 if platform == 'darwin':
473 # MacOSX 10.4 has a broken readline. Don't try to build
474 # the readline module unless the user has installed a fixed
475 # readline package
476 if find_file('readline/rlconf.h', inc_dirs, []) is None:
477 do_readline = False
478 if do_readline:
479 if sys.platform == 'darwin':
480 # In every directory on the search path search for a dynamic
481 # library and then a static library, instead of first looking
482 # for dynamic libraries on the entiry path.
483 # This way a staticly linked custom readline gets picked up
484 # before the (broken) dynamic library in /usr/lib.
485 readline_extra_link_args = ('-Wl,-search_paths_first',)
486 else:
487 readline_extra_link_args = ()
488
489 readline_libs = ['readline']
490 if self.compiler.find_library_file(lib_dirs,
491 'ncursesw'):
492 readline_libs.append('ncursesw')
493 elif self.compiler.find_library_file(lib_dirs,
494 'ncurses'):
495 readline_libs.append('ncurses')
496 elif self.compiler.find_library_file(lib_dirs, 'curses'):
497 readline_libs.append('curses')
498 elif self.compiler.find_library_file(lib_dirs +
499 ['/usr/lib/termcap'],
500 'termcap'):
501 readline_libs.append('termcap')
502 exts.append( Extension('readline', ['readline.c'],
503 library_dirs=['/usr/lib/termcap'],
504 extra_link_args=readline_extra_link_args,
505 libraries=readline_libs) )
506 if platform not in ['mac']:
507 # crypt module.
508
509 if self.compiler.find_library_file(lib_dirs, 'crypt'):
510 libs = ['crypt']
511 else:
512 libs = []
513 exts.append( Extension('crypt', ['cryptmodule.c'], libraries=libs) )
514
515 # CSV files
516 exts.append( Extension('_csv', ['_csv.c']) )
517
518 # socket(2)
519 exts.append( Extension('_socket', ['socketmodule.c'],
520 depends = ['socketmodule.h']) )
521 # Detect SSL support for the socket module (via _ssl)
522 search_for_ssl_incs_in = [
523 '/usr/local/ssl/include',
524 '/usr/contrib/ssl/include/'
525 ]
526 ssl_incs = find_file('openssl/ssl.h', inc_dirs,
527 search_for_ssl_incs_in
528 )
529 if ssl_incs is not None:
530 krb5_h = find_file('krb5.h', inc_dirs,
531 ['/usr/kerberos/include'])
532 if krb5_h:
533 ssl_incs += krb5_h
534 ssl_libs = find_library_file(self.compiler, 'ssl',lib_dirs,
535 ['/usr/local/ssl/lib',
536 '/usr/contrib/ssl/lib/'
537 ] )
538
539 if (ssl_incs is not None and
540 ssl_libs is not None):
541 exts.append( Extension('_ssl', ['_ssl.c'],
542 include_dirs = ssl_incs,
543 library_dirs = ssl_libs,
544 libraries = ['ssl', 'crypto'],
545 depends = ['socketmodule.h']), )
546
547 # find out which version of OpenSSL we have
548 openssl_ver = 0
549 openssl_ver_re = re.compile(
550 '^\s*#\s*define\s+OPENSSL_VERSION_NUMBER\s+(0x[0-9a-fA-F]+)' )
551 for ssl_inc_dir in inc_dirs + search_for_ssl_incs_in:
552 name = os.path.join(ssl_inc_dir, 'openssl', 'opensslv.h')
553 if os.path.isfile(name):
554 try:
555 incfile = open(name, 'r')
556 for line in incfile:
557 m = openssl_ver_re.match(line)
558 if m:
559 openssl_ver = eval(m.group(1))
560 break
561 except IOError:
562 pass
563
564 # first version found is what we'll use (as the compiler should)
565 if openssl_ver:
566 break
567
568 #print 'openssl_ver = 0x%08x' % openssl_ver
569
570 if (ssl_incs is not None and
571 ssl_libs is not None and
572 openssl_ver >= 0x00907000):
573 # The _hashlib module wraps optimized implementations
574 # of hash functions from the OpenSSL library.
575 exts.append( Extension('_hashlib', ['_hashopenssl.c'],
576 include_dirs = ssl_incs,
577 library_dirs = ssl_libs,
578 libraries = ['ssl', 'crypto']) )
579 else:
580 # The _sha module implements the SHA1 hash algorithm.
581 exts.append( Extension('_sha', ['shamodule.c']) )
582 # The _md5 module implements the RSA Data Security, Inc. MD5
583 # Message-Digest Algorithm, described in RFC 1321. The
584 # necessary files md5.c and md5.h are included here.
585 exts.append( Extension('_md5',
586 sources = ['md5module.c', 'md5.c'],
587 depends = ['md5.h']) )
588
589 if (openssl_ver < 0x00908000):
590 # OpenSSL doesn't do these until 0.9.8 so we'll bring our own hash
591 exts.append( Extension('_sha256', ['sha256module.c']) )
592 exts.append( Extension('_sha512', ['sha512module.c']) )
593
594
595 # Modules that provide persistent dictionary-like semantics. You will
596 # probably want to arrange for at least one of them to be available on
597 # your machine, though none are defined by default because of library
598 # dependencies. The Python module anydbm.py provides an
599 # implementation independent wrapper for these; dumbdbm.py provides
600 # similar functionality (but slower of course) implemented in Python.
601
602 # Sleepycat Berkeley DB interface. http://www.sleepycat.com
603 #
604 # This requires the Sleepycat DB code. The supported versions
605 # are set below. Visit http://www.sleepycat.com/ to download
606 # a release. Most open source OSes come with one or more
607 # versions of BerkeleyDB already installed.
608
609 max_db_ver = (4, 4)
610 min_db_ver = (3, 3)
611 db_setup_debug = False # verbose debug prints from this script?
612
613 # construct a list of paths to look for the header file in on
614 # top of the normal inc_dirs.
615 db_inc_paths = [
616 '/usr/include/db4',
617 '/usr/local/include/db4',
618 '/opt/sfw/include/db4',
619 '/sw/include/db4',
620 '/usr/include/db3',
621 '/usr/local/include/db3',
622 '/opt/sfw/include/db3',
623 '/sw/include/db3',
624 ]
625 # 4.x minor number specific paths
626 for x in (0,1,2,3,4):
627 db_inc_paths.append('/usr/include/db4%d' % x)
628 db_inc_paths.append('/usr/include/db4.%d' % x)
629 db_inc_paths.append('/usr/local/BerkeleyDB.4.%d/include' % x)
630 db_inc_paths.append('/usr/local/include/db4%d' % x)
631 db_inc_paths.append('/pkg/db-4.%d/include' % x)
632 db_inc_paths.append('/opt/db-4.%d/include' % x)
633 # 3.x minor number specific paths
634 for x in (2,3):
635 db_inc_paths.append('/usr/include/db3%d' % x)
636 db_inc_paths.append('/usr/local/BerkeleyDB.3.%d/include' % x)
637 db_inc_paths.append('/usr/local/include/db3%d' % x)
638 db_inc_paths.append('/pkg/db-3.%d/include' % x)
639 db_inc_paths.append('/opt/db-3.%d/include' % x)
640
641 # Add some common subdirectories for Sleepycat DB to the list,
642 # based on the standard include directories. This way DB3/4 gets
643 # picked up when it is installed in a non-standard prefix and
644 # the user has added that prefix into inc_dirs.
645 std_variants = []
646 for dn in inc_dirs:
647 std_variants.append(os.path.join(dn, 'db3'))
648 std_variants.append(os.path.join(dn, 'db4'))
649 for x in (0,1,2,3,4):
650 std_variants.append(os.path.join(dn, "db4%d"%x))
651 std_variants.append(os.path.join(dn, "db4.%d"%x))
652 for x in (2,3):
653 std_variants.append(os.path.join(dn, "db3%d"%x))
654 std_variants.append(os.path.join(dn, "db3.%d"%x))
655
656 db_inc_paths = std_variants + db_inc_paths
657
658
659 db_ver_inc_map = {}
660
661 class db_found(Exception): pass
662 try:
663 # See whether there is a Sleepycat header in the standard
664 # search path.
665 for d in inc_dirs + db_inc_paths:
666 f = os.path.join(d, "db.h")
667 if db_setup_debug: print "db: looking for db.h in", f
668 if os.path.exists(f):
669 f = open(f).read()
670 m = re.search(r"#define\WDB_VERSION_MAJOR\W(\d+)", f)
671 if m:
672 db_major = int(m.group(1))
673 m = re.search(r"#define\WDB_VERSION_MINOR\W(\d+)", f)
674 db_minor = int(m.group(1))
675 db_ver = (db_major, db_minor)
676
677 if ( (not db_ver_inc_map.has_key(db_ver)) and
678 (db_ver <= max_db_ver and db_ver >= min_db_ver) ):
679 # save the include directory with the db.h version
680 # (first occurrance only)
681 db_ver_inc_map[db_ver] = d
682 print "db.h: found", db_ver, "in", d
683 else:
684 # we already found a header for this library version
685 if db_setup_debug: print "db.h: ignoring", d
686 else:
687 # ignore this header, it didn't contain a version number
688 if db_setup_debug: print "db.h: unsupported version", db_ver, "in", d
689
690 db_found_vers = db_ver_inc_map.keys()
691 db_found_vers.sort()
692
693 while db_found_vers:
694 db_ver = db_found_vers.pop()
695 db_incdir = db_ver_inc_map[db_ver]
696
697 # check lib directories parallel to the location of the header
698 db_dirs_to_check = [
699 os.path.join(db_incdir, '..', 'lib64'),
700 os.path.join(db_incdir, '..', 'lib'),
701 os.path.join(db_incdir, '..', '..', 'lib64'),
702 os.path.join(db_incdir, '..', '..', 'lib'),
703 ]
704 db_dirs_to_check = filter(os.path.isdir, db_dirs_to_check)
705
706 # Look for a version specific db-X.Y before an ambiguoius dbX
707 # XXX should we -ever- look for a dbX name? Do any
708 # systems really not name their library by version and
709 # symlink to more general names?
710 for dblib in (('db-%d.%d' % db_ver),
711 ('db%d%d' % db_ver),
712 ('db%d' % db_ver[0])):
713 dblib_file = self.compiler.find_library_file(
714 db_dirs_to_check + lib_dirs, dblib )
715 if dblib_file:
716 dblib_dir = [ os.path.abspath(os.path.dirname(dblib_file)) ]
717 raise db_found
718 else:
719 if db_setup_debug: print "db lib: ", dblib, "not found"
720
721 except db_found:
722 print "db lib: using", db_ver, dblib
723 if db_setup_debug: print "db: lib dir", dblib_dir, "inc dir", db_incdir
724 db_incs = [db_incdir]
725 dblibs = [dblib]
726 # We add the runtime_library_dirs argument because the
727 # BerkeleyDB lib we're linking against often isn't in the
728 # system dynamic library search path. This is usually
729 # correct and most trouble free, but may cause problems in
730 # some unusual system configurations (e.g. the directory
731 # is on an NFS server that goes away).
732 exts.append(Extension('_bsddb', ['_bsddb.c'],
733 library_dirs=dblib_dir,
734 runtime_library_dirs=dblib_dir,
735 include_dirs=db_incs,
736 libraries=dblibs))
737 else:
738 if db_setup_debug: print "db: no appropriate library found"
739 db_incs = None
740 dblibs = []
741 dblib_dir = None
742
743 # The sqlite interface
744 sqlite_setup_debug = True # verbose debug prints from this script?
745
746 # We hunt for #define SQLITE_VERSION "n.n.n"
747 # We need to find >= sqlite version 3.0.8
748 sqlite_incdir = sqlite_libdir = None
749 sqlite_inc_paths = [ '/usr/include',
750 '/usr/include/sqlite',
751 '/usr/include/sqlite3',
752 '/usr/local/include',
753 '/usr/local/include/sqlite',
754 '/usr/local/include/sqlite3',
755 ]
756 MIN_SQLITE_VERSION_NUMBER = (3, 0, 8)
757 MIN_SQLITE_VERSION = ".".join([str(x)
758 for x in MIN_SQLITE_VERSION_NUMBER])
759
760 # Scan the default include directories before the SQLite specific
761 # ones. This allows one to override the copy of sqlite on OSX,
762 # where /usr/include contains an old version of sqlite.
763 for d in inc_dirs + sqlite_inc_paths:
764 f = os.path.join(d, "sqlite3.h")
765 if os.path.exists(f):
766 if sqlite_setup_debug: print "sqlite: found %s"%f
767 incf = open(f).read()
768 m = re.search(
769 r'\s*.*#\s*.*define\s.*SQLITE_VERSION\W*"(.*)"', incf)
770 if m:
771 sqlite_version = m.group(1)
772 sqlite_version_tuple = tuple([int(x)
773 for x in sqlite_version.split(".")])
774 if sqlite_version_tuple >= MIN_SQLITE_VERSION_NUMBER:
775 # we win!
776 print "%s/sqlite3.h: version %s"%(d, sqlite_version)
777 sqlite_incdir = d
778 break
779 else:
780 if sqlite_setup_debug:
781 print "%s: version %d is too old, need >= %s"%(d,
782 sqlite_version, MIN_SQLITE_VERSION)
783 elif sqlite_setup_debug:
784 print "sqlite: %s had no SQLITE_VERSION"%(f,)
785
786 if sqlite_incdir:
787 sqlite_dirs_to_check = [
788 os.path.join(sqlite_incdir, '..', 'lib64'),
789 os.path.join(sqlite_incdir, '..', 'lib'),
790 os.path.join(sqlite_incdir, '..', '..', 'lib64'),
791 os.path.join(sqlite_incdir, '..', '..', 'lib'),
792 ]
793 sqlite_libfile = self.compiler.find_library_file(
794 sqlite_dirs_to_check + lib_dirs, 'sqlite3')
795 sqlite_libdir = [os.path.abspath(os.path.dirname(sqlite_libfile))]
796
797 if sqlite_incdir and sqlite_libdir:
798 sqlite_srcs = ['_sqlite/cache.c',
799 '_sqlite/connection.c',
800 '_sqlite/cursor.c',
801 '_sqlite/microprotocols.c',
802 '_sqlite/module.c',
803 '_sqlite/prepare_protocol.c',
804 '_sqlite/row.c',
805 '_sqlite/statement.c',
806 '_sqlite/util.c', ]
807
808 sqlite_defines = []
809 if sys.platform != "win32":
810 sqlite_defines.append(('MODULE_NAME', '"sqlite3"'))
811 else:
812 sqlite_defines.append(('MODULE_NAME', '\\"sqlite3\\"'))
813
814
815 if sys.platform == 'darwin':
816 # In every directory on the search path search for a dynamic
817 # library and then a static library, instead of first looking
818 # for dynamic libraries on the entiry path.
819 # This way a staticly linked custom sqlite gets picked up
820 # before the dynamic library in /usr/lib.
821 sqlite_extra_link_args = ('-Wl,-search_paths_first',)
822 else:
823 sqlite_extra_link_args = ()
824
825 exts.append(Extension('_sqlite3', sqlite_srcs,
826 define_macros=sqlite_defines,
827 include_dirs=["Modules/_sqlite",
828 sqlite_incdir],
829 library_dirs=sqlite_libdir,
830 runtime_library_dirs=sqlite_libdir,
831 extra_link_args=sqlite_extra_link_args,
832 libraries=["sqlite3",]))
833
834 # Look for Berkeley db 1.85. Note that it is built as a different
835 # module name so it can be included even when later versions are
836 # available. A very restrictive search is performed to avoid
837 # accidentally building this module with a later version of the
838 # underlying db library. May BSD-ish Unixes incorporate db 1.85
839 # symbols into libc and place the include file in /usr/include.
840 f = "/usr/include/db.h"
841 if os.path.exists(f):
842 data = open(f).read()
843 m = re.search(r"#s*define\s+HASHVERSION\s+2\s*", data)
844 if m is not None:
845 # bingo - old version used hash file format version 2
846 ### XXX this should be fixed to not be platform-dependent
847 ### but I don't have direct access to an osf1 platform and
848 ### seemed to be muffing the search somehow
849 libraries = platform == "osf1" and ['db'] or None
850 if libraries is not None:
851 exts.append(Extension('bsddb185', ['bsddbmodule.c'],
852 libraries=libraries))
853 else:
854 exts.append(Extension('bsddb185', ['bsddbmodule.c']))
855
856 # The standard Unix dbm module:
857 if platform not in ['cygwin']:
858 if find_file("ndbm.h", inc_dirs, []) is not None:
859 # Some systems have -lndbm, others don't
860 if self.compiler.find_library_file(lib_dirs, 'ndbm'):
861 ndbm_libs = ['ndbm']
862 else:
863 ndbm_libs = []
864 exts.append( Extension('dbm', ['dbmmodule.c'],
865 define_macros=[('HAVE_NDBM_H',None)],
866 libraries = ndbm_libs ) )
867 elif (self.compiler.find_library_file(lib_dirs, 'gdbm')
868 and find_file("gdbm/ndbm.h", inc_dirs, []) is not None):
869 exts.append( Extension('dbm', ['dbmmodule.c'],
870 define_macros=[('HAVE_GDBM_NDBM_H',None)],
871 libraries = ['gdbm'] ) )
872 elif db_incs is not None:
873 exts.append( Extension('dbm', ['dbmmodule.c'],
874 library_dirs=dblib_dir,
875 runtime_library_dirs=dblib_dir,
876 include_dirs=db_incs,
877 define_macros=[('HAVE_BERKDB_H',None),
878 ('DB_DBM_HSEARCH',None)],
879 libraries=dblibs))
880
881 # Anthony Baxter's gdbm module. GNU dbm(3) will require -lgdbm:
882 if (self.compiler.find_library_file(lib_dirs, 'gdbm')):
883 exts.append( Extension('gdbm', ['gdbmmodule.c'],
884 libraries = ['gdbm'] ) )
885
886 # Unix-only modules
887 if platform not in ['mac', 'win32']:
888 # Steen Lumholt's termios module
889 exts.append( Extension('termios', ['termios.c']) )
890 # Jeremy Hylton's rlimit interface
891 if platform not in ['atheos']:
892 exts.append( Extension('resource', ['resource.c']) )
893
894 # Sun yellow pages. Some systems have the functions in libc.
895 if platform not in ['cygwin', 'atheos']:
896 if (self.compiler.find_library_file(lib_dirs, 'nsl')):
897 libs = ['nsl']
898 else:
899 libs = []
900 exts.append( Extension('nis', ['nismodule.c'],
901 libraries = libs) )
902
903 # Curses support, requiring the System V version of curses, often
904 # provided by the ncurses library.
905 panel_library = 'panel'
906 if (self.compiler.find_library_file(lib_dirs, 'ncursesw')):
907 curses_libs = ['ncursesw']
908 # Bug 1464056: If _curses.so links with ncursesw,
909 # _curses_panel.so must link with panelw.
910 panel_library = 'panelw'
911 exts.append( Extension('_curses', ['_cursesmodule.c'],
912 libraries = curses_libs) )
913 elif (self.compiler.find_library_file(lib_dirs, 'ncurses')):
914 curses_libs = ['ncurses']
915 exts.append( Extension('_curses', ['_cursesmodule.c'],
916 libraries = curses_libs) )
917 elif (self.compiler.find_library_file(lib_dirs, 'curses')
918 and platform != 'darwin'):
919 # OSX has an old Berkeley curses, not good enough for
920 # the _curses module.
921 if (self.compiler.find_library_file(lib_dirs, 'terminfo')):
922 curses_libs = ['curses', 'terminfo']
923 elif (self.compiler.find_library_file(lib_dirs, 'termcap')):
924 curses_libs = ['curses', 'termcap']
925 else:
926 curses_libs = ['curses']
927
928 exts.append( Extension('_curses', ['_cursesmodule.c'],
929 libraries = curses_libs) )
930
931 # If the curses module is enabled, check for the panel module
932 if (module_enabled(exts, '_curses') and
933 self.compiler.find_library_file(lib_dirs, panel_library)):
934 exts.append( Extension('_curses_panel', ['_curses_panel.c'],
935 libraries = [panel_library] + curses_libs) )
936
937
938 # Andrew Kuchling's zlib module. Note that some versions of zlib
939 # 1.1.3 have security problems. See CERT Advisory CA-2002-07:
940 # http://www.cert.org/advisories/CA-2002-07.html
941 #
942 # zlib 1.1.4 is fixed, but at least one vendor (RedHat) has decided to
943 # patch its zlib 1.1.3 package instead of upgrading to 1.1.4. For
944 # now, we still accept 1.1.3, because we think it's difficult to
945 # exploit this in Python, and we'd rather make it RedHat's problem
946 # than our problem <wink>.
947 #
948 # You can upgrade zlib to version 1.1.4 yourself by going to
949 # http://www.gzip.org/zlib/
950 zlib_inc = find_file('zlib.h', [], inc_dirs)
951 if zlib_inc is not None:
952 zlib_h = zlib_inc[0] + '/zlib.h'
953 version = '"0.0.0"'
954 version_req = '"1.1.3"'
955 fp = open(zlib_h)
956 while 1:
957 line = fp.readline()
958 if not line:
959 break
960 if line.startswith('#define ZLIB_VERSION'):
961 version = line.split()[2]
962 break
963 if version >= version_req:
964 if (self.compiler.find_library_file(lib_dirs, 'z')):
965 if sys.platform == "darwin":
966 zlib_extra_link_args = ('-Wl,-search_paths_first',)
967 else:
968 zlib_extra_link_args = ()
969 exts.append( Extension('zlib', ['zlibmodule.c'],
970 libraries = ['z'],
971 extra_link_args = zlib_extra_link_args))
972
973 # Gustavo Niemeyer's bz2 module.
974 if (self.compiler.find_library_file(lib_dirs, 'bz2')):
975 if sys.platform == "darwin":
976 bz2_extra_link_args = ('-Wl,-search_paths_first',)
977 else:
978 bz2_extra_link_args = ()
979 exts.append( Extension('bz2', ['bz2module.c'],
980 libraries = ['bz2'],
981 extra_link_args = bz2_extra_link_args) )
982
983 # Interface to the Expat XML parser
984 #
985 # Expat was written by James Clark and is now maintained by a
986 # group of developers on SourceForge; see www.libexpat.org for
987 # more information. The pyexpat module was written by Paul
988 # Prescod after a prototype by Jack Jansen. The Expat source
989 # is included in Modules/expat/. Usage of a system
990 # shared libexpat.so/expat.dll is not advised.
991 #
992 # More information on Expat can be found at www.libexpat.org.
993 #
994 expatinc = os.path.join(os.getcwd(), srcdir, 'Modules', 'expat')
995 define_macros = [
996 ('HAVE_EXPAT_CONFIG_H', '1'),
997 ]
998
999 exts.append(Extension('pyexpat',
1000 define_macros = define_macros,
1001 include_dirs = [expatinc],
1002 sources = ['pyexpat.c',
1003 'expat/xmlparse.c',
1004 'expat/xmlrole.c',
1005 'expat/xmltok.c',
1006 ],
1007 ))
1008
1009 # Fredrik Lundh's cElementTree module. Note that this also
1010 # uses expat (via the CAPI hook in pyexpat).
1011
1012 if os.path.isfile(os.path.join(srcdir, 'Modules', '_elementtree.c')):
1013 define_macros.append(('USE_PYEXPAT_CAPI', None))
1014 exts.append(Extension('_elementtree',
1015 define_macros = define_macros,
1016 include_dirs = [expatinc],
1017 sources = ['_elementtree.c'],
1018 ))
1019
1020 # Hye-Shik Chang's CJKCodecs modules.
1021 if have_unicode:
1022 exts.append(Extension('_multibytecodec',
1023 ['cjkcodecs/multibytecodec.c']))
1024 for loc in ('kr', 'jp', 'cn', 'tw', 'hk', 'iso2022'):
1025 exts.append(Extension('_codecs_' + loc,
1026 ['cjkcodecs/_codecs_%s.c' % loc]))
1027
1028 # Dynamic loading module
1029 if sys.maxint == 0x7fffffff:
1030 # This requires sizeof(int) == sizeof(long) == sizeof(char*)
1031 dl_inc = find_file('dlfcn.h', [], inc_dirs)
1032 if (dl_inc is not None) and (platform not in ['atheos']):
1033 exts.append( Extension('dl', ['dlmodule.c']) )
1034
1035 # Thomas Heller's _ctypes module
1036 self.detect_ctypes(inc_dirs, lib_dirs)
1037
1038 # Platform-specific libraries
1039 if platform == 'linux2':
1040 # Linux-specific modules
1041 exts.append( Extension('linuxaudiodev', ['linuxaudiodev.c']) )
1042
1043 if platform in ('linux2', 'freebsd4', 'freebsd5', 'freebsd6',
1044 'freebsd7'):
1045 exts.append( Extension('ossaudiodev', ['ossaudiodev.c']) )
1046
1047 if platform == 'sunos5':
1048 # SunOS specific modules
1049 exts.append( Extension('sunaudiodev', ['sunaudiodev.c']) )
1050
1051 if platform == 'darwin' and ("--disable-toolbox-glue" not in
1052 sysconfig.get_config_var("CONFIG_ARGS")):
1053
1054 if os.uname()[2] > '8.':
1055 # We're on Mac OS X 10.4 or later, the compiler should
1056 # support '-Wno-deprecated-declarations'. This will
1057 # surpress deprecation warnings for the Carbon extensions,
1058 # these extensions wrap the Carbon APIs and even those
1059 # parts that are deprecated.
1060 carbon_extra_compile_args = ['-Wno-deprecated-declarations']
1061 else:
1062 carbon_extra_compile_args = []
1063
1064 # Mac OS X specific modules.
1065 def macSrcExists(name1, name2=''):
1066 if not name1:
1067 return None
1068 names = (name1,)
1069 if name2:
1070 names = (name1, name2)
1071 path = os.path.join(srcdir, 'Mac', 'Modules', *names)
1072 return os.path.exists(path)
1073
1074 def addMacExtension(name, kwds, extra_srcs=[]):
1075 dirname = ''
1076 if name[0] == '_':
1077 dirname = name[1:].lower()
1078 cname = name + '.c'
1079 cmodulename = name + 'module.c'
1080 # Check for NNN.c, NNNmodule.c, _nnn/NNN.c, _nnn/NNNmodule.c
1081 if macSrcExists(cname):
1082 srcs = [cname]
1083 elif macSrcExists(cmodulename):
1084 srcs = [cmodulename]
1085 elif macSrcExists(dirname, cname):
1086 # XXX(nnorwitz): If all the names ended with module, we
1087 # wouldn't need this condition. ibcarbon is the only one.
1088 srcs = [os.path.join(dirname, cname)]
1089 elif macSrcExists(dirname, cmodulename):
1090 srcs = [os.path.join(dirname, cmodulename)]
1091 else:
1092 raise RuntimeError("%s not found" % name)
1093
1094 # Here's the whole point: add the extension with sources
1095 exts.append(Extension(name, srcs + extra_srcs, **kwds))
1096
1097 # Core Foundation
1098 core_kwds = {'extra_compile_args': carbon_extra_compile_args,
1099 'extra_link_args': ['-framework', 'CoreFoundation'],
1100 }
1101 addMacExtension('_CF', core_kwds, ['cf/pycfbridge.c'])
1102 addMacExtension('autoGIL', core_kwds)
1103
1104 # Carbon
1105 carbon_kwds = {'extra_compile_args': carbon_extra_compile_args,
1106 'extra_link_args': ['-framework', 'Carbon'],
1107 }
1108 CARBON_EXTS = ['ColorPicker', 'gestalt', 'MacOS', 'Nav',
1109 'OSATerminology', 'icglue',
1110 # All these are in subdirs
1111 '_AE', '_AH', '_App', '_CarbonEvt', '_Cm', '_Ctl',
1112 '_Dlg', '_Drag', '_Evt', '_File', '_Folder', '_Fm',
1113 '_Help', '_Icn', '_IBCarbon', '_List',
1114 '_Menu', '_Mlte', '_OSA', '_Res', '_Qd', '_Qdoffs',
1115 '_Scrap', '_Snd', '_TE', '_Win',
1116 ]
1117 for name in CARBON_EXTS:
1118 addMacExtension(name, carbon_kwds)
1119
1120 # Application Services & QuickTime
1121 app_kwds = {'extra_compile_args': carbon_extra_compile_args,
1122 'extra_link_args': ['-framework','ApplicationServices'],
1123 }
1124 addMacExtension('_Launch', app_kwds)
1125 addMacExtension('_CG', app_kwds)
1126
1127 exts.append( Extension('_Qt', ['qt/_Qtmodule.c'],
1128 extra_compile_args=carbon_extra_compile_args,
1129 extra_link_args=['-framework', 'QuickTime',
1130 '-framework', 'Carbon']) )
1131
1132
1133 self.extensions.extend(exts)
1134
1135 # Call the method for detecting whether _tkinter can be compiled
1136 self.detect_tkinter(inc_dirs, lib_dirs)
1137
1138 def detect_tkinter_darwin(self, inc_dirs, lib_dirs):
1139 # The _tkinter module, using frameworks. Since frameworks are quite
1140 # different the UNIX search logic is not sharable.
1141 from os.path import join, exists
1142 framework_dirs = [
1143 '/System/Library/Frameworks/',
1144 '/Library/Frameworks',
1145 join(os.getenv('HOME'), '/Library/Frameworks')
1146 ]
1147
1148 # Find the directory that contains the Tcl.framework and Tk.framework
1149 # bundles.
1150 # XXX distutils should support -F!
1151 for F in framework_dirs:
1152 # both Tcl.framework and Tk.framework should be present
1153 for fw in 'Tcl', 'Tk':
1154 if not exists(join(F, fw + '.framework')):
1155 break
1156 else:
1157 # ok, F is now directory with both frameworks. Continure
1158 # building
1159 break
1160 else:
1161 # Tk and Tcl frameworks not found. Normal "unix" tkinter search
1162 # will now resume.
1163 return 0
1164
1165 # For 8.4a2, we must add -I options that point inside the Tcl and Tk
1166 # frameworks. In later release we should hopefully be able to pass
1167 # the -F option to gcc, which specifies a framework lookup path.
1168 #
1169 include_dirs = [
1170 join(F, fw + '.framework', H)
1171 for fw in 'Tcl', 'Tk'
1172 for H in 'Headers', 'Versions/Current/PrivateHeaders'
1173 ]
1174
1175 # For 8.4a2, the X11 headers are not included. Rather than include a
1176 # complicated search, this is a hard-coded path. It could bail out
1177 # if X11 libs are not found...
1178 include_dirs.append('/usr/X11R6/include')
1179 frameworks = ['-framework', 'Tcl', '-framework', 'Tk']
1180
1181 ext = Extension('_tkinter', ['_tkinter.c', 'tkappinit.c'],
1182 define_macros=[('WITH_APPINIT', 1)],
1183 include_dirs = include_dirs,
1184 libraries = [],
1185 extra_compile_args = frameworks,
1186 extra_link_args = frameworks,
1187 )
1188 self.extensions.append(ext)
1189 return 1
1190
1191
1192 def detect_tkinter(self, inc_dirs, lib_dirs):
1193 # The _tkinter module.
1194
1195 # Rather than complicate the code below, detecting and building
1196 # AquaTk is a separate method. Only one Tkinter will be built on
1197 # Darwin - either AquaTk, if it is found, or X11 based Tk.
1198 platform = self.get_platform()
1199 if (platform == 'darwin' and
1200 self.detect_tkinter_darwin(inc_dirs, lib_dirs)):
1201 return
1202
1203 # Assume we haven't found any of the libraries or include files
1204 # The versions with dots are used on Unix, and the versions without
1205 # dots on Windows, for detection by cygwin.
1206 tcllib = tklib = tcl_includes = tk_includes = None
1207 for version in ['8.5', '85', '8.4', '84', '8.3', '83', '8.2',
1208 '82', '8.1', '81', '8.0', '80']:
1209 tklib = self.compiler.find_library_file(lib_dirs, 'tk' + version)
1210 tcllib = self.compiler.find_library_file(lib_dirs, 'tcl' + version)
1211 if tklib and tcllib:
1212 # Exit the loop when we've found the Tcl/Tk libraries
1213 break
1214
1215 # Now check for the header files
1216 if tklib and tcllib:
1217 # Check for the include files on Debian and {Free,Open}BSD, where
1218 # they're put in /usr/include/{tcl,tk}X.Y
1219 dotversion = version
1220 if '.' not in dotversion and "bsd" in sys.platform.lower():
1221 # OpenBSD and FreeBSD use Tcl/Tk library names like libtcl83.a,
1222 # but the include subdirs are named like .../include/tcl8.3.
1223 dotversion = dotversion[:-1] + '.' + dotversion[-1]
1224 tcl_include_sub = []
1225 tk_include_sub = []
1226 for dir in inc_dirs:
1227 tcl_include_sub += [dir + os.sep + "tcl" + dotversion]
1228 tk_include_sub += [dir + os.sep + "tk" + dotversion]
1229 tk_include_sub += tcl_include_sub
1230 tcl_includes = find_file('tcl.h', inc_dirs, tcl_include_sub)
1231 tk_includes = find_file('tk.h', inc_dirs, tk_include_sub)
1232
1233 if (tcllib is None or tklib is None or
1234 tcl_includes is None or tk_includes is None):
1235 self.announce("INFO: Can't locate Tcl/Tk libs and/or headers", 2)
1236 return
1237
1238 # OK... everything seems to be present for Tcl/Tk.
1239
1240 include_dirs = [] ; libs = [] ; defs = [] ; added_lib_dirs = []
1241 for dir in tcl_includes + tk_includes:
1242 if dir not in include_dirs:
1243 include_dirs.append(dir)
1244
1245 # Check for various platform-specific directories
1246 if platform == 'sunos5':
1247 include_dirs.append('/usr/openwin/include')
1248 added_lib_dirs.append('/usr/openwin/lib')
1249 elif os.path.exists('/usr/X11R6/include'):
1250 include_dirs.append('/usr/X11R6/include')
1251 added_lib_dirs.append('/usr/X11R6/lib64')
1252 added_lib_dirs.append('/usr/X11R6/lib')
1253 elif os.path.exists('/usr/X11R5/include'):
1254 include_dirs.append('/usr/X11R5/include')
1255 added_lib_dirs.append('/usr/X11R5/lib')
1256 else:
1257 # Assume default location for X11
1258 include_dirs.append('/usr/X11/include')
1259 added_lib_dirs.append('/usr/X11/lib')
1260
1261 # If Cygwin, then verify that X is installed before proceeding
1262 if platform == 'cygwin':
1263 x11_inc = find_file('X11/Xlib.h', [], include_dirs)
1264 if x11_inc is None:
1265 return
1266
1267 # Check for BLT extension
1268 if self.compiler.find_library_file(lib_dirs + added_lib_dirs,
1269 'BLT8.0'):
1270 defs.append( ('WITH_BLT', 1) )
1271 libs.append('BLT8.0')
1272 elif self.compiler.find_library_file(lib_dirs + added_lib_dirs,
1273 'BLT'):
1274 defs.append( ('WITH_BLT', 1) )
1275 libs.append('BLT')
1276
1277 # Add the Tcl/Tk libraries
1278 libs.append('tk'+ version)
1279 libs.append('tcl'+ version)
1280
1281 if platform in ['aix3', 'aix4']:
1282 libs.append('ld')
1283
1284 # Finally, link with the X11 libraries (not appropriate on cygwin)
1285 if platform != "cygwin":
1286 libs.append('X11')
1287
1288 ext = Extension('_tkinter', ['_tkinter.c', 'tkappinit.c'],
1289 define_macros=[('WITH_APPINIT', 1)] + defs,
1290 include_dirs = include_dirs,
1291 libraries = libs,
1292 library_dirs = added_lib_dirs,
1293 )
1294 self.extensions.append(ext)
1295
1296## # Uncomment these lines if you want to play with xxmodule.c
1297## ext = Extension('xx', ['xxmodule.c'])
1298## self.extensions.append(ext)
1299
1300 # XXX handle these, but how to detect?
1301 # *** Uncomment and edit for PIL (TkImaging) extension only:
1302 # -DWITH_PIL -I../Extensions/Imaging/libImaging tkImaging.c \
1303 # *** Uncomment and edit for TOGL extension only:
1304 # -DWITH_TOGL togl.c \
1305 # *** Uncomment these for TOGL extension only:
1306 # -lGL -lGLU -lXext -lXmu \
1307
1308 def configure_ctypes(self, ext):
1309 if not self.use_system_libffi:
1310 (srcdir,) = sysconfig.get_config_vars('srcdir')
1311 ffi_builddir = os.path.join(self.build_temp, 'libffi')
1312 ffi_srcdir = os.path.abspath(os.path.join(srcdir, 'Modules',
1313 '_ctypes', 'libffi'))
1314 ffi_configfile = os.path.join(ffi_builddir, 'fficonfig.py')
1315
1316 from distutils.dep_util import newer_group
1317
1318 config_sources = [os.path.join(ffi_srcdir, fname)
1319 for fname in os.listdir(ffi_srcdir)]
1320 if self.force or newer_group(config_sources,
1321 ffi_configfile):
1322 from distutils.dir_util import mkpath
1323 mkpath(ffi_builddir)
1324 config_args = []
1325
1326 # Pass empty CFLAGS because we'll just append the resulting
1327 # CFLAGS to Python's; -g or -O2 is to be avoided.
1328 cmd = "cd %s && env CFLAGS='' '%s/configure' %s" \
1329 % (ffi_builddir, ffi_srcdir, " ".join(config_args))
1330
1331 res = os.system(cmd)
1332 if res or not os.path.exists(ffi_configfile):
1333 print "Failed to configure _ctypes module"
1334 return False
1335
1336 fficonfig = {}
1337 execfile(ffi_configfile, globals(), fficonfig)
1338 ffi_srcdir = os.path.join(fficonfig['ffi_srcdir'], 'src')
1339
1340 # Add .S (preprocessed assembly) to C compiler source extensions.
1341 self.compiler.src_extensions.append('.S')
1342
1343 include_dirs = [os.path.join(ffi_builddir, 'include'),
1344 ffi_builddir, ffi_srcdir]
1345 extra_compile_args = fficonfig['ffi_cflags'].split()
1346
1347 ext.sources.extend(fficonfig['ffi_sources'])
1348 ext.include_dirs.extend(include_dirs)
1349 ext.extra_compile_args.extend(extra_compile_args)
1350 return True
1351
1352 def detect_ctypes(self, inc_dirs, lib_dirs):
1353 self.use_system_libffi = False
1354 include_dirs = []
1355 extra_compile_args = []
1356 extra_link_args = []
1357 sources = ['_ctypes/_ctypes.c',
1358 '_ctypes/callbacks.c',
1359 '_ctypes/callproc.c',
1360 '_ctypes/stgdict.c',
1361 '_ctypes/cfield.c',
1362 '_ctypes/malloc_closure.c']
1363 depends = ['_ctypes/ctypes.h']
1364
1365 if sys.platform == 'darwin':
1366 sources.append('_ctypes/darwin/dlfcn_simple.c')
1367 include_dirs.append('_ctypes/darwin')
1368# XXX Is this still needed?
1369## extra_link_args.extend(['-read_only_relocs', 'warning'])
1370
1371 elif sys.platform == 'sunos5':
1372 # XXX This shouldn't be necessary; it appears that some
1373 # of the assembler code is non-PIC (i.e. it has relocations
1374 # when it shouldn't. The proper fix would be to rewrite
1375 # the assembler code to be PIC.
1376 # This only works with GCC; the Sun compiler likely refuses
1377 # this option. If you want to compile ctypes with the Sun
1378 # compiler, please research a proper solution, instead of
1379 # finding some -z option for the Sun compiler.
1380 extra_link_args.append('-mimpure-text')
1381
1382 ext = Extension('_ctypes',
1383 include_dirs=include_dirs,
1384 extra_compile_args=extra_compile_args,
1385 extra_link_args=extra_link_args,
1386 libraries=[],
1387 sources=sources,
1388 depends=depends)
1389 ext_test = Extension('_ctypes_test',
1390 sources=['_ctypes/_ctypes_test.c'])
1391 self.extensions.extend([ext, ext_test])
1392
1393 if not '--with-system-ffi' in sysconfig.get_config_var("CONFIG_ARGS"):
1394 return
1395
1396 ffi_inc = find_file('ffi.h', [], inc_dirs)
1397 if ffi_inc is not None:
1398 ffi_h = ffi_inc[0] + '/ffi.h'
1399 fp = open(ffi_h)
1400 while 1:
1401 line = fp.readline()
1402 if not line:
1403 ffi_inc = None
1404 break
1405 if line.startswith('#define LIBFFI_H'):
1406 break
1407 ffi_lib = None
1408 if ffi_inc is not None:
1409 for lib_name in ('ffi_convenience', 'ffi_pic', 'ffi'):
1410 if (self.compiler.find_library_file(lib_dirs, lib_name)):
1411 ffi_lib = lib_name
1412 break
1413
1414 if ffi_inc and ffi_lib:
1415 ext.include_dirs.extend(ffi_inc)
1416 ext.libraries.append(ffi_lib)
1417 self.use_system_libffi = True
1418
1419
1420class PyBuildInstall(install):
1421 # Suppress the warning about installation into the lib_dynload
1422 # directory, which is not in sys.path when running Python during
1423 # installation:
1424 def initialize_options (self):
1425 install.initialize_options(self)
1426 self.warn_dir=0
1427
1428class PyBuildInstallLib(install_lib):
1429 # Do exactly what install_lib does but make sure correct access modes get
1430 # set on installed directories and files. All installed files with get
1431 # mode 644 unless they are a shared library in which case they will get
1432 # mode 755. All installed directories will get mode 755.
1433
1434 so_ext = sysconfig.get_config_var("SO")
1435
1436 def install(self):
1437 outfiles = install_lib.install(self)
1438 self.set_file_modes(outfiles, 0644, 0755)
1439 self.set_dir_modes(self.install_dir, 0755)
1440 return outfiles
1441
1442 def set_file_modes(self, files, defaultMode, sharedLibMode):
1443 if not self.is_chmod_supported(): return
1444 if not files: return
1445
1446 for filename in files:
1447 if os.path.islink(filename): continue
1448 mode = defaultMode
1449 if filename.endswith(self.so_ext): mode = sharedLibMode
1450 log.info("changing mode of %s to %o", filename, mode)
1451 if not self.dry_run: os.chmod(filename, mode)
1452
1453 def set_dir_modes(self, dirname, mode):
1454 if not self.is_chmod_supported(): return
1455 os.path.walk(dirname, self.set_dir_modes_visitor, mode)
1456
1457 def set_dir_modes_visitor(self, mode, dirname, names):
1458 if os.path.islink(dirname): return
1459 log.info("changing mode of %s to %o", dirname, mode)
1460 if not self.dry_run: os.chmod(dirname, mode)
1461
1462 def is_chmod_supported(self):
1463 return hasattr(os, 'chmod')
1464
1465SUMMARY = """
1466Python is an interpreted, interactive, object-oriented programming
1467language. It is often compared to Tcl, Perl, Scheme or Java.
1468
1469Python combines remarkable power with very clear syntax. It has
1470modules, classes, exceptions, very high level dynamic data types, and
1471dynamic typing. There are interfaces to many system calls and
1472libraries, as well as to various windowing systems (X11, Motif, Tk,
1473Mac, MFC). New built-in modules are easily written in C or C++. Python
1474is also usable as an extension language for applications that need a
1475programmable interface.
1476
1477The Python implementation is portable: it runs on many brands of UNIX,
1478on Windows, DOS, OS/2, Mac, Amiga... If your favorite system isn't
1479listed here, it may still be supported, if there's a C compiler for
1480it. Ask around on comp.lang.python -- or just try compiling Python
1481yourself.
1482"""
1483
1484CLASSIFIERS = """
1485Development Status :: 3 - Alpha
1486Development Status :: 6 - Mature
1487License :: OSI Approved :: Python Software Foundation License
1488Natural Language :: English
1489Programming Language :: C
1490Programming Language :: Python
1491Topic :: Software Development
1492"""
1493
1494def main():
1495 # turn off warnings when deprecated modules are imported
1496 import warnings
1497 warnings.filterwarnings("ignore",category=DeprecationWarning)
1498 setup(# PyPI Metadata (PEP 301)
1499 name = "Python",
1500 version = sys.version.split()[0],
1501 url = "http://www.python.org/%s" % sys.version[:3],
1502 maintainer = "Guido van Rossum and the Python community",
1503 maintainer_email = "python-dev@python.org",
1504 description = "A high-level object-oriented programming language",
1505 long_description = SUMMARY.strip(),
1506 license = "PSF license",
1507 classifiers = filter(None, CLASSIFIERS.split("\n")),
1508 platforms = ["Many"],
1509
1510 # Build info
1511 cmdclass = {'build_ext':PyBuildExt, 'install':PyBuildInstall,
1512 'install_lib':PyBuildInstallLib},
1513 # The struct module is defined here, because build_ext won't be
1514 # called unless there's at least one extension module defined.
1515 ext_modules=[Extension('_struct', ['_struct.c'])],
1516
1517 # Scripts to install
1518 scripts = ['Tools/scripts/pydoc', 'Tools/scripts/idle',
1519 'Lib/smtpd.py']
1520 )
1521
1522# --install-platlib
1523if __name__ == '__main__':
1524 main()
Note: See TracBrowser for help on using the repository browser.