1 dnl Process this file with autoconf 2.0 or later to make a configure script.
3 # Set VERSION so we only need to edit in one place (i.e., here)
4 m4_define(PYTHON_VERSION, 2.6)
6 AC_REVISION($Revision$)
8 AC_INIT(python, PYTHON_VERSION, http://www.python.org/python-bugs)
9 AC_CONFIG_SRCDIR([Include/object.h])
10 AC_CONFIG_HEADER(pyconfig.h)
12 dnl This is for stuff that absolutely must end up in pyconfig.h.
13 dnl Please use pyport.h instead, if possible.
19 /* Define the macros needed if on a UnixWare 7.x system. */
20 #if defined(__USLC__) && defined(__SCO_VERSION__)
21 #define STRICT_SYSV_CURSES /* Don't use ncurses extensions */
24 #endif /*Py_PYCONFIG_H*/
27 # We don't use PACKAGE_ variables, and they cause conflicts
28 # with other autoconf-based packages that include Python.h
29 grep -v 'define PACKAGE_' <confdefs.h >confdefs.h.new
31 mv confdefs.h.new confdefs.h
34 VERSION=PYTHON_VERSION
39 # The later defininition of _XOPEN_SOURCE disables certain features
40 # on Linux, so we need _GNU_SOURCE to re-enable them (makedev, tm_zone).
41 AC_DEFINE(_GNU_SOURCE, 1, [Define on Linux to activate all library features])
43 # The later defininition of _XOPEN_SOURCE and _POSIX_C_SOURCE disables
44 # certain features on NetBSD, so we need _NETBSD_SOURCE to re-enable
46 AC_DEFINE(_NETBSD_SOURCE, 1, [Define on NetBSD to activate all library features])
48 # The later defininition of _XOPEN_SOURCE and _POSIX_C_SOURCE disables
49 # certain features on FreeBSD, so we need __BSD_VISIBLE to re-enable
51 AC_DEFINE(__BSD_VISIBLE, 1, [Define on FreeBSD to activate all library features])
53 # The later defininition of _XOPEN_SOURCE and _POSIX_C_SOURCE disables
54 # u_int on Irix 5.3. Defining _BSD_TYPES brings it back.
55 AC_DEFINE(_BSD_TYPES, 1, [Define on Irix to enable u_int])
57 define_xopen_source=yes
59 # Arguments passed to configure.
61 CONFIG_ARGS="$ac_configure_args"
63 AC_ARG_ENABLE(universalsdk,
64 AC_HELP_STRING(--enable-universalsdk@<:@=SDKDIR@:>@, Build against Mac OS X 10.4u SDK (ppc/i386)),
68 enableval=/Developer/SDKs/MacOSX10.4u.sdk
77 UNIVERSALSDK=$enableval
84 AC_SUBST(UNIVERSALSDK)
86 dnl quadrigraphs "@<:@" and "@:>@" produce "[" and "]" in the output
87 AC_ARG_ENABLE(framework,
88 AC_HELP_STRING(--enable-framework@<:@=INSTALLDIR@:>@, Build (MacOSX|Darwin) framework),
92 enableval=/Library/Frameworks
97 PYTHONFRAMEWORKDIR=no-framework
98 PYTHONFRAMEWORKPREFIX=
99 PYTHONFRAMEWORKINSTALLDIR=
100 FRAMEWORKINSTALLFIRST=
101 FRAMEWORKINSTALLLAST=
102 FRAMEWORKALTINSTALLFIRST=
103 FRAMEWORKALTINSTALLLAST=
104 if test "x${prefix}" = "xNONE"; then
105 FRAMEWORKUNIXTOOLSPREFIX="${ac_default_prefix}"
107 FRAMEWORKUNIXTOOLSPREFIX="${prefix}"
112 PYTHONFRAMEWORK=Python
113 PYTHONFRAMEWORKDIR=Python.framework
114 PYTHONFRAMEWORKPREFIX=$enableval
115 PYTHONFRAMEWORKINSTALLDIR=$PYTHONFRAMEWORKPREFIX/$PYTHONFRAMEWORKDIR
116 FRAMEWORKINSTALLFIRST="frameworkinstallstructure"
117 FRAMEWORKINSTALLLAST="frameworkinstallmaclib frameworkinstallapps frameworkinstallunixtools"
118 FRAMEWORKALTINSTALLFIRST="${FRAMEWORKINSTALLFIRST} bininstall maninstall"
119 FRAMEWORKALTINSTALLLAST="frameworkinstallmaclib frameworkinstallapps frameworkaltinstallunixtools"
120 if test "x${prefix}" = "xNONE" ; then
121 FRAMEWORKUNIXTOOLSPREFIX="${ac_default_prefix}"
123 FRAMEWORKUNIXTOOLSPREFIX="${prefix}"
125 prefix=$PYTHONFRAMEWORKINSTALLDIR/Versions/$VERSION
127 # Add makefiles for Mac specific code to the list of output
129 AC_CONFIG_FILES(Mac/Makefile)
130 AC_CONFIG_FILES(Mac/PythonLauncher/Makefile)
131 AC_CONFIG_FILES(Mac/IDLE/Makefile)
135 PYTHONFRAMEWORKDIR=no-framework
136 PYTHONFRAMEWORKPREFIX=
137 PYTHONFRAMEWORKINSTALLDIR=
138 FRAMEWORKINSTALLFIRST=
139 FRAMEWORKINSTALLLAST=
140 FRAMEWORKALTINSTALLFIRST=
141 FRAMEWORKALTINSTALLLAST=
142 if test "x${prefix}" = "xNONE" ; then
143 FRAMEWORKUNIXTOOLSPREFIX="${ac_default_prefix}"
145 FRAMEWORKUNIXTOOLSPREFIX="${prefix}"
149 AC_SUBST(PYTHONFRAMEWORK)
150 AC_SUBST(PYTHONFRAMEWORKDIR)
151 AC_SUBST(PYTHONFRAMEWORKPREFIX)
152 AC_SUBST(PYTHONFRAMEWORKINSTALLDIR)
153 AC_SUBST(FRAMEWORKINSTALLFIRST)
154 AC_SUBST(FRAMEWORKINSTALLLAST)
155 AC_SUBST(FRAMEWORKALTINSTALLFIRST)
156 AC_SUBST(FRAMEWORKALTINSTALLLAST)
157 AC_SUBST(FRAMEWORKUNIXTOOLSPREFIX)
160 ## AC_HELP_STRING(--with-dyld,
161 ## Use (OpenStep|Rhapsody) dynamic linker))
163 # Set name for machine-dependent library files
165 AC_MSG_CHECKING(MACHDEP)
166 if test -z "$MACHDEP"
168 ac_sys_system=`uname -s`
169 if test "$ac_sys_system" = "AIX" -o "$ac_sys_system" = "Monterey64" \
170 -o "$ac_sys_system" = "UnixWare" -o "$ac_sys_system" = "OpenUNIX"; then
171 ac_sys_release=`uname -v`
173 ac_sys_release=`uname -r`
175 ac_md_system=`echo $ac_sys_system |
176 tr -d '[/ ]' | tr '[[A-Z]]' '[[a-z]]'`
177 ac_md_release=`echo $ac_sys_release |
178 tr -d '[/ ]' | sed 's/^[[A-Z]]\.//' | sed 's/\..*//'`
179 MACHDEP="$ac_md_system$ac_md_release"
182 cygwin*) MACHDEP="cygwin";;
183 darwin*) MACHDEP="darwin";;
184 atheos*) MACHDEP="atheos";;
185 irix646) MACHDEP="irix6";;
186 '') MACHDEP="unknown";;
190 # Some systems cannot stand _XOPEN_SOURCE being defined at all; they
191 # disable features if it is defined, without any means to access these
192 # features as extensions. For these systems, we skip the definition of
193 # _XOPEN_SOURCE. Before adding a system to the list to gain access to
194 # some feature, make sure there is no alternative way to access this
195 # feature. Also, when using wildcards, make sure you have verified the
196 # need for not defining _XOPEN_SOURCE on all systems matching the
197 # wildcard, and that the wildcard does not include future systems
198 # (which may remove their limitations).
199 dnl quadrigraphs "@<:@" and "@:>@" produce "[" and "]" in the output
200 case $ac_sys_system/$ac_sys_release in
201 # On OpenBSD, select(2) is not available if _XOPEN_SOURCE is defined,
202 # even though select is a POSIX function. Reported by J. Ribbens.
203 # Reconfirmed for OpenBSD 3.3 by Zachary Hamm, for 3.4 by Jason Ish.
204 OpenBSD/2.* | OpenBSD/3.@<:@0123456789@:>@ | OpenBSD/4.@<:@0@:>@)
205 define_xopen_source=no
206 # OpenBSD undoes our definition of __BSD_VISIBLE if _XOPEN_SOURCE is
207 # also defined. This can be overridden by defining _BSD_SOURCE
208 # As this has a different meaning on Linux, only define it on OpenBSD
209 AC_DEFINE(_BSD_SOURCE, 1, [Define on OpenBSD to activate all library features])
211 # Defining _XOPEN_SOURCE on NetBSD version prior to the introduction of
212 # _NETBSD_SOURCE disables certain features (eg. setgroups). Reported by
214 NetBSD/1.5 | NetBSD/1.5.* | NetBSD/1.6 | NetBSD/1.6.* | NetBSD/1.6[A-S])
215 define_xopen_source=no;;
216 # On Solaris 2.6, sys/wait.h is inconsistent in the usage
217 # of union __?sigval. Reported by Stuart Bishop.
219 define_xopen_source=no;;
220 # On UnixWare 7, u_long is never defined with _XOPEN_SOURCE,
221 # but used in /usr/include/netinet/tcp.h. Reported by Tim Rice.
222 # Reconfirmed for 7.1.4 by Martin v. Loewis.
223 OpenUNIX/8.0.0| UnixWare/7.1.@<:@0-4@:>@)
224 define_xopen_source=no;;
225 # On OpenServer 5, u_short is never defined with _XOPEN_SOURCE,
226 # but used in struct sockaddr.sa_family. Reported by Tim Rice.
228 define_xopen_source=no;;
229 # On FreeBSD 4.8 and MacOS X 10.2, a bug in ncurses.h means that
230 # it craps out if _XOPEN_EXTENDED_SOURCE is defined. Apparently,
231 # this is fixed in 10.3, which identifies itself as Darwin/7.*
232 # This should hopefully be fixed in FreeBSD 4.9
233 FreeBSD/4.8* | Darwin/6* )
234 define_xopen_source=no;;
235 # On AIX 4 and 5.1, mbstate_t is defined only when _XOPEN_SOURCE == 500 but
236 # used in wcsnrtombs() and mbsnrtowcs() even if _XOPEN_SOURCE is not defined
237 # or has another value. By not (re)defining it, the defaults come in place.
239 define_xopen_source=no;;
241 if test `uname -r` -eq 1; then
242 define_xopen_source=no
245 # On Mac OS X 10.4, defining _POSIX_C_SOURCE or _XOPEN_SOURCE
246 # disables platform specific features beyond repair.
247 # On Mac OS X 10.3, defining _POSIX_C_SOURCE or _XOPEN_SOURCE
248 # has no effect, don't bother defining them
249 Darwin/@<:@789@:>@.*)
250 define_xopen_source=no
255 if test $define_xopen_source = yes
257 # On Solaris w/ g++ it appears that _XOPEN_SOURCE has to be
258 # defined precisely as g++ defines it
259 # Furthermore, on Solaris 10, XPG6 requires the use of a C99
261 case $ac_sys_system/$ac_sys_release in
262 SunOS/5.8|SunOS/5.9|SunOS/5.10)
263 AC_DEFINE(_XOPEN_SOURCE, 500,
264 Define to the level of X/Open that your system supports)
267 AC_DEFINE(_XOPEN_SOURCE, 600,
268 Define to the level of X/Open that your system supports)
272 # On Tru64 Unix 4.0F, defining _XOPEN_SOURCE also requires
273 # definition of _XOPEN_SOURCE_EXTENDED and _POSIX_C_SOURCE, or else
274 # several APIs are not declared. Since this is also needed in some
275 # cases for HP-UX, we define it globally.
276 # except for Solaris 10, where it must not be defined,
277 # as it implies XPG4.2
278 case $ac_sys_system/$ac_sys_release in
282 AC_DEFINE(_XOPEN_SOURCE_EXTENDED, 1,
283 Define to activate Unix95-and-earlier features)
287 AC_DEFINE(_POSIX_C_SOURCE, 200112L, Define to activate features from IEEE Stds 1003.1-2001)
292 # SGI compilers allow the specification of the both the ABI and the
293 # ISA on the command line. Depending on the values of these switches,
294 # different and often incompatable code will be generated.
296 # The SGI_ABI variable can be used to modify the CC and LDFLAGS and
297 # thus supply support for various ABI/ISA combinations. The MACHDEP
298 # variable is also adjusted.
301 if test ! -z "$SGI_ABI"
304 LDFLAGS="$SGI_ABI $LDFLAGS"
305 MACHDEP=`echo "${MACHDEP}${SGI_ABI}" | sed 's/ *//g'`
307 AC_MSG_RESULT($MACHDEP)
309 # And add extra plat-mac for darwin
310 AC_SUBST(EXTRAPLATDIR)
311 AC_SUBST(EXTRAMACHDEPPATH)
312 AC_MSG_CHECKING(EXTRAPLATDIR)
313 if test -z "$EXTRAPLATDIR"
317 EXTRAPLATDIR="\$(PLATMACDIRS)"
318 EXTRAMACHDEPPATH="\$(PLATMACPATH)"
326 AC_MSG_RESULT($EXTRAPLATDIR)
328 # Record the configure-time value of MACOSX_DEPLOYMENT_TARGET,
329 # it may influence the way we can build extensions, so distutils
331 AC_SUBST(CONFIGURE_MACOSX_DEPLOYMENT_TARGET)
332 AC_SUBST(EXPORT_MACOSX_DEPLOYMENT_TARGET)
333 CONFIGURE_MACOSX_DEPLOYMENT_TARGET=
334 EXPORT_MACOSX_DEPLOYMENT_TARGET='#'
336 # checks for alternative programs
338 # compiler flags are generated in two sets, BASECFLAGS and OPT. OPT is just
339 # for debug/optimization stuff. BASECFLAGS is for flags that are required
340 # just to get things to compile and link. Users are free to override OPT
341 # when running configure or make. The build should not break if they do.
342 # BASECFLAGS should generally not be messed with, however.
344 # XXX shouldn't some/most/all of this code be merged with the stuff later
345 # on that fiddles with OPT and BASECFLAGS?
346 AC_MSG_CHECKING(for --without-gcc)
348 AC_HELP_STRING(--without-gcc,never use gcc),
356 without_gcc=$withval;;
358 case $ac_sys_system in
366 BASECFLAGS="$BASECFLAGS -export pragma"
368 LDFLAGS="$LDFLAGS -nodup"
376 AC_MSG_ERROR([Unknown BeOS platform "$BE_HOST_CPU"])
379 AR="\$(srcdir)/Modules/ar_beos"
387 AC_MSG_RESULT($without_gcc)
389 # If the user switches compilers, we can't believe the cache
390 if test ! -z "$ac_cv_prog_CC" -a ! -z "$CC" -a "$CC" != "$ac_cv_prog_CC"
392 AC_MSG_ERROR([cached CC is different -- throw away $cache_file
393 (it is also a good idea to do 'make clean' before compiling)])
400 AC_MSG_CHECKING(for --with-cxx-main=<compiler>)
401 AC_ARG_WITH(cxx_main,
402 AC_HELP_STRING([--with-cxx-main=<compiler>],
403 [compile main() and link python executable with C++ compiler]),
409 yes) with_cxx_main=yes
421 AC_MSG_RESULT($with_cxx_main)
427 gcc) AC_PATH_PROG(CXX, [g++], [g++], [notfound]) ;;
428 cc) AC_PATH_PROG(CXX, [c++], [c++], [notfound]) ;;
430 if test "$CXX" = "notfound"
437 AC_CHECK_PROGS(CXX, $CCC c++ g++ gcc CC cxx cc++ cl, notfound)
438 if test "$CXX" = "notfound"
443 if test "$preset_cxx" != "$CXX"
447 By default, distutils will build C++ extension modules with "$CXX".
448 If this is not intended, then set CXX on the configure command line.
453 # checks for UNIX variants that set C preprocessor variables
456 # Check for unsupported systems
457 case $ac_sys_system/$ac_sys_release in
459 echo This system \($ac_sys_system/$ac_sys_release\) is no longer supported.
460 echo See README for details.
465 AC_MSG_CHECKING(for --with-suffix)
467 AC_HELP_STRING(--with-suffix=.exe, set executable suffix),
474 AC_MSG_RESULT($EXEEXT)
476 # Test whether we're running on a non-case-sensitive system, in which
477 # case we give a warning if no ext is given
478 AC_SUBST(BUILDEXEEXT)
479 AC_MSG_CHECKING(for case-insensitive build directory)
480 if test ! -d CaseSensitiveTestDir; then
481 mkdir CaseSensitiveTestDir
484 if test -d casesensitivetestdir
492 rmdir CaseSensitiveTestDir
497 gcc) CC="$CC -D_HAVE_BSDI";;
501 case $ac_sys_system in
504 cc|*/cc) CC="$CC -Ae";;
508 cc) CC="$CC -Wl,-Bexport";;
511 # Some functions have a prototype only with that define, e.g. confstr
512 AC_DEFINE(__EXTENSIONS__, 1, [Defined on Solaris to see additional function prototypes.])
518 AC_MSG_CHECKING(LIBRARY)
519 if test -z "$LIBRARY"
521 LIBRARY='libpython$(VERSION).a'
523 AC_MSG_RESULT($LIBRARY)
525 # LDLIBRARY is the name of the library to link against (as opposed to the
526 # name of the library into which to insert object files). BLDLIBRARY is also
527 # the library to link against, usually. On Mac OS X frameworks, BLDLIBRARY
528 # is blank as the main program is not linked directly against LDLIBRARY.
529 # LDLIBRARYDIR is the path to LDLIBRARY, which is made in a subdirectory. On
530 # systems without shared libraries, LDLIBRARY is the same as LIBRARY
531 # (defined in the Makefiles). On Cygwin LDLIBRARY is the import library,
532 # DLLLIBRARY is the shared (i.e., DLL) library.
534 # RUNSHARED is used to run shared python without installed libraries
536 # INSTSONAME is the name of the shared library that will be use to install
537 # on the system - some systems like version suffix, others don't
541 AC_SUBST(LDLIBRARYDIR)
545 BLDLIBRARY='$(LDLIBRARY)'
546 INSTSONAME='$(LDLIBRARY)'
551 # LINKCC is the command that links the python executable -- default is $(CC).
552 # If CXX is set, and if it is needed to link a main function that was
553 # compiled with CXX, LINKCC is CXX instead. Always using CXX is undesirable:
554 # python might then depend on the C++ runtime
555 # This is altered for AIX in order to build the export list before
558 AC_MSG_CHECKING(LINKCC)
561 LINKCC='$(PURIFY) $(MAINCC)'
562 case $ac_sys_system in
565 if test $ac_sys_release -ge 5 -o \
566 $ac_sys_release -eq 4 -a `uname -r` -ge 2 ; then
569 LINKCC="\$(srcdir)/Modules/makexp_aix Modules/python.exp $exp_extra \$(LIBRARY); $LINKCC";;
571 LINKCC="$LINKCC -L/usr/lib/ia64l64";;
574 AC_MSG_RESULT($LINKCC)
576 AC_MSG_CHECKING(for --enable-shared)
577 AC_ARG_ENABLE(shared,
578 AC_HELP_STRING(--enable-shared, disable/enable building shared python library))
580 if test -z "$enable_shared"
582 case $ac_sys_system in
584 enable_shared="yes";;
589 AC_MSG_RESULT($enable_shared)
591 AC_MSG_CHECKING(for --enable-profiling)
592 AC_ARG_ENABLE(profiling,
593 AC_HELP_STRING(--enable-profiling, enable C-level code profiling),
596 AC_TRY_RUN([int main() { return 0; }],
597 ac_enable_profiling="yes",
598 ac_enable_profiling="no",
599 ac_enable_profiling="no")
601 AC_MSG_RESULT($ac_enable_profiling)
603 case "$ac_enable_profiling" in
605 BASECFLAGS="-pg $BASECFLAGS"
606 LDFLAGS="-pg $LDFLAGS"
610 AC_MSG_CHECKING(LDLIBRARY)
612 # MacOSX framework builds need more magic. LDLIBRARY is the dynamic
613 # library that we build, but we do not want to link against it (we
614 # will find it with a -framework option). For this reason there is an
615 # extra variable BLDLIBRARY against which Python and the extension
616 # modules are linked, BLDLIBRARY. This is normally the same as
617 # LDLIBRARY, but empty for MacOSX framework builds.
618 if test "$enable_framework"
620 LDLIBRARY='$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
621 RUNSHARED=DYLD_FRAMEWORK_PATH="`pwd`:$DYLD_FRAMEWORK_PATH"
624 BLDLIBRARY='$(LDLIBRARY)'
627 # Other platforms follow
628 if test $enable_shared = "yes"; then
629 AC_DEFINE(Py_ENABLE_SHARED, 1, [Defined if Python is built as a shared library.])
630 case $ac_sys_system in
632 LDLIBRARY='libpython$(VERSION).so'
635 LDLIBRARY='libpython$(VERSION).dll.a'
636 DLLLIBRARY='libpython$(VERSION).dll'
639 LDLIBRARY='libpython$(VERSION).so'
640 BLDLIBRARY='-Wl,-R,$(LIBDIR) -L. -lpython$(VERSION)'
641 RUNSHARED=LD_LIBRARY_PATH=`pwd`:${LD_LIBRARY_PATH}
642 INSTSONAME="$LDLIBRARY".$SOVERSION
644 Linux*|GNU*|NetBSD*|FreeBSD*|DragonFly*)
645 LDLIBRARY='libpython$(VERSION).so'
646 BLDLIBRARY='-L. -lpython$(VERSION)'
647 RUNSHARED=LD_LIBRARY_PATH=`pwd`:${LD_LIBRARY_PATH}
648 case $ac_sys_system in
650 SOVERSION=`echo $SOVERSION|cut -d "." -f 1`
653 INSTSONAME="$LDLIBRARY".$SOVERSION
658 LDLIBRARY='libpython$(VERSION).so'
661 LDLIBRARY='libpython$(VERSION).sl'
664 BLDLIBRARY='-Wl,+b,$(LIBDIR) -L. -lpython$(VERSION)'
665 RUNSHARED=SHLIB_PATH=`pwd`:${SHLIB_PATH}
668 LDLIBRARY='libpython$(VERSION).so'
669 BLDLIBRARY='-rpath $(LIBDIR) -L. -lpython$(VERSION)'
670 RUNSHARED=LD_LIBRARY_PATH=`pwd`:${LD_LIBRARY_PATH}
673 LDLIBRARY='libpython$(VERSION).so'
674 BLDLIBRARY='-L. -lpython$(VERSION)'
675 RUNSHARED=DLL_PATH=`pwd`:${DLL_PATH:-/atheos/sys/libs:/atheos/autolnk/lib}
678 else # shared is disabled
679 case $ac_sys_system in
681 BLDLIBRARY='$(LIBRARY)'
682 LDLIBRARY='libpython$(VERSION).dll.a'
687 AC_MSG_RESULT($LDLIBRARY)
691 AC_CHECK_PROGS(AR, ar aal, ar)
694 AC_CHECK_PROG(SVNVERSION, svnversion, found, not-found)
695 if test $SVNVERSION = found
697 SVNVERSION="svnversion \$(srcdir)"
699 SVNVERSION="echo exported"
704 # install -d does not work on BSDI or HP-UX
705 if test -z "$INSTALL"
707 INSTALL="${srcdir}/install-sh -c"
712 # Not every filesystem supports hard links
714 if test -z "$LN" ; then
715 case $ac_sys_system in
717 CYGWIN*) LN="ln -s";;
718 atheos*) LN="ln -s";;
723 # Check for --with-pydebug
724 AC_MSG_CHECKING(for --with-pydebug)
726 AC_HELP_STRING(--with-pydebug, build with Py_DEBUG defined),
728 if test "$withval" != no
730 AC_DEFINE(Py_DEBUG, 1,
731 [Define if you want to build an interpreter with many run-time checks.])
734 else AC_MSG_RESULT(no); Py_DEBUG='false'
738 # XXX Shouldn't the code above that fiddles with BASECFLAGS and OPT be
739 # merged with this chunk of code?
741 # Optimizer/debugger flags
742 # ------------------------
743 # (The following bit of code is complicated enough - please keep things
744 # indented properly. Just pretend you're editing Python code. ;-)
746 # There are two parallel sets of case statements below, one that checks to
747 # see if OPT was set and one that does BASECFLAGS setting based upon
748 # compiler and platform. BASECFLAGS tweaks need to be made even if the
751 # tweak OPT based on compiler and platform, only if the user didn't set
752 # it on the command line
758 if test "$CC" != 'g++' ; then
759 STRICT_PROTO="-Wstrict-prototypes"
761 # For gcc 4.x we need to use -fwrapv so lets check if its supported
762 if "$CC" -v --help 2>/dev/null |grep -- -fwrapv > /dev/null; then
765 case $ac_cv_prog_cc_g in
767 if test "$Py_DEBUG" = 'true' ; then
768 # Optimization messes up debuggers, so turn it off for
770 OPT="-g -Wall $STRICT_PROTO"
772 OPT="-g $WRAP -O3 -Wall $STRICT_PROTO"
776 OPT="-O3 -Wall $STRICT_PROTO"
779 case $ac_sys_system in
780 SCO_SV*) OPT="$OPT -m486 -DSCO5"
790 # The current (beta) Monterey compiler dies with optimizations
791 # XXX what is Monterey? Does it still die w/ -O? Can we get rid of this?
792 case $ac_sys_system in
801 # tweak BASECFLAGS based on compiler and platform
804 # Python violates C99 rules, by casting between incompatible
805 # pointer types. GCC may generate bad code as a result of that,
806 # so use -fno-strict-aliasing if supported.
807 AC_MSG_CHECKING(whether $CC accepts -fno-strict-aliasing)
809 CC="$CC -fno-strict-aliasing"
810 AC_TRY_RUN([int main() { return 0; }],
811 ac_cv_no_strict_aliasing_ok=yes,
812 ac_cv_no_strict_aliasing_ok=no,
813 ac_cv_no_strict_aliasing_ok=no)
815 AC_MSG_RESULT($ac_cv_no_strict_aliasing_ok)
816 if test $ac_cv_no_strict_aliasing_ok = yes
818 BASECFLAGS="$BASECFLAGS -fno-strict-aliasing"
820 case $ac_sys_system in
822 BASECFLAGS="$BASECFLAGS -m486 -DSCO5"
824 # is there any other compiler on Darwin besides gcc?
826 # -Wno-long-double, -no-cpp-precomp, and -mno-fused-madd
827 # used to be here, but non-Apple gcc doesn't accept them.
828 if test "${enable_universalsdk}"; then
829 BASECFLAGS="-arch ppc -arch i386 -isysroot ${UNIVERSALSDK} ${BASECFLAGS}"
834 BASECFLAGS="$BASECFLAGS -mieee"
840 case $ac_sys_system in
842 BASECFLAGS="$BASECFLAGS -K pentium,host,inline,loop_unroll,alloca "
845 BASECFLAGS="$BASECFLAGS -ieee -std"
848 BASECFLAGS="$BASECFLAGS -belf -Ki486 -DSCO5"
854 if test "$Py_DEBUG" = 'true'; then
860 if test "$ac_arch_flags"
862 BASECFLAGS="$BASECFLAGS $ac_arch_flags"
865 # disable check for icc since it seems to pass, but generates a warning
868 ac_cv_opt_olimit_ok=no
871 AC_MSG_CHECKING(whether $CC accepts -OPT:Olimit=0)
872 AC_CACHE_VAL(ac_cv_opt_olimit_ok,
874 CC="$CC -OPT:Olimit=0"
875 AC_TRY_RUN([int main() { return 0; }],
876 ac_cv_opt_olimit_ok=yes,
877 ac_cv_opt_olimit_ok=no,
878 ac_cv_opt_olimit_ok=no)
880 AC_MSG_RESULT($ac_cv_opt_olimit_ok)
881 if test $ac_cv_opt_olimit_ok = yes; then
882 case $ac_sys_system in
883 # XXX is this branch needed? On MacOSX 10.2.2 the result of the
884 # olimit_ok test is "no". Is it "yes" in some other Darwin-esque
889 BASECFLAGS="$BASECFLAGS -OPT:Olimit=0"
893 AC_MSG_CHECKING(whether $CC accepts -Olimit 1500)
894 AC_CACHE_VAL(ac_cv_olimit_ok,
896 CC="$CC -Olimit 1500"
897 AC_TRY_RUN([int main() { return 0; }],
902 AC_MSG_RESULT($ac_cv_olimit_ok)
903 if test $ac_cv_olimit_ok = yes; then
904 BASECFLAGS="$BASECFLAGS -Olimit 1500"
908 # Check whether GCC supports PyArg_ParseTuple format
909 if test "$GCC" = "yes"
911 AC_MSG_CHECKING(whether gcc supports ParseTuple __format__)
913 CFLAGS="$CFLAGS -Werror"
915 void f(char*,...)__attribute((format(PyArg_ParseTuple, 1, 2)));
917 AC_DEFINE(HAVE_ATTRIBUTE_FORMAT_PARSETUPLE, 1, [Define if GCC supports __attribute__((format(PyArg_ParseTuple, 2, 3)))])
924 # On some compilers, pthreads are available without further options
925 # (e.g. MacOS X). On some of these systems, the compiler will not
926 # complain if unaccepted options are passed (e.g. gcc on Mac OS X).
927 # So we have to see first whether pthreads are available without
928 # options before we can check whether -Kpthread improves anything.
929 AC_MSG_CHECKING(whether pthreads are available without options)
930 AC_CACHE_VAL(ac_cv_pthread_is_default,
934 void* routine(void* p){return NULL;}
938 if(pthread_create(&p,NULL,routine,NULL)!=0)
940 (void)pthread_detach(p);
945 ac_cv_pthread_is_default=yes
949 ac_cv_pthread_is_default=no,
950 ac_cv_pthread_is_default=no)
952 AC_MSG_RESULT($ac_cv_pthread_is_default)
955 if test $ac_cv_pthread_is_default = yes
959 # -Kpthread, if available, provides the right #defines
960 # and linker options to make pthread_create available
961 # Some compilers won't report that they do not support -Kpthread,
962 # so we need to run a program to see whether it really made the
963 # function available.
964 AC_MSG_CHECKING(whether $CC accepts -Kpthread)
965 AC_CACHE_VAL(ac_cv_kpthread,
971 void* routine(void* p){return NULL;}
975 if(pthread_create(&p,NULL,routine,NULL)!=0)
977 (void)pthread_detach(p);
985 AC_MSG_RESULT($ac_cv_kpthread)
988 if test $ac_cv_kpthread = no -a $ac_cv_pthread_is_default = no
990 # -Kthread, if available, provides the right #defines
991 # and linker options to make pthread_create available
992 # Some compilers won't report that they do not support -Kthread,
993 # so we need to run a program to see whether it really made the
994 # function available.
995 AC_MSG_CHECKING(whether $CC accepts -Kthread)
996 AC_CACHE_VAL(ac_cv_kthread,
1000 #include <pthread.h>
1002 void* routine(void* p){return NULL;}
1006 if(pthread_create(&p,NULL,routine,NULL)!=0)
1008 (void)pthread_detach(p);
1016 AC_MSG_RESULT($ac_cv_kthread)
1019 if test $ac_cv_kthread = no -a $ac_cv_pthread_is_default = no
1021 # -pthread, if available, provides the right #defines
1022 # and linker options to make pthread_create available
1023 # Some compilers won't report that they do not support -pthread,
1024 # so we need to run a program to see whether it really made the
1025 # function available.
1026 AC_MSG_CHECKING(whether $CC accepts -pthread)
1027 AC_CACHE_VAL(ac_cv_thread,
1031 #include <pthread.h>
1033 void* routine(void* p){return NULL;}
1037 if(pthread_create(&p,NULL,routine,NULL)!=0)
1039 (void)pthread_detach(p);
1047 AC_MSG_RESULT($ac_cv_pthread)
1050 # If we have set a CC compiler flag for thread support then
1051 # check if it works for CXX, too.
1055 AC_MSG_CHECKING(whether $CXX also accepts flags for thread support)
1058 if test "$ac_cv_kpthread" = "yes"
1060 CXX="$CXX -Kpthread"
1061 ac_cv_cxx_thread=yes
1062 elif test "$ac_cv_kthread" = "yes"
1065 ac_cv_cxx_thread=yes
1066 elif test "$ac_cv_pthread" = "yes"
1069 ac_cv_cxx_thread=yes
1072 if test $ac_cv_cxx_thread = yes
1074 echo 'void foo();int main(){foo();}void foo(){}' > conftest.$ac_ext
1075 $CXX -c conftest.$ac_ext 2>&5
1076 if $CXX -o conftest$ac_exeext conftest.$ac_objext 2>&5 \
1077 && test -s conftest$ac_exeext && ./conftest$ac_exeext
1079 ac_cv_cxx_thread=yes
1085 AC_MSG_RESULT($ac_cv_cxx_thread)
1089 dnl # check for ANSI or K&R ("traditional") preprocessor
1090 dnl AC_MSG_CHECKING(for C preprocessor type)
1091 dnl AC_TRY_COMPILE([
1092 dnl #define spam(name, doc) {#name, &name, #name "() -- " doc}
1094 dnl struct {char *name; int *addr; char *doc;} desc = spam(foo, "something");
1095 dnl ], [;], cpp_type=ansi, AC_DEFINE(HAVE_OLD_CPP) cpp_type=traditional)
1096 dnl AC_MSG_RESULT($cpp_type)
1098 # checks for header files
1100 AC_CHECK_HEADERS(asm/types.h conio.h curses.h direct.h dlfcn.h errno.h \
1102 io.h langinfo.h libintl.h ncurses.h poll.h process.h pthread.h \
1103 shadow.h signal.h stdint.h stropts.h termios.h thread.h \
1105 sys/audioio.h sys/bsdtty.h sys/epoll.h sys/event.h sys/file.h sys/loadavg.h \
1106 sys/lock.h sys/mkdev.h sys/modem.h \
1107 sys/param.h sys/poll.h sys/select.h sys/socket.h sys/statvfs.h sys/stat.h \
1109 sys/times.h sys/types.h sys/un.h sys/utsname.h sys/wait.h pty.h libutil.h \
1110 sys/resource.h netpacket/packet.h sysexits.h bluetooth.h \
1111 bluetooth/bluetooth.h linux/tipc.h)
1115 # On Solaris, term.h requires curses.h
1116 AC_CHECK_HEADERS(term.h,,,[
1117 #ifdef HAVE_CURSES_H
1122 # On Linux, netlink.h requires asm/types.h
1123 AC_CHECK_HEADERS(linux/netlink.h,,,[
1124 #ifdef HAVE_ASM_TYPES_H
1125 #include <asm/types.h>
1127 #ifdef HAVE_SYS_SOCKET_H
1128 #include <sys/socket.h>
1132 # checks for typedefs
1134 AC_MSG_CHECKING(for clock_t in time.h)
1135 AC_EGREP_HEADER(clock_t, time.h, was_it_defined=yes, [
1136 AC_DEFINE(clock_t, long, [Define to 'long' if <time.h> doesn't define.])
1138 AC_MSG_RESULT($was_it_defined)
1140 # Check whether using makedev requires defining _OSF_SOURCE
1141 AC_MSG_CHECKING(for makedev)
1142 AC_TRY_LINK([#include <sys/types.h> ],
1144 ac_cv_has_makedev=yes,
1145 ac_cv_has_makedev=no)
1146 if test "$ac_cv_has_makedev" = "no"; then
1147 # we didn't link, try if _OSF_SOURCE will allow us to link
1149 #define _OSF_SOURCE 1
1150 #include <sys/types.h>
1153 ac_cv_has_makedev=yes,
1154 ac_cv_has_makedev=no)
1155 if test "$ac_cv_has_makedev" = "yes"; then
1156 AC_DEFINE(_OSF_SOURCE, 1, [Define _OSF_SOURCE to get the makedev macro.])
1159 AC_MSG_RESULT($ac_cv_has_makedev)
1160 if test "$ac_cv_has_makedev" = "yes"; then
1161 AC_DEFINE(HAVE_MAKEDEV, 1, [Define this if you have the makedev macro.])
1164 # Enabling LFS on Solaris (2.6 to 9) with gcc 2.95 triggers a bug in
1165 # the system headers: If _XOPEN_SOURCE and _LARGEFILE_SOURCE are
1166 # defined, but the compiler does not support pragma redefine_extname,
1167 # and _LARGEFILE64_SOURCE is not defined, the headers refer to 64-bit
1168 # structures (such as rlimit64) without declaring them. As a
1169 # work-around, disable LFS on such configurations
1172 AC_MSG_CHECKING(Solaris LFS bug)
1174 #define _LARGEFILE_SOURCE 1
1175 #define _FILE_OFFSET_BITS 64
1176 #include <sys/resource.h>
1177 ],struct rlimit foo;,sol_lfs_bug=no,sol_lfs_bug=yes)
1178 AC_MSG_RESULT($sol_lfs_bug)
1179 if test "$sol_lfs_bug" = "yes"; then
1183 if test "$use_lfs" = "yes"; then
1184 # Two defines needed to enable largefile support on various platforms
1185 # These may affect some typedefs
1186 AC_DEFINE(_LARGEFILE_SOURCE, 1,
1187 [This must be defined on some systems to enable large file support.])
1188 AC_DEFINE(_FILE_OFFSET_BITS, 64,
1189 [This must be set to 64 on some systems to enable large file support.])
1192 # Add some code to confdefs.h so that the test for off_t works on SCO
1193 cat >> confdefs.h <<\EOF
1199 # Type availability checks
1206 AC_CHECK_TYPE(ssize_t,
1207 AC_DEFINE(HAVE_SSIZE_T, 1, Define if your compiler provides ssize_t),,)
1209 # Sizes of various common basic types
1210 # ANSI C requires sizeof(char) == 1, so no need to check it
1211 AC_CHECK_SIZEOF(int, 4)
1212 AC_CHECK_SIZEOF(long, 4)
1213 AC_CHECK_SIZEOF(void *, 4)
1214 AC_CHECK_SIZEOF(short, 2)
1215 AC_CHECK_SIZEOF(float, 4)
1216 AC_CHECK_SIZEOF(double, 8)
1217 AC_CHECK_SIZEOF(fpos_t, 4)
1218 AC_CHECK_SIZEOF(size_t, 4)
1219 AC_CHECK_SIZEOF(pid_t, 4)
1221 AC_MSG_CHECKING(for long long support)
1223 AC_TRY_COMPILE([], [long long x; x = (long long)0;], [
1224 AC_DEFINE(HAVE_LONG_LONG, 1, [Define this if you have the type long long.])
1227 AC_MSG_RESULT($have_long_long)
1228 if test "$have_long_long" = yes ; then
1229 AC_CHECK_SIZEOF(long long, 8)
1232 AC_MSG_CHECKING(for _Bool support)
1234 AC_TRY_COMPILE([], [_Bool x; x = (_Bool)0;], [
1235 AC_DEFINE(HAVE_C99_BOOL, 1, [Define this if you have the type _Bool.])
1238 AC_MSG_RESULT($have_c99_bool)
1239 if test "$have_c99_bool" = yes ; then
1240 AC_CHECK_SIZEOF(_Bool, 1)
1243 AC_CHECK_TYPES(uintptr_t,
1244 [AC_CHECK_SIZEOF(uintptr_t, 4)],
1245 [], [#ifdef HAVE_STDINT_H
1250 # Hmph. AC_CHECK_SIZEOF() doesn't include <sys/types.h>.
1251 AC_MSG_CHECKING(size of off_t)
1252 AC_CACHE_VAL(ac_cv_sizeof_off_t,
1253 [AC_TRY_RUN([#include <stdio.h>
1254 #include <sys/types.h>
1257 FILE *f=fopen("conftestval", "w");
1259 fprintf(f, "%d\n", sizeof(off_t));
1262 ac_cv_sizeof_off_t=`cat conftestval`,
1263 ac_cv_sizeof_off_t=0,
1264 ac_cv_sizeof_off_t=4)
1266 AC_MSG_RESULT($ac_cv_sizeof_off_t)
1267 AC_DEFINE_UNQUOTED(SIZEOF_OFF_T, $ac_cv_sizeof_off_t,
1268 [The number of bytes in an off_t.])
1270 AC_MSG_CHECKING(whether to enable large file support)
1271 if test "$have_long_long" = yes -a \
1272 "$ac_cv_sizeof_off_t" -gt "$ac_cv_sizeof_long" -a \
1273 "$ac_cv_sizeof_long_long" -ge "$ac_cv_sizeof_off_t"; then
1274 AC_DEFINE(HAVE_LARGEFILE_SUPPORT, 1,
1275 [Defined to enable large file support when an off_t is bigger than a long
1276 and long long is available and at least as big as an off_t. You may need
1277 to add some flags for configuration and compilation to enable this mode.
1278 (For Solaris and Linux, the necessary defines are already defined.)])
1284 # AC_CHECK_SIZEOF() doesn't include <time.h>.
1285 AC_MSG_CHECKING(size of time_t)
1286 AC_CACHE_VAL(ac_cv_sizeof_time_t,
1287 [AC_TRY_RUN([#include <stdio.h>
1291 FILE *f=fopen("conftestval", "w");
1293 fprintf(f, "%d\n", sizeof(time_t));
1296 ac_cv_sizeof_time_t=`cat conftestval`,
1297 ac_cv_sizeof_time_t=0,
1298 ac_cv_sizeof_time_t=4)
1300 AC_MSG_RESULT($ac_cv_sizeof_time_t)
1301 AC_DEFINE_UNQUOTED(SIZEOF_TIME_T, $ac_cv_sizeof_time_t,
1302 [The number of bytes in a time_t.])
1305 # if have pthread_t then define SIZEOF_PTHREAD_T
1307 if test "$ac_cv_kpthread" = "yes"
1308 then CC="$CC -Kpthread"
1309 elif test "$ac_cv_kthread" = "yes"
1310 then CC="$CC -Kthread"
1311 elif test "$ac_cv_pthread" = "yes"
1312 then CC="$CC -pthread"
1314 AC_MSG_CHECKING(for pthread_t)
1316 AC_TRY_COMPILE([#include <pthread.h>], [pthread_t x; x = *(pthread_t*)0;], have_pthread_t=yes)
1317 AC_MSG_RESULT($have_pthread_t)
1318 if test "$have_pthread_t" = yes ; then
1319 # AC_CHECK_SIZEOF() doesn't include <pthread.h>.
1320 AC_MSG_CHECKING(size of pthread_t)
1321 AC_CACHE_VAL(ac_cv_sizeof_pthread_t,
1322 [AC_TRY_RUN([#include <stdio.h>
1323 #include <pthread.h>
1326 FILE *f=fopen("conftestval", "w");
1328 fprintf(f, "%d\n", sizeof(pthread_t));
1331 ac_cv_sizeof_pthread_t=`cat conftestval`,
1332 ac_cv_sizeof_pthread_t=0,
1333 ac_cv_sizeof_pthread_t=4)
1335 AC_MSG_RESULT($ac_cv_sizeof_pthread_t)
1336 AC_DEFINE_UNQUOTED(SIZEOF_PTHREAD_T, $ac_cv_sizeof_pthread_t,
1337 [The number of bytes in a pthread_t.])
1341 AC_MSG_CHECKING(for --enable-toolbox-glue)
1342 AC_ARG_ENABLE(toolbox-glue,
1343 AC_HELP_STRING(--enable-toolbox-glue, disable/enable MacOSX glue code for extensions))
1345 if test -z "$enable_toolbox_glue"
1347 case $ac_sys_system/$ac_sys_release in
1349 enable_toolbox_glue="yes";;
1351 enable_toolbox_glue="no";;
1354 case "$enable_toolbox_glue" in
1356 extra_machdep_objs="Python/mactoolboxglue.o"
1357 extra_undefs="-u _PyMac_Error"
1358 AC_DEFINE(USE_TOOLBOX_OBJECT_GLUE, 1,
1359 [Define if you want to use MacPython modules on MacOSX in unix-Python.])
1362 extra_machdep_objs=""
1366 AC_MSG_RESULT($enable_toolbox_glue)
1368 AC_SUBST(OTHER_LIBTOOL_OPT)
1369 case $ac_sys_system/$ac_sys_release in
1370 Darwin/@<:@01567@:>@\..*)
1371 OTHER_LIBTOOL_OPT="-prebind -seg1addr 0x10000000"
1374 OTHER_LIBTOOL_OPT=""
1378 AC_SUBST(LIBTOOL_CRUFT)
1379 case $ac_sys_system/$ac_sys_release in
1380 Darwin/@<:@01567@:>@\..*)
1381 LIBTOOL_CRUFT="-framework System -lcc_dynamic"
1382 if test "${enable_universalsdk}"; then
1385 LIBTOOL_CRUFT="${LIBTOOL_CRUFT} -arch_only `arch`"
1387 LIBTOOL_CRUFT=$LIBTOOL_CRUFT' -install_name $(PYTHONFRAMEWORKINSTALLDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1388 LIBTOOL_CRUFT=$LIBTOOL_CRUFT' -compatibility_version $(VERSION) -current_version $(VERSION)';;
1390 gcc_version=`gcc -v 2>&1 | grep version | cut -d\ -f3`
1391 if test ${gcc_version} '<' 4.0
1393 LIBTOOL_CRUFT="-lcc_dynamic"
1397 LIBTOOL_CRUFT=$LIBTOOL_CRUFT" -lSystem -lSystemStubs -arch_only `arch`"
1398 LIBTOOL_CRUFT=$LIBTOOL_CRUFT' -install_name $(PYTHONFRAMEWORKINSTALLDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1399 LIBTOOL_CRUFT=$LIBTOOL_CRUFT' -compatibility_version $(VERSION) -current_version $(VERSION)';;
1402 AC_MSG_CHECKING(for --enable-framework)
1403 if test "$enable_framework"
1405 BASECFLAGS="$BASECFLAGS -fno-common -dynamic"
1406 # -F. is needed to allow linking to the framework while
1407 # in the build location.
1408 AC_DEFINE(WITH_NEXT_FRAMEWORK, 1,
1409 [Define if you want to produce an OpenStep/Rhapsody framework
1410 (shared library plus accessory files).])
1416 AC_MSG_CHECKING(for dyld)
1417 case $ac_sys_system/$ac_sys_release in
1419 AC_DEFINE(WITH_DYLD, 1,
1420 [Define if you want to use the new-style (Openstep, Rhapsody, MacOS)
1421 dynamic linker (dyld) instead of the old-style (NextStep) dynamic
1422 linker (rld). Dyld is necessary to support frameworks.])
1423 AC_MSG_RESULT(always on for Darwin)
1430 # Set info about shared libraries.
1435 AC_SUBST(LINKFORSHARED)
1436 # SO is the extension of shared libraries `(including the dot!)
1437 # -- usually .so, .sl on HP-UX, .dll on Cygwin
1441 case $ac_sys_system in
1452 # this might also be a termcap variable, see #610332
1454 echo '====================================================================='
1456 echo '+ WARNING: You have set SO in your environment. +'
1457 echo '+ Do you really mean to change the extension for shared libraries? +'
1458 echo '+ Continuing in 10 seconds to let you to ponder. +'
1460 echo '====================================================================='
1464 AC_DEFINE_UNQUOTED(SHLIB_EXT, "$SO", [Define this to be extension of shared libraries (including the dot!).])
1465 # LDSHARED is the ld *command* used to create shared library
1466 # -- "cc -G" on SunOS 5.x, "ld -shared" on IRIX 5
1467 # (Shared libraries in this instance are shared modules to be loaded into
1468 # Python, as opposed to building Python itself as a shared library.)
1469 AC_MSG_CHECKING(LDSHARED)
1470 if test -z "$LDSHARED"
1472 case $ac_sys_system/$ac_sys_release in
1474 BLDSHARED="\$(srcdir)/Modules/ld_so_aix \$(CC) -bI:Modules/python.exp"
1475 LDSHARED="\$(BINLIBDEST)/config/ld_so_aix \$(CC) -bI:\$(BINLIBDEST)/config/python.exp"
1478 BLDSHARED="\$(srcdir)/Modules/ld_so_beos $LDLIBRARY"
1479 LDSHARED="\$(BINLIBDEST)/config/ld_so_beos \$(LIBDIR)/$LDLIBRARY"
1481 IRIX/5*) LDSHARED="ld -shared";;
1482 IRIX*/6*) LDSHARED="ld ${SGI_ABI} -shared -all";;
1484 if test "$GCC" = "yes"
1485 then LDSHARED='$(CC) -shared'
1486 else LDSHARED='$(CC) -G';
1488 hp*|HP*) LDSHARED="ld -b";;
1489 OSF*) LDSHARED="ld -shared -expect_unresolved \"*\"";;
1491 LDSHARED='$(CC) $(LDFLAGS) -bundle'
1492 if test "$enable_framework" ; then
1493 # Link against the framework. All externals should be defined.
1494 BLDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1495 LDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKPREFIX)/$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1497 # No framework. Ignore undefined symbols, assuming they come from Python
1498 LDSHARED="$LDSHARED -undefined suppress"
1500 Darwin/1.4*|Darwin/5.*|Darwin/6.*)
1501 LDSHARED='$(CC) $(LDFLAGS) -bundle'
1502 if test "$enable_framework" ; then
1503 # Link against the framework. All externals should be defined.
1504 BLDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1505 LDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKPREFIX)/$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1507 # No framework, use the Python app as bundle-loader
1508 BLDSHARED="$LDSHARED "'-bundle_loader $(BUILDPYTHON)'
1509 LDSHARED="$LDSHARED "'-bundle_loader $(BINDIR)/python$(VERSION)$(EXE)'
1512 # Use -undefined dynamic_lookup whenever possible (10.3 and later).
1513 # This allows an extension to be used in any Python
1514 cur_target=`sw_vers -productVersion | sed 's/\(10\.[[0-9]]*\).*/\1/'`
1515 if test ${cur_target} '>' 10.2; then
1518 CONFIGURE_MACOSX_DEPLOYMENT_TARGET=${MACOSX_DEPLOYMENT_TARGET-${cur_target}}
1520 # Make sure that MACOSX_DEPLOYMENT_TARGET is set in the
1521 # environment with a value that is the same as what we'll use
1522 # in the Makefile to ensure that we'll get the same compiler
1523 # environment during configure and build time.
1524 MACOSX_DEPLOYMENT_TARGET="$CONFIGURE_MACOSX_DEPLOYMENT_TARGET"
1525 export MACOSX_DEPLOYMENT_TARGET
1527 EXPORT_MACOSX_DEPLOYMENT_TARGET=''
1528 if test ${MACOSX_DEPLOYMENT_TARGET-${cur_target}} '>' 10.2
1530 if test "${enable_universalsdk}"; then
1531 LDFLAGS="-arch i386 -arch ppc -isysroot ${UNIVERSALSDK} ${LDFLAGS}"
1533 LDSHARED='$(CC) $(LDFLAGS) -bundle -undefined dynamic_lookup'
1534 BLDSHARED="$LDSHARED"
1536 LDSHARED='$(CC) $(LDFLAGS) -bundle'
1537 if test "$enable_framework" ; then
1538 # Link against the framework. All externals should be defined.
1539 BLDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1540 LDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKPREFIX)/$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1542 # No framework, use the Python app as bundle-loader
1543 BLDSHARED="$LDSHARED "'-bundle_loader $(BUILDPYTHON)'
1544 LDSHARED="$LDSHARED "'-bundle_loader $(BINDIR)/python$(VERSION)$(EXE)'
1548 Linux*|GNU*) LDSHARED='$(CC) -shared';;
1549 BSD/OS*/4*) LDSHARED="gcc -shared";;
1551 if [[ "`$CC -dM -E - </dev/null | grep __ELF__`" != "" ]]
1553 LDSHARED="$CC -shared ${LDFLAGS}"
1555 LDSHARED="ld -Bshareable ${LDFLAGS}"
1558 if [[ "`$CC -dM -E - </dev/null | grep __ELF__`" != "" ]]
1560 LDSHARED='$(CC) -shared $(CCSHARED) ${LDFLAGS}'
1563 [[01]].* | 2.[[0-7]] | 2.[[0-7]].*)
1564 LDSHARED="ld -Bshareable ${LDFLAGS}"
1567 LDSHARED='$(CC) -shared $(CCSHARED) ${LDFLAGS}'
1571 NetBSD*|DragonFly*) LDSHARED="cc -shared ${LDFLAGS}";;
1572 OpenUNIX*|UnixWare*)
1573 if test "$GCC" = "yes"
1574 then LDSHARED='$(CC) -shared'
1575 else LDSHARED='$(CC) -G'
1577 SCO_SV*) LDSHARED='$(CC) -Wl,-G,-Bexport';;
1578 Monterey*) LDSHARED="cc -G -dy -Bdynamic -Bexport -L/usr/lib/ia64l64";;
1579 CYGWIN*) LDSHARED="gcc -shared -Wl,--enable-auto-image-base";;
1580 atheos*) LDSHARED="gcc -shared";;
1584 AC_MSG_RESULT($LDSHARED)
1585 BLDSHARED=${BLDSHARED-$LDSHARED}
1586 # CCSHARED are the C *flags* used to create objects to go into a shared
1587 # library (module) -- this is only needed for a few systems
1588 AC_MSG_CHECKING(CCSHARED)
1589 if test -z "$CCSHARED"
1591 case $ac_sys_system/$ac_sys_release in
1592 SunOS*) if test "$GCC" = yes;
1593 then CCSHARED="-fPIC";
1594 elif test `uname -p` = sparc;
1595 then CCSHARED="-xcode=pic32";
1596 else CCSHARED="-Kpic";
1598 hp*|HP*) if test "$GCC" = yes;
1599 then CCSHARED="-fPIC";
1602 Linux*|GNU*) CCSHARED="-fPIC";;
1603 BSD/OS*/4*) CCSHARED="-fpic";;
1604 FreeBSD*|NetBSD*|OpenBSD*|DragonFly*) CCSHARED="-fPIC";;
1605 OpenUNIX*|UnixWare*)
1606 if test "$GCC" = "yes"
1607 then CCSHARED="-fPIC"
1608 else CCSHARED="-KPIC"
1611 if test "$GCC" = "yes"
1612 then CCSHARED="-fPIC"
1613 else CCSHARED="-Kpic -belf"
1615 Monterey*) CCSHARED="-G";;
1616 IRIX*/6*) case $CC in
1617 *gcc*) CCSHARED="-shared";;
1620 atheos*) CCSHARED="-fPIC";;
1623 AC_MSG_RESULT($CCSHARED)
1624 # LINKFORSHARED are the flags passed to the $(CC) command that links
1625 # the python executable -- this is only needed for a few systems
1626 AC_MSG_CHECKING(LINKFORSHARED)
1627 if test -z "$LINKFORSHARED"
1629 case $ac_sys_system/$ac_sys_release in
1630 AIX*) LINKFORSHARED='-Wl,-bE:Modules/python.exp -lld';;
1632 LINKFORSHARED="-Wl,-E -Wl,+s";;
1633 # LINKFORSHARED="-Wl,-E -Wl,+s -Wl,+b\$(BINLIBDEST)/lib-dynload";;
1634 BSD/OS/4*) LINKFORSHARED="-Xlinker -export-dynamic";;
1635 Linux*|GNU*) LINKFORSHARED="-Xlinker -export-dynamic";;
1636 # -u libsys_s pulls in all symbols in libsys
1638 # -u _PyMac_Error is needed to pull in the mac toolbox glue,
1640 # not used by the core itself but which needs to be in the core so
1641 # that dynamically loaded extension modules have access to it.
1642 # -prebind is no longer used, because it actually seems to give a
1643 # slowdown in stead of a speedup, maybe due to the large number of
1644 # dynamic loads Python does.
1646 LINKFORSHARED="$extra_undefs"
1647 if test "$enable_framework"
1649 LINKFORSHARED="$LINKFORSHARED "'$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1651 LINKFORSHARED="$LINKFORSHARED";;
1652 OpenUNIX*|UnixWare*) LINKFORSHARED="-Wl,-Bexport";;
1653 SCO_SV*) LINKFORSHARED="-Wl,-Bexport";;
1654 ReliantUNIX*) LINKFORSHARED="-W1 -Blargedynsym";;
1655 FreeBSD*|NetBSD*|OpenBSD*|DragonFly*)
1656 if [[ "`$CC -dM -E - </dev/null | grep __ELF__`" != "" ]]
1658 LINKFORSHARED="-Wl,--export-dynamic"
1660 SunOS/5*) case $CC in
1662 if $CC -Xlinker --help 2>&1 | grep export-dynamic >/dev/null
1664 LINKFORSHARED="-Xlinker --export-dynamic"
1668 if test $enable_shared = "no"
1670 LINKFORSHARED='-Wl,--out-implib=$(LDLIBRARY)'
1674 AC_MSG_RESULT($LINKFORSHARED)
1676 AC_SUBST(CFLAGSFORSHARED)
1677 AC_MSG_CHECKING(CFLAGSFORSHARED)
1678 if test ! "$LIBRARY" = "$LDLIBRARY"
1680 case $ac_sys_system in
1682 # Cygwin needs CCSHARED when building extension DLLs
1683 # but not when building the interpreter DLL.
1684 CFLAGSFORSHARED='';;
1686 CFLAGSFORSHARED='$(CCSHARED)'
1689 AC_MSG_RESULT($CFLAGSFORSHARED)
1691 # SHLIBS are libraries (except -lc and -lm) to link to the python shared
1692 # library (with --enable-shared).
1693 # For platforms on which shared libraries are not allowed to have unresolved
1694 # symbols, this must be set to $(LIBS) (expanded by make). We do this even
1695 # if it is not required, since it creates a dependency of the shared library
1696 # to LIBS. This, in turn, means that applications linking the shared libpython
1697 # don't need to link LIBS explicitly. The default should be only changed
1698 # on systems where this approach causes problems.
1700 AC_MSG_CHECKING(SHLIBS)
1701 case "$ac_sys_system" in
1705 AC_MSG_RESULT($SHLIBS)
1708 # checks for libraries
1709 AC_CHECK_LIB(dl, dlopen) # Dynamic linking for SunOS/Solaris and SYSV
1710 AC_CHECK_LIB(dld, shl_load) # Dynamic linking for HP-UX
1712 # only check for sem_ini if thread support is requested
1713 if test "$with_threads" = "yes" -o -z "$with_threads"; then
1714 AC_SEARCH_LIBS(sem_init, pthread rt posix4) # 'Real Time' functions on Solaris
1715 # posix4 on Solaris 2.6
1716 # pthread (first!) on Linux
1719 # check if we need libintl for locale functions
1720 AC_CHECK_LIB(intl, textdomain,
1721 AC_DEFINE(WITH_LIBINTL, 1,
1722 [Define to 1 if libintl is needed for locale functions.]))
1724 # checks for system dependent C++ extensions support
1725 case "$ac_sys_system" in
1726 AIX*) AC_MSG_CHECKING(for genuine AIX C++ extensions support)
1727 AC_TRY_LINK([#include "/usr/lpp/xlC/include/load.h"],
1728 [loadAndInit("", 0, "")],
1729 [AC_DEFINE(AIX_GENUINE_CPLUSPLUS, 1,
1730 [Define for AIX if your compiler is a genuine IBM xlC/xlC_r
1731 and you want support for AIX C++ shared extension modules.])
1732 AC_MSG_RESULT(yes)],
1733 [AC_MSG_RESULT(no)]);;
1737 # Most SVR4 platforms (e.g. Solaris) need -lsocket and -lnsl.
1738 # BeOS' sockets are stashed in libnet.
1739 AC_CHECK_LIB(nsl, t_open, [LIBS="-lnsl $LIBS"]) # SVR4
1740 AC_CHECK_LIB(socket, socket, [LIBS="-lsocket $LIBS"], [], $LIBS) # SVR4 sockets
1742 case "$ac_sys_system" in
1744 AC_CHECK_LIB(net, socket, [LIBS="-lnet $LIBS"], [], $LIBS) # BeOS
1748 AC_MSG_CHECKING(for --with-libs)
1750 AC_HELP_STRING(--with-libs='lib1 ...', link against additional libs),
1752 AC_MSG_RESULT($withval)
1753 LIBS="$withval $LIBS"
1755 [AC_MSG_RESULT(no)])
1757 # Check for use of the system libffi library
1758 AC_MSG_CHECKING(for --with-system-ffi)
1759 AC_ARG_WITH(system_ffi,
1760 AC_HELP_STRING(--with-system-ffi, build _ctypes module using an installed ffi library))
1762 AC_MSG_RESULT($with_system_ffi)
1764 # Determine if signalmodule should be used.
1765 AC_SUBST(USE_SIGNAL_MODULE)
1766 AC_SUBST(SIGNAL_OBJS)
1767 AC_MSG_CHECKING(for --with-signal-module)
1768 AC_ARG_WITH(signal-module,
1769 AC_HELP_STRING(--with-signal-module, disable/enable signal module))
1771 if test -z "$with_signal_module"
1772 then with_signal_module="yes"
1774 AC_MSG_RESULT($with_signal_module)
1776 if test "${with_signal_module}" = "yes"; then
1777 USE_SIGNAL_MODULE=""
1780 USE_SIGNAL_MODULE="#"
1781 SIGNAL_OBJS="Parser/intrcheck.o Python/sigcheck.o"
1784 # This is used to generate Setup.config
1785 AC_SUBST(USE_THREAD_MODULE)
1786 USE_THREAD_MODULE=""
1788 AC_MSG_CHECKING(for --with-dec-threads)
1790 AC_ARG_WITH(dec-threads,
1791 AC_HELP_STRING(--with-dec-threads, use DEC Alpha/OSF1 thread-safe libraries),
1793 AC_MSG_RESULT($withval)
1795 if test "${with_thread+set}" != set; then
1796 with_thread="$withval";
1798 [AC_MSG_RESULT(no)])
1800 # Templates for things AC_DEFINEd more than once.
1801 # For a single AC_DEFINE, no template is needed.
1802 AH_TEMPLATE(C_THREADS,[Define if you have the Mach cthreads package])
1803 AH_TEMPLATE(_REENTRANT,
1804 [Define to force use of thread-safe errno, h_errno, and other functions])
1805 AH_TEMPLATE(WITH_THREAD,
1806 [Define if you want to compile in rudimentary thread support])
1808 AC_MSG_CHECKING(for --with-threads)
1809 dnl quadrigraphs "@<:@" and "@:>@" produce "[" and "]" in the output
1810 AC_ARG_WITH(threads,
1811 AC_HELP_STRING(--with(out)-threads@<:@=DIRECTORY@:>@, disable/enable thread support))
1813 # --with-thread is deprecated, but check for it anyway
1814 dnl quadrigraphs "@<:@" and "@:>@" produce "[" and "]" in the output
1816 AC_HELP_STRING(--with(out)-thread@<:@=DIRECTORY@:>@, deprecated; use --with(out)-threads),
1817 [with_threads=$with_thread])
1819 if test -z "$with_threads"
1820 then with_threads="yes"
1822 AC_MSG_RESULT($with_threads)
1825 if test "$with_threads" = "no"
1827 USE_THREAD_MODULE="#"
1828 elif test "$ac_cv_pthread_is_default" = yes
1830 AC_DEFINE(WITH_THREAD)
1831 # Defining _REENTRANT on system with POSIX threads should not hurt.
1832 AC_DEFINE(_REENTRANT)
1834 THREADOBJ="Python/thread.o"
1835 elif test "$ac_cv_kpthread" = "yes"
1838 if test "$ac_cv_cxx_thread" = "yes"; then
1839 CXX="$CXX -Kpthread"
1841 AC_DEFINE(WITH_THREAD)
1843 THREADOBJ="Python/thread.o"
1844 elif test "$ac_cv_kthread" = "yes"
1847 if test "$ac_cv_cxx_thread" = "yes"; then
1850 AC_DEFINE(WITH_THREAD)
1852 THREADOBJ="Python/thread.o"
1853 elif test "$ac_cv_pthread" = "yes"
1856 if test "$ac_cv_cxx_thread" = "yes"; then
1859 AC_DEFINE(WITH_THREAD)
1861 THREADOBJ="Python/thread.o"
1863 if test ! -z "$with_threads" -a -d "$with_threads"
1864 then LDFLAGS="$LDFLAGS -L$with_threads"
1866 if test ! -z "$withval" -a -d "$withval"
1867 then LDFLAGS="$LDFLAGS -L$withval"
1870 # According to the POSIX spec, a pthreads implementation must
1871 # define _POSIX_THREADS in unistd.h. Some apparently don't
1872 # (e.g. gnu pth with pthread emulation)
1873 AC_MSG_CHECKING(for _POSIX_THREADS in unistd.h)
1877 #ifdef _POSIX_THREADS
1880 ], unistd_defines_pthreads=yes, unistd_defines_pthreads=no)
1881 AC_MSG_RESULT($unistd_defines_pthreads)
1883 AC_DEFINE(_REENTRANT)
1884 AC_CHECK_HEADER(cthreads.h, [AC_DEFINE(WITH_THREAD)
1885 AC_DEFINE(C_THREADS)
1886 AC_DEFINE(HURD_C_THREADS, 1,
1887 [Define if you are using Mach cthreads directly under /include])
1888 LIBS="$LIBS -lthreads"
1889 THREADOBJ="Python/thread.o"],[
1890 AC_CHECK_HEADER(mach/cthreads.h, [AC_DEFINE(WITH_THREAD)
1891 AC_DEFINE(C_THREADS)
1892 AC_DEFINE(MACH_C_THREADS, 1,
1893 [Define if you are using Mach cthreads under mach /])
1894 THREADOBJ="Python/thread.o"],[
1895 AC_MSG_CHECKING(for --with-pth)
1897 AC_HELP_STRING(--with-pth, use GNU pth threading libraries),
1898 [AC_MSG_RESULT($withval)
1899 AC_DEFINE([WITH_THREAD])
1900 AC_DEFINE([HAVE_PTH], 1,
1901 [Define if you have GNU PTH threads.])
1903 THREADOBJ="Python/thread.o"],
1906 # Just looking for pthread_create in libpthread is not enough:
1907 # on HP/UX, pthread.h renames pthread_create to a different symbol name.
1908 # So we really have to include pthread.h, and then link.
1910 LIBS="$LIBS -lpthread"
1911 AC_MSG_CHECKING([for pthread_create in -lpthread])
1912 AC_TRY_LINK([#include <pthread.h>
1914 void * start_routine (void *arg) { exit (0); }], [
1915 pthread_create (NULL, NULL, start_routine, NULL)], [
1917 AC_DEFINE(WITH_THREAD)
1919 THREADOBJ="Python/thread.o"],[
1921 AC_CHECK_FUNC(pthread_detach, [AC_DEFINE(WITH_THREAD)
1923 THREADOBJ="Python/thread.o"],[
1924 AC_CHECK_HEADER(atheos/threads.h, [AC_DEFINE(WITH_THREAD)
1925 AC_DEFINE(ATHEOS_THREADS, 1,
1926 [Define this if you have AtheOS threads.])
1927 THREADOBJ="Python/thread.o"],[
1928 AC_CHECK_HEADER(kernel/OS.h, [AC_DEFINE(WITH_THREAD)
1929 AC_DEFINE(BEOS_THREADS, 1,
1930 [Define this if you have BeOS threads.])
1931 THREADOBJ="Python/thread.o"],[
1932 AC_CHECK_LIB(pthreads, pthread_create, [AC_DEFINE(WITH_THREAD)
1934 LIBS="$LIBS -lpthreads"
1935 THREADOBJ="Python/thread.o"], [
1936 AC_CHECK_LIB(c_r, pthread_create, [AC_DEFINE(WITH_THREAD)
1939 THREADOBJ="Python/thread.o"], [
1940 AC_CHECK_LIB(pthread, __pthread_create_system, [AC_DEFINE(WITH_THREAD)
1942 LIBS="$LIBS -lpthread"
1943 THREADOBJ="Python/thread.o"], [
1944 AC_CHECK_LIB(cma, pthread_create, [AC_DEFINE(WITH_THREAD)
1947 THREADOBJ="Python/thread.o"],[
1948 USE_THREAD_MODULE="#"])
1949 ])])])])])])])])])])
1951 AC_CHECK_LIB(mpc, usconfig, [AC_DEFINE(WITH_THREAD)
1953 THREADOBJ="Python/thread.o"
1954 USE_THREAD_MODULE=""])
1956 if test "$posix_threads" != "yes"; then
1957 AC_CHECK_LIB(thread, thr_create, [AC_DEFINE(WITH_THREAD)
1958 LIBS="$LIBS -lthread"
1959 THREADOBJ="Python/thread.o"
1960 USE_THREAD_MODULE=""])
1963 if test "$USE_THREAD_MODULE" != "#"
1965 # If the above checks didn't disable threads, (at least) OSF1
1966 # needs this '-threads' argument during linking.
1967 case $ac_sys_system in
1968 OSF1) LDLAST=-threads;;
1973 if test "$posix_threads" = "yes"; then
1974 if test "$unistd_defines_pthreads" = "no"; then
1975 AC_DEFINE(_POSIX_THREADS, 1,
1976 [Define if you have POSIX threads,
1977 and your system does not define that.])
1980 # Bug 662787: Using semaphores causes unexplicable hangs on Solaris 8.
1981 case $ac_sys_system/$ac_sys_release in
1982 SunOS/5.6) AC_DEFINE(HAVE_PTHREAD_DESTRUCTOR, 1,
1983 Defined for Solaris 2.6 bug in pthread header.)
1985 SunOS/5.8) AC_DEFINE(HAVE_BROKEN_POSIX_SEMAPHORES, 1,
1986 Define if the Posix semaphores do not work on your system)
1988 AIX/5) AC_DEFINE(HAVE_BROKEN_POSIX_SEMAPHORES, 1,
1989 Define if the Posix semaphores do not work on your system)
1993 AC_MSG_CHECKING(if PTHREAD_SCOPE_SYSTEM is supported)
1994 AC_CACHE_VAL(ac_cv_pthread_system_supported,
1995 [AC_TRY_RUN([#include <pthread.h>
1996 void *foo(void *parm) {
2000 pthread_attr_t attr;
2002 if (pthread_attr_init(&attr)) exit(-1);
2003 if (pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM)) exit(-1);
2004 if (pthread_create(&id, &attr, foo, NULL)) exit(-1);
2007 ac_cv_pthread_system_supported=yes,
2008 ac_cv_pthread_system_supported=no,
2009 ac_cv_pthread_system_supported=no)
2011 AC_MSG_RESULT($ac_cv_pthread_system_supported)
2012 if test "$ac_cv_pthread_system_supported" = "yes"; then
2013 AC_DEFINE(PTHREAD_SYSTEM_SCHED_SUPPORTED, 1, [Defined if PTHREAD_SCOPE_SYSTEM supported.])
2015 AC_CHECK_FUNCS(pthread_sigmask,
2016 [case $ac_sys_system in
2018 AC_DEFINE(HAVE_BROKEN_PTHREAD_SIGMASK, 1,
2019 [Define if pthread_sigmask() does not work on your system.])
2025 # Check for enable-ipv6
2026 AH_TEMPLATE(ENABLE_IPV6, [Define if --enable-ipv6 is specified])
2027 AC_MSG_CHECKING([if --enable-ipv6 is specified])
2029 [ --enable-ipv6 Enable ipv6 (with ipv4) support
2030 --disable-ipv6 Disable ipv6 support],
2031 [ case "$enableval" in
2036 *) AC_MSG_RESULT(yes)
2037 AC_DEFINE(ENABLE_IPV6)
2043 dnl the check does not work on cross compilation case...
2044 AC_TRY_RUN([ /* AF_INET6 available check */
2045 #include <sys/types.h>
2046 #include <sys/socket.h>
2049 if (socket(AF_INET6, SOCK_STREAM, 0) < 0)
2063 if test "$ipv6" = "yes"; then
2064 AC_MSG_CHECKING(if RFC2553 API is available)
2065 AC_TRY_COMPILE([#include <sys/types.h>
2066 #include <netinet/in.h>],
2067 [struct sockaddr_in6 x;
2071 AC_MSG_RESULT(no, IPv6 disabled)
2075 if test "$ipv6" = "yes"; then
2076 AC_DEFINE(ENABLE_IPV6)
2084 if test "$ipv6" = "yes"; then
2085 AC_MSG_CHECKING([ipv6 stack type])
2086 for i in inria kame linux-glibc linux-inet6 solaris toshiba v6d zeta;
2090 dnl http://www.kame.net/
2092 #include <netinet/in.h>
2093 #ifdef IPV6_INRIA_VERSION
2099 dnl http://www.kame.net/
2101 #include <netinet/in.h>
2107 ipv6libdir=/usr/local/v6/lib
2111 dnl http://www.v6.linux.or.jp/
2113 #include <features.h>
2114 #if defined(__GLIBC__) && ((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 1) || (__GLIBC__ > 2))
2121 dnl http://www.v6.linux.or.jp/
2122 if test -d /usr/inet6; then
2125 ipv6libdir=/usr/inet6/lib
2126 BASECFLAGS="-I/usr/inet6/include $BASECFLAGS"
2130 if test -f /etc/netconfig; then
2131 if /usr/xpg4/bin/grep -q tcp6 /etc/netconfig; then
2139 #include <sys/param.h>
2140 #ifdef _TOSHIBA_INET6
2145 ipv6libdir=/usr/local/v6/lib])
2149 #include </usr/local/v6/include/sys/v6config.h>
2155 ipv6libdir=/usr/local/v6/lib;
2156 BASECFLAGS="-I/usr/local/v6/include $BASECFLAGS"])
2160 #include <sys/param.h>
2161 #ifdef _ZETA_MINAMI_INET6
2166 ipv6libdir=/usr/local/v6/lib])
2169 if test "$ipv6type" != "unknown"; then
2173 AC_MSG_RESULT($ipv6type)
2176 if test "$ipv6" = "yes" -a "$ipv6lib" != "none"; then
2177 if test -d $ipv6libdir -a -f $ipv6libdir/lib$ipv6lib.a; then
2178 LIBS="-L$ipv6libdir -l$ipv6lib $LIBS"
2179 echo "using lib$ipv6lib"
2181 if test $ipv6trylibc = "yes"; then
2184 echo 'Fatal: no $ipv6lib library found. cannot continue.'
2185 echo "You need to fetch lib$ipv6lib.a from appropriate"
2186 echo 'ipv6 kit and compile beforehand.'
2192 # Check for --with-doc-strings
2193 AC_MSG_CHECKING(for --with-doc-strings)
2194 AC_ARG_WITH(doc-strings,
2195 AC_HELP_STRING(--with(out)-doc-strings, disable/enable documentation strings))
2197 if test -z "$with_doc_strings"
2198 then with_doc_strings="yes"
2200 if test "$with_doc_strings" != "no"
2202 AC_DEFINE(WITH_DOC_STRINGS, 1,
2203 [Define if you want documentation strings in extension modules])
2205 AC_MSG_RESULT($with_doc_strings)
2207 # Check for Python-specific malloc support
2208 AC_MSG_CHECKING(for --with-tsc)
2210 [ --with(out)-tsc enable/disable timestamp counter profile], [
2211 if test "$withval" != no
2213 AC_DEFINE(WITH_TSC, 1,
2214 [Define to profile with the Pentium timestamp counter])
2216 else AC_MSG_RESULT(no)
2218 [AC_MSG_RESULT(no)])
2220 # Check for Python-specific malloc support
2221 AC_MSG_CHECKING(for --with-pymalloc)
2222 AC_ARG_WITH(pymalloc,
2223 AC_HELP_STRING(--with(out)-pymalloc, disable/enable specialized mallocs))
2225 if test -z "$with_pymalloc"
2226 then with_pymalloc="yes"
2228 if test "$with_pymalloc" != "no"
2230 AC_DEFINE(WITH_PYMALLOC, 1,
2231 [Define if you want to compile in Python-specific mallocs])
2233 AC_MSG_RESULT($with_pymalloc)
2235 # Check for --with-wctype-functions
2236 AC_MSG_CHECKING(for --with-wctype-functions)
2237 AC_ARG_WITH(wctype-functions,
2238 AC_HELP_STRING(--with-wctype-functions, use wctype.h functions),
2240 if test "$withval" != no
2242 AC_DEFINE(WANT_WCTYPE_FUNCTIONS, 1,
2243 [Define if you want wctype.h functions to be used instead of the
2244 one supplied by Python itself. (see Include/unicodectype.h).])
2246 else AC_MSG_RESULT(no)
2248 [AC_MSG_RESULT(no)])
2250 # -I${DLINCLDIR} is added to the compile rule for importdl.o
2254 # the dlopen() function means we might want to use dynload_shlib.o. some
2255 # platforms, such as AIX, have dlopen(), but don't want to use it.
2256 AC_CHECK_FUNCS(dlopen)
2258 # DYNLOADFILE specifies which dynload_*.o file we will use for dynamic
2259 # loading of modules.
2260 AC_SUBST(DYNLOADFILE)
2261 AC_MSG_CHECKING(DYNLOADFILE)
2262 if test -z "$DYNLOADFILE"
2264 case $ac_sys_system/$ac_sys_release in
2265 AIX*) # Use dynload_shlib.c and dlopen() if we have it; otherwise dynload_aix.c
2266 if test "$ac_cv_func_dlopen" = yes
2267 then DYNLOADFILE="dynload_shlib.o"
2268 else DYNLOADFILE="dynload_aix.o"
2271 BeOS*) DYNLOADFILE="dynload_beos.o";;
2272 hp*|HP*) DYNLOADFILE="dynload_hpux.o";;
2273 # Use dynload_next.c only on 10.2 and below, which don't have native dlopen()
2274 Darwin/@<:@0156@:>@\..*) DYNLOADFILE="dynload_next.o";;
2275 atheos*) DYNLOADFILE="dynload_atheos.o";;
2277 # use dynload_shlib.c and dlopen() if we have it; otherwise stub
2278 # out any dynamic loading
2279 if test "$ac_cv_func_dlopen" = yes
2280 then DYNLOADFILE="dynload_shlib.o"
2281 else DYNLOADFILE="dynload_stub.o"
2286 AC_MSG_RESULT($DYNLOADFILE)
2287 if test "$DYNLOADFILE" != "dynload_stub.o"
2289 AC_DEFINE(HAVE_DYNAMIC_LOADING, 1,
2290 [Defined when any dynamic module loading is enabled.])
2293 # MACHDEP_OBJS can be set to platform-specific object files needed by Python
2295 AC_SUBST(MACHDEP_OBJS)
2296 AC_MSG_CHECKING(MACHDEP_OBJS)
2297 if test -z "$MACHDEP_OBJS"
2299 MACHDEP_OBJS=$extra_machdep_objs
2301 MACHDEP_OBJS="$MACHDEP_OBJS $extra_machdep_objs"
2303 AC_MSG_RESULT(MACHDEP_OBJS)
2305 # checks for library functions
2306 AC_CHECK_FUNCS(alarm bind_textdomain_codeset chown clock confstr \
2307 ctermid execv fchmod fchown fork fpathconf ftime ftruncate \
2308 gai_strerror getgroups getlogin getloadavg getpeername getpgid getpid \
2309 getpriority getpwent getspnam getspent getsid getwd \
2310 kill killpg lchmod lchown lstat mkfifo mknod mktime \
2311 mremap nice pathconf pause plock poll pthread_init \
2312 putenv readlink realpath \
2313 select setegid seteuid setgid \
2314 setlocale setregid setreuid setsid setpgid setpgrp setuid setvbuf snprintf \
2315 sigaction siginterrupt sigrelse strftime \
2316 sysconf tcgetpgrp tcsetpgrp tempnam timegm times tmpfile tmpnam tmpnam_r \
2317 truncate uname unsetenv utimes waitpid wait3 wait4 wcscoll _getpty)
2319 # For some functions, having a definition is not sufficient, since
2320 # we want to take their address.
2321 AC_MSG_CHECKING(for chroot)
2322 AC_TRY_COMPILE([#include <unistd.h>], void *x=chroot,
2323 AC_DEFINE(HAVE_CHROOT, 1, Define if you have the 'chroot' function.)
2327 AC_MSG_CHECKING(for link)
2328 AC_TRY_COMPILE([#include <unistd.h>], void *x=link,
2329 AC_DEFINE(HAVE_LINK, 1, Define if you have the 'link' function.)
2333 AC_MSG_CHECKING(for symlink)
2334 AC_TRY_COMPILE([#include <unistd.h>], void *x=symlink,
2335 AC_DEFINE(HAVE_SYMLINK, 1, Define if you have the 'symlink' function.)
2339 AC_MSG_CHECKING(for fchdir)
2340 AC_TRY_COMPILE([#include <unistd.h>], void *x=fchdir,
2341 AC_DEFINE(HAVE_FCHDIR, 1, Define if you have the 'fchdir' function.)
2345 AC_MSG_CHECKING(for fsync)
2346 AC_TRY_COMPILE([#include <unistd.h>], void *x=fsync,
2347 AC_DEFINE(HAVE_FSYNC, 1, Define if you have the 'fsync' function.)
2351 AC_MSG_CHECKING(for fdatasync)
2352 AC_TRY_COMPILE([#include <unistd.h>], void *x=fdatasync,
2353 AC_DEFINE(HAVE_FDATASYNC, 1, Define if you have the 'fdatasync' function.)
2357 AC_MSG_CHECKING(for epoll)
2358 AC_TRY_COMPILE([#include <sys/epoll.h>], void *x=epoll_create,
2359 AC_DEFINE(HAVE_EPOLL, 1, Define if you have the 'epoll' functions.)
2363 AC_MSG_CHECKING(for kqueue)
2365 #include <sys/types.h>
2366 #include <sys/event.h>
2368 AC_DEFINE(HAVE_KQUEUE, 1, Define if you have the 'kqueue' functions.)
2372 # On some systems (eg. FreeBSD 5), we would find a definition of the
2373 # functions ctermid_r, setgroups in the library, but no prototype
2374 # (e.g. because we use _XOPEN_SOURCE). See whether we can take their
2375 # address to avoid compiler warnings and potential miscompilations
2376 # because of the missing prototypes.
2378 AC_MSG_CHECKING(for ctermid_r)
2380 #include "confdefs.h"
2382 ], void* p = ctermid_r,
2383 AC_DEFINE(HAVE_CTERMID_R, 1, Define if you have the 'ctermid_r' function.)
2388 AC_MSG_CHECKING(for flock)
2390 #include "confdefs.h"
2391 #include <sys/file.h>
2393 AC_DEFINE(HAVE_FLOCK, 1, Define if you have the 'flock' function.)
2398 AC_MSG_CHECKING(for getpagesize)
2400 #include "confdefs.h"
2402 ], void* p = getpagesize,
2403 AC_DEFINE(HAVE_GETPAGESIZE, 1, Define if you have the 'getpagesize' function.)
2409 AC_CHECK_PROGS(TRUE, true, /bin/true)
2411 dnl On some systems (e.g. Solaris 9), hstrerror and inet_aton are in -lresolv
2412 dnl On others, they are in the C library, so we to take no action
2413 AC_CHECK_LIB(c, inet_aton, [$ac_cv_prog_TRUE],
2414 AC_CHECK_LIB(resolv, inet_aton)
2417 # On Tru64, chflags seems to be present, but calling it will
2419 AC_MSG_CHECKING(for chflags)
2421 #include <sys/stat.h>
2423 int main(int argc, char*argv[])
2425 if(chflags(argv[0], 0) != 0)
2429 ],AC_DEFINE(HAVE_CHFLAGS, 1, Define to 1 if you have the `chflags' function.)
2434 AC_MSG_CHECKING(for lchflags)
2436 #include <sys/stat.h>
2438 int main(int argc, char*argv[])
2440 if(lchflags(argv[0], 0) != 0)
2444 ],AC_DEFINE(HAVE_LCHFLAGS, 1, Define to 1 if you have the `lchflags' function.)
2449 dnl Check if system zlib has *Copy() functions
2451 dnl On MacOSX the linker will search for dylibs on the entire linker path
2452 dnl before searching for static libraries. setup.py adds -Wl,-search_paths_first
2453 dnl to revert to a more traditional unix behaviour and make it possible to
2454 dnl override the system libz with a local static library of libz. Temporarily
2455 dnl add that flag to our CFLAGS as well to ensure that we check the version
2456 dnl of libz that will be used by setup.py.
2457 dnl The -L/usr/local/lib is needed as wel to get the same compilation
2458 dnl environment as setup.py (and leaving it out can cause configure to use the
2459 dnl wrong version of the library)
2460 case $ac_sys_system/$ac_sys_release in
2462 _CUR_CFLAGS="${CFLAGS}"
2463 _CUR_LDFLAGS="${LDFLAGS}"
2464 CFLAGS="${CFLAGS} -Wl,-search_paths_first"
2465 LDFLAGS="${LDFLAGS} -Wl,-search_paths_first -L/usr/local/lib"
2469 AC_CHECK_LIB(z, inflateCopy, AC_DEFINE(HAVE_ZLIB_COPY, 1, Define if the zlib library has inflateCopy))
2471 case $ac_sys_system/$ac_sys_release in
2473 CFLAGS="${_CUR_CFLAGS}"
2474 LDFLAGS="${_CUR_LDFLAGS}"
2478 AC_MSG_CHECKING(for hstrerror)
2480 #include "confdefs.h"
2482 ], void* p = hstrerror; hstrerror(0),
2483 AC_DEFINE(HAVE_HSTRERROR, 1, Define if you have the 'hstrerror' function.)
2488 AC_MSG_CHECKING(for inet_aton)
2490 #include "confdefs.h"
2491 #include <sys/types.h>
2492 #include <sys/socket.h>
2493 #include <netinet/in.h>
2494 #include <arpa/inet.h>
2495 ], void* p = inet_aton;inet_aton(0,0),
2496 AC_DEFINE(HAVE_INET_ATON, 1, Define if you have the 'inet_aton' function.)
2501 AC_MSG_CHECKING(for inet_pton)
2503 #include "confdefs.h"
2504 #include <sys/types.h>
2505 #include <sys/socket.h>
2506 #include <netinet/in.h>
2507 #include <arpa/inet.h>
2508 ], void* p = inet_pton,
2509 AC_DEFINE(HAVE_INET_PTON, 1, Define if you have the 'inet_pton' function.)
2514 # On some systems, setgroups is in unistd.h, on others, in grp.h
2515 AC_MSG_CHECKING(for setgroups)
2517 #include "confdefs.h"
2523 void* p = setgroups,
2524 AC_DEFINE(HAVE_SETGROUPS, 1, Define if you have the 'setgroups' function.)
2529 # check for openpty and forkpty
2531 AC_CHECK_FUNCS(openpty,,
2532 AC_CHECK_LIB(util,openpty,
2533 [AC_DEFINE(HAVE_OPENPTY) LIBS="$LIBS -lutil"],
2534 AC_CHECK_LIB(bsd,openpty, [AC_DEFINE(HAVE_OPENPTY) LIBS="$LIBS -lbsd"])
2537 AC_CHECK_FUNCS(forkpty,,
2538 AC_CHECK_LIB(util,forkpty,
2539 [AC_DEFINE(HAVE_FORKPTY) LIBS="$LIBS -lutil"],
2540 AC_CHECK_LIB(bsd,forkpty, [AC_DEFINE(HAVE_FORKPTY) LIBS="$LIBS -lbsd"])
2545 AC_CHECK_FUNCS(memmove)
2547 # check for long file support functions
2548 AC_CHECK_FUNCS(fseek64 fseeko fstatvfs ftell64 ftello statvfs)
2550 AC_REPLACE_FUNCS(dup2 getcwd strdup)
2551 AC_CHECK_FUNCS(getpgrp,
2552 AC_TRY_COMPILE([#include <unistd.h>],
2554 AC_DEFINE(GETPGRP_HAVE_ARG, 1,
2555 [Define if getpgrp() must be called as getpgrp(0).])
2558 AC_CHECK_FUNCS(setpgrp,
2559 AC_TRY_COMPILE([#include <unistd.h>],
2561 AC_DEFINE(SETPGRP_HAVE_ARG, 1,
2562 [Define if setpgrp() must be called as setpgrp(0, 0).])
2565 AC_CHECK_FUNCS(gettimeofday,
2566 AC_TRY_COMPILE([#include <sys/time.h>],
2567 [gettimeofday((struct timeval*)0,(struct timezone*)0);], ,
2568 AC_DEFINE(GETTIMEOFDAY_NO_TZ, 1,
2569 [Define if gettimeofday() does not have second (timezone) argument
2570 This is the case on Motorola V4 (R40V4.2)])
2574 AC_MSG_CHECKING(for major, minor, and makedev)
2576 #if defined(MAJOR_IN_MKDEV)
2577 #include <sys/mkdev.h>
2578 #elif defined(MAJOR_IN_SYSMACROS)
2579 #include <sys/sysmacros.h>
2581 #include <sys/types.h>
2584 makedev(major(0),minor(0));
2586 AC_DEFINE(HAVE_DEVICE_MACROS, 1,
2587 [Define to 1 if you have the device macros.])
2593 # On OSF/1 V5.1, getaddrinfo is available, but a define
2594 # for [no]getaddrinfo in netdb.h.
2595 AC_MSG_CHECKING(for getaddrinfo)
2597 #include <sys/types.h>
2598 #include <sys/socket.h>
2602 getaddrinfo(NULL, NULL, NULL, NULL);
2605 AC_MSG_CHECKING(getaddrinfo bug)
2607 #include <sys/types.h>
2610 #include <sys/socket.h>
2611 #include <netinet/in.h>
2615 int passive, gaierr, inet4 = 0, inet6 = 0;
2616 struct addrinfo hints, *ai, *aitop;
2617 char straddr[INET6_ADDRSTRLEN], strport[16];
2619 for (passive = 0; passive <= 1; passive++) {
2620 memset(&hints, 0, sizeof(hints));
2621 hints.ai_family = AF_UNSPEC;
2622 hints.ai_flags = passive ? AI_PASSIVE : 0;
2623 hints.ai_socktype = SOCK_STREAM;
2624 hints.ai_protocol = IPPROTO_TCP;
2625 if ((gaierr = getaddrinfo(NULL, "54321", &hints, &aitop)) != 0) {
2626 (void)gai_strerror(gaierr);
2629 for (ai = aitop; ai; ai = ai->ai_next) {
2630 if (ai->ai_addr == NULL ||
2631 ai->ai_addrlen == 0 ||
2632 getnameinfo(ai->ai_addr, ai->ai_addrlen,
2633 straddr, sizeof(straddr), strport, sizeof(strport),
2634 NI_NUMERICHOST|NI_NUMERICSERV) != 0) {
2637 switch (ai->ai_family) {
2639 if (strcmp(strport, "54321") != 0) {
2643 if (strcmp(straddr, "0.0.0.0") != 0) {
2647 if (strcmp(straddr, "127.0.0.1") != 0) {
2654 if (strcmp(strport, "54321") != 0) {
2658 if (strcmp(straddr, "::") != 0) {
2662 if (strcmp(straddr, "::1") != 0) {
2672 /* another family support? */
2678 if (!(inet4 == 0 || inet4 == 2))
2680 if (!(inet6 == 0 || inet6 == 2))
2684 freeaddrinfo(aitop);
2689 freeaddrinfo(aitop);
2694 buggygetaddrinfo=no,
2695 AC_MSG_RESULT(buggy)
2696 buggygetaddrinfo=yes,
2697 AC_MSG_RESULT(buggy)
2698 buggygetaddrinfo=yes)], [
2700 buggygetaddrinfo=yes
2703 if test "$buggygetaddrinfo" = "yes"; then
2704 if test "$ipv6" = "yes"; then
2705 echo 'Fatal: You must get working getaddrinfo() function.'
2706 echo ' or you can specify "--disable-ipv6"'.
2710 AC_DEFINE(HAVE_GETADDRINFO, 1, [Define if you have the getaddrinfo function.])
2712 AC_CHECK_FUNCS(getnameinfo)
2714 # checks for structures
2718 AC_CHECK_MEMBERS([struct stat.st_rdev])
2719 AC_CHECK_MEMBERS([struct stat.st_blksize])
2720 AC_CHECK_MEMBERS([struct stat.st_flags])
2721 AC_CHECK_MEMBERS([struct stat.st_gen])
2722 AC_CHECK_MEMBERS([struct stat.st_birthtime])
2725 AC_MSG_CHECKING(for time.h that defines altzone)
2726 AC_CACHE_VAL(ac_cv_header_time_altzone,
2727 [AC_TRY_COMPILE([#include <time.h>], [return altzone;],
2728 ac_cv_header_time_altzone=yes,
2729 ac_cv_header_time_altzone=no)])
2730 AC_MSG_RESULT($ac_cv_header_time_altzone)
2731 if test $ac_cv_header_time_altzone = yes; then
2732 AC_DEFINE(HAVE_ALTZONE, 1, [Define this if your time.h defines altzone.])
2736 AC_MSG_CHECKING(whether sys/select.h and sys/time.h may both be included)
2738 #include <sys/types.h>
2739 #include <sys/select.h>
2740 #include <sys/time.h>
2742 AC_DEFINE(SYS_SELECT_WITH_SYS_TIME, 1,
2743 [Define if you can safely include both <sys/select.h> and <sys/time.h>
2744 (which you can't on SCO ODT 3.0).])
2747 AC_MSG_RESULT($was_it_defined)
2749 AC_MSG_CHECKING(for addrinfo)
2750 AC_CACHE_VAL(ac_cv_struct_addrinfo,
2752 # include <netdb.h>],
2753 [struct addrinfo a],
2754 ac_cv_struct_addrinfo=yes,
2755 ac_cv_struct_addrinfo=no))
2756 AC_MSG_RESULT($ac_cv_struct_addrinfo)
2757 if test $ac_cv_struct_addrinfo = yes; then
2758 AC_DEFINE(HAVE_ADDRINFO, 1, [struct addrinfo (netdb.h)])
2761 AC_MSG_CHECKING(for sockaddr_storage)
2762 AC_CACHE_VAL(ac_cv_struct_sockaddr_storage,
2764 # include <sys/types.h>
2765 # include <sys/socket.h>],
2766 [struct sockaddr_storage s],
2767 ac_cv_struct_sockaddr_storage=yes,
2768 ac_cv_struct_sockaddr_storage=no))
2769 AC_MSG_RESULT($ac_cv_struct_sockaddr_storage)
2770 if test $ac_cv_struct_sockaddr_storage = yes; then
2771 AC_DEFINE(HAVE_SOCKADDR_STORAGE, 1, [struct sockaddr_storage (sys/socket.h)])
2774 # checks for compiler characteristics
2780 AC_MSG_CHECKING(for working volatile)
2781 AC_TRY_COMPILE([],[volatile int x; x = 0;], works=yes,
2782 AC_DEFINE(volatile, [], [Define to empty if the keyword does not work.])
2784 AC_MSG_RESULT($works)
2787 AC_MSG_CHECKING(for working signed char)
2788 AC_TRY_COMPILE([], [signed char c;], works=yes,
2789 AC_DEFINE(signed, [], [Define to empty if the keyword does not work.])
2791 AC_MSG_RESULT($works)
2794 AC_MSG_CHECKING(for prototypes)
2795 AC_TRY_COMPILE([int foo(int x) { return 0; }], [return foo(10);],[
2796 AC_DEFINE(HAVE_PROTOTYPES, 1,
2797 [Define if your compiler supports function prototype])
2800 AC_MSG_RESULT($have_prototypes)
2803 AC_MSG_CHECKING(for variable length prototypes and stdarg.h)
2806 int foo(int x, ...) {
2814 ], [return foo(10, "", 3.14);], [
2815 AC_DEFINE(HAVE_STDARG_PROTOTYPES, 1,
2816 [Define if your compiler supports variable length function prototypes
2817 (e.g. void fprintf(FILE *, char *, ...);) *and* <stdarg.h>])
2820 AC_MSG_RESULT($works)
2822 # check for socketpair
2823 AC_MSG_CHECKING(for socketpair)
2825 #include <sys/types.h>
2826 #include <sys/socket.h>
2827 ], void *x=socketpair,
2828 AC_DEFINE(HAVE_SOCKETPAIR, 1, Define if you have the 'socketpair' function.)
2833 # check if sockaddr has sa_len member
2834 AC_MSG_CHECKING(if sockaddr has sa_len member)
2835 AC_TRY_COMPILE([#include <sys/types.h>
2836 #include <sys/socket.h>],
2840 AC_DEFINE(HAVE_SOCKADDR_SA_LEN, 1, [Define if sockaddr has sa_len member]),
2844 AC_MSG_CHECKING(whether va_list is an array)
2846 #ifdef HAVE_STDARG_PROTOTYPES
2849 #include <varargs.h>
2851 ], [va_list list1, list2; list1 = list2;], , [
2852 AC_DEFINE(VA_LIST_IS_ARRAY, 1, [Define if a va_list is an array of some kind])
2853 va_list_is_array=yes
2855 AC_MSG_RESULT($va_list_is_array)
2857 # sigh -- gethostbyname_r is a mess; it can have 3, 5 or 6 arguments :-(
2858 AH_TEMPLATE(HAVE_GETHOSTBYNAME_R,
2859 [Define this if you have some version of gethostbyname_r()])
2861 AC_CHECK_FUNC(gethostbyname_r, [
2862 AC_DEFINE(HAVE_GETHOSTBYNAME_R)
2863 AC_MSG_CHECKING([gethostbyname_r with 6 args])
2865 CFLAGS="$CFLAGS $MY_CPPFLAGS $MY_THREAD_CPPFLAGS $MY_CFLAGS"
2870 struct hostent *he, *res;
2875 (void) gethostbyname_r(name, he, buffer, buflen, &res, &h_errnop)
2877 AC_DEFINE(HAVE_GETHOSTBYNAME_R)
2878 AC_DEFINE(HAVE_GETHOSTBYNAME_R_6_ARG, 1,
2879 [Define this if you have the 6-arg version of gethostbyname_r().])
2883 AC_MSG_CHECKING([gethostbyname_r with 5 args])
2893 (void) gethostbyname_r(name, he, buffer, buflen, &h_errnop)
2895 AC_DEFINE(HAVE_GETHOSTBYNAME_R)
2896 AC_DEFINE(HAVE_GETHOSTBYNAME_R_5_ARG, 1,
2897 [Define this if you have the 5-arg version of gethostbyname_r().])
2901 AC_MSG_CHECKING([gethostbyname_r with 3 args])
2907 struct hostent_data data;
2909 (void) gethostbyname_r(name, he, &data);
2911 AC_DEFINE(HAVE_GETHOSTBYNAME_R)
2912 AC_DEFINE(HAVE_GETHOSTBYNAME_R_3_ARG, 1,
2913 [Define this if you have the 3-arg version of gethostbyname_r().])
2922 AC_CHECK_FUNCS(gethostbyname)
2924 AC_SUBST(HAVE_GETHOSTBYNAME_R_6_ARG)
2925 AC_SUBST(HAVE_GETHOSTBYNAME_R_5_ARG)
2926 AC_SUBST(HAVE_GETHOSTBYNAME_R_3_ARG)
2927 AC_SUBST(HAVE_GETHOSTBYNAME_R)
2928 AC_SUBST(HAVE_GETHOSTBYNAME)
2930 # checks for system services
2933 # Linux requires this for correct f.p. operations
2934 AC_CHECK_FUNC(__fpu_control,
2936 [AC_CHECK_LIB(ieee, __fpu_control)
2939 # Check for --with-fpectl
2940 AC_MSG_CHECKING(for --with-fpectl)
2942 AC_HELP_STRING(--with-fpectl, enable SIGFPE catching),
2944 if test "$withval" != no
2946 AC_DEFINE(WANT_SIGFPE_HANDLER, 1,
2947 [Define if you want SIGFPE handled (see Include/pyfpe.h).])
2949 else AC_MSG_RESULT(no)
2951 [AC_MSG_RESULT(no)])
2953 # check for --with-libm=...
2955 case $ac_sys_system in
2960 AC_MSG_CHECKING(for --with-libm=STRING)
2962 AC_HELP_STRING(--with-libm=STRING, math library),
2964 if test "$withval" = no
2966 AC_MSG_RESULT(force LIBM empty)
2967 elif test "$withval" != yes
2969 AC_MSG_RESULT(set LIBM="$withval")
2970 else AC_MSG_ERROR([proper usage is --with-libm=STRING])
2972 [AC_MSG_RESULT(default LIBM="$LIBM")])
2974 # check for --with-libc=...
2976 AC_MSG_CHECKING(for --with-libc=STRING)
2978 AC_HELP_STRING(--with-libc=STRING, C library),
2980 if test "$withval" = no
2982 AC_MSG_RESULT(force LIBC empty)
2983 elif test "$withval" != yes
2985 AC_MSG_RESULT(set LIBC="$withval")
2986 else AC_MSG_ERROR([proper usage is --with-libc=STRING])
2988 [AC_MSG_RESULT(default LIBC="$LIBC")])
2990 # ************************************
2991 # * Check for mathematical functions *
2992 # ************************************
2995 AC_REPLACE_FUNCS(hypot)
2997 AC_CHECK_FUNCS(acosh asinh atanh copysign expm1 finite isinf isnan log1p)
3002 AC_CHECK_HEADER(wchar.h, [
3003 AC_DEFINE(HAVE_WCHAR_H, 1,
3004 [Define if the compiler provides a wchar.h header file.])
3010 # determine wchar_t size
3011 if test "$wchar_h" = yes
3013 AC_CHECK_SIZEOF(wchar_t, 4, [#include <wchar.h>])
3016 AC_MSG_CHECKING(for UCS-4 tcl)
3020 #if TCL_UTF_MAX != 6
3021 # error "NOT UCS4_TCL"
3023 AC_DEFINE(HAVE_UCS4_TCL, 1, [Define this if you have tcl and TCL_UTF_MAX==6])
3026 AC_MSG_RESULT($have_ucs4_tcl)
3028 # check whether wchar_t is signed or not
3029 if test "$wchar_h" = yes
3031 # check whether wchar_t is signed or not
3032 AC_MSG_CHECKING(whether wchar_t is signed)
3033 AC_CACHE_VAL(ac_cv_wchar_t_signed, [
3038 /* Success: exit code 0 */
3039 exit((((wchar_t) -1) < ((wchar_t) 0)) ? 0 : 1);
3042 ac_cv_wchar_t_signed=yes,
3043 ac_cv_wchar_t_signed=no,
3044 ac_cv_wchar_t_signed=yes)])
3045 AC_MSG_RESULT($ac_cv_wchar_t_signed)
3048 AC_MSG_CHECKING(what type to use for unicode)
3049 dnl quadrigraphs "@<:@" and "@:>@" produce "[" and "]" in the output
3050 AC_ARG_ENABLE(unicode,
3051 AC_HELP_STRING(--enable-unicode@<:@=ucs@<:@24@:>@@:>@, Enable Unicode strings (default is yes)),
3053 [enable_unicode=yes])
3055 if test $enable_unicode = yes
3057 # Without any arguments, Py_UNICODE defaults to two-byte mode
3058 case "$have_ucs4_tcl" in
3059 yes) enable_unicode="ucs4"
3061 *) enable_unicode="ucs2"
3066 AH_TEMPLATE(Py_UNICODE_SIZE,
3067 [Define as the size of the unicode type.])
3068 case "$enable_unicode" in
3069 ucs2) unicode_size="2"
3070 AC_DEFINE(Py_UNICODE_SIZE,2)
3072 ucs4) unicode_size="4"
3073 AC_DEFINE(Py_UNICODE_SIZE,4)
3077 AH_TEMPLATE(PY_UNICODE_TYPE,
3078 [Define as the integral type used for Unicode representation.])
3080 AC_SUBST(UNICODE_OBJS)
3081 if test "$enable_unicode" = "no"
3084 AC_MSG_RESULT(not used)
3086 UNICODE_OBJS="Objects/unicodeobject.o Objects/unicodectype.o"
3087 AC_DEFINE(Py_USING_UNICODE, 1,
3088 [Define if you want to have a Unicode type.])
3090 # wchar_t is only usable if it maps to an unsigned type
3091 if test "$unicode_size" = "$ac_cv_sizeof_wchar_t" \
3092 -a "$ac_cv_wchar_t_signed" = "no"
3094 PY_UNICODE_TYPE="wchar_t"
3095 AC_DEFINE(HAVE_USABLE_WCHAR_T, 1,
3096 [Define if you have a useable wchar_t type defined in wchar.h; useable
3097 means wchar_t must be an unsigned type with at least 16 bits. (see
3098 Include/unicodeobject.h).])
3099 AC_DEFINE(PY_UNICODE_TYPE,wchar_t)
3100 elif test "$ac_cv_sizeof_short" = "$unicode_size"
3102 PY_UNICODE_TYPE="unsigned short"
3103 AC_DEFINE(PY_UNICODE_TYPE,unsigned short)
3104 elif test "$ac_cv_sizeof_long" = "$unicode_size"
3106 PY_UNICODE_TYPE="unsigned long"
3107 AC_DEFINE(PY_UNICODE_TYPE,unsigned long)
3109 PY_UNICODE_TYPE="no type found"
3111 AC_MSG_RESULT($PY_UNICODE_TYPE)
3114 # check for endianness
3116 AH_VERBATIM([WORDS_BIGENDIAN],
3118 /* Define to 1 if your processor stores words with the most significant byte
3119 first (like Motorola and SPARC, unlike Intel and VAX).
3121 The block below does compile-time checking for endianness on platforms
3122 that use GCC and therefore allows compiling fat binaries on OSX by using
3123 '-arch ppc -arch i386' as the compile flags. The phrasing was choosen
3124 such that the configure-result is used on systems that don't use GCC.
3126 #ifdef __BIG_ENDIAN__
3127 #define WORDS_BIGENDIAN 1
3129 #ifndef __LITTLE_ENDIAN__
3130 #undef WORDS_BIGENDIAN
3134 # Check whether right shifting a negative integer extends the sign bit
3135 # or fills with zeros (like the Cray J90, according to Tim Peters).
3136 AC_MSG_CHECKING(whether right shift extends the sign bit)
3137 AC_CACHE_VAL(ac_cv_rshift_extends_sign, [
3141 exit(((-1)>>3 == -1) ? 0 : 1);
3144 ac_cv_rshift_extends_sign=yes,
3145 ac_cv_rshift_extends_sign=no,
3146 ac_cv_rshift_extends_sign=yes)])
3147 AC_MSG_RESULT($ac_cv_rshift_extends_sign)
3148 if test "$ac_cv_rshift_extends_sign" = no
3150 AC_DEFINE(SIGNED_RIGHT_SHIFT_ZERO_FILLS, 1,
3151 [Define if i>>j for signed int i does not extend the sign bit
3155 # check for getc_unlocked and related locking functions
3156 AC_MSG_CHECKING(for getc_unlocked() and friends)
3157 AC_CACHE_VAL(ac_cv_have_getc_unlocked, [
3158 AC_TRY_LINK([#include <stdio.h>],[
3159 FILE *f = fopen("/dev/null", "r");
3163 ], ac_cv_have_getc_unlocked=yes, ac_cv_have_getc_unlocked=no)])
3164 AC_MSG_RESULT($ac_cv_have_getc_unlocked)
3165 if test "$ac_cv_have_getc_unlocked" = yes
3167 AC_DEFINE(HAVE_GETC_UNLOCKED, 1,
3168 [Define this if you have flockfile(), getc_unlocked(), and funlockfile()])
3171 # check where readline lives
3172 # save the value of LIBS so we don't actually link Python with readline
3173 LIBS_no_readline=$LIBS
3174 AC_CHECK_LIB(readline, readline)
3175 if test "$ac_cv_have_readline_readline" = no
3177 AC_CHECK_LIB(termcap, readline)
3180 # check for readline 2.1
3181 AC_CHECK_LIB(readline, rl_callback_handler_install,
3182 AC_DEFINE(HAVE_RL_CALLBACK, 1,
3183 [Define if you have readline 2.1]), , )
3185 # check for readline 2.2
3186 AC_TRY_CPP([#include <readline/readline.h>],
3187 have_readline=yes, have_readline=no)
3188 if test $have_readline = yes
3190 AC_EGREP_HEADER([extern int rl_completion_append_character;],
3191 [readline/readline.h],
3192 AC_DEFINE(HAVE_RL_COMPLETION_APPEND_CHARACTER, 1,
3193 [Define if you have readline 2.2]), )
3196 # check for readline 4.0
3197 AC_CHECK_LIB(readline, rl_pre_input_hook,
3198 AC_DEFINE(HAVE_RL_PRE_INPUT_HOOK, 1,
3199 [Define if you have readline 4.0]), , )
3202 AC_CHECK_LIB(readline, rl_completion_display_matches_hook,
3203 AC_DEFINE(HAVE_RL_COMPLETION_DISPLAY_MATCHES_HOOK, 1,
3204 [Define if you have readline 4.0]), , )
3206 # check for readline 4.2
3207 AC_CHECK_LIB(readline, rl_completion_matches,
3208 AC_DEFINE(HAVE_RL_COMPLETION_MATCHES, 1,
3209 [Define if you have readline 4.2]), , )
3211 # also in readline 4.2
3212 AC_TRY_CPP([#include <readline/readline.h>],
3213 have_readline=yes, have_readline=no)
3214 if test $have_readline = yes
3216 AC_EGREP_HEADER([extern int rl_catch_signals;],
3217 [readline/readline.h],
3218 AC_DEFINE(HAVE_RL_CATCH_SIGNAL, 1,
3219 [Define if you can turn off readline's signal handling.]), )
3222 # End of readline checks: restore LIBS
3223 LIBS=$LIBS_no_readline
3225 AC_MSG_CHECKING(for broken nice())
3226 AC_CACHE_VAL(ac_cv_broken_nice, [
3231 if (val1 != -1 && val1 == nice(2))
3236 ac_cv_broken_nice=yes,
3237 ac_cv_broken_nice=no,
3238 ac_cv_broken_nice=no)])
3239 AC_MSG_RESULT($ac_cv_broken_nice)
3240 if test "$ac_cv_broken_nice" = yes
3242 AC_DEFINE(HAVE_BROKEN_NICE, 1,
3243 [Define if nice() returns success/failure instead of the new priority.])
3246 AC_MSG_CHECKING(for broken poll())
3252 struct pollfd poll_struct = { 42, POLLIN|POLLPRI|POLLOUT, 0 };
3256 int poll_test = poll (&poll_struct, 1, 0);
3262 else if (poll_test == 0 && poll_struct.revents != POLLNVAL)
3272 ac_cv_broken_poll=yes,
3273 ac_cv_broken_poll=no,
3274 ac_cv_broken_poll=no)
3275 AC_MSG_RESULT($ac_cv_broken_poll)
3276 if test "$ac_cv_broken_poll" = yes
3278 AC_DEFINE(HAVE_BROKEN_POLL, 1,
3279 [Define if poll() sets errno on invalid file descriptors.])
3282 # Before we can test tzset, we need to check if struct tm has a tm_zone
3283 # (which is not required by ISO C or UNIX spec) and/or if we support
3287 # check tzset(3) exists and works like we expect it to
3288 AC_MSG_CHECKING(for working tzset())
3289 AC_CACHE_VAL(ac_cv_working_tzset, [
3296 extern char *tzname[];
3301 /* Note that we need to ensure that not only does tzset(3)
3302 do 'something' with localtime, but it works as documented
3303 in the library reference and as expected by the test suite.
3304 This includes making sure that tzname is set properly if
3305 tm->tm_zone does not exist since it is the alternative way
3306 of getting timezone info.
3308 Red Hat 6.2 doesn't understand the southern hemisphere
3309 after New Year's Day.
3312 time_t groundhogday = 1044144000; /* GMT-based */
3313 time_t midyear = groundhogday + (365 * 24 * 3600 / 2);
3317 if (localtime(&groundhogday)->tm_hour != 0)
3320 /* For UTC, tzname[1] is sometimes "", sometimes " " */
3321 if (strcmp(tzname[0], "UTC") ||
3322 (tzname[1][0] != 0 && tzname[1][0] != ' '))
3326 putenv("TZ=EST+5EDT,M4.1.0,M10.5.0");
3328 if (localtime(&groundhogday)->tm_hour != 19)
3331 if (strcmp(tzname[0], "EST") || strcmp(tzname[1], "EDT"))
3335 putenv("TZ=AEST-10AEDT-11,M10.5.0,M3.5.0");
3337 if (localtime(&groundhogday)->tm_hour != 11)
3340 if (strcmp(tzname[0], "AEST") || strcmp(tzname[1], "AEDT"))
3344 #if HAVE_STRUCT_TM_TM_ZONE
3345 if (strcmp(localtime(&groundhogday)->tm_zone, "AEDT"))
3347 if (strcmp(localtime(&midyear)->tm_zone, "AEST"))
3354 ac_cv_working_tzset=yes,
3355 ac_cv_working_tzset=no,
3356 ac_cv_working_tzset=no)])
3357 AC_MSG_RESULT($ac_cv_working_tzset)
3358 if test "$ac_cv_working_tzset" = yes
3360 AC_DEFINE(HAVE_WORKING_TZSET, 1,
3361 [Define if tzset() actually switches the local timezone in a meaningful way.])
3364 # Look for subsecond timestamps in struct stat
3365 AC_MSG_CHECKING(for tv_nsec in struct stat)
3366 AC_CACHE_VAL(ac_cv_stat_tv_nsec,
3367 AC_TRY_COMPILE([#include <sys/stat.h>], [
3369 st.st_mtim.tv_nsec = 1;
3371 ac_cv_stat_tv_nsec=yes,
3372 ac_cv_stat_tv_nsec=no,
3373 ac_cv_stat_tv_nsec=no))
3374 AC_MSG_RESULT($ac_cv_stat_tv_nsec)
3375 if test "$ac_cv_stat_tv_nsec" = yes
3377 AC_DEFINE(HAVE_STAT_TV_NSEC, 1,
3378 [Define if you have struct stat.st_mtim.tv_nsec])
3381 # Look for BSD style subsecond timestamps in struct stat
3382 AC_MSG_CHECKING(for tv_nsec2 in struct stat)
3383 AC_CACHE_VAL(ac_cv_stat_tv_nsec2,
3384 AC_TRY_COMPILE([#include <sys/stat.h>], [
3386 st.st_mtimespec.tv_nsec = 1;
3388 ac_cv_stat_tv_nsec2=yes,
3389 ac_cv_stat_tv_nsec2=no,
3390 ac_cv_stat_tv_nsec2=no))
3391 AC_MSG_RESULT($ac_cv_stat_tv_nsec2)
3392 if test "$ac_cv_stat_tv_nsec2" = yes
3394 AC_DEFINE(HAVE_STAT_TV_NSEC2, 1,
3395 [Define if you have struct stat.st_mtimensec])
3398 # On HP/UX 11.0, mvwdelch is a block with a return statement
3399 AC_MSG_CHECKING(whether mvwdelch is an expression)
3400 AC_CACHE_VAL(ac_cv_mvwdelch_is_expression,
3401 AC_TRY_COMPILE([#include <curses.h>], [
3403 rtn = mvwdelch(0,0,0);
3404 ], ac_cv_mvwdelch_is_expression=yes,
3405 ac_cv_mvwdelch_is_expression=no,
3406 ac_cv_mvwdelch_is_expression=yes))
3407 AC_MSG_RESULT($ac_cv_mvwdelch_is_expression)
3409 if test "$ac_cv_mvwdelch_is_expression" = yes
3411 AC_DEFINE(MVWDELCH_IS_EXPRESSION, 1,
3412 [Define if mvwdelch in curses.h is an expression.])
3415 AC_MSG_CHECKING(whether WINDOW has _flags)
3416 AC_CACHE_VAL(ac_cv_window_has_flags,
3417 AC_TRY_COMPILE([#include <curses.h>], [
3420 ], ac_cv_window_has_flags=yes,
3421 ac_cv_window_has_flags=no,
3422 ac_cv_window_has_flags=no))
3423 AC_MSG_RESULT($ac_cv_window_has_flags)
3426 if test "$ac_cv_window_has_flags" = yes
3428 AC_DEFINE(WINDOW_HAS_FLAGS, 1,
3429 [Define if WINDOW in curses.h offers a field _flags.])
3432 AC_MSG_CHECKING(for is_term_resized)
3433 AC_TRY_COMPILE([#include <curses.h>], void *x=is_term_resized,
3434 AC_DEFINE(HAVE_CURSES_IS_TERM_RESIZED, 1, Define if you have the 'is_term_resized' function.)
3439 AC_MSG_CHECKING(for resize_term)
3440 AC_TRY_COMPILE([#include <curses.h>], void *x=resize_term,
3441 AC_DEFINE(HAVE_CURSES_RESIZE_TERM, 1, Define if you have the 'resize_term' function.)
3446 AC_MSG_CHECKING(for resizeterm)
3447 AC_TRY_COMPILE([#include <curses.h>], void *x=resizeterm,
3448 AC_DEFINE(HAVE_CURSES_RESIZETERM, 1, Define if you have the 'resizeterm' function.)
3453 AC_MSG_CHECKING(for /dev/ptmx)
3455 if test -r /dev/ptmx
3458 AC_DEFINE(HAVE_DEV_PTMX, 1,
3459 [Define if we have /dev/ptmx.])
3464 AC_MSG_CHECKING(for /dev/ptc)
3469 AC_DEFINE(HAVE_DEV_PTC, 1,
3470 [Define if we have /dev/ptc.])
3475 AC_MSG_CHECKING(for %zd printf() format support)
3476 AC_TRY_RUN([#include <stdio.h>
3480 #ifdef HAVE_SYS_TYPES_H
3481 #include <sys/types.h>
3485 typedef ssize_t Py_ssize_t;
3486 #elif SIZEOF_VOID_P == SIZEOF_LONG
3487 typedef long Py_ssize_t;
3489 typedef int Py_ssize_t;
3496 if(sprintf(buffer, "%zd", (size_t)123) < 0)
3499 if (strcmp(buffer, "123"))
3502 if (sprintf(buffer, "%zd", (Py_ssize_t)-123) < 0)
3505 if (strcmp(buffer, "-123"))
3511 AC_DEFINE(PY_FORMAT_SIZE_T, "z", [Define to printf format modifier for Py_ssize_t])],
3514 AC_CHECK_TYPE(socklen_t,,
3515 AC_DEFINE(socklen_t,int,
3516 Define to `int' if <sys/socket.h> does not define.),[
3517 #ifdef HAVE_SYS_TYPES_H
3518 #include <sys/types.h>
3520 #ifdef HAVE_SYS_SOCKET_H
3521 #include <sys/socket.h>
3525 AC_SUBST(THREADHEADERS)
3527 for h in `(cd $srcdir;echo Python/thread_*.h)`
3529 THREADHEADERS="$THREADHEADERS \$(srcdir)/$h"
3533 SRCDIRS="Parser Grammar Objects Python Modules Mac"
3534 AC_MSG_CHECKING(for build directories)
3535 for dir in $SRCDIRS; do
3536 if test ! -d $dir; then
3542 # generate output files
3543 AC_CONFIG_FILES(Makefile.pre Modules/Setup.config)
3546 echo "creating Modules/Setup"
3547 if test ! -f Modules/Setup
3549 cp $srcdir/Modules/Setup.dist Modules/Setup
3552 echo "creating Modules/Setup.local"
3553 if test ! -f Modules/Setup.local
3555 echo "# Edit this file for local setup changes" >Modules/Setup.local
3558 echo "creating Makefile"
3559 $SHELL $srcdir/Modules/makesetup -c $srcdir/Modules/config.c.in \
3560 -s Modules Modules/Setup.config \
3561 Modules/Setup.local Modules/Setup
3563 case $ac_sys_system in
3567 Support for BeOS is deprecated as of Python 2.6.
3568 See PEP 11 for the gory details.