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.5)
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@:>@)
205 define_xopen_source=no;;
206 # On Solaris 2.6, sys/wait.h is inconsistent in the usage
207 # of union __?sigval. Reported by Stuart Bishop.
209 define_xopen_source=no;;
210 # On UnixWare 7, u_long is never defined with _XOPEN_SOURCE,
211 # but used in /usr/include/netinet/tcp.h. Reported by Tim Rice.
212 # Reconfirmed for 7.1.4 by Martin v. Loewis.
213 OpenUNIX/8.0.0| UnixWare/7.1.@<:@0-4@:>@)
214 define_xopen_source=no;;
215 # On OpenServer 5, u_short is never defined with _XOPEN_SOURCE,
216 # but used in struct sockaddr.sa_family. Reported by Tim Rice.
218 define_xopen_source=no;;
219 # On FreeBSD 4.8 and MacOS X 10.2, a bug in ncurses.h means that
220 # it craps out if _XOPEN_EXTENDED_SOURCE is defined. Apparently,
221 # this is fixed in 10.3, which identifies itself as Darwin/7.*
222 # This should hopefully be fixed in FreeBSD 4.9
223 FreeBSD/4.8* | Darwin/6* )
224 define_xopen_source=no;;
225 # On AIX 4 and 5.1, mbstate_t is defined only when _XOPEN_SOURCE == 500 but
226 # used in wcsnrtombs() and mbsnrtowcs() even if _XOPEN_SOURCE is not defined
227 # or has another value. By not (re)defining it, the defaults come in place.
229 define_xopen_source=no;;
231 if test `uname -r` -eq 1; then
232 define_xopen_source=no
235 # On Mac OS X 10.4, defining _POSIX_C_SOURCE or _XOPEN_SOURCE
236 # disables platform specific features beyond repair.
237 # On Mac OS X 10.3, defining _POSIX_C_SOURCE or _XOPEN_SOURCE
238 # has no effect, don't bother defining them
240 define_xopen_source=no
245 if test $define_xopen_source = yes
247 # On Solaris w/ g++ it appears that _XOPEN_SOURCE has to be
248 # defined precisely as g++ defines it
249 # Furthermore, on Solaris 10, XPG6 requires the use of a C99
251 case $ac_sys_system/$ac_sys_release in
252 SunOS/5.8|SunOS/5.9|SunOS/5.10)
253 AC_DEFINE(_XOPEN_SOURCE, 500,
254 Define to the level of X/Open that your system supports)
257 AC_DEFINE(_XOPEN_SOURCE, 600,
258 Define to the level of X/Open that your system supports)
262 # On Tru64 Unix 4.0F, defining _XOPEN_SOURCE also requires
263 # definition of _XOPEN_SOURCE_EXTENDED and _POSIX_C_SOURCE, or else
264 # several APIs are not declared. Since this is also needed in some
265 # cases for HP-UX, we define it globally.
266 # except for Solaris 10, where it must not be defined,
267 # as it implies XPG4.2
268 case $ac_sys_system/$ac_sys_release in
272 AC_DEFINE(_XOPEN_SOURCE_EXTENDED, 1,
273 Define to activate Unix95-and-earlier features)
277 AC_DEFINE(_POSIX_C_SOURCE, 200112L, Define to activate features from IEEE Stds 1003.1-2001)
282 # SGI compilers allow the specification of the both the ABI and the
283 # ISA on the command line. Depending on the values of these switches,
284 # different and often incompatable code will be generated.
286 # The SGI_ABI variable can be used to modify the CC and LDFLAGS and
287 # thus supply support for various ABI/ISA combinations. The MACHDEP
288 # variable is also adjusted.
291 if test ! -z "$SGI_ABI"
294 LDFLAGS="$SGI_ABI $LDFLAGS"
295 MACHDEP=`echo "${MACHDEP}${SGI_ABI}" | sed 's/ *//g'`
297 AC_MSG_RESULT($MACHDEP)
299 # And add extra plat-mac for darwin
300 AC_SUBST(EXTRAPLATDIR)
301 AC_SUBST(EXTRAMACHDEPPATH)
302 AC_MSG_CHECKING(EXTRAPLATDIR)
303 if test -z "$EXTRAPLATDIR"
307 EXTRAPLATDIR="\$(PLATMACDIRS)"
308 EXTRAMACHDEPPATH="\$(PLATMACPATH)"
316 AC_MSG_RESULT($EXTRAPLATDIR)
318 # Record the configure-time value of MACOSX_DEPLOYMENT_TARGET,
319 # it may influence the way we can build extensions, so distutils
321 AC_SUBST(CONFIGURE_MACOSX_DEPLOYMENT_TARGET)
322 AC_SUBST(EXPORT_MACOSX_DEPLOYMENT_TARGET)
323 CONFIGURE_MACOSX_DEPLOYMENT_TARGET=
324 EXPORT_MACOSX_DEPLOYMENT_TARGET='#'
326 # checks for alternative programs
328 # compiler flags are generated in two sets, BASECFLAGS and OPT. OPT is just
329 # for debug/optimization stuff. BASECFLAGS is for flags that are required
330 # just to get things to compile and link. Users are free to override OPT
331 # when running configure or make. The build should not break if they do.
332 # BASECFLAGS should generally not be messed with, however.
334 # XXX shouldn't some/most/all of this code be merged with the stuff later
335 # on that fiddles with OPT and BASECFLAGS?
336 AC_MSG_CHECKING(for --without-gcc)
338 AC_HELP_STRING(--without-gcc,never use gcc),
346 without_gcc=$withval;;
348 case $ac_sys_system in
356 BASECFLAGS="$BASECFLAGS -export pragma"
358 LDFLAGS="$LDFLAGS -nodup"
366 AC_MSG_ERROR([Unknown BeOS platform "$BE_HOST_CPU"])
369 AR="\$(srcdir)/Modules/ar_beos"
377 AC_MSG_RESULT($without_gcc)
379 # If the user switches compilers, we can't believe the cache
380 if test ! -z "$ac_cv_prog_CC" -a ! -z "$CC" -a "$CC" != "$ac_cv_prog_CC"
382 AC_MSG_ERROR([cached CC is different -- throw away $cache_file
383 (it is also a good idea to do 'make clean' before compiling)])
390 AC_MSG_CHECKING(for --with-cxx-main=<compiler>)
391 AC_ARG_WITH(cxx_main,
392 AC_HELP_STRING([--with-cxx-main=<compiler>],
393 [compile main() and link python executable with C++ compiler]),
399 yes) with_cxx_main=yes
411 AC_MSG_RESULT($with_cxx_main)
417 gcc) AC_PATH_PROG(CXX, [g++], [g++], [notfound]) ;;
418 cc) AC_PATH_PROG(CXX, [c++], [c++], [notfound]) ;;
420 if test "$CXX" = "notfound"
427 AC_CHECK_PROGS(CXX, $CCC c++ g++ gcc CC cxx cc++ cl, notfound)
428 if test "$CXX" = "notfound"
433 if test "$preset_cxx" != "$CXX"
437 By default, distutils will build C++ extension modules with "$CXX".
438 If this is not intended, then set CXX on the configure command line.
443 # checks for UNIX variants that set C preprocessor variables
446 # Check for unsupported systems
447 case $ac_sys_system/$ac_sys_release in
449 echo This system \($ac_sys_system/$ac_sys_release\) is no longer supported.
450 echo See README for details.
455 AC_MSG_CHECKING(for --with-suffix)
457 AC_HELP_STRING(--with-suffix=.exe, set executable suffix),
464 AC_MSG_RESULT($EXEEXT)
466 # Test whether we're running on a non-case-sensitive system, in which
467 # case we give a warning if no ext is given
468 AC_SUBST(BUILDEXEEXT)
469 AC_MSG_CHECKING(for case-insensitive build directory)
470 if test ! -d CaseSensitiveTestDir; then
471 mkdir CaseSensitiveTestDir
474 if test -d casesensitivetestdir
482 rmdir CaseSensitiveTestDir
487 gcc) CC="$CC -D_HAVE_BSDI";;
491 case $ac_sys_system in
494 cc|*/cc) CC="$CC -Ae";;
498 cc) CC="$CC -Wl,-Bexport";;
501 # Some functions have a prototype only with that define, e.g. confstr
502 AC_DEFINE(__EXTENSIONS__, 1, [Defined on Solaris to see additional function prototypes.])
508 AC_MSG_CHECKING(LIBRARY)
509 if test -z "$LIBRARY"
511 LIBRARY='libpython$(VERSION).a'
513 AC_MSG_RESULT($LIBRARY)
515 # LDLIBRARY is the name of the library to link against (as opposed to the
516 # name of the library into which to insert object files). BLDLIBRARY is also
517 # the library to link against, usually. On Mac OS X frameworks, BLDLIBRARY
518 # is blank as the main program is not linked directly against LDLIBRARY.
519 # LDLIBRARYDIR is the path to LDLIBRARY, which is made in a subdirectory. On
520 # systems without shared libraries, LDLIBRARY is the same as LIBRARY
521 # (defined in the Makefiles). On Cygwin LDLIBRARY is the import library,
522 # DLLLIBRARY is the shared (i.e., DLL) library.
524 # RUNSHARED is used to run shared python without installed libraries
526 # INSTSONAME is the name of the shared library that will be use to install
527 # on the system - some systems like version suffix, others don't
531 AC_SUBST(LDLIBRARYDIR)
535 BLDLIBRARY='$(LDLIBRARY)'
536 INSTSONAME='$(LDLIBRARY)'
541 # LINKCC is the command that links the python executable -- default is $(CC).
542 # If CXX is set, and if it is needed to link a main function that was
543 # compiled with CXX, LINKCC is CXX instead. Always using CXX is undesirable:
544 # python might then depend on the C++ runtime
545 # This is altered for AIX in order to build the export list before
548 AC_MSG_CHECKING(LINKCC)
551 LINKCC='$(PURIFY) $(MAINCC)'
552 case $ac_sys_system in
555 if test $ac_sys_release -ge 5 -o \
556 $ac_sys_release -eq 4 -a `uname -r` -ge 2 ; then
559 LINKCC="\$(srcdir)/Modules/makexp_aix Modules/python.exp $exp_extra \$(LIBRARY); $LINKCC";;
561 LINKCC="$LINKCC -L/usr/lib/ia64l64";;
564 AC_MSG_RESULT($LINKCC)
566 AC_MSG_CHECKING(for --enable-shared)
567 AC_ARG_ENABLE(shared,
568 AC_HELP_STRING(--enable-shared, disable/enable building shared python library))
570 if test -z "$enable_shared"
572 case $ac_sys_system in
574 enable_shared="yes";;
579 AC_MSG_RESULT($enable_shared)
581 AC_MSG_CHECKING(for --enable-profiling)
582 AC_ARG_ENABLE(profiling,
583 AC_HELP_STRING(--enable-profiling, enable C-level code profiling),
586 AC_TRY_RUN([int main() { return 0; }],
587 ac_enable_profiling="yes",
588 ac_enable_profiling="no",
589 ac_enable_profiling="no")
591 AC_MSG_RESULT($ac_enable_profiling)
593 case "$ac_enable_profiling" in
595 BASECFLAGS="-pg $BASECFLAGS"
596 LDFLAGS="-pg $LDFLAGS"
600 AC_MSG_CHECKING(LDLIBRARY)
602 # MacOSX framework builds need more magic. LDLIBRARY is the dynamic
603 # library that we build, but we do not want to link against it (we
604 # will find it with a -framework option). For this reason there is an
605 # extra variable BLDLIBRARY against which Python and the extension
606 # modules are linked, BLDLIBRARY. This is normally the same as
607 # LDLIBRARY, but empty for MacOSX framework builds.
608 if test "$enable_framework"
610 LDLIBRARY='$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
611 RUNSHARED=DYLD_FRAMEWORK_PATH="`pwd`:$DYLD_FRAMEWORK_PATH"
614 BLDLIBRARY='$(LDLIBRARY)'
617 # Other platforms follow
618 if test $enable_shared = "yes"; then
619 AC_DEFINE(Py_ENABLE_SHARED, 1, [Defined if Python is built as a shared library.])
620 case $ac_sys_system in
622 LDLIBRARY='libpython$(VERSION).so'
625 LDLIBRARY='libpython$(VERSION).dll.a'
626 DLLLIBRARY='libpython$(VERSION).dll'
629 LDLIBRARY='libpython$(VERSION).so'
630 BLDLIBRARY='-Wl,-R,$(LIBDIR) -L. -lpython$(VERSION)'
631 RUNSHARED=LD_LIBRARY_PATH=`pwd`:${LD_LIBRARY_PATH}
632 INSTSONAME="$LDLIBRARY".$SOVERSION
634 Linux*|GNU*|NetBSD*|FreeBSD*|DragonFly*)
635 LDLIBRARY='libpython$(VERSION).so'
636 BLDLIBRARY='-L. -lpython$(VERSION)'
637 RUNSHARED=LD_LIBRARY_PATH=`pwd`:${LD_LIBRARY_PATH}
638 case $ac_sys_system in
640 SOVERSION=`echo $SOVERSION|cut -d "." -f 1`
643 INSTSONAME="$LDLIBRARY".$SOVERSION
648 LDLIBRARY='libpython$(VERSION).so'
651 LDLIBRARY='libpython$(VERSION).sl'
654 BLDLIBRARY='-Wl,+b,$(LIBDIR) -L. -lpython$(VERSION)'
655 RUNSHARED=SHLIB_PATH=`pwd`:${SHLIB_PATH}
658 LDLIBRARY='libpython$(VERSION).so'
659 BLDLIBRARY='-rpath $(LIBDIR) -L. -lpython$(VERSION)'
660 RUNSHARED=LD_LIBRARY_PATH=`pwd`:${LD_LIBRARY_PATH}
663 LDLIBRARY='libpython$(VERSION).so'
664 BLDLIBRARY='-L. -lpython$(VERSION)'
665 RUNSHARED=DLL_PATH=`pwd`:${DLL_PATH:-/atheos/sys/libs:/atheos/autolnk/lib}
668 else # shared is disabled
669 case $ac_sys_system in
671 BLDLIBRARY='$(LIBRARY)'
672 LDLIBRARY='libpython$(VERSION).dll.a'
677 AC_MSG_RESULT($LDLIBRARY)
681 AC_CHECK_PROGS(AR, ar aal, ar)
684 AC_CHECK_PROG(SVNVERSION, svnversion, found, not-found)
685 if test $SVNVERSION = found
687 SVNVERSION="svnversion \$(srcdir)"
689 SVNVERSION="echo exported"
694 # install -d does not work on BSDI or HP-UX
695 if test -z "$INSTALL"
697 INSTALL="${srcdir}/install-sh -c"
702 # Not every filesystem supports hard links
704 if test -z "$LN" ; then
705 case $ac_sys_system in
707 CYGWIN*) LN="ln -s";;
708 atheos*) LN="ln -s";;
713 # Check for --with-pydebug
714 AC_MSG_CHECKING(for --with-pydebug)
716 AC_HELP_STRING(--with-pydebug, build with Py_DEBUG defined),
718 if test "$withval" != no
720 AC_DEFINE(Py_DEBUG, 1,
721 [Define if you want to build an interpreter with many run-time checks.])
724 else AC_MSG_RESULT(no); Py_DEBUG='false'
728 # XXX Shouldn't the code above that fiddles with BASECFLAGS and OPT be
729 # merged with this chunk of code?
731 # Optimizer/debugger flags
732 # ------------------------
733 # (The following bit of code is complicated enough - please keep things
734 # indented properly. Just pretend you're editing Python code. ;-)
736 # There are two parallel sets of case statements below, one that checks to
737 # see if OPT was set and one that does BASECFLAGS setting based upon
738 # compiler and platform. BASECFLAGS tweaks need to be made even if the
741 # tweak OPT based on compiler and platform, only if the user didn't set
742 # it on the command line
748 if test "$CC" != 'g++' ; then
749 STRICT_PROTO="-Wstrict-prototypes"
751 case $ac_cv_prog_cc_g in
753 if test "$Py_DEBUG" = 'true' ; then
754 # Optimization messes up debuggers, so turn it off for
756 OPT="-g -Wall $STRICT_PROTO"
758 OPT="-g -O3 -Wall $STRICT_PROTO"
762 OPT="-O3 -Wall $STRICT_PROTO"
765 case $ac_sys_system in
766 SCO_SV*) OPT="$OPT -m486 -DSCO5"
776 # The current (beta) Monterey compiler dies with optimizations
777 # XXX what is Monterey? Does it still die w/ -O? Can we get rid of this?
778 case $ac_sys_system in
787 # tweak BASECFLAGS based on compiler and platform
790 # Python violates C99 rules, by casting between incompatible
791 # pointer types. GCC may generate bad code as a result of that,
792 # so use -fno-strict-aliasing if supported.
793 AC_MSG_CHECKING(whether $CC accepts -fno-strict-aliasing)
795 CC="$CC -fno-strict-aliasing"
796 AC_TRY_RUN([int main() { return 0; }],
797 ac_cv_no_strict_aliasing_ok=yes,
798 ac_cv_no_strict_aliasing_ok=no,
799 ac_cv_no_strict_aliasing_ok=no)
801 AC_MSG_RESULT($ac_cv_no_strict_aliasing_ok)
802 if test $ac_cv_no_strict_aliasing_ok = yes
804 BASECFLAGS="$BASECFLAGS -fno-strict-aliasing"
806 case $ac_sys_system in
808 BASECFLAGS="$BASECFLAGS -m486 -DSCO5"
810 # is there any other compiler on Darwin besides gcc?
812 BASECFLAGS="$BASECFLAGS -Wno-long-double -no-cpp-precomp -mno-fused-madd"
813 if test "${enable_universalsdk}"; then
814 BASECFLAGS="-arch ppc -arch i386 -isysroot ${UNIVERSALSDK} ${BASECFLAGS}"
819 BASECFLAGS="$BASECFLAGS -mieee"
825 case $ac_sys_system in
827 BASECFLAGS="$BASECFLAGS -K pentium,host,inline,loop_unroll,alloca "
830 BASECFLAGS="$BASECFLAGS -ieee -std"
833 BASECFLAGS="$BASECFLAGS -belf -Ki486 -DSCO5"
839 if test "$Py_DEBUG" = 'true'; then
845 if test "$ac_arch_flags"
847 BASECFLAGS="$BASECFLAGS $ac_arch_flags"
850 # disable check for icc since it seems to pass, but generates a warning
853 ac_cv_opt_olimit_ok=no
856 AC_MSG_CHECKING(whether $CC accepts -OPT:Olimit=0)
857 AC_CACHE_VAL(ac_cv_opt_olimit_ok,
859 CC="$CC -OPT:Olimit=0"
860 AC_TRY_RUN([int main() { return 0; }],
861 ac_cv_opt_olimit_ok=yes,
862 ac_cv_opt_olimit_ok=no,
863 ac_cv_opt_olimit_ok=no)
865 AC_MSG_RESULT($ac_cv_opt_olimit_ok)
866 if test $ac_cv_opt_olimit_ok = yes; then
867 case $ac_sys_system in
868 # XXX is this branch needed? On MacOSX 10.2.2 the result of the
869 # olimit_ok test is "no". Is it "yes" in some other Darwin-esque
874 BASECFLAGS="$BASECFLAGS -OPT:Olimit=0"
878 AC_MSG_CHECKING(whether $CC accepts -Olimit 1500)
879 AC_CACHE_VAL(ac_cv_olimit_ok,
881 CC="$CC -Olimit 1500"
882 AC_TRY_RUN([int main() { return 0; }],
887 AC_MSG_RESULT($ac_cv_olimit_ok)
888 if test $ac_cv_olimit_ok = yes; then
889 BASECFLAGS="$BASECFLAGS -Olimit 1500"
893 # On some compilers, pthreads are available without further options
894 # (e.g. MacOS X). On some of these systems, the compiler will not
895 # complain if unaccepted options are passed (e.g. gcc on Mac OS X).
896 # So we have to see first whether pthreads are available without
897 # options before we can check whether -Kpthread improves anything.
898 AC_MSG_CHECKING(whether pthreads are available without options)
899 AC_CACHE_VAL(ac_cv_pthread_is_default,
903 void* routine(void* p){return NULL;}
907 if(pthread_create(&p,NULL,routine,NULL)!=0)
909 (void)pthread_detach(p);
914 ac_cv_pthread_is_default=yes
918 ac_cv_pthread_is_default=no,
919 ac_cv_pthread_is_default=no)
921 AC_MSG_RESULT($ac_cv_pthread_is_default)
924 if test $ac_cv_pthread_is_default = yes
928 # -Kpthread, if available, provides the right #defines
929 # and linker options to make pthread_create available
930 # Some compilers won't report that they do not support -Kpthread,
931 # so we need to run a program to see whether it really made the
932 # function available.
933 AC_MSG_CHECKING(whether $CC accepts -Kpthread)
934 AC_CACHE_VAL(ac_cv_kpthread,
940 void* routine(void* p){return NULL;}
944 if(pthread_create(&p,NULL,routine,NULL)!=0)
946 (void)pthread_detach(p);
954 AC_MSG_RESULT($ac_cv_kpthread)
957 if test $ac_cv_kpthread = no -a $ac_cv_pthread_is_default = no
959 # -Kthread, 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 -Kthread,
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 -Kthread)
965 AC_CACHE_VAL(ac_cv_kthread,
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_kthread)
988 if test $ac_cv_kthread = no -a $ac_cv_pthread_is_default = no
990 # -pthread, 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 -pthread,
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 -pthread)
996 AC_CACHE_VAL(ac_cv_thread,
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_pthread)
1019 # If we have set a CC compiler flag for thread support then
1020 # check if it works for CXX, too.
1024 AC_MSG_CHECKING(whether $CXX also accepts flags for thread support)
1027 if test "$ac_cv_kpthread" = "yes"
1029 CXX="$CXX -Kpthread"
1030 ac_cv_cxx_thread=yes
1031 elif test "$ac_cv_kthread" = "yes"
1034 ac_cv_cxx_thread=yes
1035 elif test "$ac_cv_pthread" = "yes"
1038 ac_cv_cxx_thread=yes
1041 if test $ac_cv_cxx_thread = yes
1043 echo 'void foo();int main(){foo();}void foo(){}' > conftest.$ac_ext
1044 $CXX -c conftest.$ac_ext 2>&5
1045 if $CXX -o conftest$ac_exeext conftest.$ac_objext 2>&5 \
1046 && test -s conftest$ac_exeext && ./conftest$ac_exeext
1048 ac_cv_cxx_thread=yes
1054 AC_MSG_RESULT($ac_cv_cxx_thread)
1058 dnl # check for ANSI or K&R ("traditional") preprocessor
1059 dnl AC_MSG_CHECKING(for C preprocessor type)
1060 dnl AC_TRY_COMPILE([
1061 dnl #define spam(name, doc) {#name, &name, #name "() -- " doc}
1063 dnl struct {char *name; int *addr; char *doc;} desc = spam(foo, "something");
1064 dnl ], [;], cpp_type=ansi, AC_DEFINE(HAVE_OLD_CPP) cpp_type=traditional)
1065 dnl AC_MSG_RESULT($cpp_type)
1067 # checks for header files
1069 AC_CHECK_HEADERS(asm/types.h conio.h curses.h direct.h dlfcn.h errno.h \
1071 shadow.h io.h langinfo.h libintl.h ncurses.h poll.h process.h pthread.h \
1072 signal.h stropts.h termios.h thread.h \
1074 sys/audioio.h sys/bsdtty.h sys/file.h sys/loadavg.h sys/lock.h sys/mkdev.h \
1076 sys/param.h sys/poll.h sys/select.h sys/socket.h sys/statvfs.h sys/stat.h \
1078 sys/times.h sys/types.h sys/un.h sys/utsname.h sys/wait.h pty.h libutil.h \
1079 sys/resource.h netpacket/packet.h sysexits.h bluetooth.h \
1080 bluetooth/bluetooth.h)
1084 # On Solaris, term.h requires curses.h
1085 AC_CHECK_HEADERS(term.h,,,[
1086 #ifdef HAVE_CURSES_H
1091 # On Linux, netlink.h requires asm/types.h
1092 AC_CHECK_HEADERS(linux/netlink.h,,,[
1093 #ifdef HAVE_ASM_TYPES_H
1094 #include <asm/types.h>
1096 #ifdef HAVE_SYS_SOCKET_H
1097 #include <sys/socket.h>
1101 # checks for typedefs
1103 AC_MSG_CHECKING(for clock_t in time.h)
1104 AC_EGREP_HEADER(clock_t, time.h, was_it_defined=yes, [
1105 AC_DEFINE(clock_t, long, [Define to 'long' if <time.h> doesn't define.])
1107 AC_MSG_RESULT($was_it_defined)
1109 # Check whether using makedev requires defining _OSF_SOURCE
1110 AC_MSG_CHECKING(for makedev)
1111 AC_TRY_LINK([#include <sys/types.h> ],
1113 ac_cv_has_makedev=yes,
1114 ac_cv_has_makedev=no)
1115 if test "$ac_cv_has_makedev" = "no"; then
1116 # we didn't link, try if _OSF_SOURCE will allow us to link
1118 #define _OSF_SOURCE 1
1119 #include <sys/types.h>
1122 ac_cv_has_makedev=yes,
1123 ac_cv_has_makedev=no)
1124 if test "$ac_cv_has_makedev" = "yes"; then
1125 AC_DEFINE(_OSF_SOURCE, 1, [Define _OSF_SOURCE to get the makedev macro.])
1128 AC_MSG_RESULT($ac_cv_has_makedev)
1129 if test "$ac_cv_has_makedev" = "yes"; then
1130 AC_DEFINE(HAVE_MAKEDEV, 1, [Define this if you have the makedev macro.])
1133 # Enabling LFS on Solaris (2.6 to 9) with gcc 2.95 triggers a bug in
1134 # the system headers: If _XOPEN_SOURCE and _LARGEFILE_SOURCE are
1135 # defined, but the compiler does not support pragma redefine_extname,
1136 # and _LARGEFILE64_SOURCE is not defined, the headers refer to 64-bit
1137 # structures (such as rlimit64) without declaring them. As a
1138 # work-around, disable LFS on such configurations
1141 AC_MSG_CHECKING(Solaris LFS bug)
1143 #define _LARGEFILE_SOURCE 1
1144 #define _FILE_OFFSET_BITS 64
1145 #include <sys/resource.h>
1146 ],struct rlimit foo;,sol_lfs_bug=no,sol_lfs_bug=yes)
1147 AC_MSG_RESULT($sol_lfs_bug)
1148 if test "$sol_lfs_bug" = "yes"; then
1152 if test "$use_lfs" = "yes"; then
1153 # Two defines needed to enable largefile support on various platforms
1154 # These may affect some typedefs
1155 AC_DEFINE(_LARGEFILE_SOURCE, 1,
1156 [This must be defined on some systems to enable large file support.])
1157 AC_DEFINE(_FILE_OFFSET_BITS, 64,
1158 [This must be set to 64 on some systems to enable large file support.])
1161 # Add some code to confdefs.h so that the test for off_t works on SCO
1162 cat >> confdefs.h <<\EOF
1168 # Type availability checks
1175 AC_CHECK_TYPE(ssize_t,
1176 AC_DEFINE(HAVE_SSIZE_T, 1, Define if your compiler provides ssize_t),,)
1178 # Sizes of various common basic types
1179 # ANSI C requires sizeof(char) == 1, so no need to check it
1180 AC_CHECK_SIZEOF(int, 4)
1181 AC_CHECK_SIZEOF(long, 4)
1182 AC_CHECK_SIZEOF(void *, 4)
1183 AC_CHECK_SIZEOF(short, 2)
1184 AC_CHECK_SIZEOF(float, 4)
1185 AC_CHECK_SIZEOF(double, 8)
1186 AC_CHECK_SIZEOF(fpos_t, 4)
1187 AC_CHECK_SIZEOF(size_t, 4)
1189 AC_MSG_CHECKING(for long long support)
1191 AC_TRY_COMPILE([], [long long x; x = (long long)0;], [
1192 AC_DEFINE(HAVE_LONG_LONG, 1, [Define this if you have the type long long.])
1195 AC_MSG_RESULT($have_long_long)
1196 if test "$have_long_long" = yes ; then
1197 AC_CHECK_SIZEOF(long long, 8)
1200 AC_MSG_CHECKING(for uintptr_t support)
1202 AC_TRY_COMPILE([], [uintptr_t x; x = (uintptr_t)0;], [
1203 AC_DEFINE(HAVE_UINTPTR_T, 1, [Define this if you have the type uintptr_t.])
1206 AC_MSG_RESULT($have_uintptr_t)
1207 if test "$have_uintptr_t" = yes ; then
1208 AC_CHECK_SIZEOF(uintptr_t, 4)
1211 # Hmph. AC_CHECK_SIZEOF() doesn't include <sys/types.h>.
1212 AC_MSG_CHECKING(size of off_t)
1213 AC_CACHE_VAL(ac_cv_sizeof_off_t,
1214 [AC_TRY_RUN([#include <stdio.h>
1215 #include <sys/types.h>
1218 FILE *f=fopen("conftestval", "w");
1220 fprintf(f, "%d\n", sizeof(off_t));
1223 ac_cv_sizeof_off_t=`cat conftestval`,
1224 ac_cv_sizeof_off_t=0,
1225 ac_cv_sizeof_off_t=4)
1227 AC_MSG_RESULT($ac_cv_sizeof_off_t)
1228 AC_DEFINE_UNQUOTED(SIZEOF_OFF_T, $ac_cv_sizeof_off_t,
1229 [The number of bytes in an off_t.])
1231 AC_MSG_CHECKING(whether to enable large file support)
1232 if test "$have_long_long" = yes -a \
1233 "$ac_cv_sizeof_off_t" -gt "$ac_cv_sizeof_long" -a \
1234 "$ac_cv_sizeof_long_long" -ge "$ac_cv_sizeof_off_t"; then
1235 AC_DEFINE(HAVE_LARGEFILE_SUPPORT, 1,
1236 [Defined to enable large file support when an off_t is bigger than a long
1237 and long long is available and at least as big as an off_t. You may need
1238 to add some flags for configuration and compilation to enable this mode.
1239 (For Solaris and Linux, the necessary defines are already defined.)])
1245 # AC_CHECK_SIZEOF() doesn't include <time.h>.
1246 AC_MSG_CHECKING(size of time_t)
1247 AC_CACHE_VAL(ac_cv_sizeof_time_t,
1248 [AC_TRY_RUN([#include <stdio.h>
1252 FILE *f=fopen("conftestval", "w");
1254 fprintf(f, "%d\n", sizeof(time_t));
1257 ac_cv_sizeof_time_t=`cat conftestval`,
1258 ac_cv_sizeof_time_t=0,
1259 ac_cv_sizeof_time_t=4)
1261 AC_MSG_RESULT($ac_cv_sizeof_time_t)
1262 AC_DEFINE_UNQUOTED(SIZEOF_TIME_T, $ac_cv_sizeof_time_t,
1263 [The number of bytes in a time_t.])
1266 # if have pthread_t then define SIZEOF_PTHREAD_T
1268 if test "$ac_cv_kpthread" = "yes"
1269 then CC="$CC -Kpthread"
1270 elif test "$ac_cv_kthread" = "yes"
1271 then CC="$CC -Kthread"
1272 elif test "$ac_cv_pthread" = "yes"
1273 then CC="$CC -pthread"
1275 AC_MSG_CHECKING(for pthread_t)
1277 AC_TRY_COMPILE([#include <pthread.h>], [pthread_t x; x = *(pthread_t*)0;], have_pthread_t=yes)
1278 AC_MSG_RESULT($have_pthread_t)
1279 if test "$have_pthread_t" = yes ; then
1280 # AC_CHECK_SIZEOF() doesn't include <pthread.h>.
1281 AC_MSG_CHECKING(size of pthread_t)
1282 AC_CACHE_VAL(ac_cv_sizeof_pthread_t,
1283 [AC_TRY_RUN([#include <stdio.h>
1284 #include <pthread.h>
1287 FILE *f=fopen("conftestval", "w");
1289 fprintf(f, "%d\n", sizeof(pthread_t));
1292 ac_cv_sizeof_pthread_t=`cat conftestval`,
1293 ac_cv_sizeof_pthread_t=0,
1294 ac_cv_sizeof_pthread_t=4)
1296 AC_MSG_RESULT($ac_cv_sizeof_pthread_t)
1297 AC_DEFINE_UNQUOTED(SIZEOF_PTHREAD_T, $ac_cv_sizeof_pthread_t,
1298 [The number of bytes in a pthread_t.])
1302 AC_MSG_CHECKING(for --enable-toolbox-glue)
1303 AC_ARG_ENABLE(toolbox-glue,
1304 AC_HELP_STRING(--enable-toolbox-glue, disable/enable MacOSX glue code for extensions))
1306 if test -z "$enable_toolbox_glue"
1308 case $ac_sys_system/$ac_sys_release in
1310 enable_toolbox_glue="yes";;
1312 enable_toolbox_glue="no";;
1315 case "$enable_toolbox_glue" in
1317 extra_machdep_objs="Python/mactoolboxglue.o"
1318 extra_undefs="-u _PyMac_Error"
1319 AC_DEFINE(USE_TOOLBOX_OBJECT_GLUE, 1,
1320 [Define if you want to use MacPython modules on MacOSX in unix-Python.])
1323 extra_machdep_objs=""
1327 AC_MSG_RESULT($enable_toolbox_glue)
1329 AC_SUBST(OTHER_LIBTOOL_OPT)
1330 case $ac_sys_system/$ac_sys_release in
1331 Darwin/@<:@01567@:>@\..*)
1332 OTHER_LIBTOOL_OPT="-prebind -seg1addr 0x10000000"
1335 OTHER_LIBTOOL_OPT=""
1339 AC_SUBST(LIBTOOL_CRUFT)
1340 case $ac_sys_system/$ac_sys_release in
1341 Darwin/@<:@01567@:>@\..*)
1342 LIBTOOL_CRUFT="-framework System -lcc_dynamic"
1343 if test "${enable_universalsdk}"; then
1346 LIBTOOL_CRUFT="${LIBTOOL_CRUFT} -arch_only `arch`"
1348 LIBTOOL_CRUFT=$LIBTOOL_CRUFT' -install_name $(PYTHONFRAMEWORKINSTALLDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1349 LIBTOOL_CRUFT=$LIBTOOL_CRUFT' -compatibility_version $(VERSION) -current_version $(VERSION)';;
1351 gcc_version=`gcc -v 2>&1 | grep version | cut -d\ -f3`
1352 if test ${gcc_version} '<' 4.0
1354 LIBTOOL_CRUFT="-lcc_dynamic"
1358 LIBTOOL_CRUFT=$LIBTOOL_CRUFT" -lSystem -lSystemStubs -arch_only `arch`"
1359 LIBTOOL_CRUFT=$LIBTOOL_CRUFT' -install_name $(PYTHONFRAMEWORKINSTALLDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1360 LIBTOOL_CRUFT=$LIBTOOL_CRUFT' -compatibility_version $(VERSION) -current_version $(VERSION)';;
1363 AC_MSG_CHECKING(for --enable-framework)
1364 if test "$enable_framework"
1366 BASECFLAGS="$BASECFLAGS -fno-common -dynamic"
1367 # -F. is needed to allow linking to the framework while
1368 # in the build location.
1369 AC_DEFINE(WITH_NEXT_FRAMEWORK, 1,
1370 [Define if you want to produce an OpenStep/Rhapsody framework
1371 (shared library plus accessory files).])
1377 AC_MSG_CHECKING(for dyld)
1378 case $ac_sys_system/$ac_sys_release in
1380 AC_DEFINE(WITH_DYLD, 1,
1381 [Define if you want to use the new-style (Openstep, Rhapsody, MacOS)
1382 dynamic linker (dyld) instead of the old-style (NextStep) dynamic
1383 linker (rld). Dyld is necessary to support frameworks.])
1384 AC_MSG_RESULT(always on for Darwin)
1391 # Set info about shared libraries.
1396 AC_SUBST(LINKFORSHARED)
1397 # SO is the extension of shared libraries `(including the dot!)
1398 # -- usually .so, .sl on HP-UX, .dll on Cygwin
1402 case $ac_sys_system in
1413 # this might also be a termcap variable, see #610332
1415 echo '====================================================================='
1417 echo '+ WARNING: You have set SO in your environment. +'
1418 echo '+ Do you really mean to change the extension for shared libraries? +'
1419 echo '+ Continuing in 10 seconds to let you to ponder. +'
1421 echo '====================================================================='
1425 AC_DEFINE_UNQUOTED(SHLIB_EXT, "$SO", [Define this to be extension of shared libraries (including the dot!).])
1426 # LDSHARED is the ld *command* used to create shared library
1427 # -- "cc -G" on SunOS 5.x, "ld -shared" on IRIX 5
1428 # (Shared libraries in this instance are shared modules to be loaded into
1429 # Python, as opposed to building Python itself as a shared library.)
1430 AC_MSG_CHECKING(LDSHARED)
1431 if test -z "$LDSHARED"
1433 case $ac_sys_system/$ac_sys_release in
1435 BLDSHARED="\$(srcdir)/Modules/ld_so_aix \$(CC) -bI:Modules/python.exp"
1436 LDSHARED="\$(BINLIBDEST)/config/ld_so_aix \$(CC) -bI:\$(BINLIBDEST)/config/python.exp"
1439 BLDSHARED="\$(srcdir)/Modules/ld_so_beos $LDLIBRARY"
1440 LDSHARED="\$(BINLIBDEST)/config/ld_so_beos \$(LIBDIR)/$LDLIBRARY"
1442 IRIX/5*) LDSHARED="ld -shared";;
1443 IRIX*/6*) LDSHARED="ld ${SGI_ABI} -shared -all";;
1445 if test "$GCC" = "yes"
1446 then LDSHARED='$(CC) -shared'
1447 else LDSHARED='$(CC) -G';
1449 hp*|HP*) LDSHARED="ld -b";;
1450 OSF*) LDSHARED="ld -shared -expect_unresolved \"*\"";;
1452 LDSHARED='$(CC) $(LDFLAGS) -bundle'
1453 if test "$enable_framework" ; then
1454 # Link against the framework. All externals should be defined.
1455 BLDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1456 LDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKPREFIX)/$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1458 # No framework. Ignore undefined symbols, assuming they come from Python
1459 LDSHARED="$LDSHARED -undefined suppress"
1461 Darwin/1.4*|Darwin/5.*|Darwin/6.*)
1462 LDSHARED='$(CC) $(LDFLAGS) -bundle'
1463 if test "$enable_framework" ; then
1464 # Link against the framework. All externals should be defined.
1465 BLDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1466 LDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKPREFIX)/$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1468 # No framework, use the Python app as bundle-loader
1469 BLDSHARED="$LDSHARED "'-bundle_loader $(BUILDPYTHON)'
1470 LDSHARED="$LDSHARED "'-bundle_loader $(BINDIR)/python$(VERSION)$(EXE)'
1473 # Use -undefined dynamic_lookup whenever possible (10.3 and later).
1474 # This allows an extension to be used in any Python
1475 cur_target=`sw_vers -productVersion | sed 's/\(10\.[[0-9]]*\).*/\1/'`
1476 if test ${cur_target} '>' 10.2; then
1479 CONFIGURE_MACOSX_DEPLOYMENT_TARGET=${MACOSX_DEPLOYMENT_TARGET-${cur_target}}
1480 EXPORT_MACOSX_DEPLOYMENT_TARGET=''
1481 if test ${MACOSX_DEPLOYMENT_TARGET-${cur_target}} '>' 10.2
1483 if test "${enable_universalsdk}"; then
1484 LDFLAGS="-arch i386 -arch ppc -isysroot ${UNIVERSALSDK} ${LDFLAGS}"
1486 LDSHARED='$(CC) $(LDFLAGS) -bundle -undefined dynamic_lookup'
1487 BLDSHARED="$LDSHARED"
1489 LDSHARED='$(CC) $(LDFLAGS) -bundle'
1490 if test "$enable_framework" ; then
1491 # Link against the framework. All externals should be defined.
1492 BLDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1493 LDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKPREFIX)/$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1495 # No framework, use the Python app as bundle-loader
1496 BLDSHARED="$LDSHARED "'-bundle_loader $(BUILDPYTHON)'
1497 LDSHARED="$LDSHARED "'-bundle_loader $(BINDIR)/python$(VERSION)$(EXE)'
1501 Linux*|GNU*) LDSHARED='$(CC) -shared';;
1502 BSD/OS*/4*) LDSHARED="gcc -shared";;
1504 if [[ "`$CC -dM -E - </dev/null | grep __ELF__`" != "" ]]
1506 LDSHARED="$CC -shared ${LDFLAGS}"
1508 LDSHARED="ld -Bshareable ${LDFLAGS}"
1511 if [[ "`$CC -dM -E - </dev/null | grep __ELF__`" != "" ]]
1513 LDSHARED='$(CC) -shared $(CCSHARED) ${LDFLAGS}'
1516 [[01]].* | 2.[[0-7]] | 2.[[0-7]].*)
1517 LDSHARED="ld -Bshareable ${LDFLAGS}"
1520 LDSHARED='$(CC) -shared $(CCSHARED) ${LDFLAGS}'
1524 NetBSD*|DragonFly*) LDSHARED="cc -shared ${LDFLAGS}";;
1525 OpenUNIX*|UnixWare*)
1526 if test "$GCC" = "yes"
1527 then LDSHARED='$(CC) -shared'
1528 else LDSHARED='$(CC) -G'
1530 SCO_SV*) LDSHARED='$(CC) -Wl,-G,-Bexport';;
1531 Monterey*) LDSHARED="cc -G -dy -Bdynamic -Bexport -L/usr/lib/ia64l64";;
1532 CYGWIN*) LDSHARED="gcc -shared -Wl,--enable-auto-image-base";;
1533 atheos*) LDSHARED="gcc -shared";;
1537 AC_MSG_RESULT($LDSHARED)
1538 BLDSHARED=${BLDSHARED-$LDSHARED}
1539 # CCSHARED are the C *flags* used to create objects to go into a shared
1540 # library (module) -- this is only needed for a few systems
1541 AC_MSG_CHECKING(CCSHARED)
1542 if test -z "$CCSHARED"
1544 case $ac_sys_system/$ac_sys_release in
1545 SunOS*) if test "$GCC" = yes;
1546 then CCSHARED="-fPIC";
1547 else CCSHARED="-xcode=pic32";
1549 hp*|HP*) if test "$GCC" = yes;
1550 then CCSHARED="-fPIC";
1553 Linux*|GNU*) CCSHARED="-fPIC";;
1554 BSD/OS*/4*) CCSHARED="-fpic";;
1555 FreeBSD*|NetBSD*|OpenBSD*|DragonFly*) CCSHARED="-fPIC";;
1556 OpenUNIX*|UnixWare*)
1557 if test "$GCC" = "yes"
1558 then CCSHARED="-fPIC"
1559 else CCSHARED="-KPIC"
1562 if test "$GCC" = "yes"
1563 then CCSHARED="-fPIC"
1564 else CCSHARED="-Kpic -belf"
1566 Monterey*) CCSHARED="-G";;
1567 IRIX*/6*) case $CC in
1568 *gcc*) CCSHARED="-shared";;
1571 atheos*) CCSHARED="-fPIC";;
1574 AC_MSG_RESULT($CCSHARED)
1575 # LINKFORSHARED are the flags passed to the $(CC) command that links
1576 # the python executable -- this is only needed for a few systems
1577 AC_MSG_CHECKING(LINKFORSHARED)
1578 if test -z "$LINKFORSHARED"
1580 case $ac_sys_system/$ac_sys_release in
1581 AIX*) LINKFORSHARED='-Wl,-bE:Modules/python.exp -lld';;
1583 LINKFORSHARED="-Wl,-E -Wl,+s";;
1584 # LINKFORSHARED="-Wl,-E -Wl,+s -Wl,+b\$(BINLIBDEST)/lib-dynload";;
1585 BSD/OS/4*) LINKFORSHARED="-Xlinker -export-dynamic";;
1586 Linux*|GNU*) LINKFORSHARED="-Xlinker -export-dynamic";;
1587 # -u libsys_s pulls in all symbols in libsys
1589 # -u _PyMac_Error is needed to pull in the mac toolbox glue,
1591 # not used by the core itself but which needs to be in the core so
1592 # that dynamically loaded extension modules have access to it.
1593 # -prebind is no longer used, because it actually seems to give a
1594 # slowdown in stead of a speedup, maybe due to the large number of
1595 # dynamic loads Python does.
1597 LINKFORSHARED="$extra_undefs"
1598 if test "$enable_framework"
1600 LINKFORSHARED="$LINKFORSHARED "'$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1602 LINKFORSHARED="$LINKFORSHARED";;
1603 OpenUNIX*|UnixWare*) LINKFORSHARED="-Wl,-Bexport";;
1604 SCO_SV*) LINKFORSHARED="-Wl,-Bexport";;
1605 ReliantUNIX*) LINKFORSHARED="-W1 -Blargedynsym";;
1606 FreeBSD*|NetBSD*|OpenBSD*|DragonFly*)
1607 if [[ "`$CC -dM -E - </dev/null | grep __ELF__`" != "" ]]
1609 LINKFORSHARED="-Wl,--export-dynamic"
1611 SunOS/5*) case $CC in
1613 if $CC -Xlinker --help 2>&1 | grep export-dynamic >/dev/null
1615 LINKFORSHARED="-Xlinker --export-dynamic"
1619 if test $enable_shared = "no"
1621 LINKFORSHARED='-Wl,--out-implib=$(LDLIBRARY)'
1625 AC_MSG_RESULT($LINKFORSHARED)
1627 AC_SUBST(CFLAGSFORSHARED)
1628 AC_MSG_CHECKING(CFLAGSFORSHARED)
1629 if test ! "$LIBRARY" = "$LDLIBRARY"
1631 case $ac_sys_system in
1633 # Cygwin needs CCSHARED when building extension DLLs
1634 # but not when building the interpreter DLL.
1635 CFLAGSFORSHARED='';;
1637 CFLAGSFORSHARED='$(CCSHARED)'
1640 AC_MSG_RESULT($CFLAGSFORSHARED)
1642 # SHLIBS are libraries (except -lc and -lm) to link to the python shared
1643 # library (with --enable-shared).
1644 # For platforms on which shared libraries are not allowed to have unresolved
1645 # symbols, this must be set to $(LIBS) (expanded by make). We do this even
1646 # if it is not required, since it creates a dependency of the shared library
1647 # to LIBS. This, in turn, means that applications linking the shared libpython
1648 # don't need to link LIBS explicitly. The default should be only changed
1649 # on systems where this approach causes problems.
1651 AC_MSG_CHECKING(SHLIBS)
1652 case "$ac_sys_system" in
1656 AC_MSG_RESULT($SHLIBS)
1659 # checks for libraries
1660 AC_CHECK_LIB(dl, dlopen) # Dynamic linking for SunOS/Solaris and SYSV
1661 AC_CHECK_LIB(dld, shl_load) # Dynamic linking for HP-UX
1663 # only check for sem_ini if thread support is requested
1664 if test "$with_threads" = "yes" -o -z "$with_threads"; then
1665 AC_SEARCH_LIBS(sem_init, pthread rt posix4) # 'Real Time' functions on Solaris
1666 # posix4 on Solaris 2.6
1667 # pthread (first!) on Linux
1670 # check if we need libintl for locale functions
1671 AC_CHECK_LIB(intl, textdomain,
1672 AC_DEFINE(WITH_LIBINTL, 1,
1673 [Define to 1 if libintl is needed for locale functions.]))
1675 # checks for system dependent C++ extensions support
1676 case "$ac_sys_system" in
1677 AIX*) AC_MSG_CHECKING(for genuine AIX C++ extensions support)
1678 AC_TRY_LINK([#include "/usr/lpp/xlC/include/load.h"],
1679 [loadAndInit("", 0, "")],
1680 [AC_DEFINE(AIX_GENUINE_CPLUSPLUS, 1,
1681 [Define for AIX if your compiler is a genuine IBM xlC/xlC_r
1682 and you want support for AIX C++ shared extension modules.])
1683 AC_MSG_RESULT(yes)],
1684 [AC_MSG_RESULT(no)]);;
1688 # Most SVR4 platforms (e.g. Solaris) need -lsocket and -lnsl.
1689 # BeOS' sockets are stashed in libnet.
1690 AC_CHECK_LIB(nsl, t_open, [LIBS="-lnsl $LIBS"]) # SVR4
1691 AC_CHECK_LIB(socket, socket, [LIBS="-lsocket $LIBS"], [], $LIBS) # SVR4 sockets
1693 case "$ac_sys_system" in
1695 AC_CHECK_LIB(net, socket, [LIBS="-lnet $LIBS"], [], $LIBS) # BeOS
1699 AC_MSG_CHECKING(for --with-libs)
1701 AC_HELP_STRING(--with-libs='lib1 ...', link against additional libs),
1703 AC_MSG_RESULT($withval)
1704 LIBS="$withval $LIBS"
1706 [AC_MSG_RESULT(no)])
1708 # Check for use of the system libffi library
1709 AC_MSG_CHECKING(for --with-system-ffi)
1710 AC_ARG_WITH(system_ffi,
1711 AC_HELP_STRING(--with-system-ffi, build _ctypes module using an installed ffi library))
1713 if test -z "$with_system_ffi"
1714 then with_system_ffi="no"
1716 AC_MSG_RESULT($with_system_ffi)
1718 # Determine if signalmodule should be used.
1719 AC_SUBST(USE_SIGNAL_MODULE)
1720 AC_SUBST(SIGNAL_OBJS)
1721 AC_MSG_CHECKING(for --with-signal-module)
1722 AC_ARG_WITH(signal-module,
1723 AC_HELP_STRING(--with-signal-module, disable/enable signal module))
1725 if test -z "$with_signal_module"
1726 then with_signal_module="yes"
1728 AC_MSG_RESULT($with_signal_module)
1730 if test "${with_signal_module}" = "yes"; then
1731 USE_SIGNAL_MODULE=""
1734 USE_SIGNAL_MODULE="#"
1735 SIGNAL_OBJS="Parser/intrcheck.o Python/sigcheck.o"
1738 # This is used to generate Setup.config
1739 AC_SUBST(USE_THREAD_MODULE)
1740 USE_THREAD_MODULE=""
1742 AC_MSG_CHECKING(for --with-dec-threads)
1744 AC_ARG_WITH(dec-threads,
1745 AC_HELP_STRING(--with-dec-threads, use DEC Alpha/OSF1 thread-safe libraries),
1747 AC_MSG_RESULT($withval)
1749 if test "${with_thread+set}" != set; then
1750 with_thread="$withval";
1752 [AC_MSG_RESULT(no)])
1754 # Templates for things AC_DEFINEd more than once.
1755 # For a single AC_DEFINE, no template is needed.
1756 AH_TEMPLATE(C_THREADS,[Define if you have the Mach cthreads package])
1757 AH_TEMPLATE(_REENTRANT,
1758 [Define to force use of thread-safe errno, h_errno, and other functions])
1759 AH_TEMPLATE(WITH_THREAD,
1760 [Define if you want to compile in rudimentary thread support])
1762 AC_MSG_CHECKING(for --with-threads)
1763 dnl quadrigraphs "@<:@" and "@:>@" produce "[" and "]" in the output
1764 AC_ARG_WITH(threads,
1765 AC_HELP_STRING(--with(out)-threads@<:@=DIRECTORY@:>@, disable/enable thread support))
1767 # --with-thread is deprecated, but check for it anyway
1768 dnl quadrigraphs "@<:@" and "@:>@" produce "[" and "]" in the output
1770 AC_HELP_STRING(--with(out)-thread@<:@=DIRECTORY@:>@, deprecated; use --with(out)-threads),
1771 [with_threads=$with_thread])
1773 if test -z "$with_threads"
1774 then with_threads="yes"
1776 AC_MSG_RESULT($with_threads)
1779 if test "$with_threads" = "no"
1781 USE_THREAD_MODULE="#"
1782 elif test "$ac_cv_pthread_is_default" = yes
1784 AC_DEFINE(WITH_THREAD)
1785 # Defining _REENTRANT on system with POSIX threads should not hurt.
1786 AC_DEFINE(_REENTRANT)
1788 THREADOBJ="Python/thread.o"
1789 elif test "$ac_cv_kpthread" = "yes"
1792 if test "$ac_cv_cxx_thread" = "yes"; then
1793 CXX="$CXX -Kpthread"
1795 AC_DEFINE(WITH_THREAD)
1797 THREADOBJ="Python/thread.o"
1798 elif test "$ac_cv_kthread" = "yes"
1801 if test "$ac_cv_cxx_thread" = "yes"; then
1804 AC_DEFINE(WITH_THREAD)
1806 THREADOBJ="Python/thread.o"
1807 elif test "$ac_cv_pthread" = "yes"
1810 if test "$ac_cv_cxx_thread" = "yes"; then
1813 AC_DEFINE(WITH_THREAD)
1815 THREADOBJ="Python/thread.o"
1817 if test ! -z "$with_threads" -a -d "$with_threads"
1818 then LDFLAGS="$LDFLAGS -L$with_threads"
1820 if test ! -z "$withval" -a -d "$withval"
1821 then LDFLAGS="$LDFLAGS -L$withval"
1824 # According to the POSIX spec, a pthreads implementation must
1825 # define _POSIX_THREADS in unistd.h. Some apparently don't
1826 # (e.g. gnu pth with pthread emulation)
1827 AC_MSG_CHECKING(for _POSIX_THREADS in unistd.h)
1831 #ifdef _POSIX_THREADS
1834 ], unistd_defines_pthreads=yes, unistd_defines_pthreads=no)
1835 AC_MSG_RESULT($unistd_defines_pthreads)
1837 AC_DEFINE(_REENTRANT)
1838 AC_CHECK_HEADER(cthreads.h, [AC_DEFINE(WITH_THREAD)
1839 AC_DEFINE(C_THREADS)
1840 AC_DEFINE(HURD_C_THREADS, 1,
1841 [Define if you are using Mach cthreads directly under /include])
1842 LIBS="$LIBS -lthreads"
1843 THREADOBJ="Python/thread.o"],[
1844 AC_CHECK_HEADER(mach/cthreads.h, [AC_DEFINE(WITH_THREAD)
1845 AC_DEFINE(C_THREADS)
1846 AC_DEFINE(MACH_C_THREADS, 1,
1847 [Define if you are using Mach cthreads under mach /])
1848 THREADOBJ="Python/thread.o"],[
1849 AC_MSG_CHECKING(for --with-pth)
1851 AC_HELP_STRING(--with-pth, use GNU pth threading libraries),
1852 [AC_MSG_RESULT($withval)
1853 AC_DEFINE([WITH_THREAD])
1854 AC_DEFINE([HAVE_PTH], 1,
1855 [Define if you have GNU PTH threads.])
1857 THREADOBJ="Python/thread.o"],
1860 # Just looking for pthread_create in libpthread is not enough:
1861 # on HP/UX, pthread.h renames pthread_create to a different symbol name.
1862 # So we really have to include pthread.h, and then link.
1864 LIBS="$LIBS -lpthread"
1865 AC_MSG_CHECKING([for pthread_create in -lpthread])
1866 AC_TRY_LINK([#include <pthread.h>
1868 void * start_routine (void *arg) { exit (0); }], [
1869 pthread_create (NULL, NULL, start_routine, NULL)], [
1871 AC_DEFINE(WITH_THREAD)
1873 THREADOBJ="Python/thread.o"],[
1875 AC_CHECK_FUNC(pthread_detach, [AC_DEFINE(WITH_THREAD)
1877 THREADOBJ="Python/thread.o"],[
1878 AC_CHECK_HEADER(atheos/threads.h, [AC_DEFINE(WITH_THREAD)
1879 AC_DEFINE(ATHEOS_THREADS, 1,
1880 [Define this if you have AtheOS threads.])
1881 THREADOBJ="Python/thread.o"],[
1882 AC_CHECK_HEADER(kernel/OS.h, [AC_DEFINE(WITH_THREAD)
1883 AC_DEFINE(BEOS_THREADS, 1,
1884 [Define this if you have BeOS threads.])
1885 THREADOBJ="Python/thread.o"],[
1886 AC_CHECK_LIB(pthreads, pthread_create, [AC_DEFINE(WITH_THREAD)
1888 LIBS="$LIBS -lpthreads"
1889 THREADOBJ="Python/thread.o"], [
1890 AC_CHECK_LIB(c_r, pthread_create, [AC_DEFINE(WITH_THREAD)
1893 THREADOBJ="Python/thread.o"], [
1894 AC_CHECK_LIB(pthread, __pthread_create_system, [AC_DEFINE(WITH_THREAD)
1896 LIBS="$LIBS -lpthread"
1897 THREADOBJ="Python/thread.o"], [
1898 AC_CHECK_LIB(cma, pthread_create, [AC_DEFINE(WITH_THREAD)
1901 THREADOBJ="Python/thread.o"],[
1902 USE_THREAD_MODULE="#"])
1903 ])])])])])])])])])])
1905 AC_CHECK_LIB(mpc, usconfig, [AC_DEFINE(WITH_THREAD)
1907 THREADOBJ="Python/thread.o"
1908 USE_THREAD_MODULE=""])
1910 if test "$posix_threads" != "yes"; then
1911 AC_CHECK_LIB(thread, thr_create, [AC_DEFINE(WITH_THREAD)
1912 LIBS="$LIBS -lthread"
1913 THREADOBJ="Python/thread.o"
1914 USE_THREAD_MODULE=""])
1917 if test "$USE_THREAD_MODULE" != "#"
1919 # If the above checks didn't disable threads, (at least) OSF1
1920 # needs this '-threads' argument during linking.
1921 case $ac_sys_system in
1922 OSF1) LDLAST=-threads;;
1927 if test "$posix_threads" = "yes"; then
1928 if test "$unistd_defines_pthreads" = "no"; then
1929 AC_DEFINE(_POSIX_THREADS, 1,
1930 [Define if you have POSIX threads,
1931 and your system does not define that.])
1934 # Bug 662787: Using semaphores causes unexplicable hangs on Solaris 8.
1935 case $ac_sys_system/$ac_sys_release in
1936 SunOS/5.6) AC_DEFINE(HAVE_PTHREAD_DESTRUCTOR, 1,
1937 Defined for Solaris 2.6 bug in pthread header.)
1939 SunOS/5.8) AC_DEFINE(HAVE_BROKEN_POSIX_SEMAPHORES, 1,
1940 Define if the Posix semaphores do not work on your system)
1944 AC_MSG_CHECKING(if PTHREAD_SCOPE_SYSTEM is supported)
1945 AC_CACHE_VAL(ac_cv_pthread_system_supported,
1946 [AC_TRY_RUN([#include <pthread.h>
1947 void *foo(void *parm) {
1951 pthread_attr_t attr;
1953 if (pthread_attr_init(&attr)) exit(-1);
1954 if (pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM)) exit(-1);
1955 if (pthread_create(&id, &attr, foo, NULL)) exit(-1);
1958 ac_cv_pthread_system_supported=yes,
1959 ac_cv_pthread_system_supported=no,
1960 ac_cv_pthread_system_supported=no)
1962 AC_MSG_RESULT($ac_cv_pthread_system_supported)
1963 if test "$ac_cv_pthread_system_supported" = "yes"; then
1964 AC_DEFINE(PTHREAD_SYSTEM_SCHED_SUPPORTED, 1, [Defined if PTHREAD_SCOPE_SYSTEM supported.])
1966 AC_CHECK_FUNCS(pthread_sigmask,
1967 [case $ac_sys_system in
1969 AC_DEFINE(HAVE_BROKEN_PTHREAD_SIGMASK, 1,
1970 [Define if pthread_sigmask() does not work on your system.])
1976 # Check for enable-ipv6
1977 AH_TEMPLATE(ENABLE_IPV6, [Define if --enable-ipv6 is specified])
1978 AC_MSG_CHECKING([if --enable-ipv6 is specified])
1980 [ --enable-ipv6 Enable ipv6 (with ipv4) support
1981 --disable-ipv6 Disable ipv6 support],
1982 [ case "$enableval" in
1987 *) AC_MSG_RESULT(yes)
1988 AC_DEFINE(ENABLE_IPV6)
1994 dnl the check does not work on cross compilation case...
1995 AC_TRY_RUN([ /* AF_INET6 available check */
1996 #include <sys/types.h>
1997 #include <sys/socket.h>
2000 if (socket(AF_INET6, SOCK_STREAM, 0) < 0)
2014 if test "$ipv6" = "yes"; then
2015 AC_MSG_CHECKING(if RFC2553 API is available)
2016 AC_TRY_COMPILE([#include <sys/types.h>
2017 #include <netinet/in.h>],
2018 [struct sockaddr_in6 x;
2022 AC_MSG_RESULT(no, IPv6 disabled)
2026 if test "$ipv6" = "yes"; then
2027 AC_DEFINE(ENABLE_IPV6)
2035 if test "$ipv6" = "yes"; then
2036 AC_MSG_CHECKING([ipv6 stack type])
2037 for i in inria kame linux-glibc linux-inet6 solaris toshiba v6d zeta;
2041 dnl http://www.kame.net/
2043 #include <netinet/in.h>
2044 #ifdef IPV6_INRIA_VERSION
2050 dnl http://www.kame.net/
2052 #include <netinet/in.h>
2058 ipv6libdir=/usr/local/v6/lib
2062 dnl http://www.v6.linux.or.jp/
2064 #include <features.h>
2065 #if defined(__GLIBC__) && ((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 1) || (__GLIBC__ > 2))
2072 dnl http://www.v6.linux.or.jp/
2073 if test -d /usr/inet6; then
2076 ipv6libdir=/usr/inet6/lib
2077 BASECFLAGS="-I/usr/inet6/include $BASECFLAGS"
2081 if test -f /etc/netconfig; then
2082 if /usr/xpg4/bin/grep -q tcp6 /etc/netconfig; then
2090 #include <sys/param.h>
2091 #ifdef _TOSHIBA_INET6
2096 ipv6libdir=/usr/local/v6/lib])
2100 #include </usr/local/v6/include/sys/v6config.h>
2106 ipv6libdir=/usr/local/v6/lib;
2107 BASECFLAGS="-I/usr/local/v6/include $BASECFLAGS"])
2111 #include <sys/param.h>
2112 #ifdef _ZETA_MINAMI_INET6
2117 ipv6libdir=/usr/local/v6/lib])
2120 if test "$ipv6type" != "unknown"; then
2124 AC_MSG_RESULT($ipv6type)
2127 if test "$ipv6" = "yes" -a "$ipv6lib" != "none"; then
2128 if test -d $ipv6libdir -a -f $ipv6libdir/lib$ipv6lib.a; then
2129 LIBS="-L$ipv6libdir -l$ipv6lib $LIBS"
2130 echo "using lib$ipv6lib"
2132 if test $ipv6trylibc = "yes"; then
2135 echo 'Fatal: no $ipv6lib library found. cannot continue.'
2136 echo "You need to fetch lib$ipv6lib.a from appropriate"
2137 echo 'ipv6 kit and compile beforehand.'
2143 # Check for --with-doc-strings
2144 AC_MSG_CHECKING(for --with-doc-strings)
2145 AC_ARG_WITH(doc-strings,
2146 AC_HELP_STRING(--with(out)-doc-strings, disable/enable documentation strings))
2148 if test -z "$with_doc_strings"
2149 then with_doc_strings="yes"
2151 if test "$with_doc_strings" != "no"
2153 AC_DEFINE(WITH_DOC_STRINGS, 1,
2154 [Define if you want documentation strings in extension modules])
2156 AC_MSG_RESULT($with_doc_strings)
2158 # Check for Python-specific malloc support
2159 AC_MSG_CHECKING(for --with-tsc)
2161 [ --with(out)-tsc enable/disable timestamp counter profile], [
2162 if test "$withval" != no
2164 AC_DEFINE(WITH_TSC, 1,
2165 [Define to profile with the Pentium timestamp counter])
2167 else AC_MSG_RESULT(no)
2169 [AC_MSG_RESULT(no)])
2171 # Check for Python-specific malloc support
2172 AC_MSG_CHECKING(for --with-pymalloc)
2173 AC_ARG_WITH(pymalloc,
2174 AC_HELP_STRING(--with(out)-pymalloc, disable/enable specialized mallocs))
2176 if test -z "$with_pymalloc"
2177 then with_pymalloc="yes"
2179 if test "$with_pymalloc" != "no"
2181 AC_DEFINE(WITH_PYMALLOC, 1,
2182 [Define if you want to compile in Python-specific mallocs])
2184 AC_MSG_RESULT($with_pymalloc)
2186 # Check for --with-wctype-functions
2187 AC_MSG_CHECKING(for --with-wctype-functions)
2188 AC_ARG_WITH(wctype-functions,
2189 AC_HELP_STRING(--with-wctype-functions, use wctype.h functions),
2191 if test "$withval" != no
2193 AC_DEFINE(WANT_WCTYPE_FUNCTIONS, 1,
2194 [Define if you want wctype.h functions to be used instead of the
2195 one supplied by Python itself. (see Include/unicodectype.h).])
2197 else AC_MSG_RESULT(no)
2199 [AC_MSG_RESULT(no)])
2201 # -I${DLINCLDIR} is added to the compile rule for importdl.o
2205 # the dlopen() function means we might want to use dynload_shlib.o. some
2206 # platforms, such as AIX, have dlopen(), but don't want to use it.
2207 AC_CHECK_FUNCS(dlopen)
2209 # DYNLOADFILE specifies which dynload_*.o file we will use for dynamic
2210 # loading of modules.
2211 AC_SUBST(DYNLOADFILE)
2212 AC_MSG_CHECKING(DYNLOADFILE)
2213 if test -z "$DYNLOADFILE"
2215 case $ac_sys_system/$ac_sys_release in
2216 AIX*) # Use dynload_shlib.c and dlopen() if we have it; otherwise dynload_aix.c
2217 if test "$ac_cv_func_dlopen" = yes
2218 then DYNLOADFILE="dynload_shlib.o"
2219 else DYNLOADFILE="dynload_aix.o"
2222 BeOS*) DYNLOADFILE="dynload_beos.o";;
2223 hp*|HP*) DYNLOADFILE="dynload_hpux.o";;
2224 # Use dynload_next.c only on 10.2 and below, which don't have native dlopen()
2225 Darwin/@<:@0156@:>@\..*) DYNLOADFILE="dynload_next.o";;
2226 atheos*) DYNLOADFILE="dynload_atheos.o";;
2228 # use dynload_shlib.c and dlopen() if we have it; otherwise stub
2229 # out any dynamic loading
2230 if test "$ac_cv_func_dlopen" = yes
2231 then DYNLOADFILE="dynload_shlib.o"
2232 else DYNLOADFILE="dynload_stub.o"
2237 AC_MSG_RESULT($DYNLOADFILE)
2238 if test "$DYNLOADFILE" != "dynload_stub.o"
2240 AC_DEFINE(HAVE_DYNAMIC_LOADING, 1,
2241 [Defined when any dynamic module loading is enabled.])
2244 # MACHDEP_OBJS can be set to platform-specific object files needed by Python
2246 AC_SUBST(MACHDEP_OBJS)
2247 AC_MSG_CHECKING(MACHDEP_OBJS)
2248 if test -z "$MACHDEP_OBJS"
2250 MACHDEP_OBJS=$extra_machdep_objs
2252 MACHDEP_OBJS="$MACHDEP_OBJS $extra_machdep_objs"
2254 AC_MSG_RESULT(MACHDEP_OBJS)
2256 # checks for library functions
2257 AC_CHECK_FUNCS(alarm bind_textdomain_codeset chown clock confstr ctermid \
2258 execv fork fpathconf ftime ftruncate \
2259 gai_strerror getgroups getlogin getloadavg getpeername getpgid getpid \
2260 getpriority getpwent getspnam getspent getsid getwd \
2261 kill killpg lchown lstat mkfifo mknod mktime \
2262 mremap nice pathconf pause plock poll pthread_init \
2263 putenv readlink realpath \
2264 select setegid seteuid setgid \
2265 setlocale setregid setreuid setsid setpgid setpgrp setuid setvbuf snprintf \
2266 sigaction siginterrupt sigrelse strftime \
2267 sysconf tcgetpgrp tcsetpgrp tempnam timegm times tmpfile tmpnam tmpnam_r \
2268 truncate uname unsetenv utimes waitpid wait3 wait4 wcscoll _getpty)
2270 # For some functions, having a definition is not sufficient, since
2271 # we want to take their address.
2272 AC_MSG_CHECKING(for chroot)
2273 AC_TRY_COMPILE([#include <unistd.h>], void *x=chroot,
2274 AC_DEFINE(HAVE_CHROOT, 1, Define if you have the 'chroot' function.)
2278 AC_MSG_CHECKING(for link)
2279 AC_TRY_COMPILE([#include <unistd.h>], void *x=link,
2280 AC_DEFINE(HAVE_LINK, 1, Define if you have the 'link' function.)
2284 AC_MSG_CHECKING(for symlink)
2285 AC_TRY_COMPILE([#include <unistd.h>], void *x=symlink,
2286 AC_DEFINE(HAVE_SYMLINK, 1, Define if you have the 'symlink' function.)
2290 AC_MSG_CHECKING(for fchdir)
2291 AC_TRY_COMPILE([#include <unistd.h>], void *x=fchdir,
2292 AC_DEFINE(HAVE_FCHDIR, 1, Define if you have the 'fchdir' function.)
2296 AC_MSG_CHECKING(for fsync)
2297 AC_TRY_COMPILE([#include <unistd.h>], void *x=fsync,
2298 AC_DEFINE(HAVE_FSYNC, 1, Define if you have the 'fsync' function.)
2302 AC_MSG_CHECKING(for fdatasync)
2303 AC_TRY_COMPILE([#include <unistd.h>], void *x=fdatasync,
2304 AC_DEFINE(HAVE_FDATASYNC, 1, Define if you have the 'fdatasync' function.)
2309 # On some systems (eg. FreeBSD 5), we would find a definition of the
2310 # functions ctermid_r, setgroups in the library, but no prototype
2311 # (e.g. because we use _XOPEN_SOURCE). See whether we can take their
2312 # address to avoid compiler warnings and potential miscompilations
2313 # because of the missing prototypes.
2315 AC_MSG_CHECKING(for ctermid_r)
2317 #include "confdefs.h"
2319 ], void* p = ctermid_r,
2320 AC_DEFINE(HAVE_CTERMID_R, 1, Define if you have the 'ctermid_r' function.)
2325 AC_MSG_CHECKING(for flock)
2327 #include "confdefs.h"
2328 #include <sys/file.h>
2330 AC_DEFINE(HAVE_FLOCK, 1, Define if you have the 'flock' function.)
2335 AC_MSG_CHECKING(for getpagesize)
2337 #include "confdefs.h"
2339 ], void* p = getpagesize,
2340 AC_DEFINE(HAVE_GETPAGESIZE, 1, Define if you have the 'getpagesize' function.)
2346 AC_CHECK_PROGS(TRUE, true, /bin/true)
2348 dnl On some systems (e.g. Solaris 9), hstrerror and inet_aton are in -lresolv
2349 dnl On others, they are in the C library, so we to take no action
2350 AC_CHECK_LIB(c, inet_aton, [$ac_cv_prog_TRUE],
2351 AC_CHECK_LIB(resolv, inet_aton)
2354 dnl Check if system zlib has *Copy() functions
2356 dnl On MacOSX the linker will search for dylibs on the entire linker path
2357 dnl before searching for static libraries. setup.py adds -Wl,-search_paths_first
2358 dnl to revert to a more traditional unix behaviour and make it possible to
2359 dnl override the system libz with a local static library of libz. Temporarily
2360 dnl add that flag to our CFLAGS as well to ensure that we check the version
2361 dnl of libz that will be used by setup.py.
2362 dnl The -L/usr/local/lib is needed as wel to get the same compilation
2363 dnl environment as setup.py (and leaving it out can cause configure to use the
2364 dnl wrong version of the library)
2365 case $ac_sys_system/$ac_sys_release in
2367 _CUR_CFLAGS="${CFLAGS}"
2368 _CUR_LDFLAGS="${LDFLAGS}"
2369 CFLAGS="${CFLAGS} -Wl,-search_paths_first"
2370 LDFLAGS="${LDFLAGS} -Wl,-search_paths_first -L/usr/local/lib"
2374 AC_CHECK_LIB(z, inflateCopy, AC_DEFINE(HAVE_ZLIB_COPY, 1, Define if the zlib library has inflateCopy))
2376 case $ac_sys_system/$ac_sys_release in
2378 CFLAGS="${_CUR_CFLAGS}"
2379 LDFLAGS="${_CUR_LDFLAGS}"
2383 AC_MSG_CHECKING(for hstrerror)
2385 #include "confdefs.h"
2387 ], void* p = hstrerror; hstrerror(0),
2388 AC_DEFINE(HAVE_HSTRERROR, 1, Define if you have the 'hstrerror' function.)
2393 AC_MSG_CHECKING(for inet_aton)
2395 #include "confdefs.h"
2396 #include <sys/types.h>
2397 #include <sys/socket.h>
2398 #include <netinet/in.h>
2399 #include <arpa/inet.h>
2400 ], void* p = inet_aton;inet_aton(0,0),
2401 AC_DEFINE(HAVE_INET_ATON, 1, Define if you have the 'inet_aton' function.)
2406 AC_MSG_CHECKING(for inet_pton)
2408 #include "confdefs.h"
2409 #include <sys/types.h>
2410 #include <sys/socket.h>
2411 #include <netinet/in.h>
2412 #include <arpa/inet.h>
2413 ], void* p = inet_pton,
2414 AC_DEFINE(HAVE_INET_PTON, 1, Define if you have the 'inet_pton' function.)
2419 # On some systems, setgroups is in unistd.h, on others, in grp.h
2420 AC_MSG_CHECKING(for setgroups)
2422 #include "confdefs.h"
2428 void* p = setgroups,
2429 AC_DEFINE(HAVE_SETGROUPS, 1, Define if you have the 'setgroups' function.)
2434 # check for openpty and forkpty
2436 AC_CHECK_FUNCS(openpty,,
2437 AC_CHECK_LIB(util,openpty,
2438 [AC_DEFINE(HAVE_OPENPTY) LIBS="$LIBS -lutil"],
2439 AC_CHECK_LIB(bsd,openpty, [AC_DEFINE(HAVE_OPENPTY) LIBS="$LIBS -lbsd"])
2442 AC_CHECK_FUNCS(forkpty,,
2443 AC_CHECK_LIB(util,forkpty,
2444 [AC_DEFINE(HAVE_FORKPTY) LIBS="$LIBS -lutil"],
2445 AC_CHECK_LIB(bsd,forkpty, [AC_DEFINE(HAVE_FORKPTY) LIBS="$LIBS -lbsd"])
2449 # check for long file support functions
2450 AC_CHECK_FUNCS(fseek64 fseeko fstatvfs ftell64 ftello statvfs)
2452 AC_REPLACE_FUNCS(dup2 getcwd strdup strerror memmove)
2453 AC_CHECK_FUNCS(getpgrp,
2454 AC_TRY_COMPILE([#include <unistd.h>],
2456 AC_DEFINE(GETPGRP_HAVE_ARG, 1,
2457 [Define if getpgrp() must be called as getpgrp(0).])
2460 AC_CHECK_FUNCS(setpgrp,
2461 AC_TRY_COMPILE([#include <unistd.h>],
2463 AC_DEFINE(SETPGRP_HAVE_ARG, 1,
2464 [Define if setpgrp() must be called as setpgrp(0, 0).])
2467 AC_CHECK_FUNCS(gettimeofday,
2468 AC_TRY_COMPILE([#include <sys/time.h>],
2469 [gettimeofday((struct timeval*)0,(struct timezone*)0);], ,
2470 AC_DEFINE(GETTIMEOFDAY_NO_TZ, 1,
2471 [Define if gettimeofday() does not have second (timezone) argument
2472 This is the case on Motorola V4 (R40V4.2)])
2476 AC_MSG_CHECKING(for major, minor, and makedev)
2478 #if defined(MAJOR_IN_MKDEV)
2479 #include <sys/mkdev.h>
2480 #elif defined(MAJOR_IN_SYSMACROS)
2481 #include <sys/sysmacros.h>
2483 #include <sys/types.h>
2486 makedev(major(0),minor(0));
2488 AC_DEFINE(HAVE_DEVICE_MACROS, 1,
2489 [Define to 1 if you have the device macros.])
2495 # On OSF/1 V5.1, getaddrinfo is available, but a define
2496 # for [no]getaddrinfo in netdb.h.
2497 AC_MSG_CHECKING(for getaddrinfo)
2499 #include <sys/types.h>
2500 #include <sys/socket.h>
2504 getaddrinfo(NULL, NULL, NULL, NULL);
2507 AC_MSG_CHECKING(getaddrinfo bug)
2509 #include <sys/types.h>
2512 #include <sys/socket.h>
2513 #include <netinet/in.h>
2517 int passive, gaierr, inet4 = 0, inet6 = 0;
2518 struct addrinfo hints, *ai, *aitop;
2519 char straddr[INET6_ADDRSTRLEN], strport[16];
2521 for (passive = 0; passive <= 1; passive++) {
2522 memset(&hints, 0, sizeof(hints));
2523 hints.ai_family = AF_UNSPEC;
2524 hints.ai_flags = passive ? AI_PASSIVE : 0;
2525 hints.ai_socktype = SOCK_STREAM;
2526 hints.ai_protocol = IPPROTO_TCP;
2527 if ((gaierr = getaddrinfo(NULL, "54321", &hints, &aitop)) != 0) {
2528 (void)gai_strerror(gaierr);
2531 for (ai = aitop; ai; ai = ai->ai_next) {
2532 if (ai->ai_addr == NULL ||
2533 ai->ai_addrlen == 0 ||
2534 getnameinfo(ai->ai_addr, ai->ai_addrlen,
2535 straddr, sizeof(straddr), strport, sizeof(strport),
2536 NI_NUMERICHOST|NI_NUMERICSERV) != 0) {
2539 switch (ai->ai_family) {
2541 if (strcmp(strport, "54321") != 0) {
2545 if (strcmp(straddr, "0.0.0.0") != 0) {
2549 if (strcmp(straddr, "127.0.0.1") != 0) {
2556 if (strcmp(strport, "54321") != 0) {
2560 if (strcmp(straddr, "::") != 0) {
2564 if (strcmp(straddr, "::1") != 0) {
2574 /* another family support? */
2580 if (!(inet4 == 0 || inet4 == 2))
2582 if (!(inet6 == 0 || inet6 == 2))
2586 freeaddrinfo(aitop);
2591 freeaddrinfo(aitop);
2596 buggygetaddrinfo=no,
2597 AC_MSG_RESULT(buggy)
2598 buggygetaddrinfo=yes,
2599 AC_MSG_RESULT(buggy)
2600 buggygetaddrinfo=yes)], [
2602 buggygetaddrinfo=yes
2605 if test "$buggygetaddrinfo" = "yes"; then
2606 if test "$ipv6" = "yes"; then
2607 echo 'Fatal: You must get working getaddrinfo() function.'
2608 echo ' or you can specify "--disable-ipv6"'.
2612 AC_DEFINE(HAVE_GETADDRINFO, 1, [Define if you have the getaddrinfo function.])
2614 AC_CHECK_FUNCS(getnameinfo)
2616 # checks for structures
2620 AC_CHECK_MEMBERS([struct stat.st_rdev])
2621 AC_CHECK_MEMBERS([struct stat.st_blksize])
2622 AC_CHECK_MEMBERS([struct stat.st_flags])
2623 AC_CHECK_MEMBERS([struct stat.st_gen])
2624 AC_CHECK_MEMBERS([struct stat.st_birthtime])
2627 AC_MSG_CHECKING(for time.h that defines altzone)
2628 AC_CACHE_VAL(ac_cv_header_time_altzone,
2629 [AC_TRY_COMPILE([#include <time.h>], [return altzone;],
2630 ac_cv_header_time_altzone=yes,
2631 ac_cv_header_time_altzone=no)])
2632 AC_MSG_RESULT($ac_cv_header_time_altzone)
2633 if test $ac_cv_header_time_altzone = yes; then
2634 AC_DEFINE(HAVE_ALTZONE, 1, [Define this if your time.h defines altzone.])
2638 AC_MSG_CHECKING(whether sys/select.h and sys/time.h may both be included)
2640 #include <sys/types.h>
2641 #include <sys/select.h>
2642 #include <sys/time.h>
2644 AC_DEFINE(SYS_SELECT_WITH_SYS_TIME, 1,
2645 [Define if you can safely include both <sys/select.h> and <sys/time.h>
2646 (which you can't on SCO ODT 3.0).])
2649 AC_MSG_RESULT($was_it_defined)
2651 AC_MSG_CHECKING(for addrinfo)
2652 AC_CACHE_VAL(ac_cv_struct_addrinfo,
2654 # include <netdb.h>],
2655 [struct addrinfo a],
2656 ac_cv_struct_addrinfo=yes,
2657 ac_cv_struct_addrinfo=no))
2658 AC_MSG_RESULT($ac_cv_struct_addrinfo)
2659 if test $ac_cv_struct_addrinfo = yes; then
2660 AC_DEFINE(HAVE_ADDRINFO, 1, [struct addrinfo (netdb.h)])
2663 AC_MSG_CHECKING(for sockaddr_storage)
2664 AC_CACHE_VAL(ac_cv_struct_sockaddr_storage,
2666 # include <sys/types.h>
2667 # include <sys/socket.h>],
2668 [struct sockaddr_storage s],
2669 ac_cv_struct_sockaddr_storage=yes,
2670 ac_cv_struct_sockaddr_storage=no))
2671 AC_MSG_RESULT($ac_cv_struct_sockaddr_storage)
2672 if test $ac_cv_struct_sockaddr_storage = yes; then
2673 AC_DEFINE(HAVE_SOCKADDR_STORAGE, 1, [struct sockaddr_storage (sys/socket.h)])
2676 # checks for compiler characteristics
2682 AC_MSG_CHECKING(for working volatile)
2683 AC_TRY_COMPILE([],[volatile int x; x = 0;], works=yes,
2684 AC_DEFINE(volatile, [], [Define to empty if the keyword does not work.])
2686 AC_MSG_RESULT($works)
2689 AC_MSG_CHECKING(for working signed char)
2690 AC_TRY_COMPILE([], [signed char c;], works=yes,
2691 AC_DEFINE(signed, [], [Define to empty if the keyword does not work.])
2693 AC_MSG_RESULT($works)
2696 AC_MSG_CHECKING(for prototypes)
2697 AC_TRY_COMPILE([int foo(int x) { return 0; }], [return foo(10);],[
2698 AC_DEFINE(HAVE_PROTOTYPES, 1,
2699 [Define if your compiler supports function prototype])
2702 AC_MSG_RESULT($have_prototypes)
2705 AC_MSG_CHECKING(for variable length prototypes and stdarg.h)
2708 int foo(int x, ...) {
2716 ], [return foo(10, "", 3.14);], [
2717 AC_DEFINE(HAVE_STDARG_PROTOTYPES, 1,
2718 [Define if your compiler supports variable length function prototypes
2719 (e.g. void fprintf(FILE *, char *, ...);) *and* <stdarg.h>])
2722 AC_MSG_RESULT($works)
2724 # check for socketpair
2725 AC_MSG_CHECKING(for socketpair)
2727 #include <sys/types.h>
2728 #include <sys/socket.h>
2729 ], void *x=socketpair,
2730 AC_DEFINE(HAVE_SOCKETPAIR, 1, Define if you have the 'socketpair' function.)
2735 # check if sockaddr has sa_len member
2736 AC_MSG_CHECKING(if sockaddr has sa_len member)
2737 AC_TRY_COMPILE([#include <sys/types.h>
2738 #include <sys/socket.h>],
2742 AC_DEFINE(HAVE_SOCKADDR_SA_LEN, 1, [Define if sockaddr has sa_len member]),
2746 AC_MSG_CHECKING(whether va_list is an array)
2748 #ifdef HAVE_STDARG_PROTOTYPES
2751 #include <varargs.h>
2753 ], [va_list list1, list2; list1 = list2;], , [
2754 AC_DEFINE(VA_LIST_IS_ARRAY, 1, [Define if a va_list is an array of some kind])
2755 va_list_is_array=yes
2757 AC_MSG_RESULT($va_list_is_array)
2759 # sigh -- gethostbyname_r is a mess; it can have 3, 5 or 6 arguments :-(
2760 AH_TEMPLATE(HAVE_GETHOSTBYNAME_R,
2761 [Define this if you have some version of gethostbyname_r()])
2763 AC_CHECK_FUNC(gethostbyname_r, [
2764 AC_DEFINE(HAVE_GETHOSTBYNAME_R)
2765 AC_MSG_CHECKING([gethostbyname_r with 6 args])
2767 CFLAGS="$CFLAGS $MY_CPPFLAGS $MY_THREAD_CPPFLAGS $MY_CFLAGS"
2772 struct hostent *he, *res;
2777 (void) gethostbyname_r(name, he, buffer, buflen, &res, &h_errnop)
2779 AC_DEFINE(HAVE_GETHOSTBYNAME_R)
2780 AC_DEFINE(HAVE_GETHOSTBYNAME_R_6_ARG, 1,
2781 [Define this if you have the 6-arg version of gethostbyname_r().])
2785 AC_MSG_CHECKING([gethostbyname_r with 5 args])
2795 (void) gethostbyname_r(name, he, buffer, buflen, &h_errnop)
2797 AC_DEFINE(HAVE_GETHOSTBYNAME_R)
2798 AC_DEFINE(HAVE_GETHOSTBYNAME_R_5_ARG, 1,
2799 [Define this if you have the 5-arg version of gethostbyname_r().])
2803 AC_MSG_CHECKING([gethostbyname_r with 3 args])
2809 struct hostent_data data;
2811 (void) gethostbyname_r(name, he, &data);
2813 AC_DEFINE(HAVE_GETHOSTBYNAME_R)
2814 AC_DEFINE(HAVE_GETHOSTBYNAME_R_3_ARG, 1,
2815 [Define this if you have the 3-arg version of gethostbyname_r().])
2824 AC_CHECK_FUNCS(gethostbyname)
2826 AC_SUBST(HAVE_GETHOSTBYNAME_R_6_ARG)
2827 AC_SUBST(HAVE_GETHOSTBYNAME_R_5_ARG)
2828 AC_SUBST(HAVE_GETHOSTBYNAME_R_3_ARG)
2829 AC_SUBST(HAVE_GETHOSTBYNAME_R)
2830 AC_SUBST(HAVE_GETHOSTBYNAME)
2832 # checks for system services
2835 # Linux requires this for correct f.p. operations
2836 AC_CHECK_FUNC(__fpu_control,
2838 [AC_CHECK_LIB(ieee, __fpu_control)
2841 # Check for --with-fpectl
2842 AC_MSG_CHECKING(for --with-fpectl)
2844 AC_HELP_STRING(--with-fpectl, enable SIGFPE catching),
2846 if test "$withval" != no
2848 AC_DEFINE(WANT_SIGFPE_HANDLER, 1,
2849 [Define if you want SIGFPE handled (see Include/pyfpe.h).])
2851 else AC_MSG_RESULT(no)
2853 [AC_MSG_RESULT(no)])
2855 # check for --with-libm=...
2857 case $ac_sys_system in
2862 AC_MSG_CHECKING(for --with-libm=STRING)
2864 AC_HELP_STRING(--with-libm=STRING, math library),
2866 if test "$withval" = no
2868 AC_MSG_RESULT(force LIBM empty)
2869 elif test "$withval" != yes
2871 AC_MSG_RESULT(set LIBM="$withval")
2872 else AC_MSG_ERROR([proper usage is --with-libm=STRING])
2874 [AC_MSG_RESULT(default LIBM="$LIBM")])
2876 # check for --with-libc=...
2878 AC_MSG_CHECKING(for --with-libc=STRING)
2880 AC_HELP_STRING(--with-libc=STRING, C library),
2882 if test "$withval" = no
2884 AC_MSG_RESULT(force LIBC empty)
2885 elif test "$withval" != yes
2887 AC_MSG_RESULT(set LIBC="$withval")
2888 else AC_MSG_ERROR([proper usage is --with-libc=STRING])
2890 [AC_MSG_RESULT(default LIBC="$LIBC")])
2892 # check for hypot() in math library
2895 AC_REPLACE_FUNCS(hypot)
2899 AC_CHECK_HEADER(wchar.h, [
2900 AC_DEFINE(HAVE_WCHAR_H, 1,
2901 [Define if the compiler provides a wchar.h header file.])
2907 # determine wchar_t size
2908 if test "$wchar_h" = yes
2910 AC_CHECK_SIZEOF(wchar_t, 4, [#include <wchar.h>])
2913 AC_MSG_CHECKING(for UCS-4 tcl)
2917 #if TCL_UTF_MAX != 6
2918 # error "NOT UCS4_TCL"
2920 AC_DEFINE(HAVE_UCS4_TCL, 1, [Define this if you have tcl and TCL_UTF_MAX==6])
2923 AC_MSG_RESULT($have_ucs4_tcl)
2925 # check whether wchar_t is signed or not
2926 if test "$wchar_h" = yes
2928 # check whether wchar_t is signed or not
2929 AC_MSG_CHECKING(whether wchar_t is signed)
2930 AC_CACHE_VAL(ac_cv_wchar_t_signed, [
2935 /* Success: exit code 0 */
2936 exit((((wchar_t) -1) < ((wchar_t) 0)) ? 0 : 1);
2939 ac_cv_wchar_t_signed=yes,
2940 ac_cv_wchar_t_signed=no,
2941 ac_cv_wchar_t_signed=yes)])
2942 AC_MSG_RESULT($ac_cv_wchar_t_signed)
2945 AC_MSG_CHECKING(what type to use for unicode)
2946 dnl quadrigraphs "@<:@" and "@:>@" produce "[" and "]" in the output
2947 AC_ARG_ENABLE(unicode,
2948 AC_HELP_STRING(--enable-unicode@<:@=ucs@<:@24@:>@@:>@, Enable Unicode strings (default is yes)),
2950 [enable_unicode=yes])
2952 if test $enable_unicode = yes
2954 # Without any arguments, Py_UNICODE defaults to two-byte mode
2955 case "$have_ucs4_tcl" in
2956 yes) enable_unicode="ucs4"
2958 *) enable_unicode="ucs2"
2963 AH_TEMPLATE(Py_UNICODE_SIZE,
2964 [Define as the size of the unicode type.])
2965 case "$enable_unicode" in
2966 ucs2) unicode_size="2"
2967 AC_DEFINE(Py_UNICODE_SIZE,2)
2969 ucs4) unicode_size="4"
2970 AC_DEFINE(Py_UNICODE_SIZE,4)
2974 AH_TEMPLATE(PY_UNICODE_TYPE,
2975 [Define as the integral type used for Unicode representation.])
2977 AC_SUBST(UNICODE_OBJS)
2978 if test "$enable_unicode" = "no"
2981 AC_MSG_RESULT(not used)
2983 UNICODE_OBJS="Objects/unicodeobject.o Objects/unicodectype.o"
2984 AC_DEFINE(Py_USING_UNICODE, 1,
2985 [Define if you want to have a Unicode type.])
2987 # wchar_t is only usable if it maps to an unsigned type
2988 if test "$unicode_size" = "$ac_cv_sizeof_wchar_t" \
2989 -a "$ac_cv_wchar_t_signed" = "no"
2991 PY_UNICODE_TYPE="wchar_t"
2992 AC_DEFINE(HAVE_USABLE_WCHAR_T, 1,
2993 [Define if you have a useable wchar_t type defined in wchar.h; useable
2994 means wchar_t must be an unsigned type with at least 16 bits. (see
2995 Include/unicodeobject.h).])
2996 AC_DEFINE(PY_UNICODE_TYPE,wchar_t)
2997 elif test "$ac_cv_sizeof_short" = "$unicode_size"
2999 PY_UNICODE_TYPE="unsigned short"
3000 AC_DEFINE(PY_UNICODE_TYPE,unsigned short)
3001 elif test "$ac_cv_sizeof_long" = "$unicode_size"
3003 PY_UNICODE_TYPE="unsigned long"
3004 AC_DEFINE(PY_UNICODE_TYPE,unsigned long)
3006 PY_UNICODE_TYPE="no type found"
3008 AC_MSG_RESULT($PY_UNICODE_TYPE)
3011 # check for endianness
3013 AH_VERBATIM([WORDS_BIGENDIAN],
3015 /* Define to 1 if your processor stores words with the most significant byte
3016 first (like Motorola and SPARC, unlike Intel and VAX).
3018 The block below does compile-time checking for endianness on platforms
3019 that use GCC and therefore allows compiling fat binaries on OSX by using
3020 '-arch ppc -arch i386' as the compile flags. The phrasing was choosen
3021 such that the configure-result is used on systems that don't use GCC.
3023 #ifdef __BIG_ENDIAN__
3024 #define WORDS_BIGENDIAN 1
3026 #ifndef __LITTLE_ENDIAN__
3027 #undef WORDS_BIGENDIAN
3031 # Check whether right shifting a negative integer extends the sign bit
3032 # or fills with zeros (like the Cray J90, according to Tim Peters).
3033 AC_MSG_CHECKING(whether right shift extends the sign bit)
3034 AC_CACHE_VAL(ac_cv_rshift_extends_sign, [
3038 exit(((-1)>>3 == -1) ? 0 : 1);
3041 ac_cv_rshift_extends_sign=yes,
3042 ac_cv_rshift_extends_sign=no,
3043 ac_cv_rshift_extends_sign=yes)])
3044 AC_MSG_RESULT($ac_cv_rshift_extends_sign)
3045 if test "$ac_cv_rshift_extends_sign" = no
3047 AC_DEFINE(SIGNED_RIGHT_SHIFT_ZERO_FILLS, 1,
3048 [Define if i>>j for signed int i does not extend the sign bit
3052 # check for getc_unlocked and related locking functions
3053 AC_MSG_CHECKING(for getc_unlocked() and friends)
3054 AC_CACHE_VAL(ac_cv_have_getc_unlocked, [
3055 AC_TRY_LINK([#include <stdio.h>],[
3056 FILE *f = fopen("/dev/null", "r");
3060 ], ac_cv_have_getc_unlocked=yes, ac_cv_have_getc_unlocked=no)])
3061 AC_MSG_RESULT($ac_cv_have_getc_unlocked)
3062 if test "$ac_cv_have_getc_unlocked" = yes
3064 AC_DEFINE(HAVE_GETC_UNLOCKED, 1,
3065 [Define this if you have flockfile(), getc_unlocked(), and funlockfile()])
3068 # check where readline lives
3069 # save the value of LIBS so we don't actually link Python with readline
3070 LIBS_no_readline=$LIBS
3071 AC_CHECK_LIB(readline, readline)
3072 if test "$ac_cv_have_readline_readline" = no
3074 AC_CHECK_LIB(termcap, readline)
3077 # check for readline 2.1
3078 AC_CHECK_LIB(readline, rl_callback_handler_install,
3079 AC_DEFINE(HAVE_RL_CALLBACK, 1,
3080 [Define if you have readline 2.1]), , )
3082 # check for readline 2.2
3083 AC_TRY_CPP([#include <readline/readline.h>],
3084 have_readline=yes, have_readline=no)
3085 if test $have_readline = yes
3087 AC_EGREP_HEADER([extern int rl_completion_append_character;],
3088 [readline/readline.h],
3089 AC_DEFINE(HAVE_RL_COMPLETION_APPEND_CHARACTER, 1,
3090 [Define if you have readline 2.2]), )
3093 # check for readline 4.0
3094 AC_CHECK_LIB(readline, rl_pre_input_hook,
3095 AC_DEFINE(HAVE_RL_PRE_INPUT_HOOK, 1,
3096 [Define if you have readline 4.0]), , )
3098 # check for readline 4.2
3099 AC_CHECK_LIB(readline, rl_completion_matches,
3100 AC_DEFINE(HAVE_RL_COMPLETION_MATCHES, 1,
3101 [Define if you have readline 4.2]), , )
3103 # also in readline 4.2
3104 AC_TRY_CPP([#include <readline/readline.h>],
3105 have_readline=yes, have_readline=no)
3106 if test $have_readline = yes
3108 AC_EGREP_HEADER([extern int rl_catch_signals;],
3109 [readline/readline.h],
3110 AC_DEFINE(HAVE_RL_CATCH_SIGNAL, 1,
3111 [Define if you can turn off readline's signal handling.]), )
3114 # End of readline checks: restore LIBS
3115 LIBS=$LIBS_no_readline
3117 AC_MSG_CHECKING(for broken nice())
3118 AC_CACHE_VAL(ac_cv_broken_nice, [
3123 if (val1 != -1 && val1 == nice(2))
3128 ac_cv_broken_nice=yes,
3129 ac_cv_broken_nice=no,
3130 ac_cv_broken_nice=no)])
3131 AC_MSG_RESULT($ac_cv_broken_nice)
3132 if test "$ac_cv_broken_nice" = yes
3134 AC_DEFINE(HAVE_BROKEN_NICE, 1,
3135 [Define if nice() returns success/failure instead of the new priority.])
3138 AC_MSG_CHECKING(for broken poll())
3144 struct pollfd poll_struct = { 42, POLLIN|POLLPRI|POLLOUT, 0 };
3148 int poll_test = poll (&poll_struct, 1, 0);
3154 else if (poll_test == 0 && poll_struct.revents != POLLNVAL)
3164 ac_cv_broken_poll=yes,
3165 ac_cv_broken_poll=no,
3166 ac_cv_broken_poll=no)
3167 AC_MSG_RESULT($ac_cv_broken_poll)
3168 if test "$ac_cv_broken_poll" = yes
3170 AC_DEFINE(HAVE_BROKEN_POLL, 1,
3171 [Define if poll() sets errno on invalid file descriptors.])
3174 # Before we can test tzset, we need to check if struct tm has a tm_zone
3175 # (which is not required by ISO C or UNIX spec) and/or if we support
3179 # check tzset(3) exists and works like we expect it to
3180 AC_MSG_CHECKING(for working tzset())
3181 AC_CACHE_VAL(ac_cv_working_tzset, [
3188 extern char *tzname[];
3193 /* Note that we need to ensure that not only does tzset(3)
3194 do 'something' with localtime, but it works as documented
3195 in the library reference and as expected by the test suite.
3196 This includes making sure that tzname is set properly if
3197 tm->tm_zone does not exist since it is the alternative way
3198 of getting timezone info.
3200 Red Hat 6.2 doesn't understand the southern hemisphere
3201 after New Year's Day.
3204 time_t groundhogday = 1044144000; /* GMT-based */
3205 time_t midyear = groundhogday + (365 * 24 * 3600 / 2);
3209 if (localtime(&groundhogday)->tm_hour != 0)
3212 /* For UTC, tzname[1] is sometimes "", sometimes " " */
3213 if (strcmp(tzname[0], "UTC") ||
3214 (tzname[1][0] != 0 && tzname[1][0] != ' '))
3218 putenv("TZ=EST+5EDT,M4.1.0,M10.5.0");
3220 if (localtime(&groundhogday)->tm_hour != 19)
3223 if (strcmp(tzname[0], "EST") || strcmp(tzname[1], "EDT"))
3227 putenv("TZ=AEST-10AEDT-11,M10.5.0,M3.5.0");
3229 if (localtime(&groundhogday)->tm_hour != 11)
3232 if (strcmp(tzname[0], "AEST") || strcmp(tzname[1], "AEDT"))
3236 #if HAVE_STRUCT_TM_TM_ZONE
3237 if (strcmp(localtime(&groundhogday)->tm_zone, "AEDT"))
3239 if (strcmp(localtime(&midyear)->tm_zone, "AEST"))
3246 ac_cv_working_tzset=yes,
3247 ac_cv_working_tzset=no,
3248 ac_cv_working_tzset=no)])
3249 AC_MSG_RESULT($ac_cv_working_tzset)
3250 if test "$ac_cv_working_tzset" = yes
3252 AC_DEFINE(HAVE_WORKING_TZSET, 1,
3253 [Define if tzset() actually switches the local timezone in a meaningful way.])
3256 # Look for subsecond timestamps in struct stat
3257 AC_MSG_CHECKING(for tv_nsec in struct stat)
3258 AC_CACHE_VAL(ac_cv_stat_tv_nsec,
3259 AC_TRY_COMPILE([#include <sys/stat.h>], [
3261 st.st_mtim.tv_nsec = 1;
3263 ac_cv_stat_tv_nsec=yes,
3264 ac_cv_stat_tv_nsec=no,
3265 ac_cv_stat_tv_nsec=no))
3266 AC_MSG_RESULT($ac_cv_stat_tv_nsec)
3267 if test "$ac_cv_stat_tv_nsec" = yes
3269 AC_DEFINE(HAVE_STAT_TV_NSEC, 1,
3270 [Define if you have struct stat.st_mtim.tv_nsec])
3273 # Look for BSD style subsecond timestamps in struct stat
3274 AC_MSG_CHECKING(for tv_nsec2 in struct stat)
3275 AC_CACHE_VAL(ac_cv_stat_tv_nsec2,
3276 AC_TRY_COMPILE([#include <sys/stat.h>], [
3278 st.st_mtimespec.tv_nsec = 1;
3280 ac_cv_stat_tv_nsec2=yes,
3281 ac_cv_stat_tv_nsec2=no,
3282 ac_cv_stat_tv_nsec2=no))
3283 AC_MSG_RESULT($ac_cv_stat_tv_nsec2)
3284 if test "$ac_cv_stat_tv_nsec2" = yes
3286 AC_DEFINE(HAVE_STAT_TV_NSEC2, 1,
3287 [Define if you have struct stat.st_mtimensec])
3290 # On HP/UX 11.0, mvwdelch is a block with a return statement
3291 AC_MSG_CHECKING(whether mvwdelch is an expression)
3292 AC_CACHE_VAL(ac_cv_mvwdelch_is_expression,
3293 AC_TRY_COMPILE([#include <curses.h>], [
3295 rtn = mvwdelch(0,0,0);
3296 ], ac_cv_mvwdelch_is_expression=yes,
3297 ac_cv_mvwdelch_is_expression=no,
3298 ac_cv_mvwdelch_is_expression=yes))
3299 AC_MSG_RESULT($ac_cv_mvwdelch_is_expression)
3301 if test "$ac_cv_mvwdelch_is_expression" = yes
3303 AC_DEFINE(MVWDELCH_IS_EXPRESSION, 1,
3304 [Define if mvwdelch in curses.h is an expression.])
3307 AC_MSG_CHECKING(whether WINDOW has _flags)
3308 AC_CACHE_VAL(ac_cv_window_has_flags,
3309 AC_TRY_COMPILE([#include <curses.h>], [
3312 ], ac_cv_window_has_flags=yes,
3313 ac_cv_window_has_flags=no,
3314 ac_cv_window_has_flags=no))
3315 AC_MSG_RESULT($ac_cv_window_has_flags)
3318 if test "$ac_cv_window_has_flags" = yes
3320 AC_DEFINE(WINDOW_HAS_FLAGS, 1,
3321 [Define if WINDOW in curses.h offers a field _flags.])
3324 AC_MSG_CHECKING(for is_term_resized)
3325 AC_TRY_COMPILE([#include <curses.h>], void *x=is_term_resized,
3326 AC_DEFINE(HAVE_CURSES_IS_TERM_RESIZED, 1, Define if you have the 'is_term_resized' function.)
3331 AC_MSG_CHECKING(for resize_term)
3332 AC_TRY_COMPILE([#include <curses.h>], void *x=resize_term,
3333 AC_DEFINE(HAVE_CURSES_RESIZE_TERM, 1, Define if you have the 'resize_term' function.)
3338 AC_MSG_CHECKING(for resizeterm)
3339 AC_TRY_COMPILE([#include <curses.h>], void *x=resizeterm,
3340 AC_DEFINE(HAVE_CURSES_RESIZETERM, 1, Define if you have the 'resizeterm' function.)
3345 AC_MSG_CHECKING(for /dev/ptmx)
3347 if test -e /dev/ptmx
3350 AC_DEFINE(HAVE_DEV_PTMX, 1,
3351 [Define if we have /dev/ptmx.])
3356 AC_MSG_CHECKING(for /dev/ptc)
3361 AC_DEFINE(HAVE_DEV_PTC, 1,
3362 [Define if we have /dev/ptc.])
3367 AC_MSG_CHECKING(for %zd printf() format support)
3368 AC_TRY_RUN([#include <stdio.h>
3376 if(sprintf(buffer, "%zd", (size_t)123) < 0)
3379 if (strncmp(buffer, "123", 3))
3385 AC_DEFINE(PY_FORMAT_SIZE_T, "z", [Define to printf format modifier for Py_ssize_t])],
3388 AC_CHECK_TYPE(socklen_t,,
3389 AC_DEFINE(socklen_t,int,
3390 Define to `int' if <sys/socket.h> does not define.),[
3391 #ifdef HAVE_SYS_TYPES_H
3392 #include <sys/types.h>
3394 #ifdef HAVE_SYS_SOCKET_H
3395 #include <sys/socket.h>
3399 AC_SUBST(THREADHEADERS)
3401 for h in `(cd $srcdir;echo Python/thread_*.h)`
3403 THREADHEADERS="$THREADHEADERS \$(srcdir)/$h"
3407 SRCDIRS="Parser Grammar Objects Python Modules Mac"
3408 AC_MSG_CHECKING(for build directories)
3409 for dir in $SRCDIRS; do
3410 if test ! -d $dir; then
3416 # generate output files
3417 AC_CONFIG_FILES(Makefile.pre Modules/Setup.config)
3420 echo "creating Modules/Setup"
3421 if test ! -f Modules/Setup
3423 cp $srcdir/Modules/Setup.dist Modules/Setup
3426 echo "creating Modules/Setup.local"
3427 if test ! -f Modules/Setup.local
3429 echo "# Edit this file for local setup changes" >Modules/Setup.local
3432 echo "creating Makefile"
3433 $SHELL $srcdir/Modules/makesetup -c $srcdir/Modules/config.c.in \
3434 -s Modules Modules/Setup.config \
3435 Modules/Setup.local Modules/Setup