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 agains 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 # Defining _XOPEN_SOURCE on NetBSD version prior to the introduction of
207 # _NETBSD_SOURCE disables certain features (eg. setgroups). Reported by
209 NetBSD/1.5 | NetBSD/1.5.* | NetBSD/1.6 | NetBSD/1.6.* | NetBSD/1.6[A-S])
210 define_xopen_source=no;;
211 # On Solaris 2.6, sys/wait.h is inconsistent in the usage
212 # of union __?sigval. Reported by Stuart Bishop.
214 define_xopen_source=no;;
215 # On UnixWare 7, u_long is never defined with _XOPEN_SOURCE,
216 # but used in /usr/include/netinet/tcp.h. Reported by Tim Rice.
217 # Reconfirmed for 7.1.4 by Martin v. Loewis.
218 OpenUNIX/8.0.0| UnixWare/7.1.@<:@0-4@:>@)
219 define_xopen_source=no;;
220 # On OpenServer 5, u_short is never defined with _XOPEN_SOURCE,
221 # but used in struct sockaddr.sa_family. Reported by Tim Rice.
223 define_xopen_source=no;;
224 # On FreeBSD 4.8 and MacOS X 10.2, a bug in ncurses.h means that
225 # it craps out if _XOPEN_EXTENDED_SOURCE is defined. Apparently,
226 # this is fixed in 10.3, which identifies itself as Darwin/7.*
227 # This should hopefully be fixed in FreeBSD 4.9
228 FreeBSD/4.8* | Darwin/6* )
229 define_xopen_source=no;;
230 # On AIX 4 and 5.1, mbstate_t is defined only when _XOPEN_SOURCE == 500 but
231 # used in wcsnrtombs() and mbsnrtowcs() even if _XOPEN_SOURCE is not defined
232 # or has another value. By not (re)defining it, the defaults come in place.
234 define_xopen_source=no;;
236 if test `uname -r` -eq 1; then
237 define_xopen_source=no
240 # On Mac OS X 10.4, defining _POSIX_C_SOURCE or _XOPEN_SOURCE
241 # disables platform specific features beyond repair.
242 # On Mac OS X 10.3, defining _POSIX_C_SOURCE or _XOPEN_SOURCE
243 # has no effect, don't bother defining them
244 Darwin/@<:@789@:>@.*)
245 define_xopen_source=no
250 if test $define_xopen_source = yes
252 # On Solaris w/ g++ it appears that _XOPEN_SOURCE has to be
253 # defined precisely as g++ defines it
254 # Furthermore, on Solaris 10, XPG6 requires the use of a C99
256 case $ac_sys_system/$ac_sys_release in
257 SunOS/5.8|SunOS/5.9|SunOS/5.10)
258 AC_DEFINE(_XOPEN_SOURCE, 500,
259 Define to the level of X/Open that your system supports)
262 AC_DEFINE(_XOPEN_SOURCE, 600,
263 Define to the level of X/Open that your system supports)
267 # On Tru64 Unix 4.0F, defining _XOPEN_SOURCE also requires
268 # definition of _XOPEN_SOURCE_EXTENDED and _POSIX_C_SOURCE, or else
269 # several APIs are not declared. Since this is also needed in some
270 # cases for HP-UX, we define it globally.
271 # except for Solaris 10, where it must not be defined,
272 # as it implies XPG4.2
273 case $ac_sys_system/$ac_sys_release in
277 AC_DEFINE(_XOPEN_SOURCE_EXTENDED, 1,
278 Define to activate Unix95-and-earlier features)
282 AC_DEFINE(_POSIX_C_SOURCE, 200112L, Define to activate features from IEEE Stds 1003.1-2001)
287 # SGI compilers allow the specification of the both the ABI and the
288 # ISA on the command line. Depending on the values of these switches,
289 # different and often incompatable code will be generated.
291 # The SGI_ABI variable can be used to modify the CC and LDFLAGS and
292 # thus supply support for various ABI/ISA combinations. The MACHDEP
293 # variable is also adjusted.
296 if test ! -z "$SGI_ABI"
299 LDFLAGS="$SGI_ABI $LDFLAGS"
300 MACHDEP=`echo "${MACHDEP}${SGI_ABI}" | sed 's/ *//g'`
302 AC_MSG_RESULT($MACHDEP)
304 # And add extra plat-mac for darwin
305 AC_SUBST(EXTRAPLATDIR)
306 AC_SUBST(EXTRAMACHDEPPATH)
307 AC_MSG_CHECKING(EXTRAPLATDIR)
308 if test -z "$EXTRAPLATDIR"
312 EXTRAPLATDIR="\$(PLATMACDIRS)"
313 EXTRAMACHDEPPATH="\$(PLATMACPATH)"
321 AC_MSG_RESULT($EXTRAPLATDIR)
323 # Record the configure-time value of MACOSX_DEPLOYMENT_TARGET,
324 # it may influence the way we can build extensions, so distutils
326 AC_SUBST(CONFIGURE_MACOSX_DEPLOYMENT_TARGET)
327 AC_SUBST(EXPORT_MACOSX_DEPLOYMENT_TARGET)
328 CONFIGURE_MACOSX_DEPLOYMENT_TARGET=
329 EXPORT_MACOSX_DEPLOYMENT_TARGET='#'
331 # checks for alternative programs
333 # compiler flags are generated in two sets, BASECFLAGS and OPT. OPT is just
334 # for debug/optimization stuff. BASECFLAGS is for flags that are required
335 # just to get things to compile and link. Users are free to override OPT
336 # when running configure or make. The build should not break if they do.
337 # BASECFLAGS should generally not be messed with, however.
339 # XXX shouldn't some/most/all of this code be merged with the stuff later
340 # on that fiddles with OPT and BASECFLAGS?
341 AC_MSG_CHECKING(for --without-gcc)
343 AC_HELP_STRING(--without-gcc,never use gcc),
351 without_gcc=$withval;;
353 case $ac_sys_system in
361 BASECFLAGS="$BASECFLAGS -export pragma"
363 LDFLAGS="$LDFLAGS -nodup"
371 AC_MSG_ERROR([Unknown BeOS platform "$BE_HOST_CPU"])
374 AR="\$(srcdir)/Modules/ar_beos"
382 AC_MSG_RESULT($without_gcc)
384 # If the user switches compilers, we can't believe the cache
385 if test ! -z "$ac_cv_prog_CC" -a ! -z "$CC" -a "$CC" != "$ac_cv_prog_CC"
387 AC_MSG_ERROR([cached CC is different -- throw away $cache_file
388 (it is also a good idea to do 'make clean' before compiling)])
395 AC_MSG_CHECKING(for --with-cxx-main=<compiler>)
396 AC_ARG_WITH(cxx_main,
397 AC_HELP_STRING([--with-cxx-main=<compiler>],
398 [compile main() and link python executable with C++ compiler]),
404 yes) with_cxx_main=yes
416 AC_MSG_RESULT($with_cxx_main)
422 gcc) AC_PATH_PROG(CXX, [g++], [g++], [notfound]) ;;
423 cc) AC_PATH_PROG(CXX, [c++], [c++], [notfound]) ;;
425 if test "$CXX" = "notfound"
432 AC_CHECK_PROGS(CXX, $CCC c++ g++ gcc CC cxx cc++ cl, notfound)
433 if test "$CXX" = "notfound"
438 if test "$preset_cxx" != "$CXX"
442 By default, distutils will build C++ extension modules with "$CXX".
443 If this is not intended, then set CXX on the configure command line.
448 # checks for UNIX variants that set C preprocessor variables
451 # Check for unsupported systems
452 case $ac_sys_system/$ac_sys_release in
454 echo This system \($ac_sys_system/$ac_sys_release\) is no longer supported.
455 echo See README for details.
460 AC_MSG_CHECKING(for --with-suffix)
462 AC_HELP_STRING(--with-suffix=.exe, set executable suffix),
469 AC_MSG_RESULT($EXEEXT)
471 # Test whether we're running on a non-case-sensitive system, in which
472 # case we give a warning if no ext is given
473 AC_SUBST(BUILDEXEEXT)
474 AC_MSG_CHECKING(for case-insensitive build directory)
475 if test ! -d CaseSensitiveTestDir; then
476 mkdir CaseSensitiveTestDir
479 if test -d casesensitivetestdir
487 rmdir CaseSensitiveTestDir
492 gcc) CC="$CC -D_HAVE_BSDI";;
496 case $ac_sys_system in
499 cc|*/cc) CC="$CC -Ae";;
503 cc) CC="$CC -Wl,-Bexport";;
506 # Some functions have a prototype only with that define, e.g. confstr
507 AC_DEFINE(__EXTENSIONS__, 1, [Defined on Solaris to see additional function prototypes.])
513 AC_MSG_CHECKING(LIBRARY)
514 if test -z "$LIBRARY"
516 LIBRARY='libpython$(VERSION).a'
518 AC_MSG_RESULT($LIBRARY)
520 # LDLIBRARY is the name of the library to link against (as opposed to the
521 # name of the library into which to insert object files). BLDLIBRARY is also
522 # the library to link against, usually. On Mac OS X frameworks, BLDLIBRARY
523 # is blank as the main program is not linked directly against LDLIBRARY.
524 # LDLIBRARYDIR is the path to LDLIBRARY, which is made in a subdirectory. On
525 # systems without shared libraries, LDLIBRARY is the same as LIBRARY
526 # (defined in the Makefiles). On Cygwin LDLIBRARY is the import library,
527 # DLLLIBRARY is the shared (i.e., DLL) library.
529 # RUNSHARED is used to run shared python without installed libraries
531 # INSTSONAME is the name of the shared library that will be use to install
532 # on the system - some systems like version suffix, others don't
536 AC_SUBST(LDLIBRARYDIR)
540 BLDLIBRARY='$(LDLIBRARY)'
541 INSTSONAME='$(LDLIBRARY)'
546 # LINKCC is the command that links the python executable -- default is $(CC).
547 # If CXX is set, and if it is needed to link a main function that was
548 # compiled with CXX, LINKCC is CXX instead. Always using CXX is undesirable:
549 # python might then depend on the C++ runtime
550 # This is altered for AIX in order to build the export list before
553 AC_MSG_CHECKING(LINKCC)
556 LINKCC='$(PURIFY) $(MAINCC)'
557 case $ac_sys_system in
560 if test $ac_sys_release -ge 5 -o \
561 $ac_sys_release -eq 4 -a `uname -r` -ge 2 ; then
564 LINKCC="\$(srcdir)/Modules/makexp_aix Modules/python.exp $exp_extra \$(LIBRARY); $LINKCC";;
566 LINKCC="$LINKCC -L/usr/lib/ia64l64";;
569 AC_MSG_RESULT($LINKCC)
571 AC_MSG_CHECKING(for --enable-shared)
572 AC_ARG_ENABLE(shared,
573 AC_HELP_STRING(--enable-shared, disable/enable building shared python library))
575 if test -z "$enable_shared"
577 case $ac_sys_system in
579 enable_shared="yes";;
584 AC_MSG_RESULT($enable_shared)
586 AC_MSG_CHECKING(for --enable-profiling)
587 AC_ARG_ENABLE(profiling,
588 AC_HELP_STRING(--enable-profiling, enable C-level code profiling),
591 AC_TRY_RUN([int main() { return 0; }],
592 ac_enable_profiling="yes",
593 ac_enable_profiling="no",
594 ac_enable_profiling="no")
596 AC_MSG_RESULT($ac_enable_profiling)
598 case "$ac_enable_profiling" in
600 BASECFLAGS="-pg $BASECFLAGS"
601 LDFLAGS="-pg $LDFLAGS"
605 AC_MSG_CHECKING(LDLIBRARY)
607 # MacOSX framework builds need more magic. LDLIBRARY is the dynamic
608 # library that we build, but we do not want to link against it (we
609 # will find it with a -framework option). For this reason there is an
610 # extra variable BLDLIBRARY against which Python and the extension
611 # modules are linked, BLDLIBRARY. This is normally the same as
612 # LDLIBRARY, but empty for MacOSX framework builds.
613 if test "$enable_framework"
615 LDLIBRARY='$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
616 RUNSHARED=DYLD_FRAMEWORK_PATH="`pwd`:$DYLD_FRAMEWORK_PATH"
619 BLDLIBRARY='$(LDLIBRARY)'
622 # Other platforms follow
623 if test $enable_shared = "yes"; then
624 AC_DEFINE(Py_ENABLE_SHARED, 1, [Defined if Python is built as a shared library.])
625 case $ac_sys_system in
627 LDLIBRARY='libpython$(VERSION).so'
630 LDLIBRARY='libpython$(VERSION).dll.a'
631 DLLLIBRARY='libpython$(VERSION).dll'
634 LDLIBRARY='libpython$(VERSION).so'
635 BLDLIBRARY='-Wl,-R,$(LIBDIR) -L. -lpython$(VERSION)'
636 RUNSHARED=LD_LIBRARY_PATH=`pwd`:${LD_LIBRARY_PATH}
637 INSTSONAME="$LDLIBRARY".$SOVERSION
639 Linux*|GNU*|NetBSD*|FreeBSD*|DragonFly*)
640 LDLIBRARY='libpython$(VERSION).so'
641 BLDLIBRARY='-L. -lpython$(VERSION)'
642 RUNSHARED=LD_LIBRARY_PATH=`pwd`:${LD_LIBRARY_PATH}
643 case $ac_sys_system in
645 SOVERSION=`echo $SOVERSION|cut -d "." -f 1`
648 INSTSONAME="$LDLIBRARY".$SOVERSION
653 LDLIBRARY='libpython$(VERSION).so'
656 LDLIBRARY='libpython$(VERSION).sl'
659 BLDLIBRARY='-Wl,+b,$(LIBDIR) -L. -lpython$(VERSION)'
660 RUNSHARED=SHLIB_PATH=`pwd`:${SHLIB_PATH}
663 LDLIBRARY='libpython$(VERSION).so'
664 BLDLIBRARY='-rpath $(LIBDIR) -L. -lpython$(VERSION)'
665 RUNSHARED=LD_LIBRARY_PATH=`pwd`:${LD_LIBRARY_PATH}
668 LDLIBRARY='libpython$(VERSION).so'
669 BLDLIBRARY='-L. -lpython$(VERSION)'
670 RUNSHARED=DLL_PATH=`pwd`:${DLL_PATH:-/atheos/sys/libs:/atheos/autolnk/lib}
673 else # shared is disabled
674 case $ac_sys_system in
676 BLDLIBRARY='$(LIBRARY)'
677 LDLIBRARY='libpython$(VERSION).dll.a'
682 AC_MSG_RESULT($LDLIBRARY)
686 AC_CHECK_PROGS(AR, ar aal, ar)
689 AC_CHECK_PROG(SVNVERSION, svnversion, found, not-found)
690 if test $SVNVERSION = found
692 SVNVERSION="svnversion \$(srcdir)"
694 SVNVERSION="echo exported"
699 # install -d does not work on BSDI or HP-UX
700 if test -z "$INSTALL"
702 INSTALL="${srcdir}/install-sh -c"
707 # Not every filesystem supports hard links
709 if test -z "$LN" ; then
710 case $ac_sys_system in
712 CYGWIN*) LN="ln -s";;
713 atheos*) LN="ln -s";;
718 # Check for --with-pydebug
719 AC_MSG_CHECKING(for --with-pydebug)
721 AC_HELP_STRING(--with-pydebug, build with Py_DEBUG defined),
723 if test "$withval" != no
725 AC_DEFINE(Py_DEBUG, 1,
726 [Define if you want to build an interpreter with many run-time checks.])
729 else AC_MSG_RESULT(no); Py_DEBUG='false'
733 # XXX Shouldn't the code above that fiddles with BASECFLAGS and OPT be
734 # merged with this chunk of code?
736 # Optimizer/debugger flags
737 # ------------------------
738 # (The following bit of code is complicated enough - please keep things
739 # indented properly. Just pretend you're editing Python code. ;-)
741 # There are two parallel sets of case statements below, one that checks to
742 # see if OPT was set and one that does BASECFLAGS setting based upon
743 # compiler and platform. BASECFLAGS tweaks need to be made even if the
746 # tweak OPT based on compiler and platform, only if the user didn't set
747 # it on the command line
753 if test "$CC" != 'g++' ; then
754 STRICT_PROTO="-Wstrict-prototypes"
756 case $ac_cv_prog_cc_g in
758 if test "$Py_DEBUG" = 'true' ; then
759 # Optimization messes up debuggers, so turn it off for
761 OPT="-g -Wall $STRICT_PROTO"
763 OPT="-g -O3 -Wall $STRICT_PROTO"
767 OPT="-O3 -Wall $STRICT_PROTO"
770 case $ac_sys_system in
771 SCO_SV*) OPT="$OPT -m486 -DSCO5"
781 # The current (beta) Monterey compiler dies with optimizations
782 # XXX what is Monterey? Does it still die w/ -O? Can we get rid of this?
783 case $ac_sys_system in
792 # tweak BASECFLAGS based on compiler and platform
795 # Python violates C99 rules, by casting between incompatible
796 # pointer types. GCC may generate bad code as a result of that,
797 # so use -fno-strict-aliasing if supported.
798 AC_MSG_CHECKING(whether $CC accepts -fno-strict-aliasing)
800 CC="$CC -fno-strict-aliasing"
801 AC_TRY_RUN([int main() { return 0; }],
802 ac_cv_no_strict_aliasing_ok=yes,
803 ac_cv_no_strict_aliasing_ok=no,
804 ac_cv_no_strict_aliasing_ok=no)
806 AC_MSG_RESULT($ac_cv_no_strict_aliasing_ok)
807 if test $ac_cv_no_strict_aliasing_ok = yes
809 BASECFLAGS="$BASECFLAGS -fno-strict-aliasing"
811 case $ac_sys_system in
813 BASECFLAGS="$BASECFLAGS -m486 -DSCO5"
815 # is there any other compiler on Darwin besides gcc?
817 BASECFLAGS="$BASECFLAGS -Wno-long-double -no-cpp-precomp -mno-fused-madd"
818 if test "${enable_universalsdk}"; then
819 BASECFLAGS="-arch ppc -arch i386 -isysroot ${UNIVERSALSDK} ${BASECFLAGS}"
824 BASECFLAGS="$BASECFLAGS -mieee"
830 case $ac_sys_system in
832 BASECFLAGS="$BASECFLAGS -K pentium,host,inline,loop_unroll,alloca "
835 BASECFLAGS="$BASECFLAGS -ieee -std"
838 BASECFLAGS="$BASECFLAGS -belf -Ki486 -DSCO5"
844 if test "$Py_DEBUG" = 'true'; then
850 if test "$ac_arch_flags"
852 BASECFLAGS="$BASECFLAGS $ac_arch_flags"
855 # disable check for icc since it seems to pass, but generates a warning
858 ac_cv_opt_olimit_ok=no
861 AC_MSG_CHECKING(whether $CC accepts -OPT:Olimit=0)
862 AC_CACHE_VAL(ac_cv_opt_olimit_ok,
864 CC="$CC -OPT:Olimit=0"
865 AC_TRY_RUN([int main() { return 0; }],
866 ac_cv_opt_olimit_ok=yes,
867 ac_cv_opt_olimit_ok=no,
868 ac_cv_opt_olimit_ok=no)
870 AC_MSG_RESULT($ac_cv_opt_olimit_ok)
871 if test $ac_cv_opt_olimit_ok = yes; then
872 case $ac_sys_system in
873 # XXX is this branch needed? On MacOSX 10.2.2 the result of the
874 # olimit_ok test is "no". Is it "yes" in some other Darwin-esque
879 BASECFLAGS="$BASECFLAGS -OPT:Olimit=0"
883 AC_MSG_CHECKING(whether $CC accepts -Olimit 1500)
884 AC_CACHE_VAL(ac_cv_olimit_ok,
886 CC="$CC -Olimit 1500"
887 AC_TRY_RUN([int main() { return 0; }],
892 AC_MSG_RESULT($ac_cv_olimit_ok)
893 if test $ac_cv_olimit_ok = yes; then
894 BASECFLAGS="$BASECFLAGS -Olimit 1500"
898 # Check whether GCC supports PyArg_ParseTuple format
899 if test "$GCC" = "yes"
901 AC_MSG_CHECKING(whether gcc supports ParseTuple __format__)
903 CFLAGS="$CFLAGS -Werror"
905 void f(char*,...)__attribute((format(PyArg_ParseTuple, 1, 2)));
907 AC_DEFINE(HAVE_ATTRIBUTE_FORMAT_PARSETUPLE, 1, [Define if GCC supports __attribute__((format(PyArg_ParseTuple, 2, 3)))])
914 # On some compilers, pthreads are available without further options
915 # (e.g. MacOS X). On some of these systems, the compiler will not
916 # complain if unaccepted options are passed (e.g. gcc on Mac OS X).
917 # So we have to see first whether pthreads are available without
918 # options before we can check whether -Kpthread improves anything.
919 AC_MSG_CHECKING(whether pthreads are available without options)
920 AC_CACHE_VAL(ac_cv_pthread_is_default,
924 void* routine(void* p){return NULL;}
928 if(pthread_create(&p,NULL,routine,NULL)!=0)
930 (void)pthread_detach(p);
935 ac_cv_pthread_is_default=yes
939 ac_cv_pthread_is_default=no,
940 ac_cv_pthread_is_default=no)
942 AC_MSG_RESULT($ac_cv_pthread_is_default)
945 if test $ac_cv_pthread_is_default = yes
949 # -Kpthread, if available, provides the right #defines
950 # and linker options to make pthread_create available
951 # Some compilers won't report that they do not support -Kpthread,
952 # so we need to run a program to see whether it really made the
953 # function available.
954 AC_MSG_CHECKING(whether $CC accepts -Kpthread)
955 AC_CACHE_VAL(ac_cv_kpthread,
961 void* routine(void* p){return NULL;}
965 if(pthread_create(&p,NULL,routine,NULL)!=0)
967 (void)pthread_detach(p);
975 AC_MSG_RESULT($ac_cv_kpthread)
978 if test $ac_cv_kpthread = no -a $ac_cv_pthread_is_default = no
980 # -Kthread, if available, provides the right #defines
981 # and linker options to make pthread_create available
982 # Some compilers won't report that they do not support -Kthread,
983 # so we need to run a program to see whether it really made the
984 # function available.
985 AC_MSG_CHECKING(whether $CC accepts -Kthread)
986 AC_CACHE_VAL(ac_cv_kthread,
992 void* routine(void* p){return NULL;}
996 if(pthread_create(&p,NULL,routine,NULL)!=0)
998 (void)pthread_detach(p);
1006 AC_MSG_RESULT($ac_cv_kthread)
1009 if test $ac_cv_kthread = no -a $ac_cv_pthread_is_default = no
1011 # -pthread, if available, provides the right #defines
1012 # and linker options to make pthread_create available
1013 # Some compilers won't report that they do not support -pthread,
1014 # so we need to run a program to see whether it really made the
1015 # function available.
1016 AC_MSG_CHECKING(whether $CC accepts -pthread)
1017 AC_CACHE_VAL(ac_cv_thread,
1021 #include <pthread.h>
1023 void* routine(void* p){return NULL;}
1027 if(pthread_create(&p,NULL,routine,NULL)!=0)
1029 (void)pthread_detach(p);
1037 AC_MSG_RESULT($ac_cv_pthread)
1040 # If we have set a CC compiler flag for thread support then
1041 # check if it works for CXX, too.
1045 AC_MSG_CHECKING(whether $CXX also accepts flags for thread support)
1048 if test "$ac_cv_kpthread" = "yes"
1050 CXX="$CXX -Kpthread"
1051 ac_cv_cxx_thread=yes
1052 elif test "$ac_cv_kthread" = "yes"
1055 ac_cv_cxx_thread=yes
1056 elif test "$ac_cv_pthread" = "yes"
1059 ac_cv_cxx_thread=yes
1062 if test $ac_cv_cxx_thread = yes
1064 echo 'void foo();int main(){foo();}void foo(){}' > conftest.$ac_ext
1065 $CXX -c conftest.$ac_ext 2>&5
1066 if $CXX -o conftest$ac_exeext conftest.$ac_objext 2>&5 \
1067 && test -s conftest$ac_exeext && ./conftest$ac_exeext
1069 ac_cv_cxx_thread=yes
1075 AC_MSG_RESULT($ac_cv_cxx_thread)
1079 dnl # check for ANSI or K&R ("traditional") preprocessor
1080 dnl AC_MSG_CHECKING(for C preprocessor type)
1081 dnl AC_TRY_COMPILE([
1082 dnl #define spam(name, doc) {#name, &name, #name "() -- " doc}
1084 dnl struct {char *name; int *addr; char *doc;} desc = spam(foo, "something");
1085 dnl ], [;], cpp_type=ansi, AC_DEFINE(HAVE_OLD_CPP) cpp_type=traditional)
1086 dnl AC_MSG_RESULT($cpp_type)
1088 # checks for header files
1090 AC_CHECK_HEADERS(asm/types.h conio.h curses.h direct.h dlfcn.h errno.h \
1092 io.h langinfo.h libintl.h ncurses.h poll.h process.h pthread.h \
1093 shadow.h signal.h stdint.h stropts.h termios.h thread.h \
1095 sys/audioio.h sys/bsdtty.h sys/file.h sys/loadavg.h sys/lock.h sys/mkdev.h \
1097 sys/param.h sys/poll.h sys/select.h sys/socket.h sys/statvfs.h sys/stat.h \
1099 sys/times.h sys/types.h sys/un.h sys/utsname.h sys/wait.h pty.h libutil.h \
1100 sys/resource.h netpacket/packet.h sysexits.h bluetooth.h \
1101 bluetooth/bluetooth.h)
1105 # On Solaris, term.h requires curses.h
1106 AC_CHECK_HEADERS(term.h,,,[
1107 #ifdef HAVE_CURSES_H
1112 # On Linux, netlink.h requires asm/types.h
1113 AC_CHECK_HEADERS(linux/netlink.h,,,[
1114 #ifdef HAVE_ASM_TYPES_H
1115 #include <asm/types.h>
1117 #ifdef HAVE_SYS_SOCKET_H
1118 #include <sys/socket.h>
1122 # checks for typedefs
1124 AC_MSG_CHECKING(for clock_t in time.h)
1125 AC_EGREP_HEADER(clock_t, time.h, was_it_defined=yes, [
1126 AC_DEFINE(clock_t, long, [Define to 'long' if <time.h> doesn't define.])
1128 AC_MSG_RESULT($was_it_defined)
1130 # Check whether using makedev requires defining _OSF_SOURCE
1131 AC_MSG_CHECKING(for makedev)
1132 AC_TRY_LINK([#include <sys/types.h> ],
1134 ac_cv_has_makedev=yes,
1135 ac_cv_has_makedev=no)
1136 if test "$ac_cv_has_makedev" = "no"; then
1137 # we didn't link, try if _OSF_SOURCE will allow us to link
1139 #define _OSF_SOURCE 1
1140 #include <sys/types.h>
1143 ac_cv_has_makedev=yes,
1144 ac_cv_has_makedev=no)
1145 if test "$ac_cv_has_makedev" = "yes"; then
1146 AC_DEFINE(_OSF_SOURCE, 1, [Define _OSF_SOURCE to get the makedev macro.])
1149 AC_MSG_RESULT($ac_cv_has_makedev)
1150 if test "$ac_cv_has_makedev" = "yes"; then
1151 AC_DEFINE(HAVE_MAKEDEV, 1, [Define this if you have the makedev macro.])
1154 # Enabling LFS on Solaris (2.6 to 9) with gcc 2.95 triggers a bug in
1155 # the system headers: If _XOPEN_SOURCE and _LARGEFILE_SOURCE are
1156 # defined, but the compiler does not support pragma redefine_extname,
1157 # and _LARGEFILE64_SOURCE is not defined, the headers refer to 64-bit
1158 # structures (such as rlimit64) without declaring them. As a
1159 # work-around, disable LFS on such configurations
1162 AC_MSG_CHECKING(Solaris LFS bug)
1164 #define _LARGEFILE_SOURCE 1
1165 #define _FILE_OFFSET_BITS 64
1166 #include <sys/resource.h>
1167 ],struct rlimit foo;,sol_lfs_bug=no,sol_lfs_bug=yes)
1168 AC_MSG_RESULT($sol_lfs_bug)
1169 if test "$sol_lfs_bug" = "yes"; then
1173 if test "$use_lfs" = "yes"; then
1174 # Two defines needed to enable largefile support on various platforms
1175 # These may affect some typedefs
1176 AC_DEFINE(_LARGEFILE_SOURCE, 1,
1177 [This must be defined on some systems to enable large file support.])
1178 AC_DEFINE(_FILE_OFFSET_BITS, 64,
1179 [This must be set to 64 on some systems to enable large file support.])
1182 # Add some code to confdefs.h so that the test for off_t works on SCO
1183 cat >> confdefs.h <<\EOF
1189 # Type availability checks
1196 AC_CHECK_TYPE(ssize_t,
1197 AC_DEFINE(HAVE_SSIZE_T, 1, Define if your compiler provides ssize_t),,)
1199 # Sizes of various common basic types
1200 # ANSI C requires sizeof(char) == 1, so no need to check it
1201 AC_CHECK_SIZEOF(int, 4)
1202 AC_CHECK_SIZEOF(long, 4)
1203 AC_CHECK_SIZEOF(void *, 4)
1204 AC_CHECK_SIZEOF(short, 2)
1205 AC_CHECK_SIZEOF(float, 4)
1206 AC_CHECK_SIZEOF(double, 8)
1207 AC_CHECK_SIZEOF(fpos_t, 4)
1208 AC_CHECK_SIZEOF(size_t, 4)
1210 AC_MSG_CHECKING(for long long support)
1212 AC_TRY_COMPILE([], [long long x; x = (long long)0;], [
1213 AC_DEFINE(HAVE_LONG_LONG, 1, [Define this if you have the type long long.])
1216 AC_MSG_RESULT($have_long_long)
1217 if test "$have_long_long" = yes ; then
1218 AC_CHECK_SIZEOF(long long, 8)
1221 AC_CHECK_TYPES(uintptr_t,
1222 [AC_CHECK_SIZEOF(uintptr_t, 4)],
1223 [], [#ifdef HAVE_STDINT_H
1228 # Hmph. AC_CHECK_SIZEOF() doesn't include <sys/types.h>.
1229 AC_MSG_CHECKING(size of off_t)
1230 AC_CACHE_VAL(ac_cv_sizeof_off_t,
1231 [AC_TRY_RUN([#include <stdio.h>
1232 #include <sys/types.h>
1235 FILE *f=fopen("conftestval", "w");
1237 fprintf(f, "%d\n", sizeof(off_t));
1240 ac_cv_sizeof_off_t=`cat conftestval`,
1241 ac_cv_sizeof_off_t=0,
1242 ac_cv_sizeof_off_t=4)
1244 AC_MSG_RESULT($ac_cv_sizeof_off_t)
1245 AC_DEFINE_UNQUOTED(SIZEOF_OFF_T, $ac_cv_sizeof_off_t,
1246 [The number of bytes in an off_t.])
1248 AC_MSG_CHECKING(whether to enable large file support)
1249 if test "$have_long_long" = yes -a \
1250 "$ac_cv_sizeof_off_t" -gt "$ac_cv_sizeof_long" -a \
1251 "$ac_cv_sizeof_long_long" -ge "$ac_cv_sizeof_off_t"; then
1252 AC_DEFINE(HAVE_LARGEFILE_SUPPORT, 1,
1253 [Defined to enable large file support when an off_t is bigger than a long
1254 and long long is available and at least as big as an off_t. You may need
1255 to add some flags for configuration and compilation to enable this mode.
1256 (For Solaris and Linux, the necessary defines are already defined.)])
1262 # AC_CHECK_SIZEOF() doesn't include <time.h>.
1263 AC_MSG_CHECKING(size of time_t)
1264 AC_CACHE_VAL(ac_cv_sizeof_time_t,
1265 [AC_TRY_RUN([#include <stdio.h>
1269 FILE *f=fopen("conftestval", "w");
1271 fprintf(f, "%d\n", sizeof(time_t));
1274 ac_cv_sizeof_time_t=`cat conftestval`,
1275 ac_cv_sizeof_time_t=0,
1276 ac_cv_sizeof_time_t=4)
1278 AC_MSG_RESULT($ac_cv_sizeof_time_t)
1279 AC_DEFINE_UNQUOTED(SIZEOF_TIME_T, $ac_cv_sizeof_time_t,
1280 [The number of bytes in a time_t.])
1283 # if have pthread_t then define SIZEOF_PTHREAD_T
1285 if test "$ac_cv_kpthread" = "yes"
1286 then CC="$CC -Kpthread"
1287 elif test "$ac_cv_kthread" = "yes"
1288 then CC="$CC -Kthread"
1289 elif test "$ac_cv_pthread" = "yes"
1290 then CC="$CC -pthread"
1292 AC_MSG_CHECKING(for pthread_t)
1294 AC_TRY_COMPILE([#include <pthread.h>], [pthread_t x; x = *(pthread_t*)0;], have_pthread_t=yes)
1295 AC_MSG_RESULT($have_pthread_t)
1296 if test "$have_pthread_t" = yes ; then
1297 # AC_CHECK_SIZEOF() doesn't include <pthread.h>.
1298 AC_MSG_CHECKING(size of pthread_t)
1299 AC_CACHE_VAL(ac_cv_sizeof_pthread_t,
1300 [AC_TRY_RUN([#include <stdio.h>
1301 #include <pthread.h>
1304 FILE *f=fopen("conftestval", "w");
1306 fprintf(f, "%d\n", sizeof(pthread_t));
1309 ac_cv_sizeof_pthread_t=`cat conftestval`,
1310 ac_cv_sizeof_pthread_t=0,
1311 ac_cv_sizeof_pthread_t=4)
1313 AC_MSG_RESULT($ac_cv_sizeof_pthread_t)
1314 AC_DEFINE_UNQUOTED(SIZEOF_PTHREAD_T, $ac_cv_sizeof_pthread_t,
1315 [The number of bytes in a pthread_t.])
1319 AC_MSG_CHECKING(for --enable-toolbox-glue)
1320 AC_ARG_ENABLE(toolbox-glue,
1321 AC_HELP_STRING(--enable-toolbox-glue, disable/enable MacOSX glue code for extensions))
1323 if test -z "$enable_toolbox_glue"
1325 case $ac_sys_system/$ac_sys_release in
1327 enable_toolbox_glue="yes";;
1329 enable_toolbox_glue="no";;
1332 case "$enable_toolbox_glue" in
1334 extra_machdep_objs="Python/mactoolboxglue.o"
1335 extra_undefs="-u _PyMac_Error"
1336 AC_DEFINE(USE_TOOLBOX_OBJECT_GLUE, 1,
1337 [Define if you want to use MacPython modules on MacOSX in unix-Python.])
1340 extra_machdep_objs=""
1344 AC_MSG_RESULT($enable_toolbox_glue)
1346 AC_SUBST(OTHER_LIBTOOL_OPT)
1347 case $ac_sys_system/$ac_sys_release in
1348 Darwin/@<:@01567@:>@\..*)
1349 OTHER_LIBTOOL_OPT="-prebind -seg1addr 0x10000000"
1352 OTHER_LIBTOOL_OPT=""
1356 AC_SUBST(LIBTOOL_CRUFT)
1357 case $ac_sys_system/$ac_sys_release in
1358 Darwin/@<:@01567@:>@\..*)
1359 LIBTOOL_CRUFT="-framework System -lcc_dynamic"
1360 if test "${enable_universalsdk}"; then
1363 LIBTOOL_CRUFT="${LIBTOOL_CRUFT} -arch_only `arch`"
1365 LIBTOOL_CRUFT=$LIBTOOL_CRUFT' -install_name $(PYTHONFRAMEWORKINSTALLDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1366 LIBTOOL_CRUFT=$LIBTOOL_CRUFT' -compatibility_version $(VERSION) -current_version $(VERSION)';;
1368 gcc_version=`gcc -v 2>&1 | grep version | cut -d\ -f3`
1369 if test ${gcc_version} '<' 4.0
1371 LIBTOOL_CRUFT="-lcc_dynamic"
1375 LIBTOOL_CRUFT=$LIBTOOL_CRUFT" -lSystem -lSystemStubs -arch_only `arch`"
1376 LIBTOOL_CRUFT=$LIBTOOL_CRUFT' -install_name $(PYTHONFRAMEWORKINSTALLDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1377 LIBTOOL_CRUFT=$LIBTOOL_CRUFT' -compatibility_version $(VERSION) -current_version $(VERSION)';;
1380 AC_MSG_CHECKING(for --enable-framework)
1381 if test "$enable_framework"
1383 BASECFLAGS="$BASECFLAGS -fno-common -dynamic"
1384 # -F. is needed to allow linking to the framework while
1385 # in the build location.
1386 AC_DEFINE(WITH_NEXT_FRAMEWORK, 1,
1387 [Define if you want to produce an OpenStep/Rhapsody framework
1388 (shared library plus accessory files).])
1394 AC_MSG_CHECKING(for dyld)
1395 case $ac_sys_system/$ac_sys_release in
1397 AC_DEFINE(WITH_DYLD, 1,
1398 [Define if you want to use the new-style (Openstep, Rhapsody, MacOS)
1399 dynamic linker (dyld) instead of the old-style (NextStep) dynamic
1400 linker (rld). Dyld is necessary to support frameworks.])
1401 AC_MSG_RESULT(always on for Darwin)
1408 # Set info about shared libraries.
1413 AC_SUBST(LINKFORSHARED)
1414 # SO is the extension of shared libraries `(including the dot!)
1415 # -- usually .so, .sl on HP-UX, .dll on Cygwin
1419 case $ac_sys_system in
1430 # this might also be a termcap variable, see #610332
1432 echo '====================================================================='
1434 echo '+ WARNING: You have set SO in your environment. +'
1435 echo '+ Do you really mean to change the extension for shared libraries? +'
1436 echo '+ Continuing in 10 seconds to let you to ponder. +'
1438 echo '====================================================================='
1442 AC_DEFINE_UNQUOTED(SHLIB_EXT, "$SO", [Define this to be extension of shared libraries (including the dot!).])
1443 # LDSHARED is the ld *command* used to create shared library
1444 # -- "cc -G" on SunOS 5.x, "ld -shared" on IRIX 5
1445 # (Shared libraries in this instance are shared modules to be loaded into
1446 # Python, as opposed to building Python itself as a shared library.)
1447 AC_MSG_CHECKING(LDSHARED)
1448 if test -z "$LDSHARED"
1450 case $ac_sys_system/$ac_sys_release in
1452 BLDSHARED="\$(srcdir)/Modules/ld_so_aix \$(CC) -bI:Modules/python.exp"
1453 LDSHARED="\$(BINLIBDEST)/config/ld_so_aix \$(CC) -bI:\$(BINLIBDEST)/config/python.exp"
1456 BLDSHARED="\$(srcdir)/Modules/ld_so_beos $LDLIBRARY"
1457 LDSHARED="\$(BINLIBDEST)/config/ld_so_beos \$(LIBDIR)/$LDLIBRARY"
1459 IRIX/5*) LDSHARED="ld -shared";;
1460 IRIX*/6*) LDSHARED="ld ${SGI_ABI} -shared -all";;
1462 if test "$GCC" = "yes"
1463 then LDSHARED='$(CC) -shared'
1464 else LDSHARED='$(CC) -G';
1466 hp*|HP*) LDSHARED="ld -b";;
1467 OSF*) LDSHARED="ld -shared -expect_unresolved \"*\"";;
1469 LDSHARED='$(CC) $(LDFLAGS) -bundle'
1470 if test "$enable_framework" ; then
1471 # Link against the framework. All externals should be defined.
1472 BLDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1473 LDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKPREFIX)/$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1475 # No framework. Ignore undefined symbols, assuming they come from Python
1476 LDSHARED="$LDSHARED -undefined suppress"
1478 Darwin/1.4*|Darwin/5.*|Darwin/6.*)
1479 LDSHARED='$(CC) $(LDFLAGS) -bundle'
1480 if test "$enable_framework" ; then
1481 # Link against the framework. All externals should be defined.
1482 BLDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1483 LDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKPREFIX)/$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1485 # No framework, use the Python app as bundle-loader
1486 BLDSHARED="$LDSHARED "'-bundle_loader $(BUILDPYTHON)'
1487 LDSHARED="$LDSHARED "'-bundle_loader $(BINDIR)/python$(VERSION)$(EXE)'
1490 # Use -undefined dynamic_lookup whenever possible (10.3 and later).
1491 # This allows an extension to be used in any Python
1492 cur_target=`sw_vers -productVersion | sed 's/\(10\.[[0-9]]*\).*/\1/'`
1493 if test ${cur_target} '>' 10.2; then
1496 CONFIGURE_MACOSX_DEPLOYMENT_TARGET=${MACOSX_DEPLOYMENT_TARGET-${cur_target}}
1497 EXPORT_MACOSX_DEPLOYMENT_TARGET=''
1498 if test ${MACOSX_DEPLOYMENT_TARGET-${cur_target}} '>' 10.2
1500 if test "${enable_universalsdk}"; then
1501 LDFLAGS="-arch i386 -arch ppc -isysroot ${UNIVERSALSDK} ${LDFLAGS}"
1503 LDSHARED='$(CC) $(LDFLAGS) -bundle -undefined dynamic_lookup'
1504 BLDSHARED="$LDSHARED"
1506 LDSHARED='$(CC) $(LDFLAGS) -bundle'
1507 if test "$enable_framework" ; then
1508 # Link against the framework. All externals should be defined.
1509 BLDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1510 LDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKPREFIX)/$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1512 # No framework, use the Python app as bundle-loader
1513 BLDSHARED="$LDSHARED "'-bundle_loader $(BUILDPYTHON)'
1514 LDSHARED="$LDSHARED "'-bundle_loader $(BINDIR)/python$(VERSION)$(EXE)'
1518 Linux*|GNU*) LDSHARED='$(CC) -shared';;
1519 BSD/OS*/4*) LDSHARED="gcc -shared";;
1521 if [[ "`$CC -dM -E - </dev/null | grep __ELF__`" != "" ]]
1523 LDSHARED="$CC -shared ${LDFLAGS}"
1525 LDSHARED="ld -Bshareable ${LDFLAGS}"
1528 if [[ "`$CC -dM -E - </dev/null | grep __ELF__`" != "" ]]
1530 LDSHARED='$(CC) -shared $(CCSHARED) ${LDFLAGS}'
1533 [[01]].* | 2.[[0-7]] | 2.[[0-7]].*)
1534 LDSHARED="ld -Bshareable ${LDFLAGS}"
1537 LDSHARED='$(CC) -shared $(CCSHARED) ${LDFLAGS}'
1541 NetBSD*|DragonFly*) LDSHARED="cc -shared ${LDFLAGS}";;
1542 OpenUNIX*|UnixWare*)
1543 if test "$GCC" = "yes"
1544 then LDSHARED='$(CC) -shared'
1545 else LDSHARED='$(CC) -G'
1547 SCO_SV*) LDSHARED='$(CC) -Wl,-G,-Bexport';;
1548 Monterey*) LDSHARED="cc -G -dy -Bdynamic -Bexport -L/usr/lib/ia64l64";;
1549 CYGWIN*) LDSHARED="gcc -shared -Wl,--enable-auto-image-base";;
1550 atheos*) LDSHARED="gcc -shared";;
1554 AC_MSG_RESULT($LDSHARED)
1555 BLDSHARED=${BLDSHARED-$LDSHARED}
1556 # CCSHARED are the C *flags* used to create objects to go into a shared
1557 # library (module) -- this is only needed for a few systems
1558 AC_MSG_CHECKING(CCSHARED)
1559 if test -z "$CCSHARED"
1561 case $ac_sys_system/$ac_sys_release in
1562 SunOS*) if test "$GCC" = yes;
1563 then CCSHARED="-fPIC";
1564 else CCSHARED="-xcode=pic32";
1566 hp*|HP*) if test "$GCC" = yes;
1567 then CCSHARED="-fPIC";
1570 Linux*|GNU*) CCSHARED="-fPIC";;
1571 BSD/OS*/4*) CCSHARED="-fpic";;
1572 FreeBSD*|NetBSD*|OpenBSD*|DragonFly*) CCSHARED="-fPIC";;
1573 OpenUNIX*|UnixWare*)
1574 if test "$GCC" = "yes"
1575 then CCSHARED="-fPIC"
1576 else CCSHARED="-KPIC"
1579 if test "$GCC" = "yes"
1580 then CCSHARED="-fPIC"
1581 else CCSHARED="-Kpic -belf"
1583 Monterey*) CCSHARED="-G";;
1584 IRIX*/6*) case $CC in
1585 *gcc*) CCSHARED="-shared";;
1588 atheos*) CCSHARED="-fPIC";;
1591 AC_MSG_RESULT($CCSHARED)
1592 # LINKFORSHARED are the flags passed to the $(CC) command that links
1593 # the python executable -- this is only needed for a few systems
1594 AC_MSG_CHECKING(LINKFORSHARED)
1595 if test -z "$LINKFORSHARED"
1597 case $ac_sys_system/$ac_sys_release in
1598 AIX*) LINKFORSHARED='-Wl,-bE:Modules/python.exp -lld';;
1600 LINKFORSHARED="-Wl,-E -Wl,+s";;
1601 # LINKFORSHARED="-Wl,-E -Wl,+s -Wl,+b\$(BINLIBDEST)/lib-dynload";;
1602 BSD/OS/4*) LINKFORSHARED="-Xlinker -export-dynamic";;
1603 Linux*|GNU*) LINKFORSHARED="-Xlinker -export-dynamic";;
1604 # -u libsys_s pulls in all symbols in libsys
1606 # -u _PyMac_Error is needed to pull in the mac toolbox glue,
1608 # not used by the core itself but which needs to be in the core so
1609 # that dynamically loaded extension modules have access to it.
1610 # -prebind is no longer used, because it actually seems to give a
1611 # slowdown in stead of a speedup, maybe due to the large number of
1612 # dynamic loads Python does.
1614 LINKFORSHARED="$extra_undefs"
1615 if test "$enable_framework"
1617 LINKFORSHARED="$LINKFORSHARED "'$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1619 LINKFORSHARED="$LINKFORSHARED";;
1620 OpenUNIX*|UnixWare*) LINKFORSHARED="-Wl,-Bexport";;
1621 SCO_SV*) LINKFORSHARED="-Wl,-Bexport";;
1622 ReliantUNIX*) LINKFORSHARED="-W1 -Blargedynsym";;
1623 FreeBSD*|NetBSD*|OpenBSD*|DragonFly*)
1624 if [[ "`$CC -dM -E - </dev/null | grep __ELF__`" != "" ]]
1626 LINKFORSHARED="-Wl,--export-dynamic"
1628 SunOS/5*) case $CC in
1630 if $CC -Xlinker --help 2>&1 | grep export-dynamic >/dev/null
1632 LINKFORSHARED="-Xlinker --export-dynamic"
1636 if test $enable_shared = "no"
1638 LINKFORSHARED='-Wl,--out-implib=$(LDLIBRARY)'
1642 AC_MSG_RESULT($LINKFORSHARED)
1644 AC_SUBST(CFLAGSFORSHARED)
1645 AC_MSG_CHECKING(CFLAGSFORSHARED)
1646 if test ! "$LIBRARY" = "$LDLIBRARY"
1648 case $ac_sys_system in
1650 # Cygwin needs CCSHARED when building extension DLLs
1651 # but not when building the interpreter DLL.
1652 CFLAGSFORSHARED='';;
1654 CFLAGSFORSHARED='$(CCSHARED)'
1657 AC_MSG_RESULT($CFLAGSFORSHARED)
1659 # SHLIBS are libraries (except -lc and -lm) to link to the python shared
1660 # library (with --enable-shared).
1661 # For platforms on which shared libraries are not allowed to have unresolved
1662 # symbols, this must be set to $(LIBS) (expanded by make). We do this even
1663 # if it is not required, since it creates a dependency of the shared library
1664 # to LIBS. This, in turn, means that applications linking the shared libpython
1665 # don't need to link LIBS explicitly. The default should be only changed
1666 # on systems where this approach causes problems.
1668 AC_MSG_CHECKING(SHLIBS)
1669 case "$ac_sys_system" in
1673 AC_MSG_RESULT($SHLIBS)
1676 # checks for libraries
1677 AC_CHECK_LIB(dl, dlopen) # Dynamic linking for SunOS/Solaris and SYSV
1678 AC_CHECK_LIB(dld, shl_load) # Dynamic linking for HP-UX
1680 # only check for sem_ini if thread support is requested
1681 if test "$with_threads" = "yes" -o -z "$with_threads"; then
1682 AC_SEARCH_LIBS(sem_init, pthread rt posix4) # 'Real Time' functions on Solaris
1683 # posix4 on Solaris 2.6
1684 # pthread (first!) on Linux
1687 # check if we need libintl for locale functions
1688 AC_CHECK_LIB(intl, textdomain,
1689 AC_DEFINE(WITH_LIBINTL, 1,
1690 [Define to 1 if libintl is needed for locale functions.]))
1692 # checks for system dependent C++ extensions support
1693 case "$ac_sys_system" in
1694 AIX*) AC_MSG_CHECKING(for genuine AIX C++ extensions support)
1695 AC_TRY_LINK([#include "/usr/lpp/xlC/include/load.h"],
1696 [loadAndInit("", 0, "")],
1697 [AC_DEFINE(AIX_GENUINE_CPLUSPLUS, 1,
1698 [Define for AIX if your compiler is a genuine IBM xlC/xlC_r
1699 and you want support for AIX C++ shared extension modules.])
1700 AC_MSG_RESULT(yes)],
1701 [AC_MSG_RESULT(no)]);;
1705 # Most SVR4 platforms (e.g. Solaris) need -lsocket and -lnsl.
1706 # BeOS' sockets are stashed in libnet.
1707 AC_CHECK_LIB(nsl, t_open, [LIBS="-lnsl $LIBS"]) # SVR4
1708 AC_CHECK_LIB(socket, socket, [LIBS="-lsocket $LIBS"], [], $LIBS) # SVR4 sockets
1710 case "$ac_sys_system" in
1712 AC_CHECK_LIB(net, socket, [LIBS="-lnet $LIBS"], [], $LIBS) # BeOS
1716 AC_MSG_CHECKING(for --with-libs)
1718 AC_HELP_STRING(--with-libs='lib1 ...', link against additional libs),
1720 AC_MSG_RESULT($withval)
1721 LIBS="$withval $LIBS"
1723 [AC_MSG_RESULT(no)])
1725 # Check for use of the system libffi library
1726 AC_MSG_CHECKING(for --with-system-ffi)
1727 AC_ARG_WITH(system_ffi,
1728 AC_HELP_STRING(--with-system-ffi, build _ctypes module using an installed ffi library))
1730 if test -z "$with_system_ffi"
1731 then with_system_ffi="no"
1733 AC_MSG_RESULT($with_system_ffi)
1735 # Determine if signalmodule should be used.
1736 AC_SUBST(USE_SIGNAL_MODULE)
1737 AC_SUBST(SIGNAL_OBJS)
1738 AC_MSG_CHECKING(for --with-signal-module)
1739 AC_ARG_WITH(signal-module,
1740 AC_HELP_STRING(--with-signal-module, disable/enable signal module))
1742 if test -z "$with_signal_module"
1743 then with_signal_module="yes"
1745 AC_MSG_RESULT($with_signal_module)
1747 if test "${with_signal_module}" = "yes"; then
1748 USE_SIGNAL_MODULE=""
1751 USE_SIGNAL_MODULE="#"
1752 SIGNAL_OBJS="Parser/intrcheck.o Python/sigcheck.o"
1755 # This is used to generate Setup.config
1756 AC_SUBST(USE_THREAD_MODULE)
1757 USE_THREAD_MODULE=""
1759 AC_MSG_CHECKING(for --with-dec-threads)
1761 AC_ARG_WITH(dec-threads,
1762 AC_HELP_STRING(--with-dec-threads, use DEC Alpha/OSF1 thread-safe libraries),
1764 AC_MSG_RESULT($withval)
1766 if test "${with_thread+set}" != set; then
1767 with_thread="$withval";
1769 [AC_MSG_RESULT(no)])
1771 # Templates for things AC_DEFINEd more than once.
1772 # For a single AC_DEFINE, no template is needed.
1773 AH_TEMPLATE(C_THREADS,[Define if you have the Mach cthreads package])
1774 AH_TEMPLATE(_REENTRANT,
1775 [Define to force use of thread-safe errno, h_errno, and other functions])
1776 AH_TEMPLATE(WITH_THREAD,
1777 [Define if you want to compile in rudimentary thread support])
1779 AC_MSG_CHECKING(for --with-threads)
1780 dnl quadrigraphs "@<:@" and "@:>@" produce "[" and "]" in the output
1781 AC_ARG_WITH(threads,
1782 AC_HELP_STRING(--with(out)-threads@<:@=DIRECTORY@:>@, disable/enable thread support))
1784 # --with-thread is deprecated, but check for it anyway
1785 dnl quadrigraphs "@<:@" and "@:>@" produce "[" and "]" in the output
1787 AC_HELP_STRING(--with(out)-thread@<:@=DIRECTORY@:>@, deprecated; use --with(out)-threads),
1788 [with_threads=$with_thread])
1790 if test -z "$with_threads"
1791 then with_threads="yes"
1793 AC_MSG_RESULT($with_threads)
1796 if test "$with_threads" = "no"
1798 USE_THREAD_MODULE="#"
1799 elif test "$ac_cv_pthread_is_default" = yes
1801 AC_DEFINE(WITH_THREAD)
1802 # Defining _REENTRANT on system with POSIX threads should not hurt.
1803 AC_DEFINE(_REENTRANT)
1805 THREADOBJ="Python/thread.o"
1806 elif test "$ac_cv_kpthread" = "yes"
1809 if test "$ac_cv_cxx_thread" = "yes"; then
1810 CXX="$CXX -Kpthread"
1812 AC_DEFINE(WITH_THREAD)
1814 THREADOBJ="Python/thread.o"
1815 elif test "$ac_cv_kthread" = "yes"
1818 if test "$ac_cv_cxx_thread" = "yes"; then
1821 AC_DEFINE(WITH_THREAD)
1823 THREADOBJ="Python/thread.o"
1824 elif test "$ac_cv_pthread" = "yes"
1827 if test "$ac_cv_cxx_thread" = "yes"; then
1830 AC_DEFINE(WITH_THREAD)
1832 THREADOBJ="Python/thread.o"
1834 if test ! -z "$with_threads" -a -d "$with_threads"
1835 then LDFLAGS="$LDFLAGS -L$with_threads"
1837 if test ! -z "$withval" -a -d "$withval"
1838 then LDFLAGS="$LDFLAGS -L$withval"
1841 # According to the POSIX spec, a pthreads implementation must
1842 # define _POSIX_THREADS in unistd.h. Some apparently don't
1843 # (e.g. gnu pth with pthread emulation)
1844 AC_MSG_CHECKING(for _POSIX_THREADS in unistd.h)
1848 #ifdef _POSIX_THREADS
1851 ], unistd_defines_pthreads=yes, unistd_defines_pthreads=no)
1852 AC_MSG_RESULT($unistd_defines_pthreads)
1854 AC_DEFINE(_REENTRANT)
1855 AC_CHECK_HEADER(cthreads.h, [AC_DEFINE(WITH_THREAD)
1856 AC_DEFINE(C_THREADS)
1857 AC_DEFINE(HURD_C_THREADS, 1,
1858 [Define if you are using Mach cthreads directly under /include])
1859 LIBS="$LIBS -lthreads"
1860 THREADOBJ="Python/thread.o"],[
1861 AC_CHECK_HEADER(mach/cthreads.h, [AC_DEFINE(WITH_THREAD)
1862 AC_DEFINE(C_THREADS)
1863 AC_DEFINE(MACH_C_THREADS, 1,
1864 [Define if you are using Mach cthreads under mach /])
1865 THREADOBJ="Python/thread.o"],[
1866 AC_MSG_CHECKING(for --with-pth)
1868 AC_HELP_STRING(--with-pth, use GNU pth threading libraries),
1869 [AC_MSG_RESULT($withval)
1870 AC_DEFINE([WITH_THREAD])
1871 AC_DEFINE([HAVE_PTH], 1,
1872 [Define if you have GNU PTH threads.])
1874 THREADOBJ="Python/thread.o"],
1877 # Just looking for pthread_create in libpthread is not enough:
1878 # on HP/UX, pthread.h renames pthread_create to a different symbol name.
1879 # So we really have to include pthread.h, and then link.
1881 LIBS="$LIBS -lpthread"
1882 AC_MSG_CHECKING([for pthread_create in -lpthread])
1883 AC_TRY_LINK([#include <pthread.h>
1885 void * start_routine (void *arg) { exit (0); }], [
1886 pthread_create (NULL, NULL, start_routine, NULL)], [
1888 AC_DEFINE(WITH_THREAD)
1890 THREADOBJ="Python/thread.o"],[
1892 AC_CHECK_FUNC(pthread_detach, [AC_DEFINE(WITH_THREAD)
1894 THREADOBJ="Python/thread.o"],[
1895 AC_CHECK_HEADER(atheos/threads.h, [AC_DEFINE(WITH_THREAD)
1896 AC_DEFINE(ATHEOS_THREADS, 1,
1897 [Define this if you have AtheOS threads.])
1898 THREADOBJ="Python/thread.o"],[
1899 AC_CHECK_HEADER(kernel/OS.h, [AC_DEFINE(WITH_THREAD)
1900 AC_DEFINE(BEOS_THREADS, 1,
1901 [Define this if you have BeOS threads.])
1902 THREADOBJ="Python/thread.o"],[
1903 AC_CHECK_LIB(pthreads, pthread_create, [AC_DEFINE(WITH_THREAD)
1905 LIBS="$LIBS -lpthreads"
1906 THREADOBJ="Python/thread.o"], [
1907 AC_CHECK_LIB(c_r, pthread_create, [AC_DEFINE(WITH_THREAD)
1910 THREADOBJ="Python/thread.o"], [
1911 AC_CHECK_LIB(pthread, __pthread_create_system, [AC_DEFINE(WITH_THREAD)
1913 LIBS="$LIBS -lpthread"
1914 THREADOBJ="Python/thread.o"], [
1915 AC_CHECK_LIB(cma, pthread_create, [AC_DEFINE(WITH_THREAD)
1918 THREADOBJ="Python/thread.o"],[
1919 USE_THREAD_MODULE="#"])
1920 ])])])])])])])])])])
1922 AC_CHECK_LIB(mpc, usconfig, [AC_DEFINE(WITH_THREAD)
1924 THREADOBJ="Python/thread.o"
1925 USE_THREAD_MODULE=""])
1927 if test "$posix_threads" != "yes"; then
1928 AC_CHECK_LIB(thread, thr_create, [AC_DEFINE(WITH_THREAD)
1929 LIBS="$LIBS -lthread"
1930 THREADOBJ="Python/thread.o"
1931 USE_THREAD_MODULE=""])
1934 if test "$USE_THREAD_MODULE" != "#"
1936 # If the above checks didn't disable threads, (at least) OSF1
1937 # needs this '-threads' argument during linking.
1938 case $ac_sys_system in
1939 OSF1) LDLAST=-threads;;
1944 if test "$posix_threads" = "yes"; then
1945 if test "$unistd_defines_pthreads" = "no"; then
1946 AC_DEFINE(_POSIX_THREADS, 1,
1947 [Define if you have POSIX threads,
1948 and your system does not define that.])
1951 # Bug 662787: Using semaphores causes unexplicable hangs on Solaris 8.
1952 case $ac_sys_system/$ac_sys_release in
1953 SunOS/5.6) AC_DEFINE(HAVE_PTHREAD_DESTRUCTOR, 1,
1954 Defined for Solaris 2.6 bug in pthread header.)
1956 SunOS/5.8) AC_DEFINE(HAVE_BROKEN_POSIX_SEMAPHORES, 1,
1957 Define if the Posix semaphores do not work on your system)
1961 AC_MSG_CHECKING(if PTHREAD_SCOPE_SYSTEM is supported)
1962 AC_CACHE_VAL(ac_cv_pthread_system_supported,
1963 [AC_TRY_RUN([#include <pthread.h>
1964 void *foo(void *parm) {
1968 pthread_attr_t attr;
1970 if (pthread_attr_init(&attr)) exit(-1);
1971 if (pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM)) exit(-1);
1972 if (pthread_create(&id, &attr, foo, NULL)) exit(-1);
1975 ac_cv_pthread_system_supported=yes,
1976 ac_cv_pthread_system_supported=no,
1977 ac_cv_pthread_system_supported=no)
1979 AC_MSG_RESULT($ac_cv_pthread_system_supported)
1980 if test "$ac_cv_pthread_system_supported" = "yes"; then
1981 AC_DEFINE(PTHREAD_SYSTEM_SCHED_SUPPORTED, 1, [Defined if PTHREAD_SCOPE_SYSTEM supported.])
1983 AC_CHECK_FUNCS(pthread_sigmask,
1984 [case $ac_sys_system in
1986 AC_DEFINE(HAVE_BROKEN_PTHREAD_SIGMASK, 1,
1987 [Define if pthread_sigmask() does not work on your system.])
1993 # Check for enable-ipv6
1994 AH_TEMPLATE(ENABLE_IPV6, [Define if --enable-ipv6 is specified])
1995 AC_MSG_CHECKING([if --enable-ipv6 is specified])
1997 [ --enable-ipv6 Enable ipv6 (with ipv4) support
1998 --disable-ipv6 Disable ipv6 support],
1999 [ case "$enableval" in
2004 *) AC_MSG_RESULT(yes)
2005 AC_DEFINE(ENABLE_IPV6)
2011 dnl the check does not work on cross compilation case...
2012 AC_TRY_RUN([ /* AF_INET6 available check */
2013 #include <sys/types.h>
2014 #include <sys/socket.h>
2017 if (socket(AF_INET6, SOCK_STREAM, 0) < 0)
2031 if test "$ipv6" = "yes"; then
2032 AC_MSG_CHECKING(if RFC2553 API is available)
2033 AC_TRY_COMPILE([#include <sys/types.h>
2034 #include <netinet/in.h>],
2035 [struct sockaddr_in6 x;
2039 AC_MSG_RESULT(no, IPv6 disabled)
2043 if test "$ipv6" = "yes"; then
2044 AC_DEFINE(ENABLE_IPV6)
2052 if test "$ipv6" = "yes"; then
2053 AC_MSG_CHECKING([ipv6 stack type])
2054 for i in inria kame linux-glibc linux-inet6 solaris toshiba v6d zeta;
2058 dnl http://www.kame.net/
2060 #include <netinet/in.h>
2061 #ifdef IPV6_INRIA_VERSION
2067 dnl http://www.kame.net/
2069 #include <netinet/in.h>
2075 ipv6libdir=/usr/local/v6/lib
2079 dnl http://www.v6.linux.or.jp/
2081 #include <features.h>
2082 #if defined(__GLIBC__) && ((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 1) || (__GLIBC__ > 2))
2089 dnl http://www.v6.linux.or.jp/
2090 if test -d /usr/inet6; then
2093 ipv6libdir=/usr/inet6/lib
2094 BASECFLAGS="-I/usr/inet6/include $BASECFLAGS"
2098 if test -f /etc/netconfig; then
2099 if /usr/xpg4/bin/grep -q tcp6 /etc/netconfig; then
2107 #include <sys/param.h>
2108 #ifdef _TOSHIBA_INET6
2113 ipv6libdir=/usr/local/v6/lib])
2117 #include </usr/local/v6/include/sys/v6config.h>
2123 ipv6libdir=/usr/local/v6/lib;
2124 BASECFLAGS="-I/usr/local/v6/include $BASECFLAGS"])
2128 #include <sys/param.h>
2129 #ifdef _ZETA_MINAMI_INET6
2134 ipv6libdir=/usr/local/v6/lib])
2137 if test "$ipv6type" != "unknown"; then
2141 AC_MSG_RESULT($ipv6type)
2144 if test "$ipv6" = "yes" -a "$ipv6lib" != "none"; then
2145 if test -d $ipv6libdir -a -f $ipv6libdir/lib$ipv6lib.a; then
2146 LIBS="-L$ipv6libdir -l$ipv6lib $LIBS"
2147 echo "using lib$ipv6lib"
2149 if test $ipv6trylibc = "yes"; then
2152 echo 'Fatal: no $ipv6lib library found. cannot continue.'
2153 echo "You need to fetch lib$ipv6lib.a from appropriate"
2154 echo 'ipv6 kit and compile beforehand.'
2160 # Check for --with-doc-strings
2161 AC_MSG_CHECKING(for --with-doc-strings)
2162 AC_ARG_WITH(doc-strings,
2163 AC_HELP_STRING(--with(out)-doc-strings, disable/enable documentation strings))
2165 if test -z "$with_doc_strings"
2166 then with_doc_strings="yes"
2168 if test "$with_doc_strings" != "no"
2170 AC_DEFINE(WITH_DOC_STRINGS, 1,
2171 [Define if you want documentation strings in extension modules])
2173 AC_MSG_RESULT($with_doc_strings)
2175 # Check for Python-specific malloc support
2176 AC_MSG_CHECKING(for --with-tsc)
2178 [ --with(out)-tsc enable/disable timestamp counter profile], [
2179 if test "$withval" != no
2181 AC_DEFINE(WITH_TSC, 1,
2182 [Define to profile with the Pentium timestamp counter])
2184 else AC_MSG_RESULT(no)
2186 [AC_MSG_RESULT(no)])
2188 # Check for Python-specific malloc support
2189 AC_MSG_CHECKING(for --with-pymalloc)
2190 AC_ARG_WITH(pymalloc,
2191 AC_HELP_STRING(--with(out)-pymalloc, disable/enable specialized mallocs))
2193 if test -z "$with_pymalloc"
2194 then with_pymalloc="yes"
2196 if test "$with_pymalloc" != "no"
2198 AC_DEFINE(WITH_PYMALLOC, 1,
2199 [Define if you want to compile in Python-specific mallocs])
2201 AC_MSG_RESULT($with_pymalloc)
2203 # Check for --with-wctype-functions
2204 AC_MSG_CHECKING(for --with-wctype-functions)
2205 AC_ARG_WITH(wctype-functions,
2206 AC_HELP_STRING(--with-wctype-functions, use wctype.h functions),
2208 if test "$withval" != no
2210 AC_DEFINE(WANT_WCTYPE_FUNCTIONS, 1,
2211 [Define if you want wctype.h functions to be used instead of the
2212 one supplied by Python itself. (see Include/unicodectype.h).])
2214 else AC_MSG_RESULT(no)
2216 [AC_MSG_RESULT(no)])
2218 # -I${DLINCLDIR} is added to the compile rule for importdl.o
2222 # the dlopen() function means we might want to use dynload_shlib.o. some
2223 # platforms, such as AIX, have dlopen(), but don't want to use it.
2224 AC_CHECK_FUNCS(dlopen)
2226 # DYNLOADFILE specifies which dynload_*.o file we will use for dynamic
2227 # loading of modules.
2228 AC_SUBST(DYNLOADFILE)
2229 AC_MSG_CHECKING(DYNLOADFILE)
2230 if test -z "$DYNLOADFILE"
2232 case $ac_sys_system/$ac_sys_release in
2233 AIX*) # Use dynload_shlib.c and dlopen() if we have it; otherwise dynload_aix.c
2234 if test "$ac_cv_func_dlopen" = yes
2235 then DYNLOADFILE="dynload_shlib.o"
2236 else DYNLOADFILE="dynload_aix.o"
2239 BeOS*) DYNLOADFILE="dynload_beos.o";;
2240 hp*|HP*) DYNLOADFILE="dynload_hpux.o";;
2241 # Use dynload_next.c only on 10.2 and below, which don't have native dlopen()
2242 Darwin/@<:@0156@:>@\..*) DYNLOADFILE="dynload_next.o";;
2243 atheos*) DYNLOADFILE="dynload_atheos.o";;
2245 # use dynload_shlib.c and dlopen() if we have it; otherwise stub
2246 # out any dynamic loading
2247 if test "$ac_cv_func_dlopen" = yes
2248 then DYNLOADFILE="dynload_shlib.o"
2249 else DYNLOADFILE="dynload_stub.o"
2254 AC_MSG_RESULT($DYNLOADFILE)
2255 if test "$DYNLOADFILE" != "dynload_stub.o"
2257 AC_DEFINE(HAVE_DYNAMIC_LOADING, 1,
2258 [Defined when any dynamic module loading is enabled.])
2261 # MACHDEP_OBJS can be set to platform-specific object files needed by Python
2263 AC_SUBST(MACHDEP_OBJS)
2264 AC_MSG_CHECKING(MACHDEP_OBJS)
2265 if test -z "$MACHDEP_OBJS"
2267 MACHDEP_OBJS=$extra_machdep_objs
2269 MACHDEP_OBJS="$MACHDEP_OBJS $extra_machdep_objs"
2271 AC_MSG_RESULT(MACHDEP_OBJS)
2273 # checks for library functions
2274 AC_CHECK_FUNCS(alarm bind_textdomain_codeset chown clock confstr ctermid \
2275 execv fork fpathconf ftime ftruncate \
2276 gai_strerror getgroups getlogin getloadavg getpeername getpgid getpid \
2277 getpriority getpwent getspnam getspent getsid getwd \
2278 kill killpg lchown lstat mkfifo mknod mktime \
2279 mremap nice pathconf pause plock poll pthread_init \
2280 putenv readlink realpath \
2281 select setegid seteuid setgid \
2282 setlocale setregid setreuid setsid setpgid setpgrp setuid setvbuf snprintf \
2283 sigaction siginterrupt sigrelse strftime \
2284 sysconf tcgetpgrp tcsetpgrp tempnam timegm times tmpfile tmpnam tmpnam_r \
2285 truncate uname unsetenv utimes waitpid wait3 wait4 wcscoll _getpty)
2287 # For some functions, having a definition is not sufficient, since
2288 # we want to take their address.
2289 AC_MSG_CHECKING(for chroot)
2290 AC_TRY_COMPILE([#include <unistd.h>], void *x=chroot,
2291 AC_DEFINE(HAVE_CHROOT, 1, Define if you have the 'chroot' function.)
2295 AC_MSG_CHECKING(for link)
2296 AC_TRY_COMPILE([#include <unistd.h>], void *x=link,
2297 AC_DEFINE(HAVE_LINK, 1, Define if you have the 'link' function.)
2301 AC_MSG_CHECKING(for symlink)
2302 AC_TRY_COMPILE([#include <unistd.h>], void *x=symlink,
2303 AC_DEFINE(HAVE_SYMLINK, 1, Define if you have the 'symlink' function.)
2307 AC_MSG_CHECKING(for fchdir)
2308 AC_TRY_COMPILE([#include <unistd.h>], void *x=fchdir,
2309 AC_DEFINE(HAVE_FCHDIR, 1, Define if you have the 'fchdir' function.)
2313 AC_MSG_CHECKING(for fsync)
2314 AC_TRY_COMPILE([#include <unistd.h>], void *x=fsync,
2315 AC_DEFINE(HAVE_FSYNC, 1, Define if you have the 'fsync' function.)
2319 AC_MSG_CHECKING(for fdatasync)
2320 AC_TRY_COMPILE([#include <unistd.h>], void *x=fdatasync,
2321 AC_DEFINE(HAVE_FDATASYNC, 1, Define if you have the 'fdatasync' function.)
2326 # On some systems (eg. FreeBSD 5), we would find a definition of the
2327 # functions ctermid_r, setgroups in the library, but no prototype
2328 # (e.g. because we use _XOPEN_SOURCE). See whether we can take their
2329 # address to avoid compiler warnings and potential miscompilations
2330 # because of the missing prototypes.
2332 AC_MSG_CHECKING(for ctermid_r)
2334 #include "confdefs.h"
2336 ], void* p = ctermid_r,
2337 AC_DEFINE(HAVE_CTERMID_R, 1, Define if you have the 'ctermid_r' function.)
2342 AC_MSG_CHECKING(for flock)
2344 #include "confdefs.h"
2345 #include <sys/file.h>
2347 AC_DEFINE(HAVE_FLOCK, 1, Define if you have the 'flock' function.)
2352 AC_MSG_CHECKING(for getpagesize)
2354 #include "confdefs.h"
2356 ], void* p = getpagesize,
2357 AC_DEFINE(HAVE_GETPAGESIZE, 1, Define if you have the 'getpagesize' function.)
2363 AC_CHECK_PROGS(TRUE, true, /bin/true)
2365 dnl On some systems (e.g. Solaris 9), hstrerror and inet_aton are in -lresolv
2366 dnl On others, they are in the C library, so we to take no action
2367 AC_CHECK_LIB(c, inet_aton, [$ac_cv_prog_TRUE],
2368 AC_CHECK_LIB(resolv, inet_aton)
2371 dnl Check if system zlib has *Copy() functions
2373 dnl On MacOSX the linker will search for dylibs on the entire linker path
2374 dnl before searching for static libraries. setup.py adds -Wl,-search_paths_first
2375 dnl to revert to a more traditional unix behaviour and make it possible to
2376 dnl override the system libz with a local static library of libz. Temporarily
2377 dnl add that flag to our CFLAGS as well to ensure that we check the version
2378 dnl of libz that will be used by setup.py.
2379 dnl The -L/usr/local/lib is needed as wel to get the same compilation
2380 dnl environment as setup.py (and leaving it out can cause configure to use the
2381 dnl wrong version of the library)
2382 case $ac_sys_system/$ac_sys_release in
2384 _CUR_CFLAGS="${CFLAGS}"
2385 _CUR_LDFLAGS="${LDFLAGS}"
2386 CFLAGS="${CFLAGS} -Wl,-search_paths_first"
2387 LDFLAGS="${LDFLAGS} -Wl,-search_paths_first -L/usr/local/lib"
2391 AC_CHECK_LIB(z, inflateCopy, AC_DEFINE(HAVE_ZLIB_COPY, 1, Define if the zlib library has inflateCopy))
2393 case $ac_sys_system/$ac_sys_release in
2395 CFLAGS="${_CUR_CFLAGS}"
2396 LDFLAGS="${_CUR_LDFLAGS}"
2400 AC_MSG_CHECKING(for hstrerror)
2402 #include "confdefs.h"
2404 ], void* p = hstrerror; hstrerror(0),
2405 AC_DEFINE(HAVE_HSTRERROR, 1, Define if you have the 'hstrerror' function.)
2410 AC_MSG_CHECKING(for inet_aton)
2412 #include "confdefs.h"
2413 #include <sys/types.h>
2414 #include <sys/socket.h>
2415 #include <netinet/in.h>
2416 #include <arpa/inet.h>
2417 ], void* p = inet_aton;inet_aton(0,0),
2418 AC_DEFINE(HAVE_INET_ATON, 1, Define if you have the 'inet_aton' function.)
2423 AC_MSG_CHECKING(for inet_pton)
2425 #include "confdefs.h"
2426 #include <sys/types.h>
2427 #include <sys/socket.h>
2428 #include <netinet/in.h>
2429 #include <arpa/inet.h>
2430 ], void* p = inet_pton,
2431 AC_DEFINE(HAVE_INET_PTON, 1, Define if you have the 'inet_pton' function.)
2436 # On some systems, setgroups is in unistd.h, on others, in grp.h
2437 AC_MSG_CHECKING(for setgroups)
2439 #include "confdefs.h"
2445 void* p = setgroups,
2446 AC_DEFINE(HAVE_SETGROUPS, 1, Define if you have the 'setgroups' function.)
2451 # check for openpty and forkpty
2453 AC_CHECK_FUNCS(openpty,,
2454 AC_CHECK_LIB(util,openpty,
2455 [AC_DEFINE(HAVE_OPENPTY) LIBS="$LIBS -lutil"],
2456 AC_CHECK_LIB(bsd,openpty, [AC_DEFINE(HAVE_OPENPTY) LIBS="$LIBS -lbsd"])
2459 AC_CHECK_FUNCS(forkpty,,
2460 AC_CHECK_LIB(util,forkpty,
2461 [AC_DEFINE(HAVE_FORKPTY) LIBS="$LIBS -lutil"],
2462 AC_CHECK_LIB(bsd,forkpty, [AC_DEFINE(HAVE_FORKPTY) LIBS="$LIBS -lbsd"])
2466 # check for long file support functions
2467 AC_CHECK_FUNCS(fseek64 fseeko fstatvfs ftell64 ftello statvfs)
2469 AC_REPLACE_FUNCS(dup2 getcwd strdup strerror memmove)
2470 AC_CHECK_FUNCS(getpgrp,
2471 AC_TRY_COMPILE([#include <unistd.h>],
2473 AC_DEFINE(GETPGRP_HAVE_ARG, 1,
2474 [Define if getpgrp() must be called as getpgrp(0).])
2477 AC_CHECK_FUNCS(setpgrp,
2478 AC_TRY_COMPILE([#include <unistd.h>],
2480 AC_DEFINE(SETPGRP_HAVE_ARG, 1,
2481 [Define if setpgrp() must be called as setpgrp(0, 0).])
2484 AC_CHECK_FUNCS(gettimeofday,
2485 AC_TRY_COMPILE([#include <sys/time.h>],
2486 [gettimeofday((struct timeval*)0,(struct timezone*)0);], ,
2487 AC_DEFINE(GETTIMEOFDAY_NO_TZ, 1,
2488 [Define if gettimeofday() does not have second (timezone) argument
2489 This is the case on Motorola V4 (R40V4.2)])
2493 AC_MSG_CHECKING(for major, minor, and makedev)
2495 #if defined(MAJOR_IN_MKDEV)
2496 #include <sys/mkdev.h>
2497 #elif defined(MAJOR_IN_SYSMACROS)
2498 #include <sys/sysmacros.h>
2500 #include <sys/types.h>
2503 makedev(major(0),minor(0));
2505 AC_DEFINE(HAVE_DEVICE_MACROS, 1,
2506 [Define to 1 if you have the device macros.])
2512 # On OSF/1 V5.1, getaddrinfo is available, but a define
2513 # for [no]getaddrinfo in netdb.h.
2514 AC_MSG_CHECKING(for getaddrinfo)
2516 #include <sys/types.h>
2517 #include <sys/socket.h>
2521 getaddrinfo(NULL, NULL, NULL, NULL);
2524 AC_MSG_CHECKING(getaddrinfo bug)
2526 #include <sys/types.h>
2529 #include <sys/socket.h>
2530 #include <netinet/in.h>
2534 int passive, gaierr, inet4 = 0, inet6 = 0;
2535 struct addrinfo hints, *ai, *aitop;
2536 char straddr[INET6_ADDRSTRLEN], strport[16];
2538 for (passive = 0; passive <= 1; passive++) {
2539 memset(&hints, 0, sizeof(hints));
2540 hints.ai_family = AF_UNSPEC;
2541 hints.ai_flags = passive ? AI_PASSIVE : 0;
2542 hints.ai_socktype = SOCK_STREAM;
2543 hints.ai_protocol = IPPROTO_TCP;
2544 if ((gaierr = getaddrinfo(NULL, "54321", &hints, &aitop)) != 0) {
2545 (void)gai_strerror(gaierr);
2548 for (ai = aitop; ai; ai = ai->ai_next) {
2549 if (ai->ai_addr == NULL ||
2550 ai->ai_addrlen == 0 ||
2551 getnameinfo(ai->ai_addr, ai->ai_addrlen,
2552 straddr, sizeof(straddr), strport, sizeof(strport),
2553 NI_NUMERICHOST|NI_NUMERICSERV) != 0) {
2556 switch (ai->ai_family) {
2558 if (strcmp(strport, "54321") != 0) {
2562 if (strcmp(straddr, "0.0.0.0") != 0) {
2566 if (strcmp(straddr, "127.0.0.1") != 0) {
2573 if (strcmp(strport, "54321") != 0) {
2577 if (strcmp(straddr, "::") != 0) {
2581 if (strcmp(straddr, "::1") != 0) {
2591 /* another family support? */
2597 if (!(inet4 == 0 || inet4 == 2))
2599 if (!(inet6 == 0 || inet6 == 2))
2603 freeaddrinfo(aitop);
2608 freeaddrinfo(aitop);
2613 buggygetaddrinfo=no,
2614 AC_MSG_RESULT(buggy)
2615 buggygetaddrinfo=yes,
2616 AC_MSG_RESULT(buggy)
2617 buggygetaddrinfo=yes)], [
2619 buggygetaddrinfo=yes
2622 if test "$buggygetaddrinfo" = "yes"; then
2623 if test "$ipv6" = "yes"; then
2624 echo 'Fatal: You must get working getaddrinfo() function.'
2625 echo ' or you can specify "--disable-ipv6"'.
2629 AC_DEFINE(HAVE_GETADDRINFO, 1, [Define if you have the getaddrinfo function.])
2631 AC_CHECK_FUNCS(getnameinfo)
2633 # checks for structures
2637 AC_CHECK_MEMBERS([struct stat.st_rdev])
2638 AC_CHECK_MEMBERS([struct stat.st_blksize])
2639 AC_CHECK_MEMBERS([struct stat.st_flags])
2640 AC_CHECK_MEMBERS([struct stat.st_gen])
2641 AC_CHECK_MEMBERS([struct stat.st_birthtime])
2644 AC_MSG_CHECKING(for time.h that defines altzone)
2645 AC_CACHE_VAL(ac_cv_header_time_altzone,
2646 [AC_TRY_COMPILE([#include <time.h>], [return altzone;],
2647 ac_cv_header_time_altzone=yes,
2648 ac_cv_header_time_altzone=no)])
2649 AC_MSG_RESULT($ac_cv_header_time_altzone)
2650 if test $ac_cv_header_time_altzone = yes; then
2651 AC_DEFINE(HAVE_ALTZONE, 1, [Define this if your time.h defines altzone.])
2655 AC_MSG_CHECKING(whether sys/select.h and sys/time.h may both be included)
2657 #include <sys/types.h>
2658 #include <sys/select.h>
2659 #include <sys/time.h>
2661 AC_DEFINE(SYS_SELECT_WITH_SYS_TIME, 1,
2662 [Define if you can safely include both <sys/select.h> and <sys/time.h>
2663 (which you can't on SCO ODT 3.0).])
2666 AC_MSG_RESULT($was_it_defined)
2668 AC_MSG_CHECKING(for addrinfo)
2669 AC_CACHE_VAL(ac_cv_struct_addrinfo,
2671 # include <netdb.h>],
2672 [struct addrinfo a],
2673 ac_cv_struct_addrinfo=yes,
2674 ac_cv_struct_addrinfo=no))
2675 AC_MSG_RESULT($ac_cv_struct_addrinfo)
2676 if test $ac_cv_struct_addrinfo = yes; then
2677 AC_DEFINE(HAVE_ADDRINFO, 1, [struct addrinfo (netdb.h)])
2680 AC_MSG_CHECKING(for sockaddr_storage)
2681 AC_CACHE_VAL(ac_cv_struct_sockaddr_storage,
2683 # include <sys/types.h>
2684 # include <sys/socket.h>],
2685 [struct sockaddr_storage s],
2686 ac_cv_struct_sockaddr_storage=yes,
2687 ac_cv_struct_sockaddr_storage=no))
2688 AC_MSG_RESULT($ac_cv_struct_sockaddr_storage)
2689 if test $ac_cv_struct_sockaddr_storage = yes; then
2690 AC_DEFINE(HAVE_SOCKADDR_STORAGE, 1, [struct sockaddr_storage (sys/socket.h)])
2693 # checks for compiler characteristics
2699 AC_MSG_CHECKING(for working volatile)
2700 AC_TRY_COMPILE([],[volatile int x; x = 0;], works=yes,
2701 AC_DEFINE(volatile, [], [Define to empty if the keyword does not work.])
2703 AC_MSG_RESULT($works)
2706 AC_MSG_CHECKING(for working signed char)
2707 AC_TRY_COMPILE([], [signed char c;], works=yes,
2708 AC_DEFINE(signed, [], [Define to empty if the keyword does not work.])
2710 AC_MSG_RESULT($works)
2713 AC_MSG_CHECKING(for prototypes)
2714 AC_TRY_COMPILE([int foo(int x) { return 0; }], [return foo(10);],[
2715 AC_DEFINE(HAVE_PROTOTYPES, 1,
2716 [Define if your compiler supports function prototype])
2719 AC_MSG_RESULT($have_prototypes)
2722 AC_MSG_CHECKING(for variable length prototypes and stdarg.h)
2725 int foo(int x, ...) {
2733 ], [return foo(10, "", 3.14);], [
2734 AC_DEFINE(HAVE_STDARG_PROTOTYPES, 1,
2735 [Define if your compiler supports variable length function prototypes
2736 (e.g. void fprintf(FILE *, char *, ...);) *and* <stdarg.h>])
2739 AC_MSG_RESULT($works)
2741 # check for socketpair
2742 AC_MSG_CHECKING(for socketpair)
2744 #include <sys/types.h>
2745 #include <sys/socket.h>
2746 ], void *x=socketpair,
2747 AC_DEFINE(HAVE_SOCKETPAIR, 1, Define if you have the 'socketpair' function.)
2752 # check if sockaddr has sa_len member
2753 AC_MSG_CHECKING(if sockaddr has sa_len member)
2754 AC_TRY_COMPILE([#include <sys/types.h>
2755 #include <sys/socket.h>],
2759 AC_DEFINE(HAVE_SOCKADDR_SA_LEN, 1, [Define if sockaddr has sa_len member]),
2763 AC_MSG_CHECKING(whether va_list is an array)
2765 #ifdef HAVE_STDARG_PROTOTYPES
2768 #include <varargs.h>
2770 ], [va_list list1, list2; list1 = list2;], , [
2771 AC_DEFINE(VA_LIST_IS_ARRAY, 1, [Define if a va_list is an array of some kind])
2772 va_list_is_array=yes
2774 AC_MSG_RESULT($va_list_is_array)
2776 # sigh -- gethostbyname_r is a mess; it can have 3, 5 or 6 arguments :-(
2777 AH_TEMPLATE(HAVE_GETHOSTBYNAME_R,
2778 [Define this if you have some version of gethostbyname_r()])
2780 AC_CHECK_FUNC(gethostbyname_r, [
2781 AC_DEFINE(HAVE_GETHOSTBYNAME_R)
2782 AC_MSG_CHECKING([gethostbyname_r with 6 args])
2784 CFLAGS="$CFLAGS $MY_CPPFLAGS $MY_THREAD_CPPFLAGS $MY_CFLAGS"
2789 struct hostent *he, *res;
2794 (void) gethostbyname_r(name, he, buffer, buflen, &res, &h_errnop)
2796 AC_DEFINE(HAVE_GETHOSTBYNAME_R)
2797 AC_DEFINE(HAVE_GETHOSTBYNAME_R_6_ARG, 1,
2798 [Define this if you have the 6-arg version of gethostbyname_r().])
2802 AC_MSG_CHECKING([gethostbyname_r with 5 args])
2812 (void) gethostbyname_r(name, he, buffer, buflen, &h_errnop)
2814 AC_DEFINE(HAVE_GETHOSTBYNAME_R)
2815 AC_DEFINE(HAVE_GETHOSTBYNAME_R_5_ARG, 1,
2816 [Define this if you have the 5-arg version of gethostbyname_r().])
2820 AC_MSG_CHECKING([gethostbyname_r with 3 args])
2826 struct hostent_data data;
2828 (void) gethostbyname_r(name, he, &data);
2830 AC_DEFINE(HAVE_GETHOSTBYNAME_R)
2831 AC_DEFINE(HAVE_GETHOSTBYNAME_R_3_ARG, 1,
2832 [Define this if you have the 3-arg version of gethostbyname_r().])
2841 AC_CHECK_FUNCS(gethostbyname)
2843 AC_SUBST(HAVE_GETHOSTBYNAME_R_6_ARG)
2844 AC_SUBST(HAVE_GETHOSTBYNAME_R_5_ARG)
2845 AC_SUBST(HAVE_GETHOSTBYNAME_R_3_ARG)
2846 AC_SUBST(HAVE_GETHOSTBYNAME_R)
2847 AC_SUBST(HAVE_GETHOSTBYNAME)
2849 # checks for system services
2852 # Linux requires this for correct f.p. operations
2853 AC_CHECK_FUNC(__fpu_control,
2855 [AC_CHECK_LIB(ieee, __fpu_control)
2858 # Check for --with-fpectl
2859 AC_MSG_CHECKING(for --with-fpectl)
2861 AC_HELP_STRING(--with-fpectl, enable SIGFPE catching),
2863 if test "$withval" != no
2865 AC_DEFINE(WANT_SIGFPE_HANDLER, 1,
2866 [Define if you want SIGFPE handled (see Include/pyfpe.h).])
2868 else AC_MSG_RESULT(no)
2870 [AC_MSG_RESULT(no)])
2872 # check for --with-libm=...
2874 case $ac_sys_system in
2879 AC_MSG_CHECKING(for --with-libm=STRING)
2881 AC_HELP_STRING(--with-libm=STRING, math library),
2883 if test "$withval" = no
2885 AC_MSG_RESULT(force LIBM empty)
2886 elif test "$withval" != yes
2888 AC_MSG_RESULT(set LIBM="$withval")
2889 else AC_MSG_ERROR([proper usage is --with-libm=STRING])
2891 [AC_MSG_RESULT(default LIBM="$LIBM")])
2893 # check for --with-libc=...
2895 AC_MSG_CHECKING(for --with-libc=STRING)
2897 AC_HELP_STRING(--with-libc=STRING, C library),
2899 if test "$withval" = no
2901 AC_MSG_RESULT(force LIBC empty)
2902 elif test "$withval" != yes
2904 AC_MSG_RESULT(set LIBC="$withval")
2905 else AC_MSG_ERROR([proper usage is --with-libc=STRING])
2907 [AC_MSG_RESULT(default LIBC="$LIBC")])
2909 # check for hypot() in math library
2912 AC_REPLACE_FUNCS(hypot)
2916 AC_CHECK_HEADER(wchar.h, [
2917 AC_DEFINE(HAVE_WCHAR_H, 1,
2918 [Define if the compiler provides a wchar.h header file.])
2924 # determine wchar_t size
2925 if test "$wchar_h" = yes
2927 AC_CHECK_SIZEOF(wchar_t, 4, [#include <wchar.h>])
2930 AC_MSG_CHECKING(for UCS-4 tcl)
2934 #if TCL_UTF_MAX != 6
2935 # error "NOT UCS4_TCL"
2937 AC_DEFINE(HAVE_UCS4_TCL, 1, [Define this if you have tcl and TCL_UTF_MAX==6])
2940 AC_MSG_RESULT($have_ucs4_tcl)
2942 # check whether wchar_t is signed or not
2943 if test "$wchar_h" = yes
2945 # check whether wchar_t is signed or not
2946 AC_MSG_CHECKING(whether wchar_t is signed)
2947 AC_CACHE_VAL(ac_cv_wchar_t_signed, [
2952 /* Success: exit code 0 */
2953 exit((((wchar_t) -1) < ((wchar_t) 0)) ? 0 : 1);
2956 ac_cv_wchar_t_signed=yes,
2957 ac_cv_wchar_t_signed=no,
2958 ac_cv_wchar_t_signed=yes)])
2959 AC_MSG_RESULT($ac_cv_wchar_t_signed)
2962 AC_MSG_CHECKING(what type to use for unicode)
2963 dnl quadrigraphs "@<:@" and "@:>@" produce "[" and "]" in the output
2964 AC_ARG_ENABLE(unicode,
2965 AC_HELP_STRING(--enable-unicode@<:@=ucs@<:@24@:>@@:>@, Enable Unicode strings (default is yes)),
2967 [enable_unicode=yes])
2969 if test $enable_unicode = yes
2971 # Without any arguments, Py_UNICODE defaults to two-byte mode
2972 case "$have_ucs4_tcl" in
2973 yes) enable_unicode="ucs4"
2975 *) enable_unicode="ucs2"
2980 AH_TEMPLATE(Py_UNICODE_SIZE,
2981 [Define as the size of the unicode type.])
2982 case "$enable_unicode" in
2983 ucs2) unicode_size="2"
2984 AC_DEFINE(Py_UNICODE_SIZE,2)
2986 ucs4) unicode_size="4"
2987 AC_DEFINE(Py_UNICODE_SIZE,4)
2991 AH_TEMPLATE(PY_UNICODE_TYPE,
2992 [Define as the integral type used for Unicode representation.])
2994 AC_SUBST(UNICODE_OBJS)
2995 if test "$enable_unicode" = "no"
2998 AC_MSG_RESULT(not used)
3000 UNICODE_OBJS="Objects/unicodeobject.o Objects/unicodectype.o"
3001 AC_DEFINE(Py_USING_UNICODE, 1,
3002 [Define if you want to have a Unicode type.])
3004 # wchar_t is only usable if it maps to an unsigned type
3005 if test "$unicode_size" = "$ac_cv_sizeof_wchar_t" \
3006 -a "$ac_cv_wchar_t_signed" = "no"
3008 PY_UNICODE_TYPE="wchar_t"
3009 AC_DEFINE(HAVE_USABLE_WCHAR_T, 1,
3010 [Define if you have a useable wchar_t type defined in wchar.h; useable
3011 means wchar_t must be an unsigned type with at least 16 bits. (see
3012 Include/unicodeobject.h).])
3013 AC_DEFINE(PY_UNICODE_TYPE,wchar_t)
3014 elif test "$ac_cv_sizeof_short" = "$unicode_size"
3016 PY_UNICODE_TYPE="unsigned short"
3017 AC_DEFINE(PY_UNICODE_TYPE,unsigned short)
3018 elif test "$ac_cv_sizeof_long" = "$unicode_size"
3020 PY_UNICODE_TYPE="unsigned long"
3021 AC_DEFINE(PY_UNICODE_TYPE,unsigned long)
3023 PY_UNICODE_TYPE="no type found"
3025 AC_MSG_RESULT($PY_UNICODE_TYPE)
3028 # check for endianness
3030 AH_VERBATIM([WORDS_BIGENDIAN],
3032 /* Define to 1 if your processor stores words with the most significant byte
3033 first (like Motorola and SPARC, unlike Intel and VAX).
3035 The block below does compile-time checking for endianness on platforms
3036 that use GCC and therefore allows compiling fat binaries on OSX by using
3037 '-arch ppc -arch i386' as the compile flags. The phrasing was choosen
3038 such that the configure-result is used on systems that don't use GCC.
3040 #ifdef __BIG_ENDIAN__
3041 #define WORDS_BIGENDIAN 1
3043 #ifndef __LITTLE_ENDIAN__
3044 #undef WORDS_BIGENDIAN
3048 # Check whether right shifting a negative integer extends the sign bit
3049 # or fills with zeros (like the Cray J90, according to Tim Peters).
3050 AC_MSG_CHECKING(whether right shift extends the sign bit)
3051 AC_CACHE_VAL(ac_cv_rshift_extends_sign, [
3055 exit(((-1)>>3 == -1) ? 0 : 1);
3058 ac_cv_rshift_extends_sign=yes,
3059 ac_cv_rshift_extends_sign=no,
3060 ac_cv_rshift_extends_sign=yes)])
3061 AC_MSG_RESULT($ac_cv_rshift_extends_sign)
3062 if test "$ac_cv_rshift_extends_sign" = no
3064 AC_DEFINE(SIGNED_RIGHT_SHIFT_ZERO_FILLS, 1,
3065 [Define if i>>j for signed int i does not extend the sign bit
3069 # check for getc_unlocked and related locking functions
3070 AC_MSG_CHECKING(for getc_unlocked() and friends)
3071 AC_CACHE_VAL(ac_cv_have_getc_unlocked, [
3072 AC_TRY_LINK([#include <stdio.h>],[
3073 FILE *f = fopen("/dev/null", "r");
3077 ], ac_cv_have_getc_unlocked=yes, ac_cv_have_getc_unlocked=no)])
3078 AC_MSG_RESULT($ac_cv_have_getc_unlocked)
3079 if test "$ac_cv_have_getc_unlocked" = yes
3081 AC_DEFINE(HAVE_GETC_UNLOCKED, 1,
3082 [Define this if you have flockfile(), getc_unlocked(), and funlockfile()])
3085 # check where readline lives
3086 # save the value of LIBS so we don't actually link Python with readline
3087 LIBS_no_readline=$LIBS
3088 AC_CHECK_LIB(readline, readline)
3089 if test "$ac_cv_have_readline_readline" = no
3091 AC_CHECK_LIB(termcap, readline)
3094 # check for readline 2.1
3095 AC_CHECK_LIB(readline, rl_callback_handler_install,
3096 AC_DEFINE(HAVE_RL_CALLBACK, 1,
3097 [Define if you have readline 2.1]), , )
3099 # check for readline 2.2
3100 AC_TRY_CPP([#include <readline/readline.h>],
3101 have_readline=yes, have_readline=no)
3102 if test $have_readline = yes
3104 AC_EGREP_HEADER([extern int rl_completion_append_character;],
3105 [readline/readline.h],
3106 AC_DEFINE(HAVE_RL_COMPLETION_APPEND_CHARACTER, 1,
3107 [Define if you have readline 2.2]), )
3110 # check for readline 4.0
3111 AC_CHECK_LIB(readline, rl_pre_input_hook,
3112 AC_DEFINE(HAVE_RL_PRE_INPUT_HOOK, 1,
3113 [Define if you have readline 4.0]), , )
3115 # check for readline 4.2
3116 AC_CHECK_LIB(readline, rl_completion_matches,
3117 AC_DEFINE(HAVE_RL_COMPLETION_MATCHES, 1,
3118 [Define if you have readline 4.2]), , )
3120 # also in readline 4.2
3121 AC_TRY_CPP([#include <readline/readline.h>],
3122 have_readline=yes, have_readline=no)
3123 if test $have_readline = yes
3125 AC_EGREP_HEADER([extern int rl_catch_signals;],
3126 [readline/readline.h],
3127 AC_DEFINE(HAVE_RL_CATCH_SIGNAL, 1,
3128 [Define if you can turn off readline's signal handling.]), )
3131 # End of readline checks: restore LIBS
3132 LIBS=$LIBS_no_readline
3134 AC_MSG_CHECKING(for broken nice())
3135 AC_CACHE_VAL(ac_cv_broken_nice, [
3140 if (val1 != -1 && val1 == nice(2))
3145 ac_cv_broken_nice=yes,
3146 ac_cv_broken_nice=no,
3147 ac_cv_broken_nice=no)])
3148 AC_MSG_RESULT($ac_cv_broken_nice)
3149 if test "$ac_cv_broken_nice" = yes
3151 AC_DEFINE(HAVE_BROKEN_NICE, 1,
3152 [Define if nice() returns success/failure instead of the new priority.])
3155 AC_MSG_CHECKING(for broken poll())
3161 struct pollfd poll_struct = { 42, POLLIN|POLLPRI|POLLOUT, 0 };
3165 int poll_test = poll (&poll_struct, 1, 0);
3171 else if (poll_test == 0 && poll_struct.revents != POLLNVAL)
3181 ac_cv_broken_poll=yes,
3182 ac_cv_broken_poll=no,
3183 ac_cv_broken_poll=no)
3184 AC_MSG_RESULT($ac_cv_broken_poll)
3185 if test "$ac_cv_broken_poll" = yes
3187 AC_DEFINE(HAVE_BROKEN_POLL, 1,
3188 [Define if poll() sets errno on invalid file descriptors.])
3191 # Before we can test tzset, we need to check if struct tm has a tm_zone
3192 # (which is not required by ISO C or UNIX spec) and/or if we support
3196 # check tzset(3) exists and works like we expect it to
3197 AC_MSG_CHECKING(for working tzset())
3198 AC_CACHE_VAL(ac_cv_working_tzset, [
3205 extern char *tzname[];
3210 /* Note that we need to ensure that not only does tzset(3)
3211 do 'something' with localtime, but it works as documented
3212 in the library reference and as expected by the test suite.
3213 This includes making sure that tzname is set properly if
3214 tm->tm_zone does not exist since it is the alternative way
3215 of getting timezone info.
3217 Red Hat 6.2 doesn't understand the southern hemisphere
3218 after New Year's Day.
3221 time_t groundhogday = 1044144000; /* GMT-based */
3222 time_t midyear = groundhogday + (365 * 24 * 3600 / 2);
3226 if (localtime(&groundhogday)->tm_hour != 0)
3229 /* For UTC, tzname[1] is sometimes "", sometimes " " */
3230 if (strcmp(tzname[0], "UTC") ||
3231 (tzname[1][0] != 0 && tzname[1][0] != ' '))
3235 putenv("TZ=EST+5EDT,M4.1.0,M10.5.0");
3237 if (localtime(&groundhogday)->tm_hour != 19)
3240 if (strcmp(tzname[0], "EST") || strcmp(tzname[1], "EDT"))
3244 putenv("TZ=AEST-10AEDT-11,M10.5.0,M3.5.0");
3246 if (localtime(&groundhogday)->tm_hour != 11)
3249 if (strcmp(tzname[0], "AEST") || strcmp(tzname[1], "AEDT"))
3253 #if HAVE_STRUCT_TM_TM_ZONE
3254 if (strcmp(localtime(&groundhogday)->tm_zone, "AEDT"))
3256 if (strcmp(localtime(&midyear)->tm_zone, "AEST"))
3263 ac_cv_working_tzset=yes,
3264 ac_cv_working_tzset=no,
3265 ac_cv_working_tzset=no)])
3266 AC_MSG_RESULT($ac_cv_working_tzset)
3267 if test "$ac_cv_working_tzset" = yes
3269 AC_DEFINE(HAVE_WORKING_TZSET, 1,
3270 [Define if tzset() actually switches the local timezone in a meaningful way.])
3273 # Look for subsecond timestamps in struct stat
3274 AC_MSG_CHECKING(for tv_nsec in struct stat)
3275 AC_CACHE_VAL(ac_cv_stat_tv_nsec,
3276 AC_TRY_COMPILE([#include <sys/stat.h>], [
3278 st.st_mtim.tv_nsec = 1;
3280 ac_cv_stat_tv_nsec=yes,
3281 ac_cv_stat_tv_nsec=no,
3282 ac_cv_stat_tv_nsec=no))
3283 AC_MSG_RESULT($ac_cv_stat_tv_nsec)
3284 if test "$ac_cv_stat_tv_nsec" = yes
3286 AC_DEFINE(HAVE_STAT_TV_NSEC, 1,
3287 [Define if you have struct stat.st_mtim.tv_nsec])
3290 # Look for BSD style subsecond timestamps in struct stat
3291 AC_MSG_CHECKING(for tv_nsec2 in struct stat)
3292 AC_CACHE_VAL(ac_cv_stat_tv_nsec2,
3293 AC_TRY_COMPILE([#include <sys/stat.h>], [
3295 st.st_mtimespec.tv_nsec = 1;
3297 ac_cv_stat_tv_nsec2=yes,
3298 ac_cv_stat_tv_nsec2=no,
3299 ac_cv_stat_tv_nsec2=no))
3300 AC_MSG_RESULT($ac_cv_stat_tv_nsec2)
3301 if test "$ac_cv_stat_tv_nsec2" = yes
3303 AC_DEFINE(HAVE_STAT_TV_NSEC2, 1,
3304 [Define if you have struct stat.st_mtimensec])
3307 # On HP/UX 11.0, mvwdelch is a block with a return statement
3308 AC_MSG_CHECKING(whether mvwdelch is an expression)
3309 AC_CACHE_VAL(ac_cv_mvwdelch_is_expression,
3310 AC_TRY_COMPILE([#include <curses.h>], [
3312 rtn = mvwdelch(0,0,0);
3313 ], ac_cv_mvwdelch_is_expression=yes,
3314 ac_cv_mvwdelch_is_expression=no,
3315 ac_cv_mvwdelch_is_expression=yes))
3316 AC_MSG_RESULT($ac_cv_mvwdelch_is_expression)
3318 if test "$ac_cv_mvwdelch_is_expression" = yes
3320 AC_DEFINE(MVWDELCH_IS_EXPRESSION, 1,
3321 [Define if mvwdelch in curses.h is an expression.])
3324 AC_MSG_CHECKING(whether WINDOW has _flags)
3325 AC_CACHE_VAL(ac_cv_window_has_flags,
3326 AC_TRY_COMPILE([#include <curses.h>], [
3329 ], ac_cv_window_has_flags=yes,
3330 ac_cv_window_has_flags=no,
3331 ac_cv_window_has_flags=no))
3332 AC_MSG_RESULT($ac_cv_window_has_flags)
3335 if test "$ac_cv_window_has_flags" = yes
3337 AC_DEFINE(WINDOW_HAS_FLAGS, 1,
3338 [Define if WINDOW in curses.h offers a field _flags.])
3341 AC_MSG_CHECKING(for is_term_resized)
3342 AC_TRY_COMPILE([#include <curses.h>], void *x=is_term_resized,
3343 AC_DEFINE(HAVE_CURSES_IS_TERM_RESIZED, 1, Define if you have the 'is_term_resized' function.)
3348 AC_MSG_CHECKING(for resize_term)
3349 AC_TRY_COMPILE([#include <curses.h>], void *x=resize_term,
3350 AC_DEFINE(HAVE_CURSES_RESIZE_TERM, 1, Define if you have the 'resize_term' function.)
3355 AC_MSG_CHECKING(for resizeterm)
3356 AC_TRY_COMPILE([#include <curses.h>], void *x=resizeterm,
3357 AC_DEFINE(HAVE_CURSES_RESIZETERM, 1, Define if you have the 'resizeterm' function.)
3362 AC_MSG_CHECKING(for /dev/ptmx)
3364 if test -r /dev/ptmx
3367 AC_DEFINE(HAVE_DEV_PTMX, 1,
3368 [Define if we have /dev/ptmx.])
3373 AC_MSG_CHECKING(for /dev/ptc)
3378 AC_DEFINE(HAVE_DEV_PTC, 1,
3379 [Define if we have /dev/ptc.])
3384 AC_MSG_CHECKING(for %zd printf() format support)
3385 AC_TRY_RUN([#include <stdio.h>
3394 typedef ssize_t Py_ssize_t;
3395 #elif SIZEOF_VOID_P == SIZEOF_LONG
3396 typedef long Py_ssize_t;
3398 typedef int Py_ssize_t;
3401 if(sprintf(buffer, "%zd", (size_t)123) < 0)
3404 if (strcmp(buffer, "123"))
3407 if (sprintf(buffer, "%zd", (Py_ssize_t)-123) < 0)
3410 if (strcmp(buffer, "-123"))
3416 AC_DEFINE(PY_FORMAT_SIZE_T, "z", [Define to printf format modifier for Py_ssize_t])],
3419 AC_CHECK_TYPE(socklen_t,,
3420 AC_DEFINE(socklen_t,int,
3421 Define to `int' if <sys/socket.h> does not define.),[
3422 #ifdef HAVE_SYS_TYPES_H
3423 #include <sys/types.h>
3425 #ifdef HAVE_SYS_SOCKET_H
3426 #include <sys/socket.h>
3430 AC_SUBST(THREADHEADERS)
3432 for h in `(cd $srcdir;echo Python/thread_*.h)`
3434 THREADHEADERS="$THREADHEADERS \$(srcdir)/$h"
3438 SRCDIRS="Parser Grammar Objects Python Modules Mac"
3439 AC_MSG_CHECKING(for build directories)
3440 for dir in $SRCDIRS; do
3441 if test ! -d $dir; then
3447 # generate output files
3448 AC_CONFIG_FILES(Makefile.pre Modules/Setup.config)
3451 echo "creating Modules/Setup"
3452 if test ! -f Modules/Setup
3454 cp $srcdir/Modules/Setup.dist Modules/Setup
3457 echo "creating Modules/Setup.local"
3458 if test ! -f Modules/Setup.local
3460 echo "# Edit this file for local setup changes" >Modules/Setup.local
3463 echo "creating Makefile"
3464 $SHELL $srcdir/Modules/makesetup -c $srcdir/Modules/config.c.in \
3465 -s Modules Modules/Setup.config \
3466 Modules/Setup.local Modules/Setup