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
2355 AC_CHECK_LIB(z, inflateCopy, AC_DEFINE(HAVE_ZLIB_COPY, 1, Define if the zlib library has inflateCopy))
2357 AC_MSG_CHECKING(for hstrerror)
2359 #include "confdefs.h"
2361 ], void* p = hstrerror; hstrerror(0),
2362 AC_DEFINE(HAVE_HSTRERROR, 1, Define if you have the 'hstrerror' function.)
2367 AC_MSG_CHECKING(for inet_aton)
2369 #include "confdefs.h"
2370 #include <sys/types.h>
2371 #include <sys/socket.h>
2372 #include <netinet/in.h>
2373 #include <arpa/inet.h>
2374 ], void* p = inet_aton;inet_aton(0,0),
2375 AC_DEFINE(HAVE_INET_ATON, 1, Define if you have the 'inet_aton' function.)
2380 AC_MSG_CHECKING(for inet_pton)
2382 #include "confdefs.h"
2383 #include <sys/types.h>
2384 #include <sys/socket.h>
2385 #include <netinet/in.h>
2386 #include <arpa/inet.h>
2387 ], void* p = inet_pton,
2388 AC_DEFINE(HAVE_INET_PTON, 1, Define if you have the 'inet_pton' function.)
2393 # On some systems, setgroups is in unistd.h, on others, in grp.h
2394 AC_MSG_CHECKING(for setgroups)
2396 #include "confdefs.h"
2402 void* p = setgroups,
2403 AC_DEFINE(HAVE_SETGROUPS, 1, Define if you have the 'setgroups' function.)
2408 # check for openpty and forkpty
2410 AC_CHECK_FUNCS(openpty,,
2411 AC_CHECK_LIB(util,openpty,
2412 [AC_DEFINE(HAVE_OPENPTY) LIBS="$LIBS -lutil"],
2413 AC_CHECK_LIB(bsd,openpty, [AC_DEFINE(HAVE_OPENPTY) LIBS="$LIBS -lbsd"])
2416 AC_CHECK_FUNCS(forkpty,,
2417 AC_CHECK_LIB(util,forkpty,
2418 [AC_DEFINE(HAVE_FORKPTY) LIBS="$LIBS -lutil"],
2419 AC_CHECK_LIB(bsd,forkpty, [AC_DEFINE(HAVE_FORKPTY) LIBS="$LIBS -lbsd"])
2423 # check for long file support functions
2424 AC_CHECK_FUNCS(fseek64 fseeko fstatvfs ftell64 ftello statvfs)
2426 AC_REPLACE_FUNCS(dup2 getcwd strdup strerror memmove)
2427 AC_CHECK_FUNCS(getpgrp,
2428 AC_TRY_COMPILE([#include <unistd.h>],
2430 AC_DEFINE(GETPGRP_HAVE_ARG, 1,
2431 [Define if getpgrp() must be called as getpgrp(0).])
2434 AC_CHECK_FUNCS(setpgrp,
2435 AC_TRY_COMPILE([#include <unistd.h>],
2437 AC_DEFINE(SETPGRP_HAVE_ARG, 1,
2438 [Define if setpgrp() must be called as setpgrp(0, 0).])
2441 AC_CHECK_FUNCS(gettimeofday,
2442 AC_TRY_COMPILE([#include <sys/time.h>],
2443 [gettimeofday((struct timeval*)0,(struct timezone*)0);], ,
2444 AC_DEFINE(GETTIMEOFDAY_NO_TZ, 1,
2445 [Define if gettimeofday() does not have second (timezone) argument
2446 This is the case on Motorola V4 (R40V4.2)])
2450 AC_MSG_CHECKING(for major, minor, and makedev)
2452 #if defined(MAJOR_IN_MKDEV)
2453 #include <sys/mkdev.h>
2454 #elif defined(MAJOR_IN_SYSMACROS)
2455 #include <sys/sysmacros.h>
2457 #include <sys/types.h>
2460 makedev(major(0),minor(0));
2462 AC_DEFINE(HAVE_DEVICE_MACROS, 1,
2463 [Define to 1 if you have the device macros.])
2469 # On OSF/1 V5.1, getaddrinfo is available, but a define
2470 # for [no]getaddrinfo in netdb.h.
2471 AC_MSG_CHECKING(for getaddrinfo)
2473 #include <sys/types.h>
2474 #include <sys/socket.h>
2478 getaddrinfo(NULL, NULL, NULL, NULL);
2481 AC_MSG_CHECKING(getaddrinfo bug)
2483 #include <sys/types.h>
2486 #include <sys/socket.h>
2487 #include <netinet/in.h>
2491 int passive, gaierr, inet4 = 0, inet6 = 0;
2492 struct addrinfo hints, *ai, *aitop;
2493 char straddr[INET6_ADDRSTRLEN], strport[16];
2495 for (passive = 0; passive <= 1; passive++) {
2496 memset(&hints, 0, sizeof(hints));
2497 hints.ai_family = AF_UNSPEC;
2498 hints.ai_flags = passive ? AI_PASSIVE : 0;
2499 hints.ai_socktype = SOCK_STREAM;
2500 hints.ai_protocol = IPPROTO_TCP;
2501 if ((gaierr = getaddrinfo(NULL, "54321", &hints, &aitop)) != 0) {
2502 (void)gai_strerror(gaierr);
2505 for (ai = aitop; ai; ai = ai->ai_next) {
2506 if (ai->ai_addr == NULL ||
2507 ai->ai_addrlen == 0 ||
2508 getnameinfo(ai->ai_addr, ai->ai_addrlen,
2509 straddr, sizeof(straddr), strport, sizeof(strport),
2510 NI_NUMERICHOST|NI_NUMERICSERV) != 0) {
2513 switch (ai->ai_family) {
2515 if (strcmp(strport, "54321") != 0) {
2519 if (strcmp(straddr, "0.0.0.0") != 0) {
2523 if (strcmp(straddr, "127.0.0.1") != 0) {
2530 if (strcmp(strport, "54321") != 0) {
2534 if (strcmp(straddr, "::") != 0) {
2538 if (strcmp(straddr, "::1") != 0) {
2548 /* another family support? */
2554 if (!(inet4 == 0 || inet4 == 2))
2556 if (!(inet6 == 0 || inet6 == 2))
2560 freeaddrinfo(aitop);
2565 freeaddrinfo(aitop);
2570 buggygetaddrinfo=no,
2571 AC_MSG_RESULT(buggy)
2572 buggygetaddrinfo=yes,
2573 AC_MSG_RESULT(buggy)
2574 buggygetaddrinfo=yes)], [
2576 buggygetaddrinfo=yes
2579 if test "$buggygetaddrinfo" = "yes"; then
2580 if test "$ipv6" = "yes"; then
2581 echo 'Fatal: You must get working getaddrinfo() function.'
2582 echo ' or you can specify "--disable-ipv6"'.
2586 AC_DEFINE(HAVE_GETADDRINFO, 1, [Define if you have the getaddrinfo function.])
2588 AC_CHECK_FUNCS(getnameinfo)
2590 # checks for structures
2594 AC_CHECK_MEMBERS([struct stat.st_rdev])
2595 AC_CHECK_MEMBERS([struct stat.st_blksize])
2596 AC_CHECK_MEMBERS([struct stat.st_flags])
2597 AC_CHECK_MEMBERS([struct stat.st_gen])
2598 AC_CHECK_MEMBERS([struct stat.st_birthtime])
2601 AC_MSG_CHECKING(for time.h that defines altzone)
2602 AC_CACHE_VAL(ac_cv_header_time_altzone,
2603 [AC_TRY_COMPILE([#include <time.h>], [return altzone;],
2604 ac_cv_header_time_altzone=yes,
2605 ac_cv_header_time_altzone=no)])
2606 AC_MSG_RESULT($ac_cv_header_time_altzone)
2607 if test $ac_cv_header_time_altzone = yes; then
2608 AC_DEFINE(HAVE_ALTZONE, 1, [Define this if your time.h defines altzone.])
2612 AC_MSG_CHECKING(whether sys/select.h and sys/time.h may both be included)
2614 #include <sys/types.h>
2615 #include <sys/select.h>
2616 #include <sys/time.h>
2618 AC_DEFINE(SYS_SELECT_WITH_SYS_TIME, 1,
2619 [Define if you can safely include both <sys/select.h> and <sys/time.h>
2620 (which you can't on SCO ODT 3.0).])
2623 AC_MSG_RESULT($was_it_defined)
2625 AC_MSG_CHECKING(for addrinfo)
2626 AC_CACHE_VAL(ac_cv_struct_addrinfo,
2628 # include <netdb.h>],
2629 [struct addrinfo a],
2630 ac_cv_struct_addrinfo=yes,
2631 ac_cv_struct_addrinfo=no))
2632 AC_MSG_RESULT($ac_cv_struct_addrinfo)
2633 if test $ac_cv_struct_addrinfo = yes; then
2634 AC_DEFINE(HAVE_ADDRINFO, 1, [struct addrinfo (netdb.h)])
2637 AC_MSG_CHECKING(for sockaddr_storage)
2638 AC_CACHE_VAL(ac_cv_struct_sockaddr_storage,
2640 # include <sys/types.h>
2641 # include <sys/socket.h>],
2642 [struct sockaddr_storage s],
2643 ac_cv_struct_sockaddr_storage=yes,
2644 ac_cv_struct_sockaddr_storage=no))
2645 AC_MSG_RESULT($ac_cv_struct_sockaddr_storage)
2646 if test $ac_cv_struct_sockaddr_storage = yes; then
2647 AC_DEFINE(HAVE_SOCKADDR_STORAGE, 1, [struct sockaddr_storage (sys/socket.h)])
2650 # checks for compiler characteristics
2656 AC_MSG_CHECKING(for working volatile)
2657 AC_TRY_COMPILE([],[volatile int x; x = 0;], works=yes,
2658 AC_DEFINE(volatile, [], [Define to empty if the keyword does not work.])
2660 AC_MSG_RESULT($works)
2663 AC_MSG_CHECKING(for working signed char)
2664 AC_TRY_COMPILE([], [signed char c;], works=yes,
2665 AC_DEFINE(signed, [], [Define to empty if the keyword does not work.])
2667 AC_MSG_RESULT($works)
2670 AC_MSG_CHECKING(for prototypes)
2671 AC_TRY_COMPILE([int foo(int x) { return 0; }], [return foo(10);],[
2672 AC_DEFINE(HAVE_PROTOTYPES, 1,
2673 [Define if your compiler supports function prototype])
2676 AC_MSG_RESULT($have_prototypes)
2679 AC_MSG_CHECKING(for variable length prototypes and stdarg.h)
2682 int foo(int x, ...) {
2690 ], [return foo(10, "", 3.14);], [
2691 AC_DEFINE(HAVE_STDARG_PROTOTYPES, 1,
2692 [Define if your compiler supports variable length function prototypes
2693 (e.g. void fprintf(FILE *, char *, ...);) *and* <stdarg.h>])
2696 AC_MSG_RESULT($works)
2698 # check for socketpair
2699 AC_MSG_CHECKING(for socketpair)
2701 #include <sys/types.h>
2702 #include <sys/socket.h>
2703 ], void *x=socketpair,
2704 AC_DEFINE(HAVE_SOCKETPAIR, 1, Define if you have the 'socketpair' function.)
2709 # check if sockaddr has sa_len member
2710 AC_MSG_CHECKING(if sockaddr has sa_len member)
2711 AC_TRY_COMPILE([#include <sys/types.h>
2712 #include <sys/socket.h>],
2716 AC_DEFINE(HAVE_SOCKADDR_SA_LEN, 1, [Define if sockaddr has sa_len member]),
2720 AC_MSG_CHECKING(whether va_list is an array)
2722 #ifdef HAVE_STDARG_PROTOTYPES
2725 #include <varargs.h>
2727 ], [va_list list1, list2; list1 = list2;], , [
2728 AC_DEFINE(VA_LIST_IS_ARRAY, 1, [Define if a va_list is an array of some kind])
2729 va_list_is_array=yes
2731 AC_MSG_RESULT($va_list_is_array)
2733 # sigh -- gethostbyname_r is a mess; it can have 3, 5 or 6 arguments :-(
2734 AH_TEMPLATE(HAVE_GETHOSTBYNAME_R,
2735 [Define this if you have some version of gethostbyname_r()])
2737 AC_CHECK_FUNC(gethostbyname_r, [
2738 AC_DEFINE(HAVE_GETHOSTBYNAME_R)
2739 AC_MSG_CHECKING([gethostbyname_r with 6 args])
2741 CFLAGS="$CFLAGS $MY_CPPFLAGS $MY_THREAD_CPPFLAGS $MY_CFLAGS"
2746 struct hostent *he, *res;
2751 (void) gethostbyname_r(name, he, buffer, buflen, &res, &h_errnop)
2753 AC_DEFINE(HAVE_GETHOSTBYNAME_R)
2754 AC_DEFINE(HAVE_GETHOSTBYNAME_R_6_ARG, 1,
2755 [Define this if you have the 6-arg version of gethostbyname_r().])
2759 AC_MSG_CHECKING([gethostbyname_r with 5 args])
2769 (void) gethostbyname_r(name, he, buffer, buflen, &h_errnop)
2771 AC_DEFINE(HAVE_GETHOSTBYNAME_R)
2772 AC_DEFINE(HAVE_GETHOSTBYNAME_R_5_ARG, 1,
2773 [Define this if you have the 5-arg version of gethostbyname_r().])
2777 AC_MSG_CHECKING([gethostbyname_r with 3 args])
2783 struct hostent_data data;
2785 (void) gethostbyname_r(name, he, &data);
2787 AC_DEFINE(HAVE_GETHOSTBYNAME_R)
2788 AC_DEFINE(HAVE_GETHOSTBYNAME_R_3_ARG, 1,
2789 [Define this if you have the 3-arg version of gethostbyname_r().])
2798 AC_CHECK_FUNCS(gethostbyname)
2800 AC_SUBST(HAVE_GETHOSTBYNAME_R_6_ARG)
2801 AC_SUBST(HAVE_GETHOSTBYNAME_R_5_ARG)
2802 AC_SUBST(HAVE_GETHOSTBYNAME_R_3_ARG)
2803 AC_SUBST(HAVE_GETHOSTBYNAME_R)
2804 AC_SUBST(HAVE_GETHOSTBYNAME)
2806 # checks for system services
2809 # Linux requires this for correct f.p. operations
2810 AC_CHECK_FUNC(__fpu_control,
2812 [AC_CHECK_LIB(ieee, __fpu_control)
2815 # Check for --with-fpectl
2816 AC_MSG_CHECKING(for --with-fpectl)
2818 AC_HELP_STRING(--with-fpectl, enable SIGFPE catching),
2820 if test "$withval" != no
2822 AC_DEFINE(WANT_SIGFPE_HANDLER, 1,
2823 [Define if you want SIGFPE handled (see Include/pyfpe.h).])
2825 else AC_MSG_RESULT(no)
2827 [AC_MSG_RESULT(no)])
2829 # check for --with-libm=...
2831 case $ac_sys_system in
2836 AC_MSG_CHECKING(for --with-libm=STRING)
2838 AC_HELP_STRING(--with-libm=STRING, math library),
2840 if test "$withval" = no
2842 AC_MSG_RESULT(force LIBM empty)
2843 elif test "$withval" != yes
2845 AC_MSG_RESULT(set LIBM="$withval")
2846 else AC_MSG_ERROR([proper usage is --with-libm=STRING])
2848 [AC_MSG_RESULT(default LIBM="$LIBM")])
2850 # check for --with-libc=...
2852 AC_MSG_CHECKING(for --with-libc=STRING)
2854 AC_HELP_STRING(--with-libc=STRING, C library),
2856 if test "$withval" = no
2858 AC_MSG_RESULT(force LIBC empty)
2859 elif test "$withval" != yes
2861 AC_MSG_RESULT(set LIBC="$withval")
2862 else AC_MSG_ERROR([proper usage is --with-libc=STRING])
2864 [AC_MSG_RESULT(default LIBC="$LIBC")])
2866 # check for hypot() in math library
2869 AC_REPLACE_FUNCS(hypot)
2873 AC_CHECK_HEADER(wchar.h, [
2874 AC_DEFINE(HAVE_WCHAR_H, 1,
2875 [Define if the compiler provides a wchar.h header file.])
2881 # determine wchar_t size
2882 if test "$wchar_h" = yes
2884 AC_CHECK_SIZEOF(wchar_t, 4, [#include <wchar.h>])
2887 AC_MSG_CHECKING(for UCS-4 tcl)
2891 #if TCL_UTF_MAX != 6
2892 # error "NOT UCS4_TCL"
2894 AC_DEFINE(HAVE_UCS4_TCL, 1, [Define this if you have tcl and TCL_UTF_MAX==6])
2897 AC_MSG_RESULT($have_ucs4_tcl)
2899 # check whether wchar_t is signed or not
2900 if test "$wchar_h" = yes
2902 # check whether wchar_t is signed or not
2903 AC_MSG_CHECKING(whether wchar_t is signed)
2904 AC_CACHE_VAL(ac_cv_wchar_t_signed, [
2909 /* Success: exit code 0 */
2910 exit((((wchar_t) -1) < ((wchar_t) 0)) ? 0 : 1);
2913 ac_cv_wchar_t_signed=yes,
2914 ac_cv_wchar_t_signed=no,
2915 ac_cv_wchar_t_signed=yes)])
2916 AC_MSG_RESULT($ac_cv_wchar_t_signed)
2919 AC_MSG_CHECKING(what type to use for unicode)
2920 dnl quadrigraphs "@<:@" and "@:>@" produce "[" and "]" in the output
2921 AC_ARG_ENABLE(unicode,
2922 AC_HELP_STRING(--enable-unicode@<:@=ucs@<:@24@:>@@:>@, Enable Unicode strings (default is yes)),
2924 [enable_unicode=yes])
2926 if test $enable_unicode = yes
2928 # Without any arguments, Py_UNICODE defaults to two-byte mode
2929 case "$have_ucs4_tcl" in
2930 yes) enable_unicode="ucs4"
2932 *) enable_unicode="ucs2"
2937 AH_TEMPLATE(Py_UNICODE_SIZE,
2938 [Define as the size of the unicode type.])
2939 case "$enable_unicode" in
2940 ucs2) unicode_size="2"
2941 AC_DEFINE(Py_UNICODE_SIZE,2)
2943 ucs4) unicode_size="4"
2944 AC_DEFINE(Py_UNICODE_SIZE,4)
2948 AH_TEMPLATE(PY_UNICODE_TYPE,
2949 [Define as the integral type used for Unicode representation.])
2951 AC_SUBST(UNICODE_OBJS)
2952 if test "$enable_unicode" = "no"
2955 AC_MSG_RESULT(not used)
2957 UNICODE_OBJS="Objects/unicodeobject.o Objects/unicodectype.o"
2958 AC_DEFINE(Py_USING_UNICODE, 1,
2959 [Define if you want to have a Unicode type.])
2961 # wchar_t is only usable if it maps to an unsigned type
2962 if test "$unicode_size" = "$ac_cv_sizeof_wchar_t" \
2963 -a "$ac_cv_wchar_t_signed" = "no"
2965 PY_UNICODE_TYPE="wchar_t"
2966 AC_DEFINE(HAVE_USABLE_WCHAR_T, 1,
2967 [Define if you have a useable wchar_t type defined in wchar.h; useable
2968 means wchar_t must be an unsigned type with at least 16 bits. (see
2969 Include/unicodeobject.h).])
2970 AC_DEFINE(PY_UNICODE_TYPE,wchar_t)
2971 elif test "$ac_cv_sizeof_short" = "$unicode_size"
2973 PY_UNICODE_TYPE="unsigned short"
2974 AC_DEFINE(PY_UNICODE_TYPE,unsigned short)
2975 elif test "$ac_cv_sizeof_long" = "$unicode_size"
2977 PY_UNICODE_TYPE="unsigned long"
2978 AC_DEFINE(PY_UNICODE_TYPE,unsigned long)
2980 PY_UNICODE_TYPE="no type found"
2982 AC_MSG_RESULT($PY_UNICODE_TYPE)
2985 # check for endianness
2987 AH_VERBATIM([WORDS_BIGENDIAN],
2989 /* Define to 1 if your processor stores words with the most significant byte
2990 first (like Motorola and SPARC, unlike Intel and VAX).
2992 The block below does compile-time checking for endianness on platforms
2993 that use GCC and therefore allows compiling fat binaries on OSX by using
2994 '-arch ppc -arch i386' as the compile flags. The phrasing was choosen
2995 such that the configure-result is used on systems that don't use GCC.
2997 #ifdef __BIG_ENDIAN__
2998 #define WORDS_BIGENDIAN 1
3000 #ifndef __LITTLE_ENDIAN__
3001 #undef WORDS_BIGENDIAN
3005 # Check whether right shifting a negative integer extends the sign bit
3006 # or fills with zeros (like the Cray J90, according to Tim Peters).
3007 AC_MSG_CHECKING(whether right shift extends the sign bit)
3008 AC_CACHE_VAL(ac_cv_rshift_extends_sign, [
3012 exit(((-1)>>3 == -1) ? 0 : 1);
3015 ac_cv_rshift_extends_sign=yes,
3016 ac_cv_rshift_extends_sign=no,
3017 ac_cv_rshift_extends_sign=yes)])
3018 AC_MSG_RESULT($ac_cv_rshift_extends_sign)
3019 if test "$ac_cv_rshift_extends_sign" = no
3021 AC_DEFINE(SIGNED_RIGHT_SHIFT_ZERO_FILLS, 1,
3022 [Define if i>>j for signed int i does not extend the sign bit
3026 # check for getc_unlocked and related locking functions
3027 AC_MSG_CHECKING(for getc_unlocked() and friends)
3028 AC_CACHE_VAL(ac_cv_have_getc_unlocked, [
3029 AC_TRY_LINK([#include <stdio.h>],[
3030 FILE *f = fopen("/dev/null", "r");
3034 ], ac_cv_have_getc_unlocked=yes, ac_cv_have_getc_unlocked=no)])
3035 AC_MSG_RESULT($ac_cv_have_getc_unlocked)
3036 if test "$ac_cv_have_getc_unlocked" = yes
3038 AC_DEFINE(HAVE_GETC_UNLOCKED, 1,
3039 [Define this if you have flockfile(), getc_unlocked(), and funlockfile()])
3042 # check where readline lives
3043 # save the value of LIBS so we don't actually link Python with readline
3044 LIBS_no_readline=$LIBS
3045 AC_CHECK_LIB(readline, readline)
3046 if test "$ac_cv_have_readline_readline" = no
3048 AC_CHECK_LIB(termcap, readline)
3051 # check for readline 2.1
3052 AC_CHECK_LIB(readline, rl_callback_handler_install,
3053 AC_DEFINE(HAVE_RL_CALLBACK, 1,
3054 [Define if you have readline 2.1]), , )
3056 # check for readline 2.2
3057 AC_TRY_CPP([#include <readline/readline.h>],
3058 have_readline=yes, have_readline=no)
3059 if test $have_readline = yes
3061 AC_EGREP_HEADER([extern int rl_completion_append_character;],
3062 [readline/readline.h],
3063 AC_DEFINE(HAVE_RL_COMPLETION_APPEND_CHARACTER, 1,
3064 [Define if you have readline 2.2]), )
3067 # check for readline 4.0
3068 AC_CHECK_LIB(readline, rl_pre_input_hook,
3069 AC_DEFINE(HAVE_RL_PRE_INPUT_HOOK, 1,
3070 [Define if you have readline 4.0]), , )
3072 # check for readline 4.2
3073 AC_CHECK_LIB(readline, rl_completion_matches,
3074 AC_DEFINE(HAVE_RL_COMPLETION_MATCHES, 1,
3075 [Define if you have readline 4.2]), , )
3077 # also in readline 4.2
3078 AC_TRY_CPP([#include <readline/readline.h>],
3079 have_readline=yes, have_readline=no)
3080 if test $have_readline = yes
3082 AC_EGREP_HEADER([extern int rl_catch_signals;],
3083 [readline/readline.h],
3084 AC_DEFINE(HAVE_RL_CATCH_SIGNAL, 1,
3085 [Define if you can turn off readline's signal handling.]), )
3088 # End of readline checks: restore LIBS
3089 LIBS=$LIBS_no_readline
3091 AC_MSG_CHECKING(for broken nice())
3092 AC_CACHE_VAL(ac_cv_broken_nice, [
3097 if (val1 != -1 && val1 == nice(2))
3102 ac_cv_broken_nice=yes,
3103 ac_cv_broken_nice=no,
3104 ac_cv_broken_nice=no)])
3105 AC_MSG_RESULT($ac_cv_broken_nice)
3106 if test "$ac_cv_broken_nice" = yes
3108 AC_DEFINE(HAVE_BROKEN_NICE, 1,
3109 [Define if nice() returns success/failure instead of the new priority.])
3112 AC_MSG_CHECKING(for broken poll())
3118 struct pollfd poll_struct = { 42, POLLIN|POLLPRI|POLLOUT, 0 };
3122 int poll_test = poll (&poll_struct, 1, 0);
3128 else if (poll_test == 0 && poll_struct.revents != POLLNVAL)
3138 ac_cv_broken_poll=yes,
3139 ac_cv_broken_poll=no,
3140 ac_cv_broken_poll=no)
3141 AC_MSG_RESULT($ac_cv_broken_poll)
3142 if test "$ac_cv_broken_poll" = yes
3144 AC_DEFINE(HAVE_BROKEN_POLL, 1,
3145 [Define if poll() sets errno on invalid file descriptors.])
3148 # Before we can test tzset, we need to check if struct tm has a tm_zone
3149 # (which is not required by ISO C or UNIX spec) and/or if we support
3153 # check tzset(3) exists and works like we expect it to
3154 AC_MSG_CHECKING(for working tzset())
3155 AC_CACHE_VAL(ac_cv_working_tzset, [
3162 extern char *tzname[];
3167 /* Note that we need to ensure that not only does tzset(3)
3168 do 'something' with localtime, but it works as documented
3169 in the library reference and as expected by the test suite.
3170 This includes making sure that tzname is set properly if
3171 tm->tm_zone does not exist since it is the alternative way
3172 of getting timezone info.
3174 Red Hat 6.2 doesn't understand the southern hemisphere
3175 after New Year's Day.
3178 time_t groundhogday = 1044144000; /* GMT-based */
3179 time_t midyear = groundhogday + (365 * 24 * 3600 / 2);
3183 if (localtime(&groundhogday)->tm_hour != 0)
3186 /* For UTC, tzname[1] is sometimes "", sometimes " " */
3187 if (strcmp(tzname[0], "UTC") ||
3188 (tzname[1][0] != 0 && tzname[1][0] != ' '))
3192 putenv("TZ=EST+5EDT,M4.1.0,M10.5.0");
3194 if (localtime(&groundhogday)->tm_hour != 19)
3197 if (strcmp(tzname[0], "EST") || strcmp(tzname[1], "EDT"))
3201 putenv("TZ=AEST-10AEDT-11,M10.5.0,M3.5.0");
3203 if (localtime(&groundhogday)->tm_hour != 11)
3206 if (strcmp(tzname[0], "AEST") || strcmp(tzname[1], "AEDT"))
3210 #if HAVE_STRUCT_TM_TM_ZONE
3211 if (strcmp(localtime(&groundhogday)->tm_zone, "AEDT"))
3213 if (strcmp(localtime(&midyear)->tm_zone, "AEST"))
3220 ac_cv_working_tzset=yes,
3221 ac_cv_working_tzset=no,
3222 ac_cv_working_tzset=no)])
3223 AC_MSG_RESULT($ac_cv_working_tzset)
3224 if test "$ac_cv_working_tzset" = yes
3226 AC_DEFINE(HAVE_WORKING_TZSET, 1,
3227 [Define if tzset() actually switches the local timezone in a meaningful way.])
3230 # Look for subsecond timestamps in struct stat
3231 AC_MSG_CHECKING(for tv_nsec in struct stat)
3232 AC_CACHE_VAL(ac_cv_stat_tv_nsec,
3233 AC_TRY_COMPILE([#include <sys/stat.h>], [
3235 st.st_mtim.tv_nsec = 1;
3237 ac_cv_stat_tv_nsec=yes,
3238 ac_cv_stat_tv_nsec=no,
3239 ac_cv_stat_tv_nsec=no))
3240 AC_MSG_RESULT($ac_cv_stat_tv_nsec)
3241 if test "$ac_cv_stat_tv_nsec" = yes
3243 AC_DEFINE(HAVE_STAT_TV_NSEC, 1,
3244 [Define if you have struct stat.st_mtim.tv_nsec])
3247 # Look for BSD style subsecond timestamps in struct stat
3248 AC_MSG_CHECKING(for tv_nsec2 in struct stat)
3249 AC_CACHE_VAL(ac_cv_stat_tv_nsec2,
3250 AC_TRY_COMPILE([#include <sys/stat.h>], [
3252 st.st_mtimespec.tv_nsec = 1;
3254 ac_cv_stat_tv_nsec2=yes,
3255 ac_cv_stat_tv_nsec2=no,
3256 ac_cv_stat_tv_nsec2=no))
3257 AC_MSG_RESULT($ac_cv_stat_tv_nsec2)
3258 if test "$ac_cv_stat_tv_nsec2" = yes
3260 AC_DEFINE(HAVE_STAT_TV_NSEC2, 1,
3261 [Define if you have struct stat.st_mtimensec])
3264 # On HP/UX 11.0, mvwdelch is a block with a return statement
3265 AC_MSG_CHECKING(whether mvwdelch is an expression)
3266 AC_CACHE_VAL(ac_cv_mvwdelch_is_expression,
3267 AC_TRY_COMPILE([#include <curses.h>], [
3269 rtn = mvwdelch(0,0,0);
3270 ], ac_cv_mvwdelch_is_expression=yes,
3271 ac_cv_mvwdelch_is_expression=no,
3272 ac_cv_mvwdelch_is_expression=yes))
3273 AC_MSG_RESULT($ac_cv_mvwdelch_is_expression)
3275 if test "$ac_cv_mvwdelch_is_expression" = yes
3277 AC_DEFINE(MVWDELCH_IS_EXPRESSION, 1,
3278 [Define if mvwdelch in curses.h is an expression.])
3281 AC_MSG_CHECKING(whether WINDOW has _flags)
3282 AC_CACHE_VAL(ac_cv_window_has_flags,
3283 AC_TRY_COMPILE([#include <curses.h>], [
3286 ], ac_cv_window_has_flags=yes,
3287 ac_cv_window_has_flags=no,
3288 ac_cv_window_has_flags=no))
3289 AC_MSG_RESULT($ac_cv_window_has_flags)
3292 if test "$ac_cv_window_has_flags" = yes
3294 AC_DEFINE(WINDOW_HAS_FLAGS, 1,
3295 [Define if WINDOW in curses.h offers a field _flags.])
3298 AC_MSG_CHECKING(for is_term_resized)
3299 AC_TRY_COMPILE([#include <curses.h>], void *x=is_term_resized,
3300 AC_DEFINE(HAVE_CURSES_IS_TERM_RESIZED, 1, Define if you have the 'is_term_resized' function.)
3305 AC_MSG_CHECKING(for resize_term)
3306 AC_TRY_COMPILE([#include <curses.h>], void *x=resize_term,
3307 AC_DEFINE(HAVE_CURSES_RESIZE_TERM, 1, Define if you have the 'resize_term' function.)
3312 AC_MSG_CHECKING(for resizeterm)
3313 AC_TRY_COMPILE([#include <curses.h>], void *x=resizeterm,
3314 AC_DEFINE(HAVE_CURSES_RESIZETERM, 1, Define if you have the 'resizeterm' function.)
3319 AC_MSG_CHECKING(for /dev/ptmx)
3321 if test -e /dev/ptmx
3324 AC_DEFINE(HAVE_DEV_PTMX, 1,
3325 [Define if we have /dev/ptmx.])
3330 AC_MSG_CHECKING(for /dev/ptc)
3335 AC_DEFINE(HAVE_DEV_PTC, 1,
3336 [Define if we have /dev/ptc.])
3341 AC_MSG_CHECKING(for %zd printf() format support)
3342 AC_TRY_RUN([#include <stdio.h>
3350 if(sprintf(buffer, "%zd", (size_t)123) < 0)
3353 if (strncmp(buffer, "123", 3))
3359 AC_DEFINE(PY_FORMAT_SIZE_T, "z", [Define to printf format modifier for Py_ssize_t])],
3362 AC_CHECK_TYPE(socklen_t,,
3363 AC_DEFINE(socklen_t,int,
3364 Define to `int' if <sys/socket.h> does not define.),[
3365 #ifdef HAVE_SYS_TYPES_H
3366 #include <sys/types.h>
3368 #ifdef HAVE_SYS_SOCKET_H
3369 #include <sys/socket.h>
3373 AC_SUBST(THREADHEADERS)
3375 for h in `(cd $srcdir;echo Python/thread_*.h)`
3377 THREADHEADERS="$THREADHEADERS \$(srcdir)/$h"
3381 SRCDIRS="Parser Grammar Objects Python Modules Mac"
3382 AC_MSG_CHECKING(for build directories)
3383 for dir in $SRCDIRS; do
3384 if test ! -d $dir; then
3390 # generate output files
3391 AC_CONFIG_FILES(Makefile.pre Modules/Setup.config)
3394 echo "creating Modules/Setup"
3395 if test ! -f Modules/Setup
3397 cp $srcdir/Modules/Setup.dist Modules/Setup
3400 echo "creating Modules/Setup.local"
3401 if test ! -f Modules/Setup.local
3403 echo "# Edit this file for local setup changes" >Modules/Setup.local
3406 echo "creating Makefile"
3407 $SHELL $srcdir/Modules/makesetup -c $srcdir/Modules/config.c.in \
3408 -s Modules Modules/Setup.config \
3409 Modules/Setup.local Modules/Setup