| blob | ee95e8ad27a0ef1997559ea06b0facff20f254a1 |
1 dnl ***********************************************
2 dnl * Please run autoreconf to test your changes! *
3 dnl ***********************************************
4 dnl NOTE: autoconf 2.64 doesn't seem to work (use 2.61).
6 # Set VERSION so we only need to edit in one place (i.e., here)
7 m4_define(PYTHON_VERSION, 2.7)
9 dnl Some m4 magic to ensure that the configure script is generated
10 dnl by the correct autoconf version.
11 m4_define([version_required],
12 [m4_if(m4_version_compare(m4_defn([m4_PACKAGE_VERSION]), [$1]), 0,
13 [],
14 [m4_fatal([Autoconf version $1 is required for Python], 63)])
15 ])
16 version_required(2.61)
18 AC_REVISION($Revision$)
19 AC_INIT(python, PYTHON_VERSION, http://bugs.python.org/)
20 AC_CONFIG_SRCDIR([Include/object.h])
21 AC_CONFIG_HEADER(pyconfig.h)
23 dnl Ensure that if prefix is specified, it does not end in a slash. If
24 dnl it does, we get path names containing '//' which is both ugly and
25 dnl can cause trouble.
27 dnl Last slash shouldn't be stripped if prefix=/
28 if test "$prefix" != "/"; then
29 prefix=`echo "$prefix" | sed -e 's/\/$//g'`
30 fi
32 dnl This is for stuff that absolutely must end up in pyconfig.h.
33 dnl Please use pyport.h instead, if possible.
34 AH_TOP([
35 #ifndef Py_PYCONFIG_H
36 #define Py_PYCONFIG_H
37 ])
38 AH_BOTTOM([
39 /* Define the macros needed if on a UnixWare 7.x system. */
40 #if defined(__USLC__) && defined(__SCO_VERSION__)
41 #define STRICT_SYSV_CURSES /* Don't use ncurses extensions */
42 #endif
44 #endif /*Py_PYCONFIG_H*/
45 ])
47 # We don't use PACKAGE_ variables, and they cause conflicts
48 # with other autoconf-based packages that include Python.h
49 grep -v 'define PACKAGE_' <confdefs.h >confdefs.h.new
50 rm confdefs.h
51 mv confdefs.h.new confdefs.h
53 AC_SUBST(VERSION)
54 VERSION=PYTHON_VERSION
56 AC_SUBST(SOVERSION)
57 SOVERSION=1.0
59 # The later defininition of _XOPEN_SOURCE disables certain features
60 # on Linux, so we need _GNU_SOURCE to re-enable them (makedev, tm_zone).
61 AC_DEFINE(_GNU_SOURCE, 1, [Define on Linux to activate all library features])
63 # The later defininition of _XOPEN_SOURCE and _POSIX_C_SOURCE disables
64 # certain features on NetBSD, so we need _NETBSD_SOURCE to re-enable
65 # them.
66 AC_DEFINE(_NETBSD_SOURCE, 1, [Define on NetBSD to activate all library features])
68 # The later defininition of _XOPEN_SOURCE and _POSIX_C_SOURCE disables
69 # certain features on FreeBSD, so we need __BSD_VISIBLE to re-enable
70 # them.
71 AC_DEFINE(__BSD_VISIBLE, 1, [Define on FreeBSD to activate all library features])
73 # The later defininition of _XOPEN_SOURCE and _POSIX_C_SOURCE disables
74 # u_int on Irix 5.3. Defining _BSD_TYPES brings it back.
75 AC_DEFINE(_BSD_TYPES, 1, [Define on Irix to enable u_int])
77 # The later defininition of _XOPEN_SOURCE and _POSIX_C_SOURCE disables
78 # certain features on Mac OS X, so we need _DARWIN_C_SOURCE to re-enable
79 # them.
80 AC_DEFINE(_DARWIN_C_SOURCE, 1, [Define on Darwin to activate all library features])
83 define_xopen_source=yes
85 # Arguments passed to configure.
86 AC_SUBST(CONFIG_ARGS)
87 CONFIG_ARGS="$ac_configure_args"
89 AC_ARG_ENABLE(universalsdk,
90 AC_HELP_STRING(--enable-universalsdk@<:@=SDKDIR@:>@, Build against Mac OS X 10.4u SDK (ppc/i386)),
91 [
92 case $enableval in
93 yes)
94 enableval=/Developer/SDKs/MacOSX10.4u.sdk
95 ;;
96 esac
97 case $enableval in
98 no)
99 UNIVERSALSDK=
100 enable_universalsdk=
101 ;;
102 *)
103 UNIVERSALSDK=$enableval
104 ;;
105 esac
106 ],[
107 UNIVERSALSDK=
108 enable_universalsdk=
109 ])
110 AC_SUBST(UNIVERSALSDK)
112 AC_SUBST(ARCH_RUN_32BIT)
114 UNIVERSAL_ARCHS="32-bit"
115 AC_MSG_CHECKING(for --with-universal-archs)
116 AC_ARG_WITH(universal-archs,
117 AC_HELP_STRING(--with-universal-archs=ARCH, select architectures for universal build ("32-bit", "64-bit", "3-way", "intel" or "all")),
118 [
119 AC_MSG_RESULT($withval)
120 UNIVERSAL_ARCHS="$withval"
121 ],
122 [
123 AC_MSG_RESULT(32-bit)
124 ])
128 AC_ARG_WITH(framework-name,
129 AC_HELP_STRING(--with-framework-name=FRAMEWORK,
130 specify an alternate name of the framework built with --enable-framework),
131 [
132 PYTHONFRAMEWORK=${withval}
133 PYTHONFRAMEWORKDIR=${withval}.framework
134 PYTHONFRAMEWORKIDENTIFIER=org.python.`echo $withval | tr '[A-Z]' '[a-z]'`
135 ],[
136 PYTHONFRAMEWORK=Python
137 PYTHONFRAMEWORKDIR=Python.framework
138 PYTHONFRAMEWORKIDENTIFIER=org.python.python
139 ])
140 dnl quadrigraphs "@<:@" and "@:>@" produce "[" and "]" in the output
141 AC_ARG_ENABLE(framework,
142 AC_HELP_STRING(--enable-framework@<:@=INSTALLDIR@:>@, Build (MacOSX|Darwin) framework),
143 [
144 case $enableval in
145 yes)
146 enableval=/Library/Frameworks
147 esac
148 case $enableval in
149 no)
150 PYTHONFRAMEWORK=
151 PYTHONFRAMEWORKDIR=no-framework
152 PYTHONFRAMEWORKPREFIX=
153 PYTHONFRAMEWORKINSTALLDIR=
154 FRAMEWORKINSTALLFIRST=
155 FRAMEWORKINSTALLLAST=
156 FRAMEWORKALTINSTALLFIRST=
157 FRAMEWORKALTINSTALLLAST=
158 if test "x${prefix}" = "xNONE"; then
159 FRAMEWORKUNIXTOOLSPREFIX="${ac_default_prefix}"
160 else
161 FRAMEWORKUNIXTOOLSPREFIX="${prefix}"
162 fi
163 enable_framework=
164 ;;
165 *)
166 PYTHONFRAMEWORKPREFIX=$enableval
167 PYTHONFRAMEWORKINSTALLDIR=$PYTHONFRAMEWORKPREFIX/$PYTHONFRAMEWORKDIR
168 FRAMEWORKINSTALLFIRST="frameworkinstallstructure"
169 FRAMEWORKALTINSTALLFIRST="frameworkinstallstructure bininstall maninstall"
170 if test "$UNIVERSAL_ARCHS" = "all"
171 then
172 FRAMEWORKINSTALLLAST="frameworkinstallmaclib frameworkinstallapps4way frameworkinstallunixtools4way"
173 FRAMEWORKALTINSTALLLAST="frameworkinstallmaclib frameworkinstallapps4way frameworkaltinstallunixtools4way"
174 else
175 FRAMEWORKINSTALLLAST="frameworkinstallmaclib frameworkinstallapps frameworkinstallunixtools"
176 FRAMEWORKALTINSTALLLAST="frameworkinstallmaclib frameworkinstallapps frameworkaltinstallunixtools"
177 fi
179 if test "x${prefix}" = "xNONE" ; then
180 FRAMEWORKUNIXTOOLSPREFIX="${ac_default_prefix}"
181 else
182 FRAMEWORKUNIXTOOLSPREFIX="${prefix}"
183 fi
184 prefix=$PYTHONFRAMEWORKINSTALLDIR/Versions/$VERSION
186 # Add files for Mac specific code to the list of output
187 # files:
188 AC_CONFIG_FILES(Mac/Makefile)
189 AC_CONFIG_FILES(Mac/PythonLauncher/Makefile)
190 AC_CONFIG_FILES(Mac/IDLE/Makefile)
191 AC_CONFIG_FILES(Mac/Resources/framework/Info.plist)
192 AC_CONFIG_FILES(Mac/Resources/app/Info.plist)
193 esac
194 ],[
195 PYTHONFRAMEWORK=
196 PYTHONFRAMEWORKDIR=no-framework
197 PYTHONFRAMEWORKPREFIX=
198 PYTHONFRAMEWORKINSTALLDIR=
199 FRAMEWORKINSTALLFIRST=
200 FRAMEWORKINSTALLLAST=
201 FRAMEWORKALTINSTALLFIRST=
202 FRAMEWORKALTINSTALLLAST=
203 if test "x${prefix}" = "xNONE" ; then
204 FRAMEWORKUNIXTOOLSPREFIX="${ac_default_prefix}"
205 else
206 FRAMEWORKUNIXTOOLSPREFIX="${prefix}"
207 fi
208 enable_framework=
210 if test "$UNIVERSAL_ARCHS" = "all"
211 then
212 FRAMEWORKINSTALLLAST=update4wayuniversal
213 FRAMEWORKALTINSTALLLAST=update4wayuniversal
214 fi
215 ])
216 AC_SUBST(PYTHONFRAMEWORK)
217 AC_SUBST(PYTHONFRAMEWORKIDENTIFIER)
218 AC_SUBST(PYTHONFRAMEWORKDIR)
219 AC_SUBST(PYTHONFRAMEWORKPREFIX)
220 AC_SUBST(PYTHONFRAMEWORKINSTALLDIR)
221 AC_SUBST(FRAMEWORKINSTALLFIRST)
222 AC_SUBST(FRAMEWORKINSTALLLAST)
223 AC_SUBST(FRAMEWORKALTINSTALLFIRST)
224 AC_SUBST(FRAMEWORKALTINSTALLLAST)
225 AC_SUBST(FRAMEWORKUNIXTOOLSPREFIX)
227 ##AC_ARG_WITH(dyld,
228 ## AC_HELP_STRING(--with-dyld,
229 ## Use (OpenStep|Rhapsody) dynamic linker))
230 ##
231 # Set name for machine-dependent library files
232 AC_SUBST(MACHDEP)
233 AC_MSG_CHECKING(MACHDEP)
234 if test -z "$MACHDEP"
235 then
236 ac_sys_system=`uname -s`
237 if test "$ac_sys_system" = "AIX" \
238 -o "$ac_sys_system" = "UnixWare" -o "$ac_sys_system" = "OpenUNIX"; then
239 ac_sys_release=`uname -v`
240 else
241 ac_sys_release=`uname -r`
242 fi
243 ac_md_system=`echo $ac_sys_system |
244 tr -d '[/ ]' | tr '[[A-Z]]' '[[a-z]]'`
245 ac_md_release=`echo $ac_sys_release |
246 tr -d '[/ ]' | sed 's/^[[A-Z]]\.//' | sed 's/\..*//'`
247 MACHDEP="$ac_md_system$ac_md_release"
249 case $MACHDEP in
250 cygwin*) MACHDEP="cygwin";;
251 darwin*) MACHDEP="darwin";;
252 atheos*) MACHDEP="atheos";;
253 irix646) MACHDEP="irix6";;
254 '') MACHDEP="unknown";;
255 esac
256 fi
258 # Some systems cannot stand _XOPEN_SOURCE being defined at all; they
259 # disable features if it is defined, without any means to access these
260 # features as extensions. For these systems, we skip the definition of
261 # _XOPEN_SOURCE. Before adding a system to the list to gain access to
262 # some feature, make sure there is no alternative way to access this
263 # feature. Also, when using wildcards, make sure you have verified the
264 # need for not defining _XOPEN_SOURCE on all systems matching the
265 # wildcard, and that the wildcard does not include future systems
266 # (which may remove their limitations).
267 dnl quadrigraphs "@<:@" and "@:>@" produce "[" and "]" in the output
268 case $ac_sys_system/$ac_sys_release in
269 # On OpenBSD, select(2) is not available if _XOPEN_SOURCE is defined,
270 # even though select is a POSIX function. Reported by J. Ribbens.
271 # Reconfirmed for OpenBSD 3.3 by Zachary Hamm, for 3.4 by Jason Ish.
272 OpenBSD/2.* | OpenBSD/3.@<:@0123456789@:>@ | OpenBSD/4.@<:@0123@:>@)
273 define_xopen_source=no
274 # OpenBSD undoes our definition of __BSD_VISIBLE if _XOPEN_SOURCE is
275 # also defined. This can be overridden by defining _BSD_SOURCE
276 # As this has a different meaning on Linux, only define it on OpenBSD
277 AC_DEFINE(_BSD_SOURCE, 1, [Define on OpenBSD to activate all library features])
278 ;;
279 # Defining _XOPEN_SOURCE on NetBSD version prior to the introduction of
280 # _NETBSD_SOURCE disables certain features (eg. setgroups). Reported by
281 # Marc Recht
282 NetBSD/1.5 | NetBSD/1.5.* | NetBSD/1.6 | NetBSD/1.6.* | NetBSD/1.6@<:@A-S@:>@)
283 define_xopen_source=no;;
284 # On Solaris 2.6, sys/wait.h is inconsistent in the usage
285 # of union __?sigval. Reported by Stuart Bishop.
286 SunOS/5.6)
287 define_xopen_source=no;;
288 # On UnixWare 7, u_long is never defined with _XOPEN_SOURCE,
289 # but used in /usr/include/netinet/tcp.h. Reported by Tim Rice.
290 # Reconfirmed for 7.1.4 by Martin v. Loewis.
291 OpenUNIX/8.0.0| UnixWare/7.1.@<:@0-4@:>@)
292 define_xopen_source=no;;
293 # On OpenServer 5, u_short is never defined with _XOPEN_SOURCE,
294 # but used in struct sockaddr.sa_family. Reported by Tim Rice.
295 SCO_SV/3.2)
296 define_xopen_source=no;;
297 # On FreeBSD 4, the math functions C89 does not cover are never defined
298 # with _XOPEN_SOURCE and __BSD_VISIBLE does not re-enable them.
299 FreeBSD/4.*)
300 define_xopen_source=no;;
301 # On MacOS X 10.2, a bug in ncurses.h means that it craps out if
302 # _XOPEN_EXTENDED_SOURCE is defined. Apparently, this is fixed in 10.3, which
303 # identifies itself as Darwin/7.*
304 # On Mac OS X 10.4, defining _POSIX_C_SOURCE or _XOPEN_SOURCE
305 # disables platform specific features beyond repair.
306 # On Mac OS X 10.3, defining _POSIX_C_SOURCE or _XOPEN_SOURCE
307 # has no effect, don't bother defining them
308 Darwin/@<:@6789@:>@.*)
309 define_xopen_source=no;;
310 # On AIX 4 and 5.1, mbstate_t is defined only when _XOPEN_SOURCE == 500 but
311 # used in wcsnrtombs() and mbsnrtowcs() even if _XOPEN_SOURCE is not defined
312 # or has another value. By not (re)defining it, the defaults come in place.
313 AIX/4)
314 define_xopen_source=no;;
315 AIX/5)
316 if test `uname -r` -eq 1; then
317 define_xopen_source=no
318 fi
319 ;;
320 # On QNX 6.3.2, defining _XOPEN_SOURCE prevents netdb.h from
321 # defining NI_NUMERICHOST.
322 QNX/6.3.2)
323 define_xopen_source=no
324 ;;
326 esac
328 if test $define_xopen_source = yes
329 then
330 # On Solaris w/ g++ it appears that _XOPEN_SOURCE has to be
331 # defined precisely as g++ defines it
332 # Furthermore, on Solaris 10, XPG6 requires the use of a C99
333 # compiler
334 case $ac_sys_system/$ac_sys_release in
335 SunOS/5.8|SunOS/5.9|SunOS/5.10)
336 AC_DEFINE(_XOPEN_SOURCE, 500,
337 Define to the level of X/Open that your system supports)
338 ;;
339 *)
340 AC_DEFINE(_XOPEN_SOURCE, 600,
341 Define to the level of X/Open that your system supports)
342 ;;
343 esac
345 # On Tru64 Unix 4.0F, defining _XOPEN_SOURCE also requires
346 # definition of _XOPEN_SOURCE_EXTENDED and _POSIX_C_SOURCE, or else
347 # several APIs are not declared. Since this is also needed in some
348 # cases for HP-UX, we define it globally.
349 # except for Solaris 10, where it must not be defined,
350 # as it implies XPG4.2
351 case $ac_sys_system/$ac_sys_release in
352 SunOS/5.10)
353 ;;
354 *)
355 AC_DEFINE(_XOPEN_SOURCE_EXTENDED, 1,
356 Define to activate Unix95-and-earlier features)
357 ;;
358 esac
360 AC_DEFINE(_POSIX_C_SOURCE, 200112L, Define to activate features from IEEE Stds 1003.1-2001)
362 fi
364 #
365 # SGI compilers allow the specification of the both the ABI and the
366 # ISA on the command line. Depending on the values of these switches,
367 # different and often incompatable code will be generated.
368 #
369 # The SGI_ABI variable can be used to modify the CC and LDFLAGS and
370 # thus supply support for various ABI/ISA combinations. The MACHDEP
371 # variable is also adjusted.
372 #
373 AC_SUBST(SGI_ABI)
374 if test ! -z "$SGI_ABI"
375 then
376 CC="cc $SGI_ABI"
377 LDFLAGS="$SGI_ABI $LDFLAGS"
378 MACHDEP=`echo "${MACHDEP}${SGI_ABI}" | sed 's/ *//g'`
379 fi
380 AC_MSG_RESULT($MACHDEP)
382 # And add extra plat-mac for darwin
383 AC_SUBST(EXTRAPLATDIR)
384 AC_SUBST(EXTRAMACHDEPPATH)
385 AC_MSG_CHECKING(EXTRAPLATDIR)
386 if test -z "$EXTRAPLATDIR"
387 then
388 case $MACHDEP in
389 darwin)
390 EXTRAPLATDIR="\$(PLATMACDIRS)"
391 EXTRAMACHDEPPATH="\$(PLATMACPATH)"
392 ;;
393 *)
394 EXTRAPLATDIR=""
395 EXTRAMACHDEPPATH=""
396 ;;
397 esac
398 fi
399 AC_MSG_RESULT($EXTRAPLATDIR)
401 # Record the configure-time value of MACOSX_DEPLOYMENT_TARGET,
402 # it may influence the way we can build extensions, so distutils
403 # needs to check it
404 AC_SUBST(CONFIGURE_MACOSX_DEPLOYMENT_TARGET)
405 AC_SUBST(EXPORT_MACOSX_DEPLOYMENT_TARGET)
406 CONFIGURE_MACOSX_DEPLOYMENT_TARGET=
407 EXPORT_MACOSX_DEPLOYMENT_TARGET='#'
409 AC_MSG_CHECKING(machine type as reported by uname -m)
410 ac_sys_machine=`uname -m`
411 AC_MSG_RESULT($ac_sys_machine)
413 # checks for alternative programs
415 # compiler flags are generated in two sets, BASECFLAGS and OPT. OPT is just
416 # for debug/optimization stuff. BASECFLAGS is for flags that are required
417 # just to get things to compile and link. Users are free to override OPT
418 # when running configure or make. The build should not break if they do.
419 # BASECFLAGS should generally not be messed with, however.
421 # XXX shouldn't some/most/all of this code be merged with the stuff later
422 # on that fiddles with OPT and BASECFLAGS?
423 AC_MSG_CHECKING(for --without-gcc)
424 AC_ARG_WITH(gcc,
425 AC_HELP_STRING(--without-gcc,never use gcc),
426 [
427 case $withval in
428 no) CC=${CC:-cc}
429 without_gcc=yes;;
430 yes) CC=gcc
431 without_gcc=no;;
432 *) CC=$withval
433 without_gcc=$withval;;
434 esac], [
435 case $ac_sys_system in
436 AIX*) CC=cc_r
437 without_gcc=;;
438 BeOS*)
439 case $BE_HOST_CPU in
440 ppc)
441 CC=mwcc
442 without_gcc=yes
443 BASECFLAGS="$BASECFLAGS -export pragma"
444 OPT="$OPT -O"
445 LDFLAGS="$LDFLAGS -nodup"
446 ;;
447 x86)
448 CC=gcc
449 without_gcc=no
450 OPT="$OPT -O"
451 ;;
452 *)
453 AC_MSG_ERROR([Unknown BeOS platform "$BE_HOST_CPU"])
454 ;;
455 esac
456 AR="\$(srcdir)/Modules/ar_beos"
457 RANLIB=:
458 ;;
459 *) without_gcc=no;;
460 esac])
461 AC_MSG_RESULT($without_gcc)
463 # If the user switches compilers, we can't believe the cache
464 if test ! -z "$ac_cv_prog_CC" -a ! -z "$CC" -a "$CC" != "$ac_cv_prog_CC"
465 then
466 AC_MSG_ERROR([cached CC is different -- throw away $cache_file
467 (it is also a good idea to do 'make clean' before compiling)])
468 fi
470 AC_PROG_CC
472 AC_SUBST(CXX)
473 AC_SUBST(MAINCC)
474 AC_MSG_CHECKING(for --with-cxx-main=<compiler>)
475 AC_ARG_WITH(cxx_main,
476 AC_HELP_STRING([--with-cxx-main=<compiler>],
477 [compile main() and link python executable with C++ compiler]),
478 [
480 case $withval in
481 no) with_cxx_main=no
482 MAINCC='$(CC)';;
483 yes) with_cxx_main=yes
484 MAINCC='$(CXX)';;
485 *) with_cxx_main=yes
486 MAINCC=$withval
487 if test -z "$CXX"
488 then
489 CXX=$withval
490 fi;;
491 esac], [
492 with_cxx_main=no
493 MAINCC='$(CC)'
494 ])
495 AC_MSG_RESULT($with_cxx_main)
497 preset_cxx="$CXX"
498 if test -z "$CXX"
499 then
500 case "$CC" in
501 gcc) AC_PATH_PROG(CXX, [g++], [g++], [notfound]) ;;
502 cc) AC_PATH_PROG(CXX, [c++], [c++], [notfound]) ;;
503 esac
504 if test "$CXX" = "notfound"
505 then
506 CXX=""
507 fi
508 fi
509 if test -z "$CXX"
510 then
511 AC_CHECK_PROGS(CXX, $CCC c++ g++ gcc CC cxx cc++ cl, notfound)
512 if test "$CXX" = "notfound"
513 then
514 CXX=""
515 fi
516 fi
517 if test "$preset_cxx" != "$CXX"
518 then
519 AC_MSG_WARN([
521 By default, distutils will build C++ extension modules with "$CXX".
522 If this is not intended, then set CXX on the configure command line.
523 ])
524 fi
527 # checks for UNIX variants that set C preprocessor variables
528 AC_AIX
530 # Check for unsupported systems
531 case $ac_sys_system/$ac_sys_release in
532 atheos*|Linux*/1*)
533 echo This system \($ac_sys_system/$ac_sys_release\) is no longer supported.
534 echo See README for details.
535 exit 1;;
536 esac
538 AC_EXEEXT
539 AC_MSG_CHECKING(for --with-suffix)
540 AC_ARG_WITH(suffix,
541 AC_HELP_STRING(--with-suffix=.exe, set executable suffix),
542 [
543 case $withval in
544 no) EXEEXT=;;
545 yes) EXEEXT=.exe;;
546 *) EXEEXT=$withval;;
547 esac])
548 AC_MSG_RESULT($EXEEXT)
550 # Test whether we're running on a non-case-sensitive system, in which
551 # case we give a warning if no ext is given
552 AC_SUBST(BUILDEXEEXT)
553 AC_MSG_CHECKING(for case-insensitive build directory)
554 if test ! -d CaseSensitiveTestDir; then
555 mkdir CaseSensitiveTestDir
556 fi
558 if test -d casesensitivetestdir
559 then
560 AC_MSG_RESULT(yes)
561 BUILDEXEEXT=.exe
562 else
563 AC_MSG_RESULT(no)
564 BUILDEXEEXT=$EXEEXT
565 fi
566 rmdir CaseSensitiveTestDir
568 case $MACHDEP in
569 bsdos*)
570 case $CC in
571 gcc) CC="$CC -D_HAVE_BSDI";;
572 esac;;
573 esac
575 case $ac_sys_system in
576 hp*|HP*)
577 case $CC in
578 cc|*/cc) CC="$CC -Ae";;
579 esac;;
580 SunOS*)
581 # Some functions have a prototype only with that define, e.g. confstr
582 AC_DEFINE(__EXTENSIONS__, 1, [Defined on Solaris to see additional function prototypes.])
583 ;;
584 esac
587 AC_SUBST(LIBRARY)
588 AC_MSG_CHECKING(LIBRARY)
589 if test -z "$LIBRARY"
590 then
591 LIBRARY='libpython$(VERSION).a'
592 fi
593 AC_MSG_RESULT($LIBRARY)
595 # LDLIBRARY is the name of the library to link against (as opposed to the
596 # name of the library into which to insert object files). BLDLIBRARY is also
597 # the library to link against, usually. On Mac OS X frameworks, BLDLIBRARY
598 # is blank as the main program is not linked directly against LDLIBRARY.
599 # LDLIBRARYDIR is the path to LDLIBRARY, which is made in a subdirectory. On
600 # systems without shared libraries, LDLIBRARY is the same as LIBRARY
601 # (defined in the Makefiles). On Cygwin LDLIBRARY is the import library,
602 # DLLLIBRARY is the shared (i.e., DLL) library.
603 #
604 # RUNSHARED is used to run shared python without installed libraries
605 #
606 # INSTSONAME is the name of the shared library that will be use to install
607 # on the system - some systems like version suffix, others don't
608 AC_SUBST(LDLIBRARY)
609 AC_SUBST(DLLLIBRARY)
610 AC_SUBST(BLDLIBRARY)
611 AC_SUBST(LDLIBRARYDIR)
612 AC_SUBST(INSTSONAME)
613 AC_SUBST(RUNSHARED)
614 LDLIBRARY="$LIBRARY"
615 BLDLIBRARY='$(LDLIBRARY)'
616 INSTSONAME='$(LDLIBRARY)'
617 DLLLIBRARY=''
618 LDLIBRARYDIR=''
619 RUNSHARED=''
621 # LINKCC is the command that links the python executable -- default is $(CC).
622 # If CXX is set, and if it is needed to link a main function that was
623 # compiled with CXX, LINKCC is CXX instead. Always using CXX is undesirable:
624 # python might then depend on the C++ runtime
625 # This is altered for AIX in order to build the export list before
626 # linking.
627 AC_SUBST(LINKCC)
628 AC_MSG_CHECKING(LINKCC)
629 if test -z "$LINKCC"
630 then
631 LINKCC='$(PURIFY) $(MAINCC)'
632 case $ac_sys_system in
633 AIX*)
634 exp_extra="\"\""
635 if test $ac_sys_release -ge 5 -o \
636 $ac_sys_release -eq 4 -a `uname -r` -ge 2 ; then
637 exp_extra="."
638 fi
639 LINKCC="\$(srcdir)/Modules/makexp_aix Modules/python.exp $exp_extra \$(LIBRARY); $LINKCC";;
640 QNX*)
641 # qcc must be used because the other compilers do not
642 # support -N.
643 LINKCC=qcc;;
644 esac
645 fi
646 AC_MSG_RESULT($LINKCC)
648 # GNULD is set to "yes" if the GNU linker is used. If this goes wrong
649 # make sure we default having it set to "no": this is used by
650 # distutils.unixccompiler to know if it should add --enable-new-dtags
651 # to linker command lines, and failing to detect GNU ld simply results
652 # in the same bahaviour as before.
653 AC_SUBST(GNULD)
654 AC_MSG_CHECKING(for GNU ld)
655 ac_prog=ld
656 if test "$GCC" = yes; then
657 ac_prog=`$CC -print-prog-name=ld`
658 fi
659 case `"$ac_prog" -V 2>&1 < /dev/null` in
660 *GNU*)
661 GNULD=yes;;
662 *)
663 GNULD=no;;
664 esac
665 AC_MSG_RESULT($GNULD)
667 AC_MSG_CHECKING(for --enable-shared)
668 AC_ARG_ENABLE(shared,
669 AC_HELP_STRING(--enable-shared, disable/enable building shared python library))
671 if test -z "$enable_shared"
672 then
673 case $ac_sys_system in
674 CYGWIN* | atheos*)
675 enable_shared="yes";;
676 *)
677 enable_shared="no";;
678 esac
679 fi
680 AC_MSG_RESULT($enable_shared)
682 AC_MSG_CHECKING(for --enable-profiling)
683 AC_ARG_ENABLE(profiling,
684 AC_HELP_STRING(--enable-profiling, enable C-level code profiling),
685 [ac_save_cc="$CC"
686 CC="$CC -pg"
687 AC_TRY_RUN([int main() { return 0; }],
688 ac_enable_profiling="yes",
689 ac_enable_profiling="no",
690 ac_enable_profiling="no")
691 CC="$ac_save_cc"])
692 AC_MSG_RESULT($ac_enable_profiling)
694 case "$ac_enable_profiling" in
695 "yes")
696 BASECFLAGS="-pg $BASECFLAGS"
697 LDFLAGS="-pg $LDFLAGS"
698 ;;
699 esac
701 AC_MSG_CHECKING(LDLIBRARY)
703 # MacOSX framework builds need more magic. LDLIBRARY is the dynamic
704 # library that we build, but we do not want to link against it (we
705 # will find it with a -framework option). For this reason there is an
706 # extra variable BLDLIBRARY against which Python and the extension
707 # modules are linked, BLDLIBRARY. This is normally the same as
708 # LDLIBRARY, but empty for MacOSX framework builds.
709 if test "$enable_framework"
710 then
711 LDLIBRARY='$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
712 RUNSHARED=DYLD_FRAMEWORK_PATH="`pwd`:$DYLD_FRAMEWORK_PATH"
713 BLDLIBRARY=''
714 else
715 BLDLIBRARY='$(LDLIBRARY)'
716 fi
718 # Other platforms follow
719 if test $enable_shared = "yes"; then
720 AC_DEFINE(Py_ENABLE_SHARED, 1, [Defined if Python is built as a shared library.])
721 case $ac_sys_system in
722 BeOS*)
723 LDLIBRARY='libpython$(VERSION).so'
724 ;;
725 CYGWIN*)
726 LDLIBRARY='libpython$(VERSION).dll.a'
727 DLLLIBRARY='libpython$(VERSION).dll'
728 ;;
729 SunOS*)
730 LDLIBRARY='libpython$(VERSION).so'
731 BLDLIBRARY='-Wl,-R,$(LIBDIR) -L. -lpython$(VERSION)'
732 RUNSHARED=LD_LIBRARY_PATH=`pwd`:${LD_LIBRARY_PATH}
733 INSTSONAME="$LDLIBRARY".$SOVERSION
734 ;;
735 Linux*|GNU*|NetBSD*|FreeBSD*|DragonFly*)
736 LDLIBRARY='libpython$(VERSION).so'
737 BLDLIBRARY='-L. -lpython$(VERSION)'
738 RUNSHARED=LD_LIBRARY_PATH=`pwd`:${LD_LIBRARY_PATH}
739 case $ac_sys_system in
740 FreeBSD*)
741 SOVERSION=`echo $SOVERSION|cut -d "." -f 1`
742 ;;
743 esac
744 INSTSONAME="$LDLIBRARY".$SOVERSION
745 ;;
746 hp*|HP*)
747 case `uname -m` in
748 ia64)
749 LDLIBRARY='libpython$(VERSION).so'
750 ;;
751 *)
752 LDLIBRARY='libpython$(VERSION).sl'
753 ;;
754 esac
755 BLDLIBRARY='-Wl,+b,$(LIBDIR) -L. -lpython$(VERSION)'
756 RUNSHARED=SHLIB_PATH=`pwd`:${SHLIB_PATH}
757 ;;
758 OSF*)
759 LDLIBRARY='libpython$(VERSION).so'
760 BLDLIBRARY='-rpath $(LIBDIR) -L. -lpython$(VERSION)'
761 RUNSHARED=LD_LIBRARY_PATH=`pwd`:${LD_LIBRARY_PATH}
762 ;;
763 atheos*)
764 LDLIBRARY='libpython$(VERSION).so'
765 BLDLIBRARY='-L. -lpython$(VERSION)'
766 RUNSHARED=DLL_PATH=`pwd`:${DLL_PATH:-/atheos/sys/libs:/atheos/autolnk/lib}
767 ;;
768 Darwin*)
769 LDLIBRARY='libpython$(VERSION).dylib'
770 BLDLIBRARY='-L. -lpython$(VERSION)'
771 RUNSHARED='DYLD_LIBRARY_PATH=`pwd`:${DYLD_LIBRARY_PATH}'
772 ;;
774 esac
775 else # shared is disabled
776 case $ac_sys_system in
777 CYGWIN*)
778 BLDLIBRARY='$(LIBRARY)'
779 LDLIBRARY='libpython$(VERSION).dll.a'
780 ;;
781 esac
782 fi
784 AC_MSG_RESULT($LDLIBRARY)
786 AC_PROG_RANLIB
787 AC_SUBST(AR)
788 AC_CHECK_PROGS(AR, ar aal, ar)
790 # tweak ARFLAGS only if the user didn't set it on the command line
791 AC_SUBST(ARFLAGS)
792 if test -z "$ARFLAGS"
793 then
794 ARFLAGS="rc"
795 fi
797 AC_SUBST(SVNVERSION)
798 AC_CHECK_PROG(SVNVERSION, svnversion, found, not-found)
799 if test $SVNVERSION = found
800 then
801 SVNVERSION="svnversion \$(srcdir)"
802 else
803 SVNVERSION="echo Unversioned directory"
804 fi
806 case $MACHDEP in
807 bsdos*|hp*|HP*)
808 # install -d does not work on BSDI or HP-UX
809 if test -z "$INSTALL"
810 then
811 INSTALL="${srcdir}/install-sh -c"
812 fi
813 esac
814 AC_PROG_INSTALL
816 # Not every filesystem supports hard links
817 AC_SUBST(LN)
818 if test -z "$LN" ; then
819 case $ac_sys_system in
820 BeOS*) LN="ln -s";;
821 CYGWIN*) LN="ln -s";;
822 atheos*) LN="ln -s";;
823 *) LN=ln;;
824 esac
825 fi
827 # Check for --with-pydebug
828 AC_MSG_CHECKING(for --with-pydebug)
829 AC_ARG_WITH(pydebug,
830 AC_HELP_STRING(--with-pydebug, build with Py_DEBUG defined),
831 [
832 if test "$withval" != no
833 then
834 AC_DEFINE(Py_DEBUG, 1,
835 [Define if you want to build an interpreter with many run-time checks.])
836 AC_MSG_RESULT(yes);
837 Py_DEBUG='true'
838 else AC_MSG_RESULT(no); Py_DEBUG='false'
839 fi],
840 [AC_MSG_RESULT(no)])
842 # XXX Shouldn't the code above that fiddles with BASECFLAGS and OPT be
843 # merged with this chunk of code?
845 # Optimizer/debugger flags
846 # ------------------------
847 # (The following bit of code is complicated enough - please keep things
848 # indented properly. Just pretend you're editing Python code. ;-)
850 # There are two parallel sets of case statements below, one that checks to
851 # see if OPT was set and one that does BASECFLAGS setting based upon
852 # compiler and platform. BASECFLAGS tweaks need to be made even if the
853 # user set OPT.
855 # tweak OPT based on compiler and platform, only if the user didn't set
856 # it on the command line
857 AC_SUBST(OPT)
858 if test -z "$OPT"
859 then
860 case $GCC in
861 yes)
862 if test "$CC" != 'g++' ; then
863 STRICT_PROTO="-Wstrict-prototypes"
864 fi
865 # For gcc 4.x we need to use -fwrapv so lets check if its supported
866 if "$CC" -v --help 2>/dev/null |grep -- -fwrapv > /dev/null; then
867 WRAP="-fwrapv"
868 fi
869 case $ac_cv_prog_cc_g in
870 yes)
871 if test "$Py_DEBUG" = 'true' ; then
872 # Optimization messes up debuggers, so turn it off for
873 # debug builds.
874 OPT="-g -Wall $STRICT_PROTO"
875 else
876 OPT="-g $WRAP -O3 -Wall $STRICT_PROTO"
877 fi
878 ;;
879 *)
880 OPT="-O3 -Wall $STRICT_PROTO"
881 ;;
882 esac
883 case $ac_sys_system in
884 SCO_SV*) OPT="$OPT -m486 -DSCO5"
885 ;;
886 esac
887 ;;
889 *)
890 OPT="-O"
891 ;;
892 esac
893 fi
895 AC_SUBST(BASECFLAGS)
897 # The -arch flags for universal builds on OSX
898 UNIVERSAL_ARCH_FLAGS=
899 AC_SUBST(UNIVERSAL_ARCH_FLAGS)
901 # tweak BASECFLAGS based on compiler and platform
902 case $GCC in
903 yes)
904 # Python violates C99 rules, by casting between incompatible
905 # pointer types. GCC may generate bad code as a result of that,
906 # so use -fno-strict-aliasing if supported.
907 AC_MSG_CHECKING(whether $CC accepts -fno-strict-aliasing)
908 ac_save_cc="$CC"
909 CC="$CC -fno-strict-aliasing"
910 AC_CACHE_VAL(ac_cv_no_strict_aliasing_ok,
911 AC_TRY_RUN([int main() { return 0; }],
912 ac_cv_no_strict_aliasing_ok=yes,
913 ac_cv_no_strict_aliasing_ok=no,
914 ac_cv_no_strict_aliasing_ok=no))
915 CC="$ac_save_cc"
916 AC_MSG_RESULT($ac_cv_no_strict_aliasing_ok)
917 if test $ac_cv_no_strict_aliasing_ok = yes
918 then
919 BASECFLAGS="$BASECFLAGS -fno-strict-aliasing"
920 fi
922 # if using gcc on alpha, use -mieee to get (near) full IEEE 754
923 # support. Without this, treatment of subnormals doesn't follow
924 # the standard.
925 case $ac_sys_machine in
926 alpha*)
927 BASECFLAGS="$BASECFLAGS -mieee"
928 ;;
929 esac
931 case $ac_sys_system in
932 SCO_SV*)
933 BASECFLAGS="$BASECFLAGS -m486 -DSCO5"
934 ;;
935 # is there any other compiler on Darwin besides gcc?
936 Darwin*)
937 # -Wno-long-double, -no-cpp-precomp, and -mno-fused-madd
938 # used to be here, but non-Apple gcc doesn't accept them.
941 if test "${enable_universalsdk}"; then
942 UNIVERSAL_ARCH_FLAGS=""
943 if test "$UNIVERSAL_ARCHS" = "32-bit" ; then
944 UNIVERSAL_ARCH_FLAGS="-arch ppc -arch i386"
945 ARCH_RUN_32BIT=""
947 elif test "$UNIVERSAL_ARCHS" = "64-bit" ; then
948 UNIVERSAL_ARCH_FLAGS="-arch ppc64 -arch x86_64"
949 ARCH_RUN_32BIT="true"
951 elif test "$UNIVERSAL_ARCHS" = "all" ; then
952 UNIVERSAL_ARCH_FLAGS="-arch i386 -arch ppc -arch ppc64 -arch x86_64"
953 ARCH_RUN_32BIT="arch -i386 -ppc"
955 elif test "$UNIVERSAL_ARCHS" = "intel" ; then
956 UNIVERSAL_ARCH_FLAGS="-arch i386 -arch x86_64"
957 ARCH_RUN_32BIT="arch -i386"
959 elif test "$UNIVERSAL_ARCHS" = "3-way" ; then
960 UNIVERSAL_ARCH_FLAGS="-arch i386 -arch ppc -arch x86_64"
961 ARCH_RUN_32BIT="arch -i386 -ppc"
963 else
964 AC_MSG_ERROR([proper usage is --with-universalarch=32-bit|64-bit|all])
966 fi
969 BASECFLAGS="${UNIVERSAL_ARCH_FLAGS} -isysroot ${UNIVERSALSDK} ${BASECFLAGS}"
970 tgt=`sw_vers -productVersion | sed 's/\(10\.[[0-9]]*\).*/\1/'`
971 if test "${UNIVERSALSDK}" != "/" -a "${tgt}" '>' '10.4' ; then
972 CFLAGS="${UNIVERSAL_ARCH_FLAGS} -isysroot ${UNIVERSALSDK} ${CFLAGS}"
973 fi
974 fi
976 # Calculate the right deployment target for this build.
977 #
978 cur_target=`sw_vers -productVersion | sed 's/\(10\.[[0-9]]*\).*/\1/'`
979 if test ${cur_target} '>' 10.2; then
980 cur_target=10.3
981 if test ${enable_universalsdk}; then
982 if test "${UNIVERSAL_ARCHS}" = "all"; then
983 # Ensure that the default platform for a
984 # 4-way universal build is OSX 10.5,
985 # that's the first OS release where
986 # 4-way builds make sense.
987 cur_target='10.5'
989 elif test "${UNIVERSAL_ARCHS}" = "3-way"; then
990 cur_target='10.5'
992 elif test "${UNIVERSAL_ARCHS}" = "intel"; then
993 cur_target='10.5'
995 elif test "${UNIVERSAL_ARCHS}" = "64-bit"; then
996 cur_target='10.5'
997 fi
998 else
999 if test `arch` = "i386"; then
1000 # On Intel macs default to a deployment
1001 # target of 10.4, that's the first OSX
1002 # release with Intel support.
1003 cur_target="10.4"
1004 fi
1005 fi
1006 fi
1007 CONFIGURE_MACOSX_DEPLOYMENT_TARGET=${MACOSX_DEPLOYMENT_TARGET-${cur_target}}
1009 # Make sure that MACOSX_DEPLOYMENT_TARGET is set in the
1010 # environment with a value that is the same as what we'll use
1011 # in the Makefile to ensure that we'll get the same compiler
1012 # environment during configure and build time.
1013 MACOSX_DEPLOYMENT_TARGET="$CONFIGURE_MACOSX_DEPLOYMENT_TARGET"
1014 export MACOSX_DEPLOYMENT_TARGET
1015 EXPORT_MACOSX_DEPLOYMENT_TARGET=''
1017 ;;
1018 OSF*)
1019 BASECFLAGS="$BASECFLAGS -mieee"
1020 ;;
1021 esac
1022 ;;
1024 *)
1025 case $ac_sys_system in
1026 OpenUNIX*|UnixWare*)
1027 BASECFLAGS="$BASECFLAGS -K pentium,host,inline,loop_unroll,alloca "
1028 ;;
1029 OSF*)
1030 BASECFLAGS="$BASECFLAGS -ieee -std"
1031 ;;
1032 SCO_SV*)
1033 BASECFLAGS="$BASECFLAGS -belf -Ki486 -DSCO5"
1034 ;;
1035 esac
1036 ;;
1037 esac
1039 if test "$Py_DEBUG" = 'true'; then
1040 :
1041 else
1042 OPT="-DNDEBUG $OPT"
1043 fi
1045 if test "$ac_arch_flags"
1046 then
1047 BASECFLAGS="$BASECFLAGS $ac_arch_flags"
1048 fi
1050 # disable check for icc since it seems to pass, but generates a warning
1051 if test "$CC" = icc
1052 then
1053 ac_cv_opt_olimit_ok=no
1054 fi
1056 AC_MSG_CHECKING(whether $CC accepts -OPT:Olimit=0)
1057 AC_CACHE_VAL(ac_cv_opt_olimit_ok,
1058 [ac_save_cc="$CC"
1059 CC="$CC -OPT:Olimit=0"
1060 AC_TRY_RUN([int main() { return 0; }],
1061 ac_cv_opt_olimit_ok=yes,
1062 ac_cv_opt_olimit_ok=no,
1063 ac_cv_opt_olimit_ok=no)
1064 CC="$ac_save_cc"])
1065 AC_MSG_RESULT($ac_cv_opt_olimit_ok)
1066 if test $ac_cv_opt_olimit_ok = yes; then
1067 case $ac_sys_system in
1068 # XXX is this branch needed? On MacOSX 10.2.2 the result of the
1069 # olimit_ok test is "no". Is it "yes" in some other Darwin-esque
1070 # environment?
1071 Darwin*)
1072 ;;
1073 *)
1074 BASECFLAGS="$BASECFLAGS -OPT:Olimit=0"
1075 ;;
1076 esac
1077 else
1078 AC_MSG_CHECKING(whether $CC accepts -Olimit 1500)
1079 AC_CACHE_VAL(ac_cv_olimit_ok,
1080 [ac_save_cc="$CC"
1081 CC="$CC -Olimit 1500"
1082 AC_TRY_RUN([int main() { return 0; }],
1083 ac_cv_olimit_ok=yes,
1084 ac_cv_olimit_ok=no,
1085 ac_cv_olimit_ok=no)
1086 CC="$ac_save_cc"])
1087 AC_MSG_RESULT($ac_cv_olimit_ok)
1088 if test $ac_cv_olimit_ok = yes; then
1089 BASECFLAGS="$BASECFLAGS -Olimit 1500"
1090 fi
1091 fi
1093 # Check whether GCC supports PyArg_ParseTuple format
1094 if test "$GCC" = "yes"
1095 then
1096 AC_MSG_CHECKING(whether gcc supports ParseTuple __format__)
1097 save_CFLAGS=$CFLAGS
1098 CFLAGS="$CFLAGS -Werror"
1099 AC_TRY_COMPILE([
1100 void f(char*,...)__attribute((format(PyArg_ParseTuple, 1, 2)));
1101 ],,
1102 AC_DEFINE(HAVE_ATTRIBUTE_FORMAT_PARSETUPLE, 1, [Define if GCC supports __attribute__((format(PyArg_ParseTuple, 2, 3)))])
1103 AC_MSG_RESULT(yes),
1104 AC_MSG_RESULT(no)
1105 )
1106 CFLAGS=$save_CFLAGS
1107 fi
1109 # On some compilers, pthreads are available without further options
1110 # (e.g. MacOS X). On some of these systems, the compiler will not
1111 # complain if unaccepted options are passed (e.g. gcc on Mac OS X).
1112 # So we have to see first whether pthreads are available without
1113 # options before we can check whether -Kpthread improves anything.
1114 AC_MSG_CHECKING(whether pthreads are available without options)
1115 AC_CACHE_VAL(ac_cv_pthread_is_default,
1116 [AC_TRY_RUN([
1117 #include <pthread.h>
1119 void* routine(void* p){return NULL;}
1121 int main(){
1122 pthread_t p;
1123 if(pthread_create(&p,NULL,routine,NULL)!=0)
1124 return 1;
1125 (void)pthread_detach(p);
1126 return 0;
1127 }
1128 ],
1129 [
1130 ac_cv_pthread_is_default=yes
1131 ac_cv_kthread=no
1132 ac_cv_pthread=no
1133 ],
1134 ac_cv_pthread_is_default=no,
1135 ac_cv_pthread_is_default=no)
1136 ])
1137 AC_MSG_RESULT($ac_cv_pthread_is_default)
1140 if test $ac_cv_pthread_is_default = yes
1141 then
1142 ac_cv_kpthread=no
1143 else
1144 # -Kpthread, if available, provides the right #defines
1145 # and linker options to make pthread_create available
1146 # Some compilers won't report that they do not support -Kpthread,
1147 # so we need to run a program to see whether it really made the
1148 # function available.
1149 AC_MSG_CHECKING(whether $CC accepts -Kpthread)
1150 AC_CACHE_VAL(ac_cv_kpthread,
1151 [ac_save_cc="$CC"
1152 CC="$CC -Kpthread"
1153 AC_TRY_RUN([
1154 #include <pthread.h>
1156 void* routine(void* p){return NULL;}
1158 int main(){
1159 pthread_t p;
1160 if(pthread_create(&p,NULL,routine,NULL)!=0)
1161 return 1;
1162 (void)pthread_detach(p);
1163 return 0;
1164 }
1165 ],
1166 ac_cv_kpthread=yes,
1167 ac_cv_kpthread=no,
1168 ac_cv_kpthread=no)
1169 CC="$ac_save_cc"])
1170 AC_MSG_RESULT($ac_cv_kpthread)
1171 fi
1173 if test $ac_cv_kpthread = no -a $ac_cv_pthread_is_default = no
1174 then
1175 # -Kthread, if available, provides the right #defines
1176 # and linker options to make pthread_create available
1177 # Some compilers won't report that they do not support -Kthread,
1178 # so we need to run a program to see whether it really made the
1179 # function available.
1180 AC_MSG_CHECKING(whether $CC accepts -Kthread)
1181 AC_CACHE_VAL(ac_cv_kthread,
1182 [ac_save_cc="$CC"
1183 CC="$CC -Kthread"
1184 AC_TRY_RUN([
1185 #include <pthread.h>
1187 void* routine(void* p){return NULL;}
1189 int main(){
1190 pthread_t p;
1191 if(pthread_create(&p,NULL,routine,NULL)!=0)
1192 return 1;
1193 (void)pthread_detach(p);
1194 return 0;
1195 }
1196 ],
1197 ac_cv_kthread=yes,
1198 ac_cv_kthread=no,
1199 ac_cv_kthread=no)
1200 CC="$ac_save_cc"])
1201 AC_MSG_RESULT($ac_cv_kthread)
1202 fi
1204 if test $ac_cv_kthread = no -a $ac_cv_pthread_is_default = no
1205 then
1206 # -pthread, if available, provides the right #defines
1207 # and linker options to make pthread_create available
1208 # Some compilers won't report that they do not support -pthread,
1209 # so we need to run a program to see whether it really made the
1210 # function available.
1211 AC_MSG_CHECKING(whether $CC accepts -pthread)
1212 AC_CACHE_VAL(ac_cv_thread,
1213 [ac_save_cc="$CC"
1214 CC="$CC -pthread"
1215 AC_TRY_RUN([
1216 #include <pthread.h>
1218 void* routine(void* p){return NULL;}
1220 int main(){
1221 pthread_t p;
1222 if(pthread_create(&p,NULL,routine,NULL)!=0)
1223 return 1;
1224 (void)pthread_detach(p);
1225 return 0;
1226 }
1227 ],
1228 ac_cv_pthread=yes,
1229 ac_cv_pthread=no,
1230 ac_cv_pthread=no)
1231 CC="$ac_save_cc"])
1232 AC_MSG_RESULT($ac_cv_pthread)
1233 fi
1235 # If we have set a CC compiler flag for thread support then
1236 # check if it works for CXX, too.
1237 ac_cv_cxx_thread=no
1238 if test ! -z "$CXX"
1239 then
1240 AC_MSG_CHECKING(whether $CXX also accepts flags for thread support)
1241 ac_save_cxx="$CXX"
1243 if test "$ac_cv_kpthread" = "yes"
1244 then
1245 CXX="$CXX -Kpthread"
1246 ac_cv_cxx_thread=yes
1247 elif test "$ac_cv_kthread" = "yes"
1248 then
1249 CXX="$CXX -Kthread"
1250 ac_cv_cxx_thread=yes
1251 elif test "$ac_cv_pthread" = "yes"
1252 then
1253 CXX="$CXX -pthread"
1254 ac_cv_cxx_thread=yes
1255 fi
1257 if test $ac_cv_cxx_thread = yes
1258 then
1259 echo 'void foo();int main(){foo();}void foo(){}' > conftest.$ac_ext
1260 $CXX -c conftest.$ac_ext 2>&5
1261 if $CXX -o conftest$ac_exeext conftest.$ac_objext 2>&5 \
1262 && test -s conftest$ac_exeext && ./conftest$ac_exeext
1263 then
1264 ac_cv_cxx_thread=yes
1265 else
1266 ac_cv_cxx_thread=no
1267 fi
1268 rm -fr conftest*
1269 fi
1270 AC_MSG_RESULT($ac_cv_cxx_thread)
1271 fi
1272 CXX="$ac_save_cxx"
1274 dnl # check for ANSI or K&R ("traditional") preprocessor
1275 dnl AC_MSG_CHECKING(for C preprocessor type)
1276 dnl AC_TRY_COMPILE([
1277 dnl #define spam(name, doc) {#name, &name, #name "() -- " doc}
1278 dnl int foo;
1279 dnl struct {char *name; int *addr; char *doc;} desc = spam(foo, "something");
1280 dnl ], [;], cpp_type=ansi, AC_DEFINE(HAVE_OLD_CPP) cpp_type=traditional)
1281 dnl AC_MSG_RESULT($cpp_type)
1283 # checks for header files
1284 AC_HEADER_STDC
1285 AC_CHECK_HEADERS(asm/types.h conio.h curses.h direct.h dlfcn.h errno.h \
1286 fcntl.h grp.h \
1287 ieeefp.h io.h langinfo.h libintl.h ncurses.h poll.h process.h pthread.h \
1288 shadow.h signal.h stdint.h stropts.h termios.h thread.h \
1289 unistd.h utime.h \
1290 sys/audioio.h sys/bsdtty.h sys/epoll.h sys/event.h sys/file.h sys/loadavg.h \
1291 sys/lock.h sys/mkdev.h sys/modem.h \
1292 sys/param.h sys/poll.h sys/select.h sys/socket.h sys/statvfs.h sys/stat.h \
1293 sys/termio.h sys/time.h \
1294 sys/times.h sys/types.h sys/un.h sys/utsname.h sys/wait.h pty.h libutil.h \
1295 sys/resource.h netpacket/packet.h sysexits.h bluetooth.h \
1296 bluetooth/bluetooth.h linux/tipc.h)
1297 AC_HEADER_DIRENT
1298 AC_HEADER_MAJOR
1300 # On Solaris, term.h requires curses.h
1301 AC_CHECK_HEADERS(term.h,,,[
1302 #ifdef HAVE_CURSES_H
1303 #include <curses.h>
1304 #endif
1305 ])
1307 # On Linux, netlink.h requires asm/types.h
1308 AC_CHECK_HEADERS(linux/netlink.h,,,[
1309 #ifdef HAVE_ASM_TYPES_H
1310 #include <asm/types.h>
1311 #endif
1312 #ifdef HAVE_SYS_SOCKET_H
1313 #include <sys/socket.h>
1314 #endif
1315 ])
1317 # checks for typedefs
1318 was_it_defined=no
1319 AC_MSG_CHECKING(for clock_t in time.h)
1320 AC_EGREP_HEADER(clock_t, time.h, was_it_defined=yes, [
1321 AC_DEFINE(clock_t, long, [Define to 'long' if <time.h> doesn't define.])
1322 ])
1323 AC_MSG_RESULT($was_it_defined)
1325 # Check whether using makedev requires defining _OSF_SOURCE
1326 AC_MSG_CHECKING(for makedev)
1327 AC_TRY_LINK([#include <sys/types.h> ],
1328 [ makedev(0, 0) ],
1329 ac_cv_has_makedev=yes,
1330 ac_cv_has_makedev=no)
1331 if test "$ac_cv_has_makedev" = "no"; then
1332 # we didn't link, try if _OSF_SOURCE will allow us to link
1333 AC_TRY_LINK([
1334 #define _OSF_SOURCE 1
1335 #include <sys/types.h>
1336 ],
1337 [ makedev(0, 0) ],
1338 ac_cv_has_makedev=yes,
1339 ac_cv_has_makedev=no)
1340 if test "$ac_cv_has_makedev" = "yes"; then
1341 AC_DEFINE(_OSF_SOURCE, 1, [Define _OSF_SOURCE to get the makedev macro.])
1342 fi
1343 fi
1344 AC_MSG_RESULT($ac_cv_has_makedev)
1345 if test "$ac_cv_has_makedev" = "yes"; then
1346 AC_DEFINE(HAVE_MAKEDEV, 1, [Define this if you have the makedev macro.])
1347 fi
1349 # Enabling LFS on Solaris (2.6 to 9) with gcc 2.95 triggers a bug in
1350 # the system headers: If _XOPEN_SOURCE and _LARGEFILE_SOURCE are
1351 # defined, but the compiler does not support pragma redefine_extname,
1352 # and _LARGEFILE64_SOURCE is not defined, the headers refer to 64-bit
1353 # structures (such as rlimit64) without declaring them. As a
1354 # work-around, disable LFS on such configurations
1356 use_lfs=yes
1357 AC_MSG_CHECKING(Solaris LFS bug)
1358 AC_TRY_COMPILE([
1359 #define _LARGEFILE_SOURCE 1
1360 #define _FILE_OFFSET_BITS 64
1361 #include <sys/resource.h>
1362 ],struct rlimit foo;,sol_lfs_bug=no,sol_lfs_bug=yes)
1363 AC_MSG_RESULT($sol_lfs_bug)
1364 if test "$sol_lfs_bug" = "yes"; then
1365 use_lfs=no
1366 fi
1368 if test "$use_lfs" = "yes"; then
1369 # Two defines needed to enable largefile support on various platforms
1370 # These may affect some typedefs
1371 AC_DEFINE(_LARGEFILE_SOURCE, 1,
1372 [This must be defined on some systems to enable large file support.])
1373 AC_DEFINE(_FILE_OFFSET_BITS, 64,
1374 [This must be set to 64 on some systems to enable large file support.])
1375 fi
1377 # Add some code to confdefs.h so that the test for off_t works on SCO
1378 cat >> confdefs.h <<\EOF
1379 #if defined(SCO_DS)
1380 #undef _OFF_T
1381 #endif
1382 EOF
1384 # Type availability checks
1385 AC_TYPE_MODE_T
1386 AC_TYPE_OFF_T
1387 AC_TYPE_PID_T
1388 AC_TYPE_SIGNAL
1389 AC_TYPE_SIZE_T
1390 AC_TYPE_UID_T
1391 AC_TYPE_UINT32_T
1392 AC_TYPE_UINT64_T
1393 AC_TYPE_INT32_T
1394 AC_TYPE_INT64_T
1395 AC_CHECK_TYPE(ssize_t,
1396 AC_DEFINE(HAVE_SSIZE_T, 1, Define if your compiler provides ssize_t),,)
1398 # Sizes of various common basic types
1399 # ANSI C requires sizeof(char) == 1, so no need to check it
1400 AC_CHECK_SIZEOF(int, 4)
1401 AC_CHECK_SIZEOF(long, 4)
1402 AC_CHECK_SIZEOF(void *, 4)
1403 AC_CHECK_SIZEOF(short, 2)
1404 AC_CHECK_SIZEOF(float, 4)
1405 AC_CHECK_SIZEOF(double, 8)
1406 AC_CHECK_SIZEOF(fpos_t, 4)
1407 AC_CHECK_SIZEOF(size_t, 4)
1408 AC_CHECK_SIZEOF(pid_t, 4)
1410 AC_MSG_CHECKING(for long long support)
1411 have_long_long=no
1412 AC_TRY_COMPILE([], [long long x; x = (long long)0;], [
1413 AC_DEFINE(HAVE_LONG_LONG, 1, [Define this if you have the type long long.])
1414 have_long_long=yes
1415 ])
1416 AC_MSG_RESULT($have_long_long)
1417 if test "$have_long_long" = yes ; then
1418 AC_CHECK_SIZEOF(long long, 8)
1419 fi
1421 AC_MSG_CHECKING(for long double support)
1422 have_long_double=no
1423 AC_TRY_COMPILE([], [long double x; x = (long double)0.;], [
1424 AC_DEFINE(HAVE_LONG_DOUBLE, 1, [Define this if you have the type long double.])
1425 have_long_double=yes
1426 ])
1427 AC_MSG_RESULT($have_long_double)
1428 if test "$have_long_double" = yes ; then
1429 AC_CHECK_SIZEOF(long double, 12)
1430 fi
1432 AC_MSG_CHECKING(for _Bool support)
1433 have_c99_bool=no
1434 AC_TRY_COMPILE([], [_Bool x; x = (_Bool)0;], [
1435 AC_DEFINE(HAVE_C99_BOOL, 1, [Define this if you have the type _Bool.])
1436 have_c99_bool=yes
1437 ])
1438 AC_MSG_RESULT($have_c99_bool)
1439 if test "$have_c99_bool" = yes ; then
1440 AC_CHECK_SIZEOF(_Bool, 1)
1441 fi
1443 AC_CHECK_TYPES(uintptr_t,
1444 [AC_CHECK_SIZEOF(uintptr_t, 4)],
1445 [], [#ifdef HAVE_STDINT_H
1446 #include <stdint.h>
1447 #endif])
1449 AC_CHECK_SIZEOF(off_t, [], [
1450 #ifdef HAVE_SYS_TYPES_H
1451 #include <sys/types.h>
1452 #endif
1453 ])
1455 AC_MSG_CHECKING(whether to enable large file support)
1456 if test "$have_long_long" = yes -a \
1457 "$ac_cv_sizeof_off_t" -gt "$ac_cv_sizeof_long" -a \
1458 "$ac_cv_sizeof_long_long" -ge "$ac_cv_sizeof_off_t"; then
1459 AC_DEFINE(HAVE_LARGEFILE_SUPPORT, 1,
1460 [Defined to enable large file support when an off_t is bigger than a long
1461 and long long is available and at least as big as an off_t. You may need
1462 to add some flags for configuration and compilation to enable this mode.
1463 (For Solaris and Linux, the necessary defines are already defined.)])
1464 AC_MSG_RESULT(yes)
1465 else
1466 AC_MSG_RESULT(no)
1467 fi
1469 AC_CHECK_SIZEOF(time_t, [], [
1470 #ifdef HAVE_SYS_TYPES_H
1471 #include <sys/types.h>
1472 #endif
1473 #ifdef HAVE_TIME_H
1474 #include <time.h>
1475 #endif
1476 ])
1478 # if have pthread_t then define SIZEOF_PTHREAD_T
1479 ac_save_cc="$CC"
1480 if test "$ac_cv_kpthread" = "yes"
1481 then CC="$CC -Kpthread"
1482 elif test "$ac_cv_kthread" = "yes"
1483 then CC="$CC -Kthread"
1484 elif test "$ac_cv_pthread" = "yes"
1485 then CC="$CC -pthread"
1486 fi
1487 AC_MSG_CHECKING(for pthread_t)
1488 have_pthread_t=no
1489 AC_TRY_COMPILE([#include <pthread.h>], [pthread_t x; x = *(pthread_t*)0;], have_pthread_t=yes)
1490 AC_MSG_RESULT($have_pthread_t)
1491 if test "$have_pthread_t" = yes ; then
1492 AC_CHECK_SIZEOF(pthread_t, [], [
1493 #ifdef HAVE_PTHREAD_H
1494 #include <pthread.h>
1495 #endif
1496 ])
1497 fi
1498 CC="$ac_save_cc"
1500 AC_MSG_CHECKING(for --enable-toolbox-glue)
1501 AC_ARG_ENABLE(toolbox-glue,
1502 AC_HELP_STRING(--enable-toolbox-glue, disable/enable MacOSX glue code for extensions))
1504 if test -z "$enable_toolbox_glue"
1505 then
1506 case $ac_sys_system/$ac_sys_release in
1507 Darwin/*)
1508 enable_toolbox_glue="yes";;
1509 *)
1510 enable_toolbox_glue="no";;
1511 esac
1512 fi
1513 case "$enable_toolbox_glue" in
1514 yes)
1515 extra_machdep_objs="Python/mactoolboxglue.o"
1516 extra_undefs="-u _PyMac_Error"
1517 AC_DEFINE(USE_TOOLBOX_OBJECT_GLUE, 1,
1518 [Define if you want to use MacPython modules on MacOSX in unix-Python.])
1519 ;;
1520 *)
1521 extra_machdep_objs=""
1522 extra_undefs=""
1523 ;;
1524 esac
1525 AC_MSG_RESULT($enable_toolbox_glue)
1528 AC_SUBST(OTHER_LIBTOOL_OPT)
1529 case $ac_sys_system/$ac_sys_release in
1530 Darwin/@<:@01567@:>@\..*)
1531 OTHER_LIBTOOL_OPT="-prebind -seg1addr 0x10000000"
1532 ;;
1533 Darwin/*)
1534 OTHER_LIBTOOL_OPT=""
1535 ;;
1536 esac
1539 ARCH_RUN_32BIT=""
1540 AC_SUBST(LIBTOOL_CRUFT)
1541 case $ac_sys_system/$ac_sys_release in
1542 Darwin/@<:@01567@:>@\..*)
1543 LIBTOOL_CRUFT="-framework System -lcc_dynamic"
1544 if test "${enable_universalsdk}"; then
1545 :
1546 else
1547 LIBTOOL_CRUFT="${LIBTOOL_CRUFT} -arch_only `arch`"
1548 fi
1549 LIBTOOL_CRUFT=$LIBTOOL_CRUFT' -install_name $(PYTHONFRAMEWORKINSTALLDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1550 LIBTOOL_CRUFT=$LIBTOOL_CRUFT' -compatibility_version $(VERSION) -current_version $(VERSION)';;
1551 Darwin/*)
1552 gcc_version=`gcc -v 2>&1 | grep version | cut -d\ -f3`
1553 if test ${gcc_version} '<' 4.0
1554 then
1555 LIBTOOL_CRUFT="-lcc_dynamic"
1556 else
1557 LIBTOOL_CRUFT=""
1558 fi
1559 AC_TRY_RUN([
1560 #include <unistd.h>
1561 int main(int argc, char*argv[])
1562 {
1563 if (sizeof(long) == 4) {
1564 return 0;
1565 } else {
1566 return 1;
1567 }
1568 ], ac_osx_32bit=yes,
1569 ac_osx_32bit=no,
1570 ac_osx_32bit=yes)
1572 if test "${ac_osx_32bit}" = "yes"; then
1573 case `arch` in
1574 i386)
1575 MACOSX_DEFAULT_ARCH="i386"
1576 ;;
1577 ppc)
1578 MACOSX_DEFAULT_ARCH="ppc"
1579 ;;
1580 *)
1581 AC_MSG_ERROR([Unexpected output of 'arch' on OSX])
1582 ;;
1583 esac
1584 else
1585 case `arch` in
1586 i386)
1587 MACOSX_DEFAULT_ARCH="x86_64"
1588 ;;
1589 ppc)
1590 MACOSX_DEFAULT_ARCH="ppc64"
1591 ;;
1592 *)
1593 AC_MSG_ERROR([Unexpected output of 'arch' on OSX])
1594 ;;
1595 esac
1597 #ARCH_RUN_32BIT="true"
1598 fi
1600 LIBTOOL_CRUFT=$LIBTOOL_CRUFT" -lSystem -lSystemStubs -arch_only ${MACOSX_DEFAULT_ARCH}"
1601 LIBTOOL_CRUFT=$LIBTOOL_CRUFT' -install_name $(PYTHONFRAMEWORKINSTALLDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1602 LIBTOOL_CRUFT=$LIBTOOL_CRUFT' -compatibility_version $(VERSION) -current_version $(VERSION)';;
1603 esac
1605 AC_MSG_CHECKING(for --enable-framework)
1606 if test "$enable_framework"
1607 then
1608 BASECFLAGS="$BASECFLAGS -fno-common -dynamic"
1609 # -F. is needed to allow linking to the framework while
1610 # in the build location.
1611 AC_DEFINE(WITH_NEXT_FRAMEWORK, 1,
1612 [Define if you want to produce an OpenStep/Rhapsody framework
1613 (shared library plus accessory files).])
1614 AC_MSG_RESULT(yes)
1615 if test $enable_shared = "yes"
1616 then
1617 AC_MSG_ERROR([Specifying both --enable-shared and --enable-framework is not supported, use only --enable-framework instead])
1618 fi
1619 else
1620 AC_MSG_RESULT(no)
1621 fi
1623 AC_MSG_CHECKING(for dyld)
1624 case $ac_sys_system/$ac_sys_release in
1625 Darwin/*)
1626 AC_DEFINE(WITH_DYLD, 1,
1627 [Define if you want to use the new-style (Openstep, Rhapsody, MacOS)
1628 dynamic linker (dyld) instead of the old-style (NextStep) dynamic
1629 linker (rld). Dyld is necessary to support frameworks.])
1630 AC_MSG_RESULT(always on for Darwin)
1631 ;;
1632 *)
1633 AC_MSG_RESULT(no)
1634 ;;
1635 esac
1637 # Set info about shared libraries.
1638 AC_SUBST(SO)
1639 AC_SUBST(LDSHARED)
1640 AC_SUBST(BLDSHARED)
1641 AC_SUBST(CCSHARED)
1642 AC_SUBST(LINKFORSHARED)
1643 # SO is the extension of shared libraries `(including the dot!)
1644 # -- usually .so, .sl on HP-UX, .dll on Cygwin
1645 AC_MSG_CHECKING(SO)
1646 if test -z "$SO"
1647 then
1648 case $ac_sys_system in
1649 hp*|HP*)
1650 case `uname -m` in
1651 ia64) SO=.so;;
1652 *) SO=.sl;;
1653 esac
1654 ;;
1655 CYGWIN*) SO=.dll;;
1656 *) SO=.so;;
1657 esac
1658 else
1659 # this might also be a termcap variable, see #610332
1660 echo
1661 echo '====================================================================='
1662 echo '+ +'
1663 echo '+ WARNING: You have set SO in your environment. +'
1664 echo '+ Do you really mean to change the extension for shared libraries? +'
1665 echo '+ Continuing in 10 seconds to let you to ponder. +'
1666 echo '+ +'
1667 echo '====================================================================='
1668 sleep 10
1669 fi
1670 AC_MSG_RESULT($SO)
1672 AC_DEFINE_UNQUOTED(SHLIB_EXT, "$SO", [Define this to be extension of shared libraries (including the dot!).])
1673 # LDSHARED is the ld *command* used to create shared library
1674 # -- "cc -G" on SunOS 5.x, "ld -shared" on IRIX 5
1675 # (Shared libraries in this instance are shared modules to be loaded into
1676 # Python, as opposed to building Python itself as a shared library.)
1677 AC_MSG_CHECKING(LDSHARED)
1678 if test -z "$LDSHARED"
1679 then
1680 case $ac_sys_system/$ac_sys_release in
1681 AIX*)
1682 BLDSHARED="\$(srcdir)/Modules/ld_so_aix \$(CC) -bI:Modules/python.exp"
1683 LDSHARED="\$(BINLIBDEST)/config/ld_so_aix \$(CC) -bI:\$(BINLIBDEST)/config/python.exp"
1684 ;;
1685 BeOS*)
1686 BLDSHARED="\$(srcdir)/Modules/ld_so_beos $LDLIBRARY"
1687 LDSHARED="\$(BINLIBDEST)/config/ld_so_beos \$(LIBDIR)/$LDLIBRARY"
1688 ;;
1689 IRIX/5*) LDSHARED="ld -shared";;
1690 IRIX*/6*) LDSHARED="ld ${SGI_ABI} -shared -all";;
1691 SunOS/5*)
1692 if test "$GCC" = "yes"
1693 then LDSHARED='$(CC) -shared'
1694 else LDSHARED='$(CC) -G';
1695 fi ;;
1696 hp*|HP*)
1697 if test "$GCC" = "yes"
1698 then LDSHARED='$(CC) -shared'
1699 else LDSHARED='ld -b';
1700 fi ;;
1701 OSF*) LDSHARED="ld -shared -expect_unresolved \"*\"";;
1702 Darwin/1.3*)
1703 LDSHARED='$(CC) $(LDFLAGS) -bundle'
1704 if test "$enable_framework" ; then
1705 # Link against the framework. All externals should be defined.
1706 BLDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1707 LDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKPREFIX)/$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1708 else
1709 # No framework. Ignore undefined symbols, assuming they come from Python
1710 LDSHARED="$LDSHARED -undefined suppress"
1711 fi ;;
1712 Darwin/1.4*|Darwin/5.*|Darwin/6.*)
1713 LDSHARED='$(CC) $(LDFLAGS) -bundle'
1714 if test "$enable_framework" ; then
1715 # Link against the framework. All externals should be defined.
1716 BLDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1717 LDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKPREFIX)/$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1718 else
1719 # No framework, use the Python app as bundle-loader
1720 BLDSHARED="$LDSHARED "'-bundle_loader $(BUILDPYTHON)'
1721 LDSHARED="$LDSHARED "'-bundle_loader $(BINDIR)/python$(VERSION)$(EXE)'
1722 fi ;;
1723 Darwin/*)
1724 # Use -undefined dynamic_lookup whenever possible (10.3 and later).
1725 # This allows an extension to be used in any Python
1727 if test ${MACOSX_DEPLOYMENT_TARGET} '>' 10.2
1728 then
1729 if test "${enable_universalsdk}"; then
1730 LDFLAGS="${UNIVERSAL_ARCH_FLAGS} -isysroot ${UNIVERSALSDK} ${LDFLAGS}"
1731 fi
1732 LDSHARED='$(CC) $(LDFLAGS) -bundle -undefined dynamic_lookup'
1733 BLDSHARED="$LDSHARED"
1734 else
1735 LDSHARED='$(CC) $(LDFLAGS) -bundle'
1736 if test "$enable_framework" ; then
1737 # Link against the framework. All externals should be defined.
1738 BLDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1739 LDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKPREFIX)/$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1740 else
1741 # No framework, use the Python app as bundle-loader
1742 BLDSHARED="$LDSHARED "'-bundle_loader $(BUILDPYTHON)'
1743 LDSHARED="$LDSHARED "'-bundle_loader $(BINDIR)/python$(VERSION)$(EXE)'
1744 fi
1745 fi
1746 ;;
1747 Linux*|GNU*|QNX*) LDSHARED='$(CC) -shared';;
1748 BSD/OS*/4*) LDSHARED="gcc -shared";;
1749 FreeBSD*)
1750 if [[ "`$CC -dM -E - </dev/null | grep __ELF__`" != "" ]]
1751 then
1752 LDSHARED="$CC -shared ${LDFLAGS}"
1753 else
1754 LDSHARED="ld -Bshareable ${LDFLAGS}"
1755 fi;;
1756 OpenBSD*)
1757 if [[ "`$CC -dM -E - </dev/null | grep __ELF__`" != "" ]]
1758 then
1759 LDSHARED='$(CC) -shared $(CCSHARED) ${LDFLAGS}'
1760 else
1761 case `uname -r` in
1762 [[01]].* | 2.[[0-7]] | 2.[[0-7]].*)
1763 LDSHARED="ld -Bshareable ${LDFLAGS}"
1764 ;;
1765 *)
1766 LDSHARED='$(CC) -shared $(CCSHARED) ${LDFLAGS}'
1767 ;;
1768 esac
1769 fi;;
1770 NetBSD*|DragonFly*) LDSHARED="cc -shared ${LDFLAGS}";;
1771 OpenUNIX*|UnixWare*)
1772 if test "$GCC" = "yes"
1773 then LDSHARED='$(CC) -shared'
1774 else LDSHARED='$(CC) -G'
1775 fi;;
1776 SCO_SV*) LDSHARED='$(CC) -Wl,-G,-Bexport';;
1777 CYGWIN*) LDSHARED="gcc -shared -Wl,--enable-auto-image-base";;
1778 atheos*) LDSHARED="gcc -shared";;
1779 *) LDSHARED="ld";;
1780 esac
1781 fi
1782 AC_MSG_RESULT($LDSHARED)
1783 BLDSHARED=${BLDSHARED-$LDSHARED}
1784 # CCSHARED are the C *flags* used to create objects to go into a shared
1785 # library (module) -- this is only needed for a few systems
1786 AC_MSG_CHECKING(CCSHARED)
1787 if test -z "$CCSHARED"
1788 then
1789 case $ac_sys_system/$ac_sys_release in
1790 SunOS*) if test "$GCC" = yes;
1791 then CCSHARED="-fPIC";
1792 elif test `uname -p` = sparc;
1793 then CCSHARED="-xcode=pic32";
1794 else CCSHARED="-Kpic";
1795 fi;;
1796 hp*|HP*) if test "$GCC" = yes;
1797 then CCSHARED="-fPIC";
1798 else CCSHARED="+z";
1799 fi;;
1800 Linux*|GNU*) CCSHARED="-fPIC";;
1801 BSD/OS*/4*) CCSHARED="-fpic";;
1802 FreeBSD*|NetBSD*|OpenBSD*|DragonFly*) CCSHARED="-fPIC";;
1803 OpenUNIX*|UnixWare*)
1804 if test "$GCC" = "yes"
1805 then CCSHARED="-fPIC"
1806 else CCSHARED="-KPIC"
1807 fi;;
1808 SCO_SV*)
1809 if test "$GCC" = "yes"
1810 then CCSHARED="-fPIC"
1811 else CCSHARED="-Kpic -belf"
1812 fi;;
1813 IRIX*/6*) case $CC in
1814 *gcc*) CCSHARED="-shared";;
1815 *) CCSHARED="";;
1816 esac;;
1817 atheos*) CCSHARED="-fPIC";;
1818 esac
1819 fi
1820 AC_MSG_RESULT($CCSHARED)
1821 # LINKFORSHARED are the flags passed to the $(CC) command that links
1822 # the python executable -- this is only needed for a few systems
1823 AC_MSG_CHECKING(LINKFORSHARED)
1824 if test -z "$LINKFORSHARED"
1825 then
1826 case $ac_sys_system/$ac_sys_release in
1827 AIX*) LINKFORSHARED='-Wl,-bE:Modules/python.exp -lld';;
1828 hp*|HP*)
1829 LINKFORSHARED="-Wl,-E -Wl,+s";;
1830 # LINKFORSHARED="-Wl,-E -Wl,+s -Wl,+b\$(BINLIBDEST)/lib-dynload";;
1831 BSD/OS/4*) LINKFORSHARED="-Xlinker -export-dynamic";;
1832 Linux*|GNU*) LINKFORSHARED="-Xlinker -export-dynamic";;
1833 # -u libsys_s pulls in all symbols in libsys
1834 Darwin/*)
1835 # -u _PyMac_Error is needed to pull in the mac toolbox glue,
1836 # which is
1837 # not used by the core itself but which needs to be in the core so
1838 # that dynamically loaded extension modules have access to it.
1839 # -prebind is no longer used, because it actually seems to give a
1840 # slowdown in stead of a speedup, maybe due to the large number of
1841 # dynamic loads Python does.
1843 LINKFORSHARED="$extra_undefs"
1844 if test "$enable_framework"
1845 then
1846 LINKFORSHARED="$LINKFORSHARED "'$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1847 fi
1848 LINKFORSHARED="$LINKFORSHARED";;
1849 OpenUNIX*|UnixWare*) LINKFORSHARED="-Wl,-Bexport";;
1850 SCO_SV*) LINKFORSHARED="-Wl,-Bexport";;
1851 ReliantUNIX*) LINKFORSHARED="-W1 -Blargedynsym";;
1852 FreeBSD*|NetBSD*|OpenBSD*|DragonFly*)
1853 if [[ "`$CC -dM -E - </dev/null | grep __ELF__`" != "" ]]
1854 then
1855 LINKFORSHARED="-Wl,--export-dynamic"
1856 fi;;
1857 SunOS/5*) case $CC in
1858 *gcc*)
1859 if $CC -Xlinker --help 2>&1 | grep export-dynamic >/dev/null
1860 then
1861 LINKFORSHARED="-Xlinker --export-dynamic"
1862 fi;;
1863 esac;;
1864 CYGWIN*)
1865 if test $enable_shared = "no"
1866 then
1867 LINKFORSHARED='-Wl,--out-implib=$(LDLIBRARY)'
1868 fi;;
1869 QNX*)
1870 # -Wl,-E causes the symbols to be added to the dynamic
1871 # symbol table so that they can be found when a module
1872 # is loaded. -N 2048K causes the stack size to be set
1873 # to 2048 kilobytes so that the stack doesn't overflow
1874 # when running test_compile.py.
1875 LINKFORSHARED='-Wl,-E -N 2048K';;
1876 esac
1877 fi
1878 AC_MSG_RESULT($LINKFORSHARED)
1881 AC_SUBST(CFLAGSFORSHARED)
1882 AC_MSG_CHECKING(CFLAGSFORSHARED)
1883 if test ! "$LIBRARY" = "$LDLIBRARY"
1884 then
1885 case $ac_sys_system in
1886 CYGWIN*)
1887 # Cygwin needs CCSHARED when building extension DLLs
1888 # but not when building the interpreter DLL.
1889 CFLAGSFORSHARED='';;
1890 *)
1891 CFLAGSFORSHARED='$(CCSHARED)'
1892 esac
1893 fi
1894 AC_MSG_RESULT($CFLAGSFORSHARED)
1896 # SHLIBS are libraries (except -lc and -lm) to link to the python shared
1897 # library (with --enable-shared).
1898 # For platforms on which shared libraries are not allowed to have unresolved
1899 # symbols, this must be set to $(LIBS) (expanded by make). We do this even
1900 # if it is not required, since it creates a dependency of the shared library
1901 # to LIBS. This, in turn, means that applications linking the shared libpython
1902 # don't need to link LIBS explicitly. The default should be only changed
1903 # on systems where this approach causes problems.
1904 AC_SUBST(SHLIBS)
1905 AC_MSG_CHECKING(SHLIBS)
1906 case "$ac_sys_system" in
1907 *)
1908 SHLIBS='$(LIBS)';;
1909 esac
1910 AC_MSG_RESULT($SHLIBS)
1913 # checks for libraries
1914 AC_CHECK_LIB(dl, dlopen) # Dynamic linking for SunOS/Solaris and SYSV
1915 AC_CHECK_LIB(dld, shl_load) # Dynamic linking for HP-UX
1917 # only check for sem_init if thread support is requested
1918 if test "$with_threads" = "yes" -o -z "$with_threads"; then
1919 AC_SEARCH_LIBS(sem_init, pthread rt posix4) # 'Real Time' functions on Solaris
1920 # posix4 on Solaris 2.6
1921 # pthread (first!) on Linux
1922 fi
1924 # check if we need libintl for locale functions
1925 AC_CHECK_LIB(intl, textdomain,
1926 AC_DEFINE(WITH_LIBINTL, 1,
1927 [Define to 1 if libintl is needed for locale functions.]))
1929 # checks for system dependent C++ extensions support
1930 case "$ac_sys_system" in
1931 AIX*) AC_MSG_CHECKING(for genuine AIX C++ extensions support)
1932 AC_TRY_LINK([#include "/usr/lpp/xlC/include/load.h"],
1933 [loadAndInit("", 0, "")],
1934 [AC_DEFINE(AIX_GENUINE_CPLUSPLUS, 1,
1935 [Define for AIX if your compiler is a genuine IBM xlC/xlC_r
1936 and you want support for AIX C++ shared extension modules.])
1937 AC_MSG_RESULT(yes)],
1938 [AC_MSG_RESULT(no)]);;
1939 *) ;;
1940 esac
1942 # Most SVR4 platforms (e.g. Solaris) need -lsocket and -lnsl.
1943 # BeOS' sockets are stashed in libnet.
1944 AC_CHECK_LIB(nsl, t_open, [LIBS="-lnsl $LIBS"]) # SVR4
1945 AC_CHECK_LIB(socket, socket, [LIBS="-lsocket $LIBS"], [], $LIBS) # SVR4 sockets
1947 case "$ac_sys_system" in
1948 BeOS*)
1949 AC_CHECK_LIB(net, socket, [LIBS="-lnet $LIBS"], [], $LIBS) # BeOS
1950 ;;
1951 esac
1953 AC_MSG_CHECKING(for --with-libs)
1954 AC_ARG_WITH(libs,
1955 AC_HELP_STRING(--with-libs='lib1 ...', link against additional libs),
1956 [
1957 AC_MSG_RESULT($withval)
1958 LIBS="$withval $LIBS"
1959 ],
1960 [AC_MSG_RESULT(no)])
1962 # Check for use of the system libffi library
1963 AC_MSG_CHECKING(for --with-system-ffi)
1964 AC_ARG_WITH(system_ffi,
1965 AC_HELP_STRING(--with-system-ffi, build _ctypes module using an installed ffi library))
1967 AC_MSG_RESULT($with_system_ffi)
1969 # Check for --with-dbmliborder
1970 AC_MSG_CHECKING(for --with-dbmliborder)
1971 AC_ARG_WITH(dbmliborder,
1972 AC_HELP_STRING([--with-dbmliborder=db1:db2:...], [order to check db backends for dbm. Valid value is a colon separated string with the backend names `ndbm', `gdbm' and `bdb'.]),
1973 [
1974 if test x$with_dbmliborder = xyes
1975 then
1976 AC_MSG_ERROR([proper usage is --with-dbmliborder=db1:db2:...])
1977 else
1978 for db in `echo $with_dbmliborder | sed 's/:/ /g'`; do
1979 if test x$db != xndbm && test x$db != xgdbm && test x$db != xbdb
1980 then
1981 AC_MSG_ERROR([proper usage is --with-dbmliborder=db1:db2:...])
1982 fi
1983 done
1984 fi])
1985 AC_MSG_RESULT($with_dbmliborder)
1987 # Determine if signalmodule should be used.
1988 AC_SUBST(USE_SIGNAL_MODULE)
1989 AC_SUBST(SIGNAL_OBJS)
1990 AC_MSG_CHECKING(for --with-signal-module)
1991 AC_ARG_WITH(signal-module,
1992 AC_HELP_STRING(--with-signal-module, disable/enable signal module))
1994 if test -z "$with_signal_module"
1995 then with_signal_module="yes"
1996 fi
1997 AC_MSG_RESULT($with_signal_module)
1999 if test "${with_signal_module}" = "yes"; then
2000 USE_SIGNAL_MODULE=""
2001 SIGNAL_OBJS=""
2002 else
2003 USE_SIGNAL_MODULE="#"
2004 SIGNAL_OBJS="Parser/intrcheck.o Python/sigcheck.o"
2005 fi
2007 # This is used to generate Setup.config
2008 AC_SUBST(USE_THREAD_MODULE)
2009 USE_THREAD_MODULE=""
2011 AC_MSG_CHECKING(for --with-dec-threads)
2012 AC_SUBST(LDLAST)
2013 AC_ARG_WITH(dec-threads,
2014 AC_HELP_STRING(--with-dec-threads, use DEC Alpha/OSF1 thread-safe libraries),
2015 [
2016 AC_MSG_RESULT($withval)
2017 LDLAST=-threads
2018 if test "${with_thread+set}" != set; then
2019 with_thread="$withval";
2020 fi],
2021 [AC_MSG_RESULT(no)])
2023 # Templates for things AC_DEFINEd more than once.
2024 # For a single AC_DEFINE, no template is needed.
2025 AH_TEMPLATE(C_THREADS,[Define if you have the Mach cthreads package])
2026 AH_TEMPLATE(_REENTRANT,
2027 [Define to force use of thread-safe errno, h_errno, and other functions])
2028 AH_TEMPLATE(WITH_THREAD,
2029 [Define if you want to compile in rudimentary thread support])
2031 AC_MSG_CHECKING(for --with-threads)
2032 dnl quadrigraphs "@<:@" and "@:>@" produce "[" and "]" in the output
2033 AC_ARG_WITH(threads,
2034 AC_HELP_STRING(--with(out)-threads@<:@=DIRECTORY@:>@, disable/enable thread support))
2036 # --with-thread is deprecated, but check for it anyway
2037 dnl quadrigraphs "@<:@" and "@:>@" produce "[" and "]" in the output
2038 AC_ARG_WITH(thread,
2039 AC_HELP_STRING(--with(out)-thread@<:@=DIRECTORY@:>@, deprecated; use --with(out)-threads),
2040 [with_threads=$with_thread])
2042 if test -z "$with_threads"
2043 then with_threads="yes"
2044 fi
2045 AC_MSG_RESULT($with_threads)
2047 AC_SUBST(THREADOBJ)
2048 if test "$with_threads" = "no"
2049 then
2050 USE_THREAD_MODULE="#"
2051 elif test "$ac_cv_pthread_is_default" = yes
2052 then
2053 AC_DEFINE(WITH_THREAD)
2054 # Defining _REENTRANT on system with POSIX threads should not hurt.
2055 AC_DEFINE(_REENTRANT)
2056 posix_threads=yes
2057 THREADOBJ="Python/thread.o"
2058 elif test "$ac_cv_kpthread" = "yes"
2059 then
2060 CC="$CC -Kpthread"
2061 if test "$ac_cv_cxx_thread" = "yes"; then
2062 CXX="$CXX -Kpthread"
2063 fi
2064 AC_DEFINE(WITH_THREAD)
2065 posix_threads=yes
2066 THREADOBJ="Python/thread.o"
2067 elif test "$ac_cv_kthread" = "yes"
2068 then
2069 CC="$CC -Kthread"
2070 if test "$ac_cv_cxx_thread" = "yes"; then
2071 CXX="$CXX -Kthread"
2072 fi
2073 AC_DEFINE(WITH_THREAD)
2074 posix_threads=yes
2075 THREADOBJ="Python/thread.o"
2076 elif test "$ac_cv_pthread" = "yes"
2077 then
2078 CC="$CC -pthread"
2079 if test "$ac_cv_cxx_thread" = "yes"; then
2080 CXX="$CXX -pthread"
2081 fi
2082 AC_DEFINE(WITH_THREAD)
2083 posix_threads=yes
2084 THREADOBJ="Python/thread.o"
2085 else
2086 if test ! -z "$with_threads" -a -d "$with_threads"
2087 then LDFLAGS="$LDFLAGS -L$with_threads"
2088 fi
2089 if test ! -z "$withval" -a -d "$withval"
2090 then LDFLAGS="$LDFLAGS -L$withval"
2091 fi
2093 # According to the POSIX spec, a pthreads implementation must
2094 # define _POSIX_THREADS in unistd.h. Some apparently don't
2095 # (e.g. gnu pth with pthread emulation)
2096 AC_MSG_CHECKING(for _POSIX_THREADS in unistd.h)
2097 AC_EGREP_CPP(yes,
2098 [
2099 #include <unistd.h>
2100 #ifdef _POSIX_THREADS
2101 yes
2102 #endif
2103 ], unistd_defines_pthreads=yes, unistd_defines_pthreads=no)
2104 AC_MSG_RESULT($unistd_defines_pthreads)
2106 AC_DEFINE(_REENTRANT)
2107 AC_CHECK_HEADER(cthreads.h, [AC_DEFINE(WITH_THREAD)
2108 AC_DEFINE(C_THREADS)
2109 AC_DEFINE(HURD_C_THREADS, 1,
2110 [Define if you are using Mach cthreads directly under /include])
2111 LIBS="$LIBS -lthreads"
2112 THREADOBJ="Python/thread.o"],[
2113 AC_CHECK_HEADER(mach/cthreads.h, [AC_DEFINE(WITH_THREAD)
2114 AC_DEFINE(C_THREADS)
2115 AC_DEFINE(MACH_C_THREADS, 1,
2116 [Define if you are using Mach cthreads under mach /])
2117 THREADOBJ="Python/thread.o"],[
2118 AC_MSG_CHECKING(for --with-pth)
2119 AC_ARG_WITH([pth],
2120 AC_HELP_STRING(--with-pth, use GNU pth threading libraries),
2121 [AC_MSG_RESULT($withval)
2122 AC_DEFINE([WITH_THREAD])
2123 AC_DEFINE([HAVE_PTH], 1,
2124 [Define if you have GNU PTH threads.])
2125 LIBS="-lpth $LIBS"
2126 THREADOBJ="Python/thread.o"],
2127 [AC_MSG_RESULT(no)
2129 # Just looking for pthread_create in libpthread is not enough:
2130 # on HP/UX, pthread.h renames pthread_create to a different symbol name.
2131 # So we really have to include pthread.h, and then link.
2132 _libs=$LIBS
2133 LIBS="$LIBS -lpthread"
2134 AC_MSG_CHECKING([for pthread_create in -lpthread])
2135 AC_TRY_LINK([#include <pthread.h>
2137 void * start_routine (void *arg) { exit (0); }], [
2138 pthread_create (NULL, NULL, start_routine, NULL)], [
2139 AC_MSG_RESULT(yes)
2140 AC_DEFINE(WITH_THREAD)
2141 posix_threads=yes
2142 THREADOBJ="Python/thread.o"],[
2143 LIBS=$_libs
2144 AC_CHECK_FUNC(pthread_detach, [AC_DEFINE(WITH_THREAD)
2145 posix_threads=yes
2146 THREADOBJ="Python/thread.o"],[
2147 AC_CHECK_HEADER(atheos/threads.h, [AC_DEFINE(WITH_THREAD)
2148 AC_DEFINE(ATHEOS_THREADS, 1,
2149 [Define this if you have AtheOS threads.])
2150 THREADOBJ="Python/thread.o"],[
2151 AC_CHECK_HEADER(kernel/OS.h, [AC_DEFINE(WITH_THREAD)
2152 AC_DEFINE(BEOS_THREADS, 1,
2153 [Define this if you have BeOS threads.])
2154 THREADOBJ="Python/thread.o"],[
2155 AC_CHECK_LIB(pthreads, pthread_create, [AC_DEFINE(WITH_THREAD)
2156 posix_threads=yes
2157 LIBS="$LIBS -lpthreads"
2158 THREADOBJ="Python/thread.o"], [
2159 AC_CHECK_LIB(c_r, pthread_create, [AC_DEFINE(WITH_THREAD)
2160 posix_threads=yes
2161 LIBS="$LIBS -lc_r"
2162 THREADOBJ="Python/thread.o"], [
2163 AC_CHECK_LIB(pthread, __pthread_create_system, [AC_DEFINE(WITH_THREAD)
2164 posix_threads=yes
2165 LIBS="$LIBS -lpthread"
2166 THREADOBJ="Python/thread.o"], [
2167 AC_CHECK_LIB(cma, pthread_create, [AC_DEFINE(WITH_THREAD)
2168 posix_threads=yes
2169 LIBS="$LIBS -lcma"
2170 THREADOBJ="Python/thread.o"],[
2171 USE_THREAD_MODULE="#"])
2172 ])])])])])])])])])])
2174 AC_CHECK_LIB(mpc, usconfig, [AC_DEFINE(WITH_THREAD)
2175 LIBS="$LIBS -lmpc"
2176 THREADOBJ="Python/thread.o"
2177 USE_THREAD_MODULE=""])
2179 if test "$posix_threads" != "yes"; then
2180 AC_CHECK_LIB(thread, thr_create, [AC_DEFINE(WITH_THREAD)
2181 LIBS="$LIBS -lthread"
2182 THREADOBJ="Python/thread.o"
2183 USE_THREAD_MODULE=""])
2184 fi
2186 if test "$USE_THREAD_MODULE" != "#"
2187 then
2188 # If the above checks didn't disable threads, (at least) OSF1
2189 # needs this '-threads' argument during linking.
2190 case $ac_sys_system in
2191 OSF1) LDLAST=-threads;;
2192 esac
2193 fi
2194 fi
2196 if test "$posix_threads" = "yes"; then
2197 if test "$unistd_defines_pthreads" = "no"; then
2198 AC_DEFINE(_POSIX_THREADS, 1,
2199 [Define if you have POSIX threads,
2200 and your system does not define that.])
2201 fi
2203 # Bug 662787: Using semaphores causes unexplicable hangs on Solaris 8.
2204 case $ac_sys_system/$ac_sys_release in
2205 SunOS/5.6) AC_DEFINE(HAVE_PTHREAD_DESTRUCTOR, 1,
2206 Defined for Solaris 2.6 bug in pthread header.)
2207 ;;
2208 SunOS/5.8) AC_DEFINE(HAVE_BROKEN_POSIX_SEMAPHORES, 1,
2209 Define if the Posix semaphores do not work on your system)
2210 ;;
2211 AIX/5) AC_DEFINE(HAVE_BROKEN_POSIX_SEMAPHORES, 1,
2212 Define if the Posix semaphores do not work on your system)
2213 ;;
2214 esac
2216 AC_MSG_CHECKING(if PTHREAD_SCOPE_SYSTEM is supported)
2217 AC_CACHE_VAL(ac_cv_pthread_system_supported,
2218 [AC_TRY_RUN([#include <pthread.h>
2219 void *foo(void *parm) {
2220 return NULL;
2221 }
2222 main() {
2223 pthread_attr_t attr;
2224 pthread_t id;
2225 if (pthread_attr_init(&attr)) exit(-1);
2226 if (pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM)) exit(-1);
2227 if (pthread_create(&id, &attr, foo, NULL)) exit(-1);
2228 exit(0);
2229 }],
2230 ac_cv_pthread_system_supported=yes,
2231 ac_cv_pthread_system_supported=no,
2232 ac_cv_pthread_system_supported=no)
2233 ])
2234 AC_MSG_RESULT($ac_cv_pthread_system_supported)
2235 if test "$ac_cv_pthread_system_supported" = "yes"; then
2236 AC_DEFINE(PTHREAD_SYSTEM_SCHED_SUPPORTED, 1, [Defined if PTHREAD_SCOPE_SYSTEM supported.])
2237 fi
2238 AC_CHECK_FUNCS(pthread_sigmask,
2239 [case $ac_sys_system in
2240 CYGWIN*)
2241 AC_DEFINE(HAVE_BROKEN_PTHREAD_SIGMASK, 1,
2242 [Define if pthread_sigmask() does not work on your system.])
2243 ;;
2244 esac])
2245 fi
2248 # Check for enable-ipv6
2249 AH_TEMPLATE(ENABLE_IPV6, [Define if --enable-ipv6 is specified])
2250 AC_MSG_CHECKING([if --enable-ipv6 is specified])
2251 AC_ARG_ENABLE(ipv6,
2252 [ --enable-ipv6 Enable ipv6 (with ipv4) support
2253 --disable-ipv6 Disable ipv6 support],
2254 [ case "$enableval" in
2255 no)
2256 AC_MSG_RESULT(no)
2257 ipv6=no
2258 ;;
2259 *) AC_MSG_RESULT(yes)
2260 AC_DEFINE(ENABLE_IPV6)
2261 ipv6=yes
2262 ;;
2263 esac ],
2265 [
2266 dnl the check does not work on cross compilation case...
2267 AC_TRY_RUN([ /* AF_INET6 available check */
2268 #include <sys/types.h>
2269 #include <sys/socket.h>
2270 main()
2271 {
2272 if (socket(AF_INET6, SOCK_STREAM, 0) < 0)
2273 exit(1);
2274 else
2275 exit(0);
2276 }
2277 ],
2278 AC_MSG_RESULT(yes)
2279 ipv6=yes,
2280 AC_MSG_RESULT(no)
2281 ipv6=no,
2282 AC_MSG_RESULT(no)
2283 ipv6=no
2284 )
2286 if test "$ipv6" = "yes"; then
2287 AC_MSG_CHECKING(if RFC2553 API is available)
2288 AC_TRY_COMPILE([#include <sys/types.h>
2289 #include <netinet/in.h>],
2290 [struct sockaddr_in6 x;
2291 x.sin6_scope_id;],
2292 AC_MSG_RESULT(yes)
2293 ipv6=yes,
2294 AC_MSG_RESULT(no, IPv6 disabled)
2295 ipv6=no)
2296 fi
2298 if test "$ipv6" = "yes"; then
2299 AC_DEFINE(ENABLE_IPV6)
2300 fi
2301 ])
2303 ipv6type=unknown
2304 ipv6lib=none
2305 ipv6trylibc=no
2307 if test "$ipv6" = "yes"; then
2308 AC_MSG_CHECKING([ipv6 stack type])
2309 for i in inria kame linux-glibc linux-inet6 solaris toshiba v6d zeta;
2310 do
2311 case $i in
2312 inria)
2313 dnl http://www.kame.net/
2314 AC_EGREP_CPP(yes, [
2315 #include <netinet/in.h>
2316 #ifdef IPV6_INRIA_VERSION
2317 yes
2318 #endif],
2319 [ipv6type=$i])
2320 ;;
2321 kame)
2322 dnl http://www.kame.net/
2323 AC_EGREP_CPP(yes, [
2324 #include <netinet/in.h>
2325 #ifdef __KAME__
2326 yes
2327 #endif],
2328 [ipv6type=$i;
2329 ipv6lib=inet6
2330 ipv6libdir=/usr/local/v6/lib
2331 ipv6trylibc=yes])
2332 ;;
2333 linux-glibc)
2334 dnl http://www.v6.linux.or.jp/
2335 AC_EGREP_CPP(yes, [
2336 #include <features.h>
2337 #if defined(__GLIBC__) && ((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 1) || (__GLIBC__ > 2))
2338 yes
2339 #endif],
2340 [ipv6type=$i;
2341 ipv6trylibc=yes])
2342 ;;
2343 linux-inet6)
2344 dnl http://www.v6.linux.or.jp/
2345 if test -d /usr/inet6; then
2346 ipv6type=$i
2347 ipv6lib=inet6
2348 ipv6libdir=/usr/inet6/lib
2349 BASECFLAGS="-I/usr/inet6/include $BASECFLAGS"
2350 fi
2351 ;;
2352 solaris)
2353 if test -f /etc/netconfig; then
2354 if /usr/xpg4/bin/grep -q tcp6 /etc/netconfig; then
2355 ipv6type=$i
2356 ipv6trylibc=yes
2357 fi
2358 fi
2359 ;;
2360 toshiba)
2361 AC_EGREP_CPP(yes, [
2362 #include <sys/param.h>
2363 #ifdef _TOSHIBA_INET6
2364 yes
2365 #endif],
2366 [ipv6type=$i;
2367 ipv6lib=inet6;
2368 ipv6libdir=/usr/local/v6/lib])
2369 ;;
2370 v6d)
2371 AC_EGREP_CPP(yes, [
2372 #include </usr/local/v6/include/sys/v6config.h>
2373 #ifdef __V6D__
2374 yes
2375 #endif],
2376 [ipv6type=$i;
2377 ipv6lib=v6;
2378 ipv6libdir=/usr/local/v6/lib;
2379 BASECFLAGS="-I/usr/local/v6/include $BASECFLAGS"])
2380 ;;
2381 zeta)
2382 AC_EGREP_CPP(yes, [
2383 #include <sys/param.h>
2384 #ifdef _ZETA_MINAMI_INET6
2385 yes
2386 #endif],
2387 [ipv6type=$i;
2388 ipv6lib=inet6;
2389 ipv6libdir=/usr/local/v6/lib])
2390 ;;
2391 esac
2392 if test "$ipv6type" != "unknown"; then
2393 break
2394 fi
2395 done
2396 AC_MSG_RESULT($ipv6type)
2397 fi
2399 if test "$ipv6" = "yes" -a "$ipv6lib" != "none"; then
2400 if test -d $ipv6libdir -a -f $ipv6libdir/lib$ipv6lib.a; then
2401 LIBS="-L$ipv6libdir -l$ipv6lib $LIBS"
2402 echo "using lib$ipv6lib"
2403 else
2404 if test $ipv6trylibc = "yes"; then
2405 echo "using libc"
2406 else
2407 echo 'Fatal: no $ipv6lib library found. cannot continue.'
2408 echo "You need to fetch lib$ipv6lib.a from appropriate"
2409 echo 'ipv6 kit and compile beforehand.'
2410 exit 1
2411 fi
2412 fi
2413 fi
2415 AC_MSG_CHECKING(for OSX 10.5 SDK or later)
2416 AC_TRY_COMPILE([#include <Carbon/Carbon.h>], FSIORefNum fRef = 0,
2417 AC_DEFINE(HAVE_OSX105_SDK, 1, Define if compiling using MacOS X 10.5 SDK or later.)
2418 AC_MSG_RESULT(yes),
2419 AC_MSG_RESULT(no)
2420 )
2422 # Check for --with-doc-strings
2423 AC_MSG_CHECKING(for --with-doc-strings)
2424 AC_ARG_WITH(doc-strings,
2425 AC_HELP_STRING(--with(out)-doc-strings, disable/enable documentation strings))
2427 if test -z "$with_doc_strings"
2428 then with_doc_strings="yes"
2429 fi
2430 if test "$with_doc_strings" != "no"
2431 then
2432 AC_DEFINE(WITH_DOC_STRINGS, 1,
2433 [Define if you want documentation strings in extension modules])
2434 fi
2435 AC_MSG_RESULT($with_doc_strings)
2437 # Check for Python-specific malloc support
2438 AC_MSG_CHECKING(for --with-tsc)
2439 AC_ARG_WITH(tsc,
2440 [ --with(out)-tsc enable/disable timestamp counter profile], [
2441 if test "$withval" != no
2442 then
2443 AC_DEFINE(WITH_TSC, 1,
2444 [Define to profile with the Pentium timestamp counter])
2445 AC_MSG_RESULT(yes)
2446 else AC_MSG_RESULT(no)
2447 fi],
2448 [AC_MSG_RESULT(no)])
2450 # Check for Python-specific malloc support
2451 AC_MSG_CHECKING(for --with-pymalloc)
2452 AC_ARG_WITH(pymalloc,
2453 AC_HELP_STRING(--with(out)-pymalloc, disable/enable specialized mallocs))
2455 if test -z "$with_pymalloc"
2456 then with_pymalloc="yes"
2457 fi
2458 if test "$with_pymalloc" != "no"
2459 then
2460 AC_DEFINE(WITH_PYMALLOC, 1,
2461 [Define if you want to compile in Python-specific mallocs])
2462 fi
2463 AC_MSG_RESULT($with_pymalloc)
2465 # Check for --with-wctype-functions
2466 AC_MSG_CHECKING(for --with-wctype-functions)
2467 AC_ARG_WITH(wctype-functions,
2468 AC_HELP_STRING(--with-wctype-functions, use wctype.h functions),
2469 [
2470 if test "$withval" != no
2471 then
2472 AC_DEFINE(WANT_WCTYPE_FUNCTIONS, 1,
2473 [Define if you want wctype.h functions to be used instead of the
2474 one supplied by Python itself. (see Include/unicodectype.h).])
2475 AC_MSG_RESULT(yes)
2476 else AC_MSG_RESULT(no)
2477 fi],
2478 [AC_MSG_RESULT(no)])
2480 # -I${DLINCLDIR} is added to the compile rule for importdl.o
2481 AC_SUBST(DLINCLDIR)
2482 DLINCLDIR=.
2484 # the dlopen() function means we might want to use dynload_shlib.o. some
2485 # platforms, such as AIX, have dlopen(), but don't want to use it.
2486 AC_CHECK_FUNCS(dlopen)
2488 # DYNLOADFILE specifies which dynload_*.o file we will use for dynamic
2489 # loading of modules.
2490 AC_SUBST(DYNLOADFILE)
2491 AC_MSG_CHECKING(DYNLOADFILE)
2492 if test -z "$DYNLOADFILE"
2493 then
2494 case $ac_sys_system/$ac_sys_release in
2495 AIX*) # Use dynload_shlib.c and dlopen() if we have it; otherwise dynload_aix.c
2496 if test "$ac_cv_func_dlopen" = yes
2497 then DYNLOADFILE="dynload_shlib.o"
2498 else DYNLOADFILE="dynload_aix.o"
2499 fi
2500 ;;
2501 BeOS*) DYNLOADFILE="dynload_beos.o";;
2502 hp*|HP*) DYNLOADFILE="dynload_hpux.o";;
2503 # Use dynload_next.c only on 10.2 and below, which don't have native dlopen()
2504 Darwin/@<:@0156@:>@\..*) DYNLOADFILE="dynload_next.o";;
2505 atheos*) DYNLOADFILE="dynload_atheos.o";;
2506 *)
2507 # use dynload_shlib.c and dlopen() if we have it; otherwise stub
2508 # out any dynamic loading
2509 if test "$ac_cv_func_dlopen" = yes
2510 then DYNLOADFILE="dynload_shlib.o"
2511 else DYNLOADFILE="dynload_stub.o"
2512 fi
2513 ;;
2514 esac
2515 fi
2516 AC_MSG_RESULT($DYNLOADFILE)
2517 if test "$DYNLOADFILE" != "dynload_stub.o"
2518 then
2519 AC_DEFINE(HAVE_DYNAMIC_LOADING, 1,
2520 [Defined when any dynamic module loading is enabled.])
2521 fi
2523 # MACHDEP_OBJS can be set to platform-specific object files needed by Python
2525 AC_SUBST(MACHDEP_OBJS)
2526 AC_MSG_CHECKING(MACHDEP_OBJS)
2527 if test -z "$MACHDEP_OBJS"
2528 then
2529 MACHDEP_OBJS=$extra_machdep_objs
2530 else
2531 MACHDEP_OBJS="$MACHDEP_OBJS $extra_machdep_objs"
2532 fi
2533 AC_MSG_RESULT(MACHDEP_OBJS)
2535 # checks for library functions
2536 AC_CHECK_FUNCS(alarm setitimer getitimer bind_textdomain_codeset chown \
2537 clock confstr ctermid execv fchmod fchown fork fpathconf ftime ftruncate \
2538 gai_strerror getgroups getlogin getloadavg getpeername getpgid getpid \
2539 getpriority getpwent getspnam getspent getsid getwd \
2540 kill killpg lchmod lchown lstat mkfifo mknod mktime \
2541 mremap nice pathconf pause plock poll pthread_init \
2542 putenv readlink realpath \
2543 select sem_open sem_timedwait sem_getvalue sem_unlink setegid seteuid \
2544 setgid \
2545 setlocale setregid setreuid setsid setpgid setpgrp setuid setvbuf snprintf \
2546 sigaction siginterrupt sigrelse strftime \
2547 sysconf tcgetpgrp tcsetpgrp tempnam timegm times tmpfile tmpnam tmpnam_r \
2548 truncate uname unsetenv utimes waitpid wait3 wait4 wcscoll _getpty)
2550 # For some functions, having a definition is not sufficient, since
2551 # we want to take their address.
2552 AC_MSG_CHECKING(for chroot)
2553 AC_TRY_COMPILE([#include <unistd.h>], void *x=chroot,
2554 AC_DEFINE(HAVE_CHROOT, 1, Define if you have the 'chroot' function.)
2555 AC_MSG_RESULT(yes),
2556 AC_MSG_RESULT(no)
2557 )
2558 AC_MSG_CHECKING(for link)
2559 AC_TRY_COMPILE([#include <unistd.h>], void *x=link,
2560 AC_DEFINE(HAVE_LINK, 1, Define if you have the 'link' function.)
2561 AC_MSG_RESULT(yes),
2562 AC_MSG_RESULT(no)
2563 )
2564 AC_MSG_CHECKING(for symlink)
2565 AC_TRY_COMPILE([#include <unistd.h>], void *x=symlink,
2566 AC_DEFINE(HAVE_SYMLINK, 1, Define if you have the 'symlink' function.)
2567 AC_MSG_RESULT(yes),
2568 AC_MSG_RESULT(no)
2569 )
2570 AC_MSG_CHECKING(for fchdir)
2571 AC_TRY_COMPILE([#include <unistd.h>], void *x=fchdir,
2572 AC_DEFINE(HAVE_FCHDIR, 1, Define if you have the 'fchdir' function.)
2573 AC_MSG_RESULT(yes),
2574 AC_MSG_RESULT(no)
2575 )
2576 AC_MSG_CHECKING(for fsync)
2577 AC_TRY_COMPILE([#include <unistd.h>], void *x=fsync,
2578 AC_DEFINE(HAVE_FSYNC, 1, Define if you have the 'fsync' function.)
2579 AC_MSG_RESULT(yes),
2580 AC_MSG_RESULT(no)
2581 )
2582 AC_MSG_CHECKING(for fdatasync)
2583 AC_TRY_COMPILE([#include <unistd.h>], void *x=fdatasync,
2584 AC_DEFINE(HAVE_FDATASYNC, 1, Define if you have the 'fdatasync' function.)
2585 AC_MSG_RESULT(yes),
2586 AC_MSG_RESULT(no)
2587 )
2588 AC_MSG_CHECKING(for epoll)
2589 AC_TRY_COMPILE([#include <sys/epoll.h>], void *x=epoll_create,
2590 AC_DEFINE(HAVE_EPOLL, 1, Define if you have the 'epoll' functions.)
2591 AC_MSG_RESULT(yes),
2592 AC_MSG_RESULT(no)
2593 )
2594 AC_MSG_CHECKING(for kqueue)
2595 AC_TRY_COMPILE([
2596 #include <sys/types.h>
2597 #include <sys/event.h>
2598 ], int x=kqueue(),
2599 AC_DEFINE(HAVE_KQUEUE, 1, Define if you have the 'kqueue' functions.)
2600 AC_MSG_RESULT(yes),
2601 AC_MSG_RESULT(no)
2602 )
2603 # On some systems (eg. FreeBSD 5), we would find a definition of the
2604 # functions ctermid_r, setgroups in the library, but no prototype
2605 # (e.g. because we use _XOPEN_SOURCE). See whether we can take their
2606 # address to avoid compiler warnings and potential miscompilations
2607 # because of the missing prototypes.
2609 AC_MSG_CHECKING(for ctermid_r)
2610 AC_TRY_COMPILE([
2611 #include "confdefs.h"
2612 #include <stdio.h>
2613 ], void* p = ctermid_r,
2614 AC_DEFINE(HAVE_CTERMID_R, 1, Define if you have the 'ctermid_r' function.)
2615 AC_MSG_RESULT(yes),
2616 AC_MSG_RESULT(no)
2617 )
2619 AC_MSG_CHECKING(for flock)
2620 AC_TRY_COMPILE([
2621 #include "confdefs.h"
2622 #include <sys/file.h>
2623 ], void* p = flock,
2624 AC_DEFINE(HAVE_FLOCK, 1, Define if you have the 'flock' function.)
2625 AC_MSG_RESULT(yes),
2626 AC_MSG_RESULT(no)
2627 )
2629 AC_MSG_CHECKING(for getpagesize)
2630 AC_TRY_COMPILE([
2631 #include "confdefs.h"
2632 #include <unistd.h>
2633 ], void* p = getpagesize,
2634 AC_DEFINE(HAVE_GETPAGESIZE, 1, Define if you have the 'getpagesize' function.)
2635 AC_MSG_RESULT(yes),
2636 AC_MSG_RESULT(no)
2637 )
2639 dnl check for true
2640 AC_CHECK_PROGS(TRUE, true, /bin/true)
2642 dnl On some systems (e.g. Solaris 9), hstrerror and inet_aton are in -lresolv
2643 dnl On others, they are in the C library, so we to take no action
2644 AC_CHECK_LIB(c, inet_aton, [$ac_cv_prog_TRUE],
2645 AC_CHECK_LIB(resolv, inet_aton)
2646 )
2648 # On Tru64, chflags seems to be present, but calling it will
2649 # exit Python
2650 AC_MSG_CHECKING(for chflags)
2651 AC_CACHE_VAL(ac_cv_have_chflags,
2652 AC_TRY_RUN([[
2653 #include <sys/stat.h>
2654 #include <unistd.h>
2655 int main(int argc, char*argv[])
2656 {
2657 if(chflags(argv[0], 0) != 0)
2658 return 1;
2659 return 0;
2660 }
2661 ]], ac_cv_have_chflags=yes,
2662 ac_cv_have_chflags=no,
2663 ac_cv_have_chflags=no)
2664 )
2665 AC_MSG_RESULT($ac_cv_have_chflags)
2666 if test $ac_cv_have_chflags = yes
2667 then
2668 AC_DEFINE(HAVE_CHFLAGS, 1, Define to 1 if you have the `chflags' function.)
2669 fi
2671 AC_MSG_CHECKING(for lchflags)
2672 AC_CACHE_VAL(ac_cv_have_lchflags,
2673 AC_TRY_RUN([[
2674 #include <sys/stat.h>
2675 #include <unistd.h>
2676 int main(int argc, char*argv[])
2677 {
2678 if(lchflags(argv[0], 0) != 0)
2679 return 1;
2680 return 0;
2681 }
2682 ]], ac_cv_have_lchflags=yes,
2683 ac_cv_have_lchflags=no,
2684 ac_cv_have_lchflags=no)
2685 )
2686 AC_MSG_RESULT($ac_cv_have_lchflags)
2687 if test $ac_cv_have_lchflags = yes
2688 then
2689 AC_DEFINE(HAVE_LCHFLAGS, 1, Define to 1 if you have the `lchflags' function.)
2690 fi
2692 dnl Check if system zlib has *Copy() functions
2693 dnl
2694 dnl On MacOSX the linker will search for dylibs on the entire linker path
2695 dnl before searching for static libraries. setup.py adds -Wl,-search_paths_first
2696 dnl to revert to a more traditional unix behaviour and make it possible to
2697 dnl override the system libz with a local static library of libz. Temporarily
2698 dnl add that flag to our CFLAGS as well to ensure that we check the version
2699 dnl of libz that will be used by setup.py.
2700 dnl The -L/usr/local/lib is needed as wel to get the same compilation
2701 dnl environment as setup.py (and leaving it out can cause configure to use the
2702 dnl wrong version of the library)
2703 case $ac_sys_system/$ac_sys_release in
2704 Darwin/*)
2705 _CUR_CFLAGS="${CFLAGS}"
2706 _CUR_LDFLAGS="${LDFLAGS}"
2707 CFLAGS="${CFLAGS} -Wl,-search_paths_first"
2708 LDFLAGS="${LDFLAGS} -Wl,-search_paths_first -L/usr/local/lib"
2709 ;;
2710 esac
2712 AC_CHECK_LIB(z, inflateCopy, AC_DEFINE(HAVE_ZLIB_COPY, 1, Define if the zlib library has inflateCopy))
2714 case $ac_sys_system/$ac_sys_release in
2715 Darwin/*)
2716 CFLAGS="${_CUR_CFLAGS}"
2717 LDFLAGS="${_CUR_LDFLAGS}"
2718 ;;
2719 esac
2721 AC_MSG_CHECKING(for hstrerror)
2722 AC_TRY_LINK([
2723 #include "confdefs.h"
2724 #include <netdb.h>
2725 ], void* p = hstrerror; hstrerror(0),
2726 AC_DEFINE(HAVE_HSTRERROR, 1, Define if you have the 'hstrerror' function.)
2727 AC_MSG_RESULT(yes),
2728 AC_MSG_RESULT(no)
2729 )
2731 AC_MSG_CHECKING(for inet_aton)
2732 AC_TRY_LINK([
2733 #include "confdefs.h"
2734 #include <sys/types.h>
2735 #include <sys/socket.h>
2736 #include <netinet/in.h>
2737 #include <arpa/inet.h>
2738 ], void* p = inet_aton;inet_aton(0,0),
2739 AC_DEFINE(HAVE_INET_ATON, 1, Define if you have the 'inet_aton' function.)
2740 AC_MSG_RESULT(yes),
2741 AC_MSG_RESULT(no)
2742 )
2744 AC_MSG_CHECKING(for inet_pton)
2745 AC_TRY_COMPILE([
2746 #include "confdefs.h"
2747 #include <sys/types.h>
2748 #include <sys/socket.h>
2749 #include <netinet/in.h>
2750 #include <arpa/inet.h>
2751 ], void* p = inet_pton,
2752 AC_DEFINE(HAVE_INET_PTON, 1, Define if you have the 'inet_pton' function.)
2753 AC_MSG_RESULT(yes),
2754 AC_MSG_RESULT(no)
2755 )
2757 # On some systems, setgroups is in unistd.h, on others, in grp.h
2758 AC_MSG_CHECKING(for setgroups)
2759 AC_TRY_COMPILE([
2760 #include "confdefs.h"
2761 #include <unistd.h>
2762 #ifdef HAVE_GRP_H
2763 #include <grp.h>
2764 #endif
2765 ],
2766 void* p = setgroups,
2767 AC_DEFINE(HAVE_SETGROUPS, 1, Define if you have the 'setgroups' function.)
2768 AC_MSG_RESULT(yes),
2769 AC_MSG_RESULT(no)
2770 )
2772 # check for openpty and forkpty
2774 AC_CHECK_FUNCS(openpty,,
2775 AC_CHECK_LIB(util,openpty,
2776 [AC_DEFINE(HAVE_OPENPTY) LIBS="$LIBS -lutil"],
2777 AC_CHECK_LIB(bsd,openpty, [AC_DEFINE(HAVE_OPENPTY) LIBS="$LIBS -lbsd"])
2778 )
2779 )
2780 AC_CHECK_FUNCS(forkpty,,
2781 AC_CHECK_LIB(util,forkpty,
2782 [AC_DEFINE(HAVE_FORKPTY) LIBS="$LIBS -lutil"],
2783 AC_CHECK_LIB(bsd,forkpty, [AC_DEFINE(HAVE_FORKPTY) LIBS="$LIBS -lbsd"])
2784 )
2785 )
2787 # Stuff for expat.
2788 AC_CHECK_FUNCS(memmove)
2790 # check for long file support functions
2791 AC_CHECK_FUNCS(fseek64 fseeko fstatvfs ftell64 ftello statvfs)
2793 AC_REPLACE_FUNCS(dup2 getcwd strdup)
2794 AC_CHECK_FUNCS(getpgrp,
2795 AC_TRY_COMPILE([#include <unistd.h>],
2796 [getpgrp(0);],
2797 AC_DEFINE(GETPGRP_HAVE_ARG, 1,
2798 [Define if getpgrp() must be called as getpgrp(0).])
2799 )
2800 )
2801 AC_CHECK_FUNCS(setpgrp,
2802 AC_TRY_COMPILE([#include <unistd.h>],
2803 [setpgrp(0,0);],
2804 AC_DEFINE(SETPGRP_HAVE_ARG, 1,
2805 [Define if setpgrp() must be called as setpgrp(0, 0).])
2806 )
2807 )
2808 AC_CHECK_FUNCS(gettimeofday,
2809 AC_TRY_COMPILE([#include <sys/time.h>],
2810 [gettimeofday((struct timeval*)0,(struct timezone*)0);], ,
2811 AC_DEFINE(GETTIMEOFDAY_NO_TZ, 1,
2812 [Define if gettimeofday() does not have second (timezone) argument
2813 This is the case on Motorola V4 (R40V4.2)])
2814 )
2815 )
2817 AC_MSG_CHECKING(for major, minor, and makedev)
2818 AC_TRY_LINK([
2819 #if defined(MAJOR_IN_MKDEV)
2820 #include <sys/mkdev.h>
2821 #elif defined(MAJOR_IN_SYSMACROS)
2822 #include <sys/sysmacros.h>
2823 #else
2824 #include <sys/types.h>
2825 #endif
2826 ],[
2827 makedev(major(0),minor(0));
2828 ],[
2829 AC_DEFINE(HAVE_DEVICE_MACROS, 1,
2830 [Define to 1 if you have the device macros.])
2831 AC_MSG_RESULT(yes)
2832 ],[
2833 AC_MSG_RESULT(no)
2834 ])
2836 # On OSF/1 V5.1, getaddrinfo is available, but a define
2837 # for [no]getaddrinfo in netdb.h.
2838 AC_MSG_CHECKING(for getaddrinfo)
2839 AC_TRY_LINK([
2840 #include <sys/types.h>
2841 #include <sys/socket.h>
2842 #include <netdb.h>
2843 #include <stdio.h>
2844 ], [getaddrinfo(NULL, NULL, NULL, NULL);],
2845 have_getaddrinfo=yes,
2846 have_getaddrinfo=no)
2847 AC_MSG_RESULT($have_getaddrinfo)
2848 if test $have_getaddrinfo = yes
2849 then
2850 AC_MSG_CHECKING(getaddrinfo bug)
2851 AC_CACHE_VAL(ac_cv_buggy_getaddrinfo,
2852 AC_TRY_RUN([[
2853 #include <sys/types.h>
2854 #include <netdb.h>
2855 #include <string.h>
2856 #include <sys/socket.h>
2857 #include <netinet/in.h>
2859 int main()
2860 {
2861 int passive, gaierr, inet4 = 0, inet6 = 0;
2862 struct addrinfo hints, *ai, *aitop;
2863 char straddr[INET6_ADDRSTRLEN], strport[16];
2865 for (passive = 0; passive <= 1; passive++) {
2866 memset(&hints, 0, sizeof(hints));
2867 hints.ai_family = AF_UNSPEC;
2868 hints.ai_flags = passive ? AI_PASSIVE : 0;
2869 hints.ai_socktype = SOCK_STREAM;
2870 hints.ai_protocol = IPPROTO_TCP;
2871 if ((gaierr = getaddrinfo(NULL, "54321", &hints, &aitop)) != 0) {
2872 (void)gai_strerror(gaierr);
2873 goto bad;
2874 }
2875 for (ai = aitop; ai; ai = ai->ai_next) {
2876 if (ai->ai_addr == NULL ||
2877 ai->ai_addrlen == 0 ||
2878 getnameinfo(ai->ai_addr, ai->ai_addrlen,
2879 straddr, sizeof(straddr), strport, sizeof(strport),
2880 NI_NUMERICHOST|NI_NUMERICSERV) != 0) {
2881 goto bad;
2882 }
2883 switch (ai->ai_family) {
2884 case AF_INET:
2885 if (strcmp(strport, "54321") != 0) {
2886 goto bad;
2887 }
2888 if (passive) {
2889 if (strcmp(straddr, "0.0.0.0") != 0) {
2890 goto bad;
2891 }
2892 } else {
2893 if (strcmp(straddr, "127.0.0.1") != 0) {
2894 goto bad;
2895 }
2896 }
2897 inet4++;
2898 break;
2899 case AF_INET6:
2900 if (strcmp(strport, "54321") != 0) {
2901 goto bad;
2902 }
2903 if (passive) {
2904 if (strcmp(straddr, "::") != 0) {
2905 goto bad;
2906 }
2907 } else {
2908 if (strcmp(straddr, "::1") != 0) {
2909 goto bad;
2910 }
2911 }
2912 inet6++;
2913 break;
2914 case AF_UNSPEC:
2915 goto bad;
2916 break;
2917 default:
2918 /* another family support? */
2919 break;
2920 }
2921 }
2922 }
2924 if (!(inet4 == 0 || inet4 == 2))
2925 goto bad;
2926 if (!(inet6 == 0 || inet6 == 2))
2927 goto bad;
2929 if (aitop)
2930 freeaddrinfo(aitop);
2931 return 0;
2933 bad:
2934 if (aitop)
2935 freeaddrinfo(aitop);
2936 return 1;
2937 }
2938 ]], ac_cv_buggy_getaddrinfo=no,
2939 ac_cv_buggy_getaddrinfo=yes,
2940 ac_cv_buggy_getaddrinfo=yes))
2941 fi
2943 if test $have_getaddrinfo = no -o $ac_cv_buggy_getaddrinfo = yes
2944 then
2945 if test $ipv6 = yes
2946 then
2947 echo 'Fatal: You must get working getaddrinfo() function.'
2948 echo ' or you can specify "--disable-ipv6"'.
2949 exit 1
2950 fi
2951 else
2952 AC_DEFINE(HAVE_GETADDRINFO, 1, [Define if you have the getaddrinfo function.])
2953 fi
2954 AC_CHECK_FUNCS(getnameinfo)
2956 # checks for structures
2957 AC_HEADER_TIME
2958 AC_STRUCT_TM
2959 AC_STRUCT_TIMEZONE
2960 AC_CHECK_MEMBERS([struct stat.st_rdev])
2961 AC_CHECK_MEMBERS([struct stat.st_blksize])
2962 AC_CHECK_MEMBERS([struct stat.st_flags])
2963 AC_CHECK_MEMBERS([struct stat.st_gen])
2964 AC_CHECK_MEMBERS([struct stat.st_birthtime])
2965 AC_STRUCT_ST_BLOCKS
2967 AC_MSG_CHECKING(for time.h that defines altzone)
2968 AC_CACHE_VAL(ac_cv_header_time_altzone,
2969 [AC_TRY_COMPILE([#include <time.h>], [return altzone;],
2970 ac_cv_header_time_altzone=yes,
2971 ac_cv_header_time_altzone=no)])
2972 AC_MSG_RESULT($ac_cv_header_time_altzone)
2973 if test $ac_cv_header_time_altzone = yes; then
2974 AC_DEFINE(HAVE_ALTZONE, 1, [Define this if your time.h defines altzone.])
2975 fi
2977 was_it_defined=no
2978 AC_MSG_CHECKING(whether sys/select.h and sys/time.h may both be included)
2979 AC_TRY_COMPILE([
2980 #include <sys/types.h>
2981 #include <sys/select.h>
2982 #include <sys/time.h>
2983 ], [;], [
2984 AC_DEFINE(SYS_SELECT_WITH_SYS_TIME, 1,
2985 [Define if you can safely include both <sys/select.h> and <sys/time.h>
2986 (which you can't on SCO ODT 3.0).])
2987 was_it_defined=yes
2988 ])
2989 AC_MSG_RESULT($was_it_defined)
2991 AC_MSG_CHECKING(for addrinfo)
2992 AC_CACHE_VAL(ac_cv_struct_addrinfo,
2993 AC_TRY_COMPILE([
2994 # include <netdb.h>],
2995 [struct addrinfo a],
2996 ac_cv_struct_addrinfo=yes,
2997 ac_cv_struct_addrinfo=no))
2998 AC_MSG_RESULT($ac_cv_struct_addrinfo)
2999 if test $ac_cv_struct_addrinfo = yes; then
3000 AC_DEFINE(HAVE_ADDRINFO, 1, [struct addrinfo (netdb.h)])
3001 fi
3003 AC_MSG_CHECKING(for sockaddr_storage)
3004 AC_CACHE_VAL(ac_cv_struct_sockaddr_storage,
3005 AC_TRY_COMPILE([
3006 # include <sys/types.h>
3007 # include <sys/socket.h>],
3008 [struct sockaddr_storage s],
3009 ac_cv_struct_sockaddr_storage=yes,
3010 ac_cv_struct_sockaddr_storage=no))
3011 AC_MSG_RESULT($ac_cv_struct_sockaddr_storage)
3012 if test $ac_cv_struct_sockaddr_storage = yes; then
3013 AC_DEFINE(HAVE_SOCKADDR_STORAGE, 1, [struct sockaddr_storage (sys/socket.h)])
3014 fi
3016 # checks for compiler characteristics
3018 AC_C_CHAR_UNSIGNED
3019 AC_C_CONST
3021 works=no
3022 AC_MSG_CHECKING(for working volatile)
3023 AC_TRY_COMPILE([],[volatile int x; x = 0;], works=yes,
3024 AC_DEFINE(volatile, [], [Define to empty if the keyword does not work.])
3025 )
3026 AC_MSG_RESULT($works)
3028 works=no
3029 AC_MSG_CHECKING(for working signed char)
3030 AC_TRY_COMPILE([], [signed char c;], works=yes,
3031 AC_DEFINE(signed, [], [Define to empty if the keyword does not work.])
3032 )
3033 AC_MSG_RESULT($works)
3035 have_prototypes=no
3036 AC_MSG_CHECKING(for prototypes)
3037 AC_TRY_COMPILE([int foo(int x) { return 0; }], [return foo(10);],[
3038 AC_DEFINE(HAVE_PROTOTYPES, 1,
3039 [Define if your compiler supports function prototype])
3040 have_prototypes=yes
3041 ])
3042 AC_MSG_RESULT($have_prototypes)
3044 works=no
3045 AC_MSG_CHECKING(for variable length prototypes and stdarg.h)
3046 AC_TRY_COMPILE([
3047 #include <stdarg.h>
3048 int foo(int x, ...) {
3049 va_list va;
3050 va_start(va, x);
3051 va_arg(va, int);
3052 va_arg(va, char *);
3053 va_arg(va, double);
3054 return 0;
3055 }
3056 ], [return foo(10, "", 3.14);], [
3057 AC_DEFINE(HAVE_STDARG_PROTOTYPES, 1,
3058 [Define if your compiler supports variable length function prototypes
3059 (e.g. void fprintf(FILE *, char *, ...);) *and* <stdarg.h>])
3060 works=yes
3061 ])
3062 AC_MSG_RESULT($works)
3064 # check for socketpair
3065 AC_MSG_CHECKING(for socketpair)
3066 AC_TRY_COMPILE([
3067 #include <sys/types.h>
3068 #include <sys/socket.h>
3069 ], void *x=socketpair,
3070 AC_DEFINE(HAVE_SOCKETPAIR, 1, Define if you have the 'socketpair' function.)
3071 AC_MSG_RESULT(yes),
3072 AC_MSG_RESULT(no)
3073 )
3075 # check if sockaddr has sa_len member
3076 AC_MSG_CHECKING(if sockaddr has sa_len member)
3077 AC_TRY_COMPILE([#include <sys/types.h>
3078 #include <sys/socket.h>],
3079 [struct sockaddr x;
3080 x.sa_len = 0;],
3081 AC_MSG_RESULT(yes)
3082 AC_DEFINE(HAVE_SOCKADDR_SA_LEN, 1, [Define if sockaddr has sa_len member]),
3083 AC_MSG_RESULT(no))
3085 va_list_is_array=no
3086 AC_MSG_CHECKING(whether va_list is an array)
3087 AC_TRY_COMPILE([
3088 #ifdef HAVE_STDARG_PROTOTYPES
3089 #include <stdarg.h>
3090 #else
3091 #include <varargs.h>
3092 #endif
3093 ], [va_list list1, list2; list1 = list2;], , [
3094 AC_DEFINE(VA_LIST_IS_ARRAY, 1, [Define if a va_list is an array of some kind])
3095 va_list_is_array=yes
3096 ])
3097 AC_MSG_RESULT($va_list_is_array)
3099 # sigh -- gethostbyname_r is a mess; it can have 3, 5 or 6 arguments :-(
3100 AH_TEMPLATE(HAVE_GETHOSTBYNAME_R,
3101 [Define this if you have some version of gethostbyname_r()])
3103 AC_CHECK_FUNC(gethostbyname_r, [
3104 AC_DEFINE(HAVE_GETHOSTBYNAME_R)
3105 AC_MSG_CHECKING([gethostbyname_r with 6 args])
3106 OLD_CFLAGS=$CFLAGS
3107 CFLAGS="$CFLAGS $MY_CPPFLAGS $MY_THREAD_CPPFLAGS $MY_CFLAGS"
3108 AC_TRY_COMPILE([
3109 # include <netdb.h>
3110 ], [
3111 char *name;
3112 struct hostent *he, *res;
3113 char buffer[2048];
3114 int buflen = 2048;
3115 int h_errnop;
3117 (void) gethostbyname_r(name, he, buffer, buflen, &res, &h_errnop)
3118 ], [
3119 AC_DEFINE(HAVE_GETHOSTBYNAME_R)
3120 AC_DEFINE(HAVE_GETHOSTBYNAME_R_6_ARG, 1,
3121 [Define this if you have the 6-arg version of gethostbyname_r().])
3122 AC_MSG_RESULT(yes)
3123 ], [
3124 AC_MSG_RESULT(no)
3125 AC_MSG_CHECKING([gethostbyname_r with 5 args])
3126 AC_TRY_COMPILE([
3127 # include <netdb.h>
3128 ], [
3129 char *name;
3130 struct hostent *he;
3131 char buffer[2048];
3132 int buflen = 2048;
3133 int h_errnop;
3135 (void) gethostbyname_r(name, he, buffer, buflen, &h_errnop)
3136 ], [
3137 AC_DEFINE(HAVE_GETHOSTBYNAME_R)
3138 AC_DEFINE(HAVE_GETHOSTBYNAME_R_5_ARG, 1,
3139 [Define this if you have the 5-arg version of gethostbyname_r().])
3140 AC_MSG_RESULT(yes)
3141 ], [
3142 AC_MSG_RESULT(no)
3143 AC_MSG_CHECKING([gethostbyname_r with 3 args])
3144 AC_TRY_COMPILE([
3145 # include <netdb.h>
3146 ], [
3147 char *name;
3148 struct hostent *he;
3149 struct hostent_data data;
3151 (void) gethostbyname_r(name, he, &data);
3152 ], [
3153 AC_DEFINE(HAVE_GETHOSTBYNAME_R)
3154 AC_DEFINE(HAVE_GETHOSTBYNAME_R_3_ARG, 1,
3155 [Define this if you have the 3-arg version of gethostbyname_r().])
3156 AC_MSG_RESULT(yes)
3157 ], [
3158 AC_MSG_RESULT(no)
3159 ])
3160 ])
3161 ])
3162 CFLAGS=$OLD_CFLAGS
3163 ], [
3164 AC_CHECK_FUNCS(gethostbyname)
3165 ])
3166 AC_SUBST(HAVE_GETHOSTBYNAME_R_6_ARG)
3167 AC_SUBST(HAVE_GETHOSTBYNAME_R_5_ARG)
3168 AC_SUBST(HAVE_GETHOSTBYNAME_R_3_ARG)
3169 AC_SUBST(HAVE_GETHOSTBYNAME_R)
3170 AC_SUBST(HAVE_GETHOSTBYNAME)
3172 # checks for system services
3173 # (none yet)
3175 # Linux requires this for correct f.p. operations
3176 AC_CHECK_FUNC(__fpu_control,
3177 [],
3178 [AC_CHECK_LIB(ieee, __fpu_control)
3179 ])
3181 # Check for --with-fpectl
3182 AC_MSG_CHECKING(for --with-fpectl)
3183 AC_ARG_WITH(fpectl,
3184 AC_HELP_STRING(--with-fpectl, enable SIGFPE catching),
3185 [
3186 if test "$withval" != no
3187 then
3188 AC_DEFINE(WANT_SIGFPE_HANDLER, 1,
3189 [Define if you want SIGFPE handled (see Include/pyfpe.h).])
3190 AC_MSG_RESULT(yes)
3191 else AC_MSG_RESULT(no)
3192 fi],
3193 [AC_MSG_RESULT(no)])
3195 # check for --with-libm=...
3196 AC_SUBST(LIBM)
3197 case $ac_sys_system in
3198 Darwin) ;;
3199 BeOS) ;;
3200 *) LIBM=-lm
3201 esac
3202 AC_MSG_CHECKING(for --with-libm=STRING)
3203 AC_ARG_WITH(libm,
3204 AC_HELP_STRING(--with-libm=STRING, math library),
3205 [
3206 if test "$withval" = no
3207 then LIBM=
3208 AC_MSG_RESULT(force LIBM empty)
3209 elif test "$withval" != yes
3210 then LIBM=$withval
3211 AC_MSG_RESULT(set LIBM="$withval")
3212 else AC_MSG_ERROR([proper usage is --with-libm=STRING])
3213 fi],
3214 [AC_MSG_RESULT(default LIBM="$LIBM")])
3216 # check for --with-libc=...
3217 AC_SUBST(LIBC)
3218 AC_MSG_CHECKING(for --with-libc=STRING)
3219 AC_ARG_WITH(libc,
3220 AC_HELP_STRING(--with-libc=STRING, C library),
3221 [
3222 if test "$withval" = no
3223 then LIBC=
3224 AC_MSG_RESULT(force LIBC empty)
3225 elif test "$withval" != yes
3226 then LIBC=$withval
3227 AC_MSG_RESULT(set LIBC="$withval")
3228 else AC_MSG_ERROR([proper usage is --with-libc=STRING])
3229 fi],
3230 [AC_MSG_RESULT(default LIBC="$LIBC")])
3232 # ************************************
3233 # * Check for mathematical functions *
3234 # ************************************
3236 LIBS_SAVE=$LIBS
3237 LIBS="$LIBS $LIBM"
3239 # Detect whether system arithmetic is subject to x87-style double
3240 # rounding issues. The result of this test has little meaning on non
3241 # IEEE 754 platforms. On IEEE 754, test should return 1 if rounding
3242 # mode is round-to-nearest and double rounding issues are present, and
3243 # 0 otherwise. See http://bugs.python.org/issue2937 for more info.
3244 AC_MSG_CHECKING(for x87-style double rounding)
3245 AC_CACHE_VAL(ac_cv_x87_double_rounding, [
3246 AC_TRY_RUN([
3247 #include <stdlib.h>
3248 #include <math.h>
3249 int main() {
3250 volatile double x, y, z;
3251 /* 1./(1-2**-53) -> 1+2**-52 (correct), 1.0 (double rounding) */
3252 x = 0.99999999999999989; /* 1-2**-53 */
3253 y = 1./x;
3254 if (y != 1.)
3255 exit(0);
3256 /* 1e16+2.99999 -> 1e16+2. (correct), 1e16+4. (double rounding) */
3257 x = 1e16;
3258 y = 2.99999;
3259 z = x + y;
3260 if (z != 1e16+4.)
3261 exit(0);
3262 /* both tests show evidence of double rounding */
3263 exit(1);
3264 }
3265 ],
3266 ac_cv_x87_double_rounding=no,
3267 ac_cv_x87_double_rounding=yes,
3268 ac_cv_x87_double_rounding=no)])
3269 AC_MSG_RESULT($ac_cv_x87_double_rounding)
3270 if test "$ac_cv_x87_double_rounding" = yes
3271 then
3272 AC_DEFINE(X87_DOUBLE_ROUNDING, 1,
3273 [Define if arithmetic is subject to x87-style double rounding issue])
3274 fi
3276 # Multiprocessing check for broken sem_getvalue
3277 AC_MSG_CHECKING(for broken sem_getvalue)
3278 AC_CACHE_VAL(ac_cv_broken_sem_getvalue,
3279 AC_TRY_RUN([
3280 #include <unistd.h>
3281 #include <fcntl.h>
3282 #include <stdio.h>
3283 #include <semaphore.h>
3284 #include <sys/stat.h>
3286 int main(void){
3287 sem_t *a = sem_open("/autoconf", O_CREAT, S_IRUSR|S_IWUSR, 0);
3288 int count;
3289 int res;
3290 if(a==SEM_FAILED){
3291 perror("sem_open");
3292 return 1;
3294 }
3295 res = sem_getvalue(a, &count);
3296 sem_close(a);
3297 return res==-1 ? 1 : 0;
3298 }
3299 ], ac_cv_broken_sem_getvalue=no,
3300 ac_cv_broken_sem_getvalue=yes,
3301 ac_cv_broken_sem_getvalue=yes)
3302 )
3303 AC_MSG_RESULT($ac_cv_broken_sem_getvalue)
3304 if test $ac_cv_broken_sem_getvalue = yes
3305 then
3306 AC_DEFINE(HAVE_BROKEN_SEM_GETVALUE, 1,
3307 [define to 1 if your sem_getvalue is broken.])
3308 fi
3310 # On FreeBSD 6.2, it appears that tanh(-0.) returns 0. instead of
3311 # -0. on some architectures.
3312 AC_MSG_CHECKING(whether tanh preserves the sign of zero)
3313 AC_CACHE_VAL(ac_cv_tanh_preserves_zero_sign, [
3314 AC_TRY_RUN([
3315 #include <math.h>
3316 #include <stdlib.h>
3317 int main() {
3318 /* return 0 if either negative zeros don't exist
3319 on this platform or if negative zeros exist
3320 and tanh(-0.) == -0. */
3321 if (atan2(0., -1.) == atan2(-0., -1.) ||
3322 atan2(tanh(-0.), -1.) == atan2(-0., -1.)) exit(0);
3323 else exit(1);
3324 }
3325 ],
3326 ac_cv_tanh_preserves_zero_sign=yes,
3327 ac_cv_tanh_preserves_zero_sign=no,
3328 ac_cv_tanh_preserves_zero_sign=no)])
3329 AC_MSG_RESULT($ac_cv_tanh_preserves_zero_sign)
3330 if test "$ac_cv_tanh_preserves_zero_sign" = yes
3331 then
3332 AC_DEFINE(TANH_PRESERVES_ZERO_SIGN, 1,
3333 [Define if tanh(-0.) is -0., or if platform doesn't have signed zeros])
3334 fi
3336 AC_CHECK_FUNCS([acosh asinh atanh copysign erf erfc expm1 finite gamma])
3337 AC_CHECK_FUNCS([hypot lgamma log1p round tgamma])
3338 AC_CHECK_DECLS([isinf, isnan, isfinite], [], [], [[#include <math.h>]])
3340 LIBS=$LIBS_SAVE
3342 # determine what size digit to use for Python's longs
3343 AC_MSG_CHECKING([digit size for Python's longs])
3344 AC_ARG_ENABLE(big-digits,
3345 AC_HELP_STRING([--enable-big-digits@<:@=BITS@:>@],[use big digits for Python longs [[BITS=30]]]),
3346 [case $enable_big_digits in
3347 yes)
3348 enable_big_digits=30 ;;
3349 no)
3350 enable_big_digits=15 ;;
3351 [15|30])
3352 ;;
3353 *)
3354 AC_MSG_ERROR([bad value $enable_big_digits for --enable-big-digits; value should be 15 or 30]) ;;
3355 esac
3356 AC_MSG_RESULT($enable_big_digits)
3357 AC_DEFINE_UNQUOTED(PYLONG_BITS_IN_DIGIT, $enable_big_digits, [Define as the preferred size in bits of long digits])
3358 ],
3359 [AC_MSG_RESULT(no value specified)])
3361 # check for wchar.h
3362 AC_CHECK_HEADER(wchar.h, [
3363 AC_DEFINE(HAVE_WCHAR_H, 1,
3364 [Define if the compiler provides a wchar.h header file.])
3365 wchar_h="yes"
3366 ],
3367 wchar_h="no"
3368 )
3370 # determine wchar_t size
3371 if test "$wchar_h" = yes
3372 then
3373 AC_CHECK_SIZEOF(wchar_t, 4, [#include <wchar.h>])
3374 fi
3376 AC_MSG_CHECKING(for UCS-4 tcl)
3377 have_ucs4_tcl=no
3378 AC_TRY_COMPILE([
3379 #include <tcl.h>
3380 #if TCL_UTF_MAX != 6
3381 # error "NOT UCS4_TCL"
3382 #endif], [], [
3383 AC_DEFINE(HAVE_UCS4_TCL, 1, [Define this if you have tcl and TCL_UTF_MAX==6])
3384 have_ucs4_tcl=yes
3385 ])
3386 AC_MSG_RESULT($have_ucs4_tcl)
3388 # check whether wchar_t is signed or not
3389 if test "$wchar_h" = yes
3390 then
3391 # check whether wchar_t is signed or not
3392 AC_MSG_CHECKING(whether wchar_t is signed)
3393 AC_CACHE_VAL(ac_cv_wchar_t_signed, [
3394 AC_TRY_RUN([
3395 #include <wchar.h>
3396 int main()
3397 {
3398 /* Success: exit code 0 */
3399 exit((((wchar_t) -1) < ((wchar_t) 0)) ? 0 : 1);
3400 }
3401 ],
3402 ac_cv_wchar_t_signed=yes,
3403 ac_cv_wchar_t_signed=no,
3404 ac_cv_wchar_t_signed=yes)])
3405 AC_MSG_RESULT($ac_cv_wchar_t_signed)
3406 fi
3408 AC_MSG_CHECKING(what type to use for unicode)
3409 dnl quadrigraphs "@<:@" and "@:>@" produce "[" and "]" in the output
3410 AC_ARG_ENABLE(unicode,
3411 AC_HELP_STRING(--enable-unicode@<:@=ucs@<:@24@:>@@:>@, Enable Unicode strings (default is yes)),
3412 [],
3413 [enable_unicode=yes])
3415 if test $enable_unicode = yes
3416 then
3417 # Without any arguments, Py_UNICODE defaults to two-byte mode
3418 case "$have_ucs4_tcl" in
3419 yes) enable_unicode="ucs4"
3420 ;;
3421 *) enable_unicode="ucs2"
3422 ;;
3423 esac
3424 fi
3426 AH_TEMPLATE(Py_UNICODE_SIZE,
3427 [Define as the size of the unicode type.])
3428 case "$enable_unicode" in
3429 ucs2) unicode_size="2"
3430 AC_DEFINE(Py_UNICODE_SIZE,2)
3431 ;;
3432 ucs4) unicode_size="4"
3433 AC_DEFINE(Py_UNICODE_SIZE,4)
3434 ;;
3435 esac
3437 AH_TEMPLATE(PY_UNICODE_TYPE,
3438 [Define as the integral type used for Unicode representation.])
3440 AC_SUBST(UNICODE_OBJS)
3441 if test "$enable_unicode" = "no"
3442 then
3443 UNICODE_OBJS=""
3444 AC_MSG_RESULT(not used)
3445 else
3446 UNICODE_OBJS="Objects/unicodeobject.o Objects/unicodectype.o"
3447 AC_DEFINE(Py_USING_UNICODE, 1,
3448 [Define if you want to have a Unicode type.])
3450 # wchar_t is only usable if it maps to an unsigned type
3451 if test "$unicode_size" = "$ac_cv_sizeof_wchar_t" \
3452 -a "$ac_cv_wchar_t_signed" = "no"
3453 then
3454 PY_UNICODE_TYPE="wchar_t"
3455 AC_DEFINE(HAVE_USABLE_WCHAR_T, 1,
3456 [Define if you have a useable wchar_t type defined in wchar.h; useable
3457 means wchar_t must be an unsigned type with at least 16 bits. (see
3458 Include/unicodeobject.h).])
3459 AC_DEFINE(PY_UNICODE_TYPE,wchar_t)
3460 elif test "$ac_cv_sizeof_short" = "$unicode_size"
3461 then
3462 PY_UNICODE_TYPE="unsigned short"
3463 AC_DEFINE(PY_UNICODE_TYPE,unsigned short)
3464 elif test "$ac_cv_sizeof_long" = "$unicode_size"
3465 then
3466 PY_UNICODE_TYPE="unsigned long"
3467 AC_DEFINE(PY_UNICODE_TYPE,unsigned long)
3468 else
3469 PY_UNICODE_TYPE="no type found"
3470 fi
3471 AC_MSG_RESULT($PY_UNICODE_TYPE)
3472 fi
3474 # check for endianness
3475 AC_C_BIGENDIAN
3477 # Check whether right shifting a negative integer extends the sign bit
3478 # or fills with zeros (like the Cray J90, according to Tim Peters).
3479 AC_MSG_CHECKING(whether right shift extends the sign bit)
3480 AC_CACHE_VAL(ac_cv_rshift_extends_sign, [
3481 AC_TRY_RUN([
3482 int main()
3483 {
3484 exit(((-1)>>3 == -1) ? 0 : 1);
3485 }
3486 ],
3487 ac_cv_rshift_extends_sign=yes,
3488 ac_cv_rshift_extends_sign=no,
3489 ac_cv_rshift_extends_sign=yes)])
3490 AC_MSG_RESULT($ac_cv_rshift_extends_sign)
3491 if test "$ac_cv_rshift_extends_sign" = no
3492 then
3493 AC_DEFINE(SIGNED_RIGHT_SHIFT_ZERO_FILLS, 1,
3494 [Define if i>>j for signed int i does not extend the sign bit
3495 when i < 0])
3496 fi
3498 # check for getc_unlocked and related locking functions
3499 AC_MSG_CHECKING(for getc_unlocked() and friends)
3500 AC_CACHE_VAL(ac_cv_have_getc_unlocked, [
3501 AC_TRY_LINK([#include <stdio.h>],[
3502 FILE *f = fopen("/dev/null", "r");
3503 flockfile(f);
3504 getc_unlocked(f);
3505 funlockfile(f);
3506 ], ac_cv_have_getc_unlocked=yes, ac_cv_have_getc_unlocked=no)])
3507 AC_MSG_RESULT($ac_cv_have_getc_unlocked)
3508 if test "$ac_cv_have_getc_unlocked" = yes
3509 then
3510 AC_DEFINE(HAVE_GETC_UNLOCKED, 1,
3511 [Define this if you have flockfile(), getc_unlocked(), and funlockfile()])
3512 fi
3514 # check where readline lives
3515 # save the value of LIBS so we don't actually link Python with readline
3516 LIBS_no_readline=$LIBS
3518 # On some systems we need to link readline to a termcap compatible
3519 # library. NOTE: Keep the precedence of listed libraries synchronised
3520 # with setup.py.
3521 py_cv_lib_readline=no
3522 AC_MSG_CHECKING([how to link readline libs])
3523 for py_libtermcap in "" ncursesw ncurses curses termcap; do
3524 if test -z "$py_libtermcap"; then
3525 READLINE_LIBS="-lreadline"
3526 else
3527 READLINE_LIBS="-lreadline -l$py_libtermcap"
3528 fi
3529 LIBS="$READLINE_LIBS $LIBS_no_readline"
3530 AC_LINK_IFELSE(
3531 [AC_LANG_CALL([],[readline])],
3532 [py_cv_lib_readline=yes])
3533 if test $py_cv_lib_readline = yes; then
3534 break
3535 fi
3536 done
3537 # Uncomment this line if you want to use READINE_LIBS in Makefile or scripts
3538 #AC_SUBST([READLINE_LIBS])
3539 if test $py_cv_lib_readline = no; then
3540 AC_MSG_RESULT([none])
3541 else
3542 AC_MSG_RESULT([$READLINE_LIBS])
3543 AC_DEFINE(HAVE_LIBREADLINE, 1,
3544 [Define if you have the readline library (-lreadline).])
3545 fi
3547 # check for readline 2.1
3548 AC_CHECK_LIB(readline, rl_callback_handler_install,
3549 AC_DEFINE(HAVE_RL_CALLBACK, 1,
3550 [Define if you have readline 2.1]), ,$READLINE_LIBS)
3552 # check for readline 2.2
3553 AC_TRY_CPP([#include <readline/readline.h>],
3554 have_readline=yes, have_readline=no)
3555 if test $have_readline = yes
3556 then
3557 AC_EGREP_HEADER([extern int rl_completion_append_character;],
3558 [readline/readline.h],
3559 AC_DEFINE(HAVE_RL_COMPLETION_APPEND_CHARACTER, 1,
3560 [Define if you have readline 2.2]), )
3561 fi
3563 # check for readline 4.0
3564 AC_CHECK_LIB(readline, rl_pre_input_hook,
3565 AC_DEFINE(HAVE_RL_PRE_INPUT_HOOK, 1,
3566 [Define if you have readline 4.0]), ,$READLINE_LIBS)
3568 # also in 4.0
3569 AC_CHECK_LIB(readline, rl_completion_display_matches_hook,
3570 AC_DEFINE(HAVE_RL_COMPLETION_DISPLAY_MATCHES_HOOK, 1,
3571 [Define if you have readline 4.0]), ,$READLINE_LIBS)
3573 # check for readline 4.2
3574 AC_CHECK_LIB(readline, rl_completion_matches,
3575 AC_DEFINE(HAVE_RL_COMPLETION_MATCHES, 1,
3576 [Define if you have readline 4.2]), ,$READLINE_LIBS)
3578 # also in readline 4.2
3579 AC_TRY_CPP([#include <readline/readline.h>],
3580 have_readline=yes, have_readline=no)
3581 if test $have_readline = yes
3582 then
3583 AC_EGREP_HEADER([extern int rl_catch_signals;],
3584 [readline/readline.h],
3585 AC_DEFINE(HAVE_RL_CATCH_SIGNAL, 1,
3586 [Define if you can turn off readline's signal handling.]), )
3587 fi
3589 # End of readline checks: restore LIBS
3590 LIBS=$LIBS_no_readline
3592 AC_MSG_CHECKING(for broken nice())
3593 AC_CACHE_VAL(ac_cv_broken_nice, [
3594 AC_TRY_RUN([
3595 int main()
3596 {
3597 int val1 = nice(1);
3598 if (val1 != -1 && val1 == nice(2))
3599 exit(0);
3600 exit(1);
3601 }
3602 ],
3603 ac_cv_broken_nice=yes,
3604 ac_cv_broken_nice=no,
3605 ac_cv_broken_nice=no)])
3606 AC_MSG_RESULT($ac_cv_broken_nice)
3607 if test "$ac_cv_broken_nice" = yes
3608 then
3609 AC_DEFINE(HAVE_BROKEN_NICE, 1,
3610 [Define if nice() returns success/failure instead of the new priority.])
3611 fi
3613 AC_MSG_CHECKING(for broken poll())
3614 AC_CACHE_VAL(ac_cv_broken_poll,
3615 AC_TRY_RUN([
3616 #include <poll.h>
3618 int main()
3619 {
3620 struct pollfd poll_struct = { 42, POLLIN|POLLPRI|POLLOUT, 0 };
3621 int poll_test;
3623 close (42);
3625 poll_test = poll(&poll_struct, 1, 0);
3626 if (poll_test < 0)
3627 return 0;
3628 else if (poll_test == 0 && poll_struct.revents != POLLNVAL)
3629 return 0;
3630 else
3631 return 1;
3632 }
3633 ],
3634 ac_cv_broken_poll=yes,
3635 ac_cv_broken_poll=no,
3636 ac_cv_broken_poll=no))
3637 AC_MSG_RESULT($ac_cv_broken_poll)
3638 if test "$ac_cv_broken_poll" = yes
3639 then
3640 AC_DEFINE(HAVE_BROKEN_POLL, 1,
3641 [Define if poll() sets errno on invalid file descriptors.])
3642 fi
3644 # Before we can test tzset, we need to check if struct tm has a tm_zone
3645 # (which is not required by ISO C or UNIX spec) and/or if we support
3646 # tzname[]
3647 AC_STRUCT_TIMEZONE
3649 # check tzset(3) exists and works like we expect it to
3650 AC_MSG_CHECKING(for working tzset())
3651 AC_CACHE_VAL(ac_cv_working_tzset, [
3652 AC_TRY_RUN([
3653 #include <stdlib.h>
3654 #include <time.h>
3655 #include <string.h>
3657 #if HAVE_TZNAME
3658 extern char *tzname[];
3659 #endif
3661 int main()
3662 {
3663 /* Note that we need to ensure that not only does tzset(3)
3664 do 'something' with localtime, but it works as documented
3665 in the library reference and as expected by the test suite.
3666 This includes making sure that tzname is set properly if
3667 tm->tm_zone does not exist since it is the alternative way
3668 of getting timezone info.
3670 Red Hat 6.2 doesn't understand the southern hemisphere
3671 after New Year's Day.
3672 */
3674 time_t groundhogday = 1044144000; /* GMT-based */
3675 time_t midyear = groundhogday + (365 * 24 * 3600 / 2);
3677 putenv("TZ=UTC+0");
3678 tzset();
3679 if (localtime(&groundhogday)->tm_hour != 0)
3680 exit(1);
3681 #if HAVE_TZNAME
3682 /* For UTC, tzname[1] is sometimes "", sometimes " " */
3683 if (strcmp(tzname[0], "UTC") ||
3684 (tzname[1][0] != 0 && tzname[1][0] != ' '))
3685 exit(1);
3686 #endif
3688 putenv("TZ=EST+5EDT,M4.1.0,M10.5.0");
3689 tzset();
3690 if (localtime(&groundhogday)->tm_hour != 19)
3691 exit(1);
3692 #if HAVE_TZNAME
3693 if (strcmp(tzname[0], "EST") || strcmp(tzname[1], "EDT"))
3694 exit(1);
3695 #endif
3697 putenv("TZ=AEST-10AEDT-11,M10.5.0,M3.5.0");
3698 tzset();
3699 if (localtime(&groundhogday)->tm_hour != 11)
3700 exit(1);
3701 #if HAVE_TZNAME
3702 if (strcmp(tzname[0], "AEST") || strcmp(tzname[1], "AEDT"))
3703 exit(1);
3704 #endif
3706 #if HAVE_STRUCT_TM_TM_ZONE
3707 if (strcmp(localtime(&groundhogday)->tm_zone, "AEDT"))
3708 exit(1);
3709 if (strcmp(localtime(&midyear)->tm_zone, "AEST"))
3710 exit(1);
3711 #endif
3713 exit(0);
3714 }
3715 ],
3716 ac_cv_working_tzset=yes,
3717 ac_cv_working_tzset=no,
3718 ac_cv_working_tzset=no)])
3719 AC_MSG_RESULT($ac_cv_working_tzset)
3720 if test "$ac_cv_working_tzset" = yes
3721 then
3722 AC_DEFINE(HAVE_WORKING_TZSET, 1,
3723 [Define if tzset() actually switches the local timezone in a meaningful way.])
3724 fi
3726 # Look for subsecond timestamps in struct stat
3727 AC_MSG_CHECKING(for tv_nsec in struct stat)
3728 AC_CACHE_VAL(ac_cv_stat_tv_nsec,
3729 AC_TRY_COMPILE([#include <sys/stat.h>], [
3730 struct stat st;
3731 st.st_mtim.tv_nsec = 1;
3732 ],
3733 ac_cv_stat_tv_nsec=yes,
3734 ac_cv_stat_tv_nsec=no,
3735 ac_cv_stat_tv_nsec=no))
3736 AC_MSG_RESULT($ac_cv_stat_tv_nsec)
3737 if test "$ac_cv_stat_tv_nsec" = yes
3738 then
3739 AC_DEFINE(HAVE_STAT_TV_NSEC, 1,
3740 [Define if you have struct stat.st_mtim.tv_nsec])
3741 fi
3743 # Look for BSD style subsecond timestamps in struct stat
3744 AC_MSG_CHECKING(for tv_nsec2 in struct stat)
3745 AC_CACHE_VAL(ac_cv_stat_tv_nsec2,
3746 AC_TRY_COMPILE([#include <sys/stat.h>], [
3747 struct stat st;
3748 st.st_mtimespec.tv_nsec = 1;
3749 ],
3750 ac_cv_stat_tv_nsec2=yes,
3751 ac_cv_stat_tv_nsec2=no,
3752 ac_cv_stat_tv_nsec2=no))
3753 AC_MSG_RESULT($ac_cv_stat_tv_nsec2)
3754 if test "$ac_cv_stat_tv_nsec2" = yes
3755 then
3756 AC_DEFINE(HAVE_STAT_TV_NSEC2, 1,
3757 [Define if you have struct stat.st_mtimensec])
3758 fi
3760 # On HP/UX 11.0, mvwdelch is a block with a return statement
3761 AC_MSG_CHECKING(whether mvwdelch is an expression)
3762 AC_CACHE_VAL(ac_cv_mvwdelch_is_expression,
3763 AC_TRY_COMPILE([#include <curses.h>], [
3764 int rtn;
3765 rtn = mvwdelch(0,0,0);
3766 ], ac_cv_mvwdelch_is_expression=yes,
3767 ac_cv_mvwdelch_is_expression=no,
3768 ac_cv_mvwdelch_is_expression=yes))
3769 AC_MSG_RESULT($ac_cv_mvwdelch_is_expression)
3771 if test "$ac_cv_mvwdelch_is_expression" = yes
3772 then
3773 AC_DEFINE(MVWDELCH_IS_EXPRESSION, 1,
3774 [Define if mvwdelch in curses.h is an expression.])
3775 fi
3777 AC_MSG_CHECKING(whether WINDOW has _flags)
3778 AC_CACHE_VAL(ac_cv_window_has_flags,
3779 AC_TRY_COMPILE([#include <curses.h>], [
3780 WINDOW *w;
3781 w->_flags = 0;
3782 ], ac_cv_window_has_flags=yes,
3783 ac_cv_window_has_flags=no,
3784 ac_cv_window_has_flags=no))
3785 AC_MSG_RESULT($ac_cv_window_has_flags)
3788 if test "$ac_cv_window_has_flags" = yes
3789 then
3790 AC_DEFINE(WINDOW_HAS_FLAGS, 1,
3791 [Define if WINDOW in curses.h offers a field _flags.])
3792 fi
3794 AC_MSG_CHECKING(for is_term_resized)
3795 AC_TRY_COMPILE([#include <curses.h>], void *x=is_term_resized,
3796 AC_DEFINE(HAVE_CURSES_IS_TERM_RESIZED, 1, Define if you have the 'is_term_resized' function.)
3797 AC_MSG_RESULT(yes),
3798 AC_MSG_RESULT(no)
3799 )
3801 AC_MSG_CHECKING(for resize_term)
3802 AC_TRY_COMPILE([#include <curses.h>], void *x=resize_term,
3803 AC_DEFINE(HAVE_CURSES_RESIZE_TERM, 1, Define if you have the 'resize_term' function.)
3804 AC_MSG_RESULT(yes),
3805 AC_MSG_RESULT(no)
3806 )
3808 AC_MSG_CHECKING(for resizeterm)
3809 AC_TRY_COMPILE([#include <curses.h>], void *x=resizeterm,
3810 AC_DEFINE(HAVE_CURSES_RESIZETERM, 1, Define if you have the 'resizeterm' function.)
3811 AC_MSG_RESULT(yes),
3812 AC_MSG_RESULT(no)
3813 )
3815 AC_MSG_CHECKING(for /dev/ptmx)
3817 if test -r /dev/ptmx
3818 then
3819 AC_MSG_RESULT(yes)
3820 AC_DEFINE(HAVE_DEV_PTMX, 1,
3821 [Define if we have /dev/ptmx.])
3822 else
3823 AC_MSG_RESULT(no)
3824 fi
3826 AC_MSG_CHECKING(for /dev/ptc)
3828 if test -r /dev/ptc
3829 then
3830 AC_MSG_RESULT(yes)
3831 AC_DEFINE(HAVE_DEV_PTC, 1,
3832 [Define if we have /dev/ptc.])
3833 else
3834 AC_MSG_RESULT(no)
3835 fi
3837 AC_MSG_CHECKING(for %zd printf() format support)
3838 AC_CACHE_VAL(ac_cv_have_size_t_format,
3839 AC_TRY_RUN([[
3840 #include <stdio.h>
3841 #include <stddef.h>
3842 #include <string.h>
3844 #ifdef HAVE_SYS_TYPES_H
3845 #include <sys/types.h>
3846 #endif
3848 #ifdef HAVE_SSIZE_T
3849 typedef ssize_t Py_ssize_t;
3850 #elif SIZEOF_VOID_P == SIZEOF_LONG
3851 typedef long Py_ssize_t;
3852 #else
3853 typedef int Py_ssize_t;
3854 #endif
3856 int main()
3857 {
3858 char buffer[256];
3860 if(sprintf(buffer, "%zd", (size_t)123) < 0)
3861 return 1;
3863 if (strcmp(buffer, "123"))
3864 return 1;
3866 if (sprintf(buffer, "%zd", (Py_ssize_t)-123) < 0)
3867 return 1;
3869 if (strcmp(buffer, "-123"))
3870 return 1;
3872 return 0;
3873 }
3874 ]], ac_cv_have_size_t_format=yes,
3875 ac_cv_have_size_t_format=no,
3876 ac_cv_have_size_t_format=no)
3877 )
3878 AC_MSG_RESULT($ac_cv_have_size_t_format)
3879 if test $ac_cv_have_size_t_format = yes
3880 then
3881 AC_DEFINE(PY_FORMAT_SIZE_T, "z",
3882 [Define to printf format modifier for Py_ssize_t])
3883 fi
3885 AC_CHECK_TYPE(socklen_t,,
3886 AC_DEFINE(socklen_t,int,
3887 Define to `int' if <sys/socket.h> does not define.),[
3888 #ifdef HAVE_SYS_TYPES_H
3889 #include <sys/types.h>
3890 #endif
3891 #ifdef HAVE_SYS_SOCKET_H
3892 #include <sys/socket.h>
3893 #endif
3894 ])
3896 AC_SUBST(THREADHEADERS)
3898 for h in `(cd $srcdir;echo Python/thread_*.h)`
3899 do
3900 THREADHEADERS="$THREADHEADERS \$(srcdir)/$h"
3901 done
3903 AC_SUBST(SRCDIRS)
3904 SRCDIRS="Parser Grammar Objects Python Modules Mac"
3905 AC_MSG_CHECKING(for build directories)
3906 for dir in $SRCDIRS; do
3907 if test ! -d $dir; then
3908 mkdir $dir
3909 fi
3910 done
3911 AC_MSG_RESULT(done)
3913 # generate output files
3914 AC_CONFIG_FILES(Makefile.pre Modules/Setup.config Misc/python.pc)
3915 AC_OUTPUT
3917 echo "creating Modules/Setup"
3918 if test ! -f Modules/Setup
3919 then
3920 cp $srcdir/Modules/Setup.dist Modules/Setup
3921 fi
3923 echo "creating Modules/Setup.local"
3924 if test ! -f Modules/Setup.local
3925 then
3926 echo "# Edit this file for local setup changes" >Modules/Setup.local
3927 fi
3929 echo "creating Makefile"
3930 $SHELL $srcdir/Modules/makesetup -c $srcdir/Modules/config.c.in \
3931 -s Modules Modules/Setup.config \
3932 Modules/Setup.local Modules/Setup
3934 case $ac_sys_system in
3935 BeOS)
3936 AC_MSG_WARN([
3938 Support for BeOS is deprecated as of Python 2.6.
3939 See PEP 11 for the gory details.
3940 ])
3941 ;;
3942 *) ;;
3943 esac
3945 mv config.c Modules