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=
105 PYTHONFRAMEWORK=Python
106 PYTHONFRAMEWORKDIR=Python.framework
107 PYTHONFRAMEWORKPREFIX=$enableval
108 PYTHONFRAMEWORKINSTALLDIR=$PYTHONFRAMEWORKPREFIX/$PYTHONFRAMEWORKDIR
109 FRAMEWORKINSTALLFIRST="frameworkinstallstructure"
110 FRAMEWORKINSTALLLAST="frameworkinstallmaclib frameworkinstallapps frameworkinstallunixtools"
111 prefix=$PYTHONFRAMEWORKINSTALLDIR/Versions/$VERSION
113 # Add makefiles for Mac specific code to the list of output
115 AC_CONFIG_FILES(Mac/OSX/Makefile)
116 AC_CONFIG_FILES(Mac/OSX/PythonLauncher/Makefile)
117 AC_CONFIG_FILES(Mac/OSX/IDLE/Makefile)
121 PYTHONFRAMEWORKDIR=no-framework
122 PYTHONFRAMEWORKPREFIX=
123 PYTHONFRAMEWORKINSTALLDIR=
124 FRAMEWORKINSTALLFIRST=
125 FRAMEWORKINSTALLLAST=
128 AC_SUBST(PYTHONFRAMEWORK)
129 AC_SUBST(PYTHONFRAMEWORKDIR)
130 AC_SUBST(PYTHONFRAMEWORKPREFIX)
131 AC_SUBST(PYTHONFRAMEWORKINSTALLDIR)
132 AC_SUBST(FRAMEWORKINSTALLFIRST)
133 AC_SUBST(FRAMEWORKINSTALLLAST)
136 ## AC_HELP_STRING(--with-dyld,
137 ## Use (OpenStep|Rhapsody) dynamic linker))
139 # Set name for machine-dependent library files
141 AC_MSG_CHECKING(MACHDEP)
142 if test -z "$MACHDEP"
144 ac_sys_system=`uname -s`
145 if test "$ac_sys_system" = "AIX" -o "$ac_sys_system" = "Monterey64" \
146 -o "$ac_sys_system" = "UnixWare" -o "$ac_sys_system" = "OpenUNIX"; then
147 ac_sys_release=`uname -v`
149 ac_sys_release=`uname -r`
151 ac_md_system=`echo $ac_sys_system |
152 tr -d '[/ ]' | tr '[[A-Z]]' '[[a-z]]'`
153 ac_md_release=`echo $ac_sys_release |
154 tr -d '[/ ]' | sed 's/^[[A-Z]]\.//' | sed 's/\..*//'`
155 MACHDEP="$ac_md_system$ac_md_release"
158 cygwin*) MACHDEP="cygwin";;
159 darwin*) MACHDEP="darwin";;
160 atheos*) MACHDEP="atheos";;
161 irix646) MACHDEP="irix6";;
162 '') MACHDEP="unknown";;
166 # Some systems cannot stand _XOPEN_SOURCE being defined at all; they
167 # disable features if it is defined, without any means to access these
168 # features as extensions. For these systems, we skip the definition of
169 # _XOPEN_SOURCE. Before adding a system to the list to gain access to
170 # some feature, make sure there is no alternative way to access this
171 # feature. Also, when using wildcards, make sure you have verified the
172 # need for not defining _XOPEN_SOURCE on all systems matching the
173 # wildcard, and that the wildcard does not include future systems
174 # (which may remove their limitations).
175 dnl quadrigraphs "@<:@" and "@:>@" produce "[" and "]" in the output
176 case $ac_sys_system/$ac_sys_release in
177 # On OpenBSD, select(2) is not available if _XOPEN_SOURCE is defined,
178 # even though select is a POSIX function. Reported by J. Ribbens.
179 # Reconfirmed for OpenBSD 3.3 by Zachary Hamm, for 3.4 by Jason Ish.
180 OpenBSD/2.* | OpenBSD/3.@<:@012345678@:>@)
181 define_xopen_source=no;;
182 # On Solaris 2.6, sys/wait.h is inconsistent in the usage
183 # of union __?sigval. Reported by Stuart Bishop.
185 define_xopen_source=no;;
186 # On UnixWare 7, u_long is never defined with _XOPEN_SOURCE,
187 # but used in /usr/include/netinet/tcp.h. Reported by Tim Rice.
188 # Reconfirmed for 7.1.4 by Martin v. Loewis.
189 OpenUNIX/8.0.0| UnixWare/7.1.@<:@0-4@:>@)
190 define_xopen_source=no;;
191 # On OpenServer 5, u_short is never defined with _XOPEN_SOURCE,
192 # but used in struct sockaddr.sa_family. Reported by Tim Rice.
194 define_xopen_source=no;;
195 # On FreeBSD 4.8 and MacOS X 10.2, a bug in ncurses.h means that
196 # it craps out if _XOPEN_EXTENDED_SOURCE is defined. Apparently,
197 # this is fixed in 10.3, which identifies itself as Darwin/7.*
198 # This should hopefully be fixed in FreeBSD 4.9
199 FreeBSD/4.8* | Darwin/6* )
200 define_xopen_source=no;;
201 # On AIX 4 and 5.1, mbstate_t is defined only when _XOPEN_SOURCE == 500 but
202 # used in wcsnrtombs() and mbsnrtowcs() even if _XOPEN_SOURCE is not defined
203 # or has another value. By not (re)defining it, the defaults come in place.
205 define_xopen_source=no;;
207 if test `uname -r` -eq 1; then
208 define_xopen_source=no
211 # On Mac OS X 10.4, defining _POSIX_C_SOURCE or _XOPEN_SOURCE
212 # disables platform specific features beyond repair.
213 # On Mac OS X 10.3, defining _POSIX_C_SOURCE or _XOPEN_SOURCE
214 # has no effect, don't bother defineing them
216 define_xopen_source=no
221 if test $define_xopen_source = yes
223 # On Solaris w/ g++ it appears that _XOPEN_SOURCE has to be
224 # defined precisely as g++ defines it
225 # Furthermore, on Solaris 10, XPG6 requires the use of a C99
227 case $ac_sys_system/$ac_sys_release in
228 SunOS/5.8|SunOS/5.9|SunOS/5.10)
229 AC_DEFINE(_XOPEN_SOURCE, 500,
230 Define to the level of X/Open that your system supports)
233 AC_DEFINE(_XOPEN_SOURCE, 600,
234 Define to the level of X/Open that your system supports)
238 # On Tru64 Unix 4.0F, defining _XOPEN_SOURCE also requires
239 # definition of _XOPEN_SOURCE_EXTENDED and _POSIX_C_SOURCE, or else
240 # several APIs are not declared. Since this is also needed in some
241 # cases for HP-UX, we define it globally.
242 # except for Solaris 10, where it must not be defined,
243 # as it implies XPG4.2
244 case $ac_sys_system/$ac_sys_release in
248 AC_DEFINE(_XOPEN_SOURCE_EXTENDED, 1,
249 Define to activate Unix95-and-earlier features)
253 AC_DEFINE(_POSIX_C_SOURCE, 200112L, Define to activate features from IEEE Stds 1003.1-2001)
258 # SGI compilers allow the specification of the both the ABI and the
259 # ISA on the command line. Depending on the values of these switches,
260 # different and often incompatable code will be generated.
262 # The SGI_ABI variable can be used to modify the CC and LDFLAGS and
263 # thus supply support for various ABI/ISA combinations. The MACHDEP
264 # variable is also adjusted.
267 if test ! -z "$SGI_ABI"
270 LDFLAGS="$SGI_ABI $LDFLAGS"
271 MACHDEP=`echo "${MACHDEP}${SGI_ABI}" | sed 's/ *//g'`
273 AC_MSG_RESULT($MACHDEP)
275 # And add extra plat-mac for darwin
276 AC_SUBST(EXTRAPLATDIR)
277 AC_SUBST(EXTRAMACHDEPPATH)
278 AC_MSG_CHECKING(EXTRAPLATDIR)
279 if test -z "$EXTRAPLATDIR"
283 EXTRAPLATDIR="\$(PLATMACDIRS)"
284 EXTRAMACHDEPPATH="\$(PLATMACPATH)"
292 AC_MSG_RESULT($EXTRAPLATDIR)
294 # Record the configure-time value of MACOSX_DEPLOYMENT_TARGET,
295 # it may influence the way we can build extensions, so distutils
297 AC_SUBST(CONFIGURE_MACOSX_DEPLOYMENT_TARGET)
298 AC_SUBST(EXPORT_MACOSX_DEPLOYMENT_TARGET)
299 CONFIGURE_MACOSX_DEPLOYMENT_TARGET=
300 EXPORT_MACOSX_DEPLOYMENT_TARGET='#'
302 # checks for alternative programs
304 # compiler flags are generated in two sets, BASECFLAGS and OPT. OPT is just
305 # for debug/optimization stuff. BASECFLAGS is for flags that are required
306 # just to get things to compile and link. Users are free to override OPT
307 # when running configure or make. The build should not break if they do.
308 # BASECFLAGS should generally not be messed with, however.
310 # XXX shouldn't some/most/all of this code be merged with the stuff later
311 # on that fiddles with OPT and BASECFLAGS?
312 AC_MSG_CHECKING(for --without-gcc)
314 AC_HELP_STRING(--without-gcc,never use gcc),
322 without_gcc=$withval;;
324 case $ac_sys_system in
332 BASECFLAGS="$BASECFLAGS -export pragma"
334 LDFLAGS="$LDFLAGS -nodup"
342 AC_MSG_ERROR([Unknown BeOS platform "$BE_HOST_CPU"])
345 AR="\$(srcdir)/Modules/ar_beos"
353 AC_MSG_RESULT($without_gcc)
355 # If the user switches compilers, we can't believe the cache
356 if test ! -z "$ac_cv_prog_CC" -a ! -z "$CC" -a "$CC" != "$ac_cv_prog_CC"
358 AC_MSG_ERROR([cached CC is different -- throw away $cache_file
359 (it is also a good idea to do 'make clean' before compiling)])
366 AC_MSG_CHECKING(for --with-cxx-main=<compiler>)
367 AC_ARG_WITH(cxx_main,
368 AC_HELP_STRING([--with-cxx-main=<compiler>],
369 [compile main() and link python executable with C++ compiler]),
375 yes) with_cxx_main=yes
387 AC_MSG_RESULT($with_cxx_main)
393 gcc) AC_PATH_PROG(CXX, [g++], [g++], [notfound]) ;;
394 cc) AC_PATH_PROG(CXX, [c++], [c++], [notfound]) ;;
396 if test "$CXX" = "notfound"
403 AC_CHECK_PROGS(CXX, $CCC c++ g++ gcc CC cxx cc++ cl, notfound)
404 if test "$CXX" = "notfound"
409 if test "$preset_cxx" != "$CXX"
413 By default, distutils will build C++ extension modules with "$CXX".
414 If this is not intended, then set CXX on the configure command line.
419 # checks for UNIX variants that set C preprocessor variables
422 # Check for unsupported systems
423 case $ac_sys_system/$ac_sys_release in
425 echo This system \($ac_sys_system/$ac_sys_release\) is no longer supported.
426 echo See README for details.
431 AC_MSG_CHECKING(for --with-suffix)
433 AC_HELP_STRING(--with-suffix=.exe, set executable suffix),
440 AC_MSG_RESULT($EXEEXT)
442 # Test whether we're running on a non-case-sensitive system, in which
443 # case we give a warning if no ext is given
444 AC_SUBST(BUILDEXEEXT)
445 AC_MSG_CHECKING(for case-insensitive build directory)
446 if test ! -d CaseSensitiveTestDir; then
447 mkdir CaseSensitiveTestDir
450 if test -d casesensitivetestdir
458 rmdir CaseSensitiveTestDir
463 gcc) CC="$CC -D_HAVE_BSDI";;
467 case $ac_sys_system in
470 cc|*/cc) CC="$CC -Ae";;
474 cc) CC="$CC -Wl,-Bexport";;
477 # Some functions have a prototype only with that define, e.g. confstr
478 AC_DEFINE(__EXTENSIONS__, 1, [Defined on Solaris to see additional function prototypes.])
484 AC_MSG_CHECKING(LIBRARY)
485 if test -z "$LIBRARY"
487 LIBRARY='libpython$(VERSION).a'
489 AC_MSG_RESULT($LIBRARY)
491 # LDLIBRARY is the name of the library to link against (as opposed to the
492 # name of the library into which to insert object files). BLDLIBRARY is also
493 # the library to link against, usually. On Mac OS X frameworks, BLDLIBRARY
494 # is blank as the main program is not linked directly against LDLIBRARY.
495 # LDLIBRARYDIR is the path to LDLIBRARY, which is made in a subdirectory. On
496 # systems without shared libraries, LDLIBRARY is the same as LIBRARY
497 # (defined in the Makefiles). On Cygwin LDLIBRARY is the import library,
498 # DLLLIBRARY is the shared (i.e., DLL) library.
500 # RUNSHARED is used to run shared python without installed libraries
502 # INSTSONAME is the name of the shared library that will be use to install
503 # on the system - some systems like version suffix, others don't
507 AC_SUBST(LDLIBRARYDIR)
511 BLDLIBRARY='$(LDLIBRARY)'
512 INSTSONAME='$(LDLIBRARY)'
517 # LINKCC is the command that links the python executable -- default is $(CC).
518 # If CXX is set, and if it is needed to link a main function that was
519 # compiled with CXX, LINKCC is CXX instead. Always using CXX is undesirable:
520 # python might then depend on the C++ runtime
521 # This is altered for AIX in order to build the export list before
524 AC_MSG_CHECKING(LINKCC)
527 LINKCC='$(PURIFY) $(MAINCC)'
528 case $ac_sys_system in
531 if test $ac_sys_release -ge 5 -o \
532 $ac_sys_release -eq 4 -a `uname -r` -ge 2 ; then
535 LINKCC="\$(srcdir)/Modules/makexp_aix Modules/python.exp $exp_extra \$(LIBRARY); $LINKCC";;
537 LINKCC="$LINKCC -L/usr/lib/ia64l64";;
540 AC_MSG_RESULT($LINKCC)
542 AC_MSG_CHECKING(for --enable-shared)
543 AC_ARG_ENABLE(shared,
544 AC_HELP_STRING(--enable-shared, disable/enable building shared python library))
546 if test -z "$enable_shared"
548 case $ac_sys_system in
550 enable_shared="yes";;
555 AC_MSG_RESULT($enable_shared)
557 AC_MSG_CHECKING(for --enable-profiling)
558 AC_ARG_ENABLE(profiling,
559 AC_HELP_STRING(--enable-profiling, enable C-level code profiling),
562 AC_TRY_RUN([int main() { return 0; }],
563 ac_enable_profiling="yes",
564 ac_enable_profiling="no",
565 ac_enable_profiling="no")
567 AC_MSG_RESULT($ac_enable_profiling)
569 case "$ac_enable_profiling" in
571 BASECFLAGS="-pg $BASECFLAGS"
572 LDFLAGS="-pg $LDFLAGS"
576 AC_MSG_CHECKING(LDLIBRARY)
578 # MacOSX framework builds need more magic. LDLIBRARY is the dynamic
579 # library that we build, but we do not want to link against it (we
580 # will find it with a -framework option). For this reason there is an
581 # extra variable BLDLIBRARY against which Python and the extension
582 # modules are linked, BLDLIBRARY. This is normally the same as
583 # LDLIBRARY, but empty for MacOSX framework builds.
584 if test "$enable_framework"
586 LDLIBRARY='$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
587 RUNSHARED=DYLD_FRAMEWORK_PATH="`pwd`:$DYLD_FRAMEWORK_PATH"
590 BLDLIBRARY='$(LDLIBRARY)'
593 # Other platforms follow
594 if test $enable_shared = "yes"; then
595 AC_DEFINE(Py_ENABLE_SHARED, 1, [Defined if Python is built as a shared library.])
596 case $ac_sys_system in
598 LDLIBRARY='libpython$(VERSION).so'
601 LDLIBRARY='libpython$(VERSION).dll.a'
602 DLLLIBRARY='libpython$(VERSION).dll'
605 LDLIBRARY='libpython$(VERSION).so'
606 BLDLIBRARY='-Wl,-R,$(LIBDIR) -L. -lpython$(VERSION)'
607 RUNSHARED=LD_LIBRARY_PATH=`pwd`:${LD_LIBRARY_PATH}
608 INSTSONAME="$LDLIBRARY".$SOVERSION
610 Linux*|GNU*|NetBSD*|FreeBSD*|DragonFly*)
611 LDLIBRARY='libpython$(VERSION).so'
612 BLDLIBRARY='-L. -lpython$(VERSION)'
613 RUNSHARED=LD_LIBRARY_PATH=`pwd`:${LD_LIBRARY_PATH}
614 case $ac_sys_system in
616 SOVERSION=`echo $SOVERSION|cut -d "." -f 1`
619 INSTSONAME="$LDLIBRARY".$SOVERSION
624 LDLIBRARY='libpython$(VERSION).so'
627 LDLIBRARY='libpython$(VERSION).sl'
630 BLDLIBRARY='-Wl,+b,$(LIBDIR) -L. -lpython$(VERSION)'
631 RUNSHARED=SHLIB_PATH=`pwd`:${SHLIB_PATH}
634 LDLIBRARY='libpython$(VERSION).so'
635 BLDLIBRARY='-rpath $(LIBDIR) -L. -lpython$(VERSION)'
636 RUNSHARED=LD_LIBRARY_PATH=`pwd`:${LD_LIBRARY_PATH}
639 LDLIBRARY='libpython$(VERSION).so'
640 BLDLIBRARY='-L. -lpython$(VERSION)'
641 RUNSHARED=DLL_PATH=`pwd`:${DLL_PATH:-/atheos/sys/libs:/atheos/autolnk/lib}
644 else # shared is disabled
645 case $ac_sys_system in
647 BLDLIBRARY='$(LIBRARY)'
648 LDLIBRARY='libpython$(VERSION).dll.a'
653 AC_MSG_RESULT($LDLIBRARY)
657 AC_CHECK_PROGS(AR, ar aal, ar)
660 AC_CHECK_PROG(SVNVERSION, svnversion, found, not-found)
661 if test $SVNVERSION = found
663 SVNVERSION="svnversion \$(srcdir)"
665 SVNVERSION="echo exported"
670 # install -d does not work on BSDI or HP-UX
671 if test -z "$INSTALL"
673 INSTALL="${srcdir}/install-sh -c"
678 # Not every filesystem supports hard links
680 if test -z "$LN" ; then
681 case $ac_sys_system in
683 CYGWIN*) LN="ln -s";;
684 atheos*) LN="ln -s";;
689 # Check for --with-pydebug
690 AC_MSG_CHECKING(for --with-pydebug)
692 AC_HELP_STRING(--with-pydebug, build with Py_DEBUG defined),
694 if test "$withval" != no
696 AC_DEFINE(Py_DEBUG, 1,
697 [Define if you want to build an interpreter with many run-time checks.])
700 else AC_MSG_RESULT(no); Py_DEBUG='false'
704 # XXX Shouldn't the code above that fiddles with BASECFLAGS and OPT be
705 # merged with this chunk of code?
707 # Optimizer/debugger flags
708 # ------------------------
709 # (The following bit of code is complicated enough - please keep things
710 # indented properly. Just pretend you're editing Python code. ;-)
712 # There are two parallel sets of case statements below, one that checks to
713 # see if OPT was set and one that does BASECFLAGS setting based upon
714 # compiler and platform. BASECFLAGS tweaks need to be made even if the
717 # tweak OPT based on compiler and platform, only if the user didn't set
718 # it on the command line
724 if test "$CC" != 'g++' ; then
725 STRICT_PROTO="-Wstrict-prototypes"
727 case $ac_cv_prog_cc_g in
729 if test "$Py_DEBUG" = 'true' ; then
730 # Optimization messes up debuggers, so turn it off for
732 OPT="-g -Wall $STRICT_PROTO"
734 OPT="-g -O3 -Wall $STRICT_PROTO"
738 OPT="-O3 -Wall $STRICT_PROTO"
741 case $ac_sys_system in
742 SCO_SV*) OPT="$OPT -m486 -DSCO5"
752 # The current (beta) Monterey compiler dies with optimizations
753 # XXX what is Monterey? Does it still die w/ -O? Can we get rid of this?
754 case $ac_sys_system in
763 # tweak BASECFLAGS based on compiler and platform
766 # Python violates C99 rules, by casting between incompatible
767 # pointer types. GCC may generate bad code as a result of that,
768 # so use -fno-strict-aliasing if supported.
769 AC_MSG_CHECKING(whether $CC accepts -fno-strict-aliasing)
771 CC="$CC -fno-strict-aliasing"
772 AC_TRY_RUN([int main() { return 0; }],
773 ac_cv_no_strict_aliasing_ok=yes,
774 ac_cv_no_strict_aliasing_ok=no,
775 ac_cv_no_strict_aliasing_ok=no)
777 AC_MSG_RESULT($ac_cv_no_strict_aliasing_ok)
778 if test $ac_cv_no_strict_aliasing_ok = yes
780 BASECFLAGS="$BASECFLAGS -fno-strict-aliasing"
782 case $ac_sys_system in
784 BASECFLAGS="$BASECFLAGS -m486 -DSCO5"
786 # is there any other compiler on Darwin besides gcc?
788 BASECFLAGS="$BASECFLAGS -Wno-long-double -no-cpp-precomp -mno-fused-madd"
789 if test "${enable_universalsdk}"; then
790 BASECFLAGS="-arch ppc -arch i386 -isysroot ${UNIVERSALSDK} ${BASECFLAGS}"
795 BASECFLAGS="$BASECFLAGS -mieee"
801 case $ac_sys_system in
803 BASECFLAGS="$BASECFLAGS -K pentium,host,inline,loop_unroll,alloca "
806 BASECFLAGS="$BASECFLAGS -ieee -std"
809 BASECFLAGS="$BASECFLAGS -belf -Ki486 -DSCO5"
815 if test "$Py_DEBUG" = 'true'; then
821 if test "$ac_arch_flags"
823 BASECFLAGS="$BASECFLAGS $ac_arch_flags"
826 # disable check for icc since it seems to pass, but generates a warning
829 ac_cv_opt_olimit_ok=no
832 AC_MSG_CHECKING(whether $CC accepts -OPT:Olimit=0)
833 AC_CACHE_VAL(ac_cv_opt_olimit_ok,
835 CC="$CC -OPT:Olimit=0"
836 AC_TRY_RUN([int main() { return 0; }],
837 ac_cv_opt_olimit_ok=yes,
838 ac_cv_opt_olimit_ok=no,
839 ac_cv_opt_olimit_ok=no)
841 AC_MSG_RESULT($ac_cv_opt_olimit_ok)
842 if test $ac_cv_opt_olimit_ok = yes; then
843 case $ac_sys_system in
844 # XXX is this branch needed? On MacOSX 10.2.2 the result of the
845 # olimit_ok test is "no". Is it "yes" in some other Darwin-esque
850 BASECFLAGS="$BASECFLAGS -OPT:Olimit=0"
854 AC_MSG_CHECKING(whether $CC accepts -Olimit 1500)
855 AC_CACHE_VAL(ac_cv_olimit_ok,
857 CC="$CC -Olimit 1500"
858 AC_TRY_RUN([int main() { return 0; }],
863 AC_MSG_RESULT($ac_cv_olimit_ok)
864 if test $ac_cv_olimit_ok = yes; then
865 BASECFLAGS="$BASECFLAGS -Olimit 1500"
869 # On some compilers, pthreads are available without further options
870 # (e.g. MacOS X). On some of these systems, the compiler will not
871 # complain if unaccepted options are passed (e.g. gcc on Mac OS X).
872 # So we have to see first whether pthreads are available without
873 # options before we can check whether -Kpthread improves anything.
874 AC_MSG_CHECKING(whether pthreads are available without options)
875 AC_CACHE_VAL(ac_cv_pthread_is_default,
879 void* routine(void* p){return NULL;}
883 if(pthread_create(&p,NULL,routine,NULL)!=0)
885 (void)pthread_detach(p);
890 ac_cv_pthread_is_default=yes
894 ac_cv_pthread_is_default=no,
895 ac_cv_pthread_is_default=no)
897 AC_MSG_RESULT($ac_cv_pthread_is_default)
900 if test $ac_cv_pthread_is_default = yes
904 # -Kpthread, if available, provides the right #defines
905 # and linker options to make pthread_create available
906 # Some compilers won't report that they do not support -Kpthread,
907 # so we need to run a program to see whether it really made the
908 # function available.
909 AC_MSG_CHECKING(whether $CC accepts -Kpthread)
910 AC_CACHE_VAL(ac_cv_kpthread,
916 void* routine(void* p){return NULL;}
920 if(pthread_create(&p,NULL,routine,NULL)!=0)
922 (void)pthread_detach(p);
930 AC_MSG_RESULT($ac_cv_kpthread)
933 if test $ac_cv_kpthread = no -a $ac_cv_pthread_is_default = no
935 # -Kthread, if available, provides the right #defines
936 # and linker options to make pthread_create available
937 # Some compilers won't report that they do not support -Kthread,
938 # so we need to run a program to see whether it really made the
939 # function available.
940 AC_MSG_CHECKING(whether $CC accepts -Kthread)
941 AC_CACHE_VAL(ac_cv_kthread,
947 void* routine(void* p){return NULL;}
951 if(pthread_create(&p,NULL,routine,NULL)!=0)
953 (void)pthread_detach(p);
961 AC_MSG_RESULT($ac_cv_kthread)
964 if test $ac_cv_kthread = no -a $ac_cv_pthread_is_default = no
966 # -pthread, if available, provides the right #defines
967 # and linker options to make pthread_create available
968 # Some compilers won't report that they do not support -pthread,
969 # so we need to run a program to see whether it really made the
970 # function available.
971 AC_MSG_CHECKING(whether $CC accepts -pthread)
972 AC_CACHE_VAL(ac_cv_thread,
978 void* routine(void* p){return NULL;}
982 if(pthread_create(&p,NULL,routine,NULL)!=0)
984 (void)pthread_detach(p);
992 AC_MSG_RESULT($ac_cv_pthread)
995 # If we have set a CC compiler flag for thread support then
996 # check if it works for CXX, too.
1000 AC_MSG_CHECKING(whether $CXX also accepts flags for thread support)
1003 if test "$ac_cv_kpthread" = "yes"
1005 CXX="$CXX -Kpthread"
1006 ac_cv_cxx_thread=yes
1007 elif test "$ac_cv_kthread" = "yes"
1010 ac_cv_cxx_thread=yes
1011 elif test "$ac_cv_pthread" = "yes"
1014 ac_cv_cxx_thread=yes
1017 if test $ac_cv_cxx_thread = yes
1019 echo 'void foo();int main(){foo();}void foo(){}' > conftest.$ac_ext
1020 $CXX -c conftest.$ac_ext 2>&5
1021 if $CXX -o conftest$ac_exeext conftest.$ac_objext 2>&5 \
1022 && test -s conftest$ac_exeext && ./conftest$ac_exeext
1024 ac_cv_cxx_thread=yes
1030 AC_MSG_RESULT($ac_cv_cxx_thread)
1034 dnl # check for ANSI or K&R ("traditional") preprocessor
1035 dnl AC_MSG_CHECKING(for C preprocessor type)
1036 dnl AC_TRY_COMPILE([
1037 dnl #define spam(name, doc) {#name, &name, #name "() -- " doc}
1039 dnl struct {char *name; int *addr; char *doc;} desc = spam(foo, "something");
1040 dnl ], [;], cpp_type=ansi, AC_DEFINE(HAVE_OLD_CPP) cpp_type=traditional)
1041 dnl AC_MSG_RESULT($cpp_type)
1043 # checks for header files
1045 AC_CHECK_HEADERS(asm/types.h curses.h dlfcn.h fcntl.h grp.h \
1046 shadow.h langinfo.h libintl.h ncurses.h poll.h pthread.h \
1047 stropts.h termios.h thread.h \
1049 sys/audioio.h sys/bsdtty.h sys/file.h sys/loadavg.h sys/lock.h sys/mkdev.h \
1051 sys/param.h sys/poll.h sys/select.h sys/socket.h sys/statvfs.h sys/time.h \
1052 sys/times.h sys/un.h sys/utsname.h sys/wait.h pty.h libutil.h \
1053 sys/resource.h netpacket/packet.h sysexits.h bluetooth.h \
1054 bluetooth/bluetooth.h)
1058 # On Solaris, term.h requires curses.h
1059 AC_CHECK_HEADERS(term.h,,,[
1060 #ifdef HAVE_CURSES_H
1065 # On Linux, netlink.h requires asm/types.h
1066 AC_CHECK_HEADERS(linux/netlink.h,,,[
1067 #ifdef HAVE_ASM_TYPES_H
1068 #include <asm/types.h>
1070 #ifdef HAVE_SYS_SOCKET_H
1071 #include <sys/socket.h>
1075 # checks for typedefs
1077 AC_MSG_CHECKING(for clock_t in time.h)
1078 AC_EGREP_HEADER(clock_t, time.h, was_it_defined=yes, [
1079 AC_DEFINE(clock_t, long, [Define to 'long' if <time.h> doesn't define.])
1081 AC_MSG_RESULT($was_it_defined)
1083 # Check whether using makedev requires defining _OSF_SOURCE
1084 AC_MSG_CHECKING(for makedev)
1085 AC_TRY_LINK([#include <sys/types.h> ],
1087 ac_cv_has_makedev=yes,
1088 ac_cv_has_makedev=no)
1089 if test "$ac_cv_has_makedev" = "no"; then
1090 # we didn't link, try if _OSF_SOURCE will allow us to link
1092 #define _OSF_SOURCE 1
1093 #include <sys/types.h>
1096 ac_cv_has_makedev=yes,
1097 ac_cv_has_makedev=no)
1098 if test "$ac_cv_has_makedev" = "yes"; then
1099 AC_DEFINE(_OSF_SOURCE, 1, [Define _OSF_SOURCE to get the makedev macro.])
1102 AC_MSG_RESULT($ac_cv_has_makedev)
1103 if test "$ac_cv_has_makedev" = "yes"; then
1104 AC_DEFINE(HAVE_MAKEDEV, 1, [Define this if you have the makedev macro.])
1107 # Enabling LFS on Solaris (2.6 to 9) with gcc 2.95 triggers a bug in
1108 # the system headers: If _XOPEN_SOURCE and _LARGEFILE_SOURCE are
1109 # defined, but the compiler does not support pragma redefine_extname,
1110 # and _LARGEFILE64_SOURCE is not defined, the headers refer to 64-bit
1111 # structures (such as rlimit64) without declaring them. As a
1112 # work-around, disable LFS on such configurations
1115 AC_MSG_CHECKING(Solaris LFS bug)
1117 #define _LARGEFILE_SOURCE 1
1118 #define _FILE_OFFSET_BITS 64
1119 #include <sys/resource.h>
1120 ],struct rlimit foo;,sol_lfs_bug=no,sol_lfs_bug=yes)
1121 AC_MSG_RESULT($sol_lfs_bug)
1122 if test "$sol_lfs_bug" = "yes"; then
1126 if test "$use_lfs" = "yes"; then
1127 # Two defines needed to enable largefile support on various platforms
1128 # These may affect some typedefs
1129 AC_DEFINE(_LARGEFILE_SOURCE, 1,
1130 [This must be defined on some systems to enable large file support.])
1131 AC_DEFINE(_FILE_OFFSET_BITS, 64,
1132 [This must be set to 64 on some systems to enable large file support.])
1135 # Add some code to confdefs.h so that the test for off_t works on SCO
1136 cat >> confdefs.h <<\EOF
1142 # Type availability checks
1149 AC_CHECK_TYPE(ssize_t,
1150 AC_DEFINE(HAVE_SSIZE_T, 1, Define if your compiler provides ssize_t),,)
1152 # Sizes of various common basic types
1153 # ANSI C requires sizeof(char) == 1, so no need to check it
1154 AC_CHECK_SIZEOF(int, 4)
1155 AC_CHECK_SIZEOF(long, 4)
1156 AC_CHECK_SIZEOF(void *, 4)
1157 AC_CHECK_SIZEOF(short, 2)
1158 AC_CHECK_SIZEOF(float, 4)
1159 AC_CHECK_SIZEOF(double, 8)
1160 AC_CHECK_SIZEOF(fpos_t, 4)
1161 AC_CHECK_SIZEOF(size_t, 4)
1163 AC_MSG_CHECKING(for long long support)
1165 AC_TRY_COMPILE([], [long long x; x = (long long)0;], [
1166 AC_DEFINE(HAVE_LONG_LONG, 1, [Define this if you have the type long long.])
1169 AC_MSG_RESULT($have_long_long)
1170 if test "$have_long_long" = yes ; then
1171 AC_CHECK_SIZEOF(long long, 8)
1174 AC_MSG_CHECKING(for uintptr_t support)
1176 AC_TRY_COMPILE([], [uintptr_t x; x = (uintptr_t)0;], [
1177 AC_DEFINE(HAVE_UINTPTR_T, 1, [Define this if you have the type uintptr_t.])
1180 AC_MSG_RESULT($have_uintptr_t)
1181 if test "$have_uintptr_t" = yes ; then
1182 AC_CHECK_SIZEOF(uintptr_t, 4)
1185 # Hmph. AC_CHECK_SIZEOF() doesn't include <sys/types.h>.
1186 AC_MSG_CHECKING(size of off_t)
1187 AC_CACHE_VAL(ac_cv_sizeof_off_t,
1188 [AC_TRY_RUN([#include <stdio.h>
1189 #include <sys/types.h>
1192 FILE *f=fopen("conftestval", "w");
1194 fprintf(f, "%d\n", sizeof(off_t));
1197 ac_cv_sizeof_off_t=`cat conftestval`,
1198 ac_cv_sizeof_off_t=0,
1199 ac_cv_sizeof_off_t=4)
1201 AC_MSG_RESULT($ac_cv_sizeof_off_t)
1202 AC_DEFINE_UNQUOTED(SIZEOF_OFF_T, $ac_cv_sizeof_off_t,
1203 [The number of bytes in an off_t.])
1205 AC_MSG_CHECKING(whether to enable large file support)
1206 if test "$have_long_long" = yes -a \
1207 "$ac_cv_sizeof_off_t" -gt "$ac_cv_sizeof_long" -a \
1208 "$ac_cv_sizeof_long_long" -ge "$ac_cv_sizeof_off_t"; then
1209 AC_DEFINE(HAVE_LARGEFILE_SUPPORT, 1,
1210 [Defined to enable large file support when an off_t is bigger than a long
1211 and long long is available and at least as big as an off_t. You may need
1212 to add some flags for configuration and compilation to enable this mode.
1213 (For Solaris and Linux, the necessary defines are already defined.)])
1219 # AC_CHECK_SIZEOF() doesn't include <time.h>.
1220 AC_MSG_CHECKING(size of time_t)
1221 AC_CACHE_VAL(ac_cv_sizeof_time_t,
1222 [AC_TRY_RUN([#include <stdio.h>
1226 FILE *f=fopen("conftestval", "w");
1228 fprintf(f, "%d\n", sizeof(time_t));
1231 ac_cv_sizeof_time_t=`cat conftestval`,
1232 ac_cv_sizeof_time_t=0,
1233 ac_cv_sizeof_time_t=4)
1235 AC_MSG_RESULT($ac_cv_sizeof_time_t)
1236 AC_DEFINE_UNQUOTED(SIZEOF_TIME_T, $ac_cv_sizeof_time_t,
1237 [The number of bytes in a time_t.])
1240 # if have pthread_t then define SIZEOF_PTHREAD_T
1242 if test "$ac_cv_kpthread" = "yes"
1243 then CC="$CC -Kpthread"
1244 elif test "$ac_cv_kthread" = "yes"
1245 then CC="$CC -Kthread"
1246 elif test "$ac_cv_pthread" = "yes"
1247 then CC="$CC -pthread"
1249 AC_MSG_CHECKING(for pthread_t)
1251 AC_TRY_COMPILE([#include <pthread.h>], [pthread_t x; x = *(pthread_t*)0;], have_pthread_t=yes)
1252 AC_MSG_RESULT($have_pthread_t)
1253 if test "$have_pthread_t" = yes ; then
1254 # AC_CHECK_SIZEOF() doesn't include <pthread.h>.
1255 AC_MSG_CHECKING(size of pthread_t)
1256 AC_CACHE_VAL(ac_cv_sizeof_pthread_t,
1257 [AC_TRY_RUN([#include <stdio.h>
1258 #include <pthread.h>
1261 FILE *f=fopen("conftestval", "w");
1263 fprintf(f, "%d\n", sizeof(pthread_t));
1266 ac_cv_sizeof_pthread_t=`cat conftestval`,
1267 ac_cv_sizeof_pthread_t=0,
1268 ac_cv_sizeof_pthread_t=4)
1270 AC_MSG_RESULT($ac_cv_sizeof_pthread_t)
1271 AC_DEFINE_UNQUOTED(SIZEOF_PTHREAD_T, $ac_cv_sizeof_pthread_t,
1272 [The number of bytes in a pthread_t.])
1276 AC_MSG_CHECKING(for --enable-toolbox-glue)
1277 AC_ARG_ENABLE(toolbox-glue,
1278 AC_HELP_STRING(--enable-toolbox-glue, disable/enable MacOSX glue code for extensions))
1280 if test -z "$enable_toolbox_glue"
1282 case $ac_sys_system/$ac_sys_release in
1284 enable_toolbox_glue="yes";;
1286 enable_toolbox_glue="no";;
1289 case "$enable_toolbox_glue" in
1291 extra_machdep_objs="Python/mactoolboxglue.o"
1292 extra_undefs="-u _PyMac_Error"
1293 AC_DEFINE(USE_TOOLBOX_OBJECT_GLUE, 1,
1294 [Define if you want to use MacPython modules on MacOSX in unix-Python.])
1297 extra_machdep_objs=""
1301 AC_MSG_RESULT($enable_toolbox_glue)
1303 AC_SUBST(OTHER_LIBTOOL_OPT)
1304 case $ac_sys_system/$ac_sys_release in
1305 Darwin/@<:@01567@:>@\..*)
1306 OTHER_LIBTOOL_OPT="-prebind -seg1addr 0x10000000"
1309 OTHER_LIBTOOL_OPT=""
1313 AC_SUBST(LIBTOOL_CRUFT)
1314 case $ac_sys_system/$ac_sys_release in
1315 Darwin/@<:@01567@:>@\..*)
1316 LIBTOOL_CRUFT="-framework System -lcc_dynamic"
1317 if test "${enable_universalsdk}"; then
1320 LIBTOOL_CRUFT="${LIBTOOL_CRUFT} -arch_only `arch`"
1322 LIBTOOL_CRUFT=$LIBTOOL_CRUFT' -install_name $(PYTHONFRAMEWORKINSTALLDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1323 LIBTOOL_CRUFT=$LIBTOOL_CRUFT' -compatibility_version $(VERSION) -current_version $(VERSION)';;
1325 gcc_version=`gcc -v 2>&1 | grep version | cut -d\ -f3`
1326 if test ${gcc_version} '<' 4.0
1328 LIBTOOL_CRUFT="-lcc_dynamic"
1332 LIBTOOL_CRUFT=$LIBTOOL_CRUFT" -lSystem -lSystemStubs -arch_only `arch`"
1333 LIBTOOL_CRUFT=$LIBTOOL_CRUFT' -install_name $(PYTHONFRAMEWORKINSTALLDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1334 LIBTOOL_CRUFT=$LIBTOOL_CRUFT' -compatibility_version $(VERSION) -current_version $(VERSION)';;
1337 AC_MSG_CHECKING(for --enable-framework)
1338 if test "$enable_framework"
1340 BASECFLAGS="$BASECFLAGS -fno-common -dynamic"
1341 # -F. is needed to allow linking to the framework while
1342 # in the build location.
1343 AC_DEFINE(WITH_NEXT_FRAMEWORK, 1,
1344 [Define if you want to produce an OpenStep/Rhapsody framework
1345 (shared library plus accessory files).])
1351 AC_MSG_CHECKING(for dyld)
1352 case $ac_sys_system/$ac_sys_release in
1354 AC_DEFINE(WITH_DYLD, 1,
1355 [Define if you want to use the new-style (Openstep, Rhapsody, MacOS)
1356 dynamic linker (dyld) instead of the old-style (NextStep) dynamic
1357 linker (rld). Dyld is necessary to support frameworks.])
1358 AC_MSG_RESULT(always on for Darwin)
1365 # Set info about shared libraries.
1370 AC_SUBST(LINKFORSHARED)
1371 # SO is the extension of shared libraries `(including the dot!)
1372 # -- usually .so, .sl on HP-UX, .dll on Cygwin
1376 case $ac_sys_system in
1387 # this might also be a termcap variable, see #610332
1389 echo '====================================================================='
1391 echo '+ WARNING: You have set SO in your environment. +'
1392 echo '+ Do you really mean to change the extension for shared libraries? +'
1393 echo '+ Continuing in 10 seconds to let you to ponder. +'
1395 echo '====================================================================='
1399 AC_DEFINE_UNQUOTED(SHLIB_EXT, "$SO", [Define this to be extension of shared libraries (including the dot!).])
1400 # LDSHARED is the ld *command* used to create shared library
1401 # -- "cc -G" on SunOS 5.x, "ld -shared" on IRIX 5
1402 # (Shared libraries in this instance are shared modules to be loaded into
1403 # Python, as opposed to building Python itself as a shared library.)
1404 AC_MSG_CHECKING(LDSHARED)
1405 if test -z "$LDSHARED"
1407 case $ac_sys_system/$ac_sys_release in
1409 BLDSHARED="\$(srcdir)/Modules/ld_so_aix \$(CC) -bI:Modules/python.exp"
1410 LDSHARED="\$(BINLIBDEST)/config/ld_so_aix \$(CC) -bI:\$(BINLIBDEST)/config/python.exp"
1413 BLDSHARED="\$(srcdir)/Modules/ld_so_beos $LDLIBRARY"
1414 LDSHARED="\$(BINLIBDEST)/config/ld_so_beos \$(LIBDIR)/$LDLIBRARY"
1416 IRIX/5*) LDSHARED="ld -shared";;
1417 IRIX*/6*) LDSHARED="ld ${SGI_ABI} -shared -all";;
1419 if test "$GCC" = "yes"
1420 then LDSHARED='$(CC) -shared'
1421 else LDSHARED='$(CC) -G';
1423 hp*|HP*) LDSHARED="ld -b";;
1424 OSF*) LDSHARED="ld -shared -expect_unresolved \"*\"";;
1426 LDSHARED='$(CC) $(LDFLAGS) -bundle'
1427 if test "$enable_framework" ; then
1428 # Link against the framework. All externals should be defined.
1429 BLDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1430 LDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKPREFIX)/$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1432 # No framework. Ignore undefined symbols, assuming they come from Python
1433 LDSHARED="$LDSHARED -undefined suppress"
1435 Darwin/1.4*|Darwin/5.*|Darwin/6.*)
1436 LDSHARED='$(CC) $(LDFLAGS) -bundle'
1437 if test "$enable_framework" ; then
1438 # Link against the framework. All externals should be defined.
1439 BLDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1440 LDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKPREFIX)/$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1442 # No framework, use the Python app as bundle-loader
1443 BLDSHARED="$LDSHARED "'-bundle_loader $(BUILDPYTHON)'
1444 LDSHARED="$LDSHARED "'-bundle_loader $(BINDIR)/python$(VERSION)$(EXE)'
1447 # Use -undefined dynamic_lookup whenever possible (10.3 and later).
1448 # This allows an extension to be used in any Python
1449 cur_target=`sw_vers -productVersion | sed 's/\(10\.[[0-9]]*\).*/\1/'`
1450 if test ${cur_target} '>' 10.2; then
1453 CONFIGURE_MACOSX_DEPLOYMENT_TARGET=${MACOSX_DEPLOYMENT_TARGET-${cur_target}}
1454 EXPORT_MACOSX_DEPLOYMENT_TARGET=''
1455 if test ${MACOSX_DEPLOYMENT_TARGET-${cur_target}} '>' 10.2
1457 if test "${enable_universalsdk}"; then
1458 LDFLAGS="-arch i386 -arch ppc -isysroot ${UNIVERSALSDK} ${LDFLAGS}"
1460 LDSHARED='$(CC) $(LDFLAGS) -bundle -undefined dynamic_lookup'
1461 BLDSHARED="$LDSHARED"
1463 LDSHARED='$(CC) $(LDFLAGS) -bundle'
1464 if test "$enable_framework" ; then
1465 # Link against the framework. All externals should be defined.
1466 BLDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1467 LDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKPREFIX)/$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1469 # No framework, use the Python app as bundle-loader
1470 BLDSHARED="$LDSHARED "'-bundle_loader $(BUILDPYTHON)'
1471 LDSHARED="$LDSHARED "'-bundle_loader $(BINDIR)/python$(VERSION)$(EXE)'
1475 Linux*|GNU*) LDSHARED='$(CC) -shared';;
1476 BSD/OS*/4*) LDSHARED="gcc -shared";;
1478 if [[ "`$CC -dM -E - </dev/null | grep __ELF__`" != "" ]]
1480 LDSHARED="$CC -shared ${LDFLAGS}"
1482 LDSHARED="ld -Bshareable ${LDFLAGS}"
1484 NetBSD*|DragonFly*) LDSHARED="cc -shared ${LDFLAGS}";;
1485 OpenUNIX*|UnixWare*)
1486 if test "$GCC" = "yes"
1487 then LDSHARED='$(CC) -shared'
1488 else LDSHARED='$(CC) -G'
1490 SCO_SV*) LDSHARED='$(CC) -Wl,-G,-Bexport';;
1491 Monterey*) LDSHARED="cc -G -dy -Bdynamic -Bexport -L/usr/lib/ia64l64";;
1492 CYGWIN*) LDSHARED="gcc -shared -Wl,--enable-auto-image-base";;
1493 atheos*) LDSHARED="gcc -shared";;
1497 AC_MSG_RESULT($LDSHARED)
1498 BLDSHARED=${BLDSHARED-$LDSHARED}
1499 # CCSHARED are the C *flags* used to create objects to go into a shared
1500 # library (module) -- this is only needed for a few systems
1501 AC_MSG_CHECKING(CCSHARED)
1502 if test -z "$CCSHARED"
1504 case $ac_sys_system/$ac_sys_release in
1505 SunOS*) if test "$GCC" = yes;
1506 then CCSHARED="-fPIC";
1507 else CCSHARED="-xcode=pic32";
1509 hp*|HP*) if test "$GCC" = yes;
1510 then CCSHARED="-fPIC";
1513 Linux*|GNU*) CCSHARED="-fPIC";;
1514 BSD/OS*/4*) CCSHARED="-fpic";;
1515 FreeBSD*|NetBSD*|OpenBSD*|DragonFly*) CCSHARED="-fPIC";;
1516 OpenUNIX*|UnixWare*)
1517 if test "$GCC" = "yes"
1518 then CCSHARED="-fPIC"
1519 else CCSHARED="-KPIC"
1522 if test "$GCC" = "yes"
1523 then CCSHARED="-fPIC"
1524 else CCSHARED="-Kpic -belf"
1526 Monterey*) CCSHARED="-G";;
1527 IRIX*/6*) case $CC in
1528 *gcc*) CCSHARED="-shared";;
1531 atheos*) CCSHARED="-fPIC";;
1534 AC_MSG_RESULT($CCSHARED)
1535 # LINKFORSHARED are the flags passed to the $(CC) command that links
1536 # the python executable -- this is only needed for a few systems
1537 AC_MSG_CHECKING(LINKFORSHARED)
1538 if test -z "$LINKFORSHARED"
1540 case $ac_sys_system/$ac_sys_release in
1541 AIX*) LINKFORSHARED='-Wl,-bE:Modules/python.exp -lld';;
1543 LINKFORSHARED="-Wl,-E -Wl,+s";;
1544 # LINKFORSHARED="-Wl,-E -Wl,+s -Wl,+b\$(BINLIBDEST)/lib-dynload";;
1545 BSD/OS/4*) LINKFORSHARED="-Xlinker -export-dynamic";;
1546 Linux*|GNU*) LINKFORSHARED="-Xlinker -export-dynamic";;
1547 # -u libsys_s pulls in all symbols in libsys
1549 # -u _PyMac_Error is needed to pull in the mac toolbox glue,
1551 # not used by the core itself but which needs to be in the core so
1552 # that dynamically loaded extension modules have access to it.
1553 # -prebind is no longer used, because it actually seems to give a
1554 # slowdown in stead of a speedup, maybe due to the large number of
1555 # dynamic loads Python does.
1557 LINKFORSHARED="$extra_undefs"
1558 if test "$enable_framework"
1560 LINKFORSHARED="$LINKFORSHARED "'$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1562 LINKFORSHARED="$LINKFORSHARED";;
1563 OpenUNIX*|UnixWare*) LINKFORSHARED="-Wl,-Bexport";;
1564 SCO_SV*) LINKFORSHARED="-Wl,-Bexport";;
1565 ReliantUNIX*) LINKFORSHARED="-W1 -Blargedynsym";;
1566 FreeBSD*|NetBSD*|OpenBSD*|DragonFly*)
1567 if [[ "`$CC -dM -E - </dev/null | grep __ELF__`" != "" ]]
1569 LINKFORSHARED="-Wl,--export-dynamic"
1571 SunOS/5*) case $CC in
1573 if $CC -Xlinker --help 2>&1 | grep export-dynamic >/dev/null
1575 LINKFORSHARED="-Xlinker --export-dynamic"
1579 if test $enable_shared = "no"
1581 LINKFORSHARED='-Wl,--out-implib=$(LDLIBRARY)'
1585 AC_MSG_RESULT($LINKFORSHARED)
1587 AC_SUBST(CFLAGSFORSHARED)
1588 AC_MSG_CHECKING(CFLAGSFORSHARED)
1589 if test ! "$LIBRARY" = "$LDLIBRARY"
1591 case $ac_sys_system in
1593 # Cygwin needs CCSHARED when building extension DLLs
1594 # but not when building the interpreter DLL.
1595 CFLAGSFORSHARED='';;
1597 CFLAGSFORSHARED='$(CCSHARED)'
1600 AC_MSG_RESULT($CFLAGSFORSHARED)
1602 # SHLIBS are libraries (except -lc and -lm) to link to the python shared
1603 # library (with --enable-shared).
1604 # For platforms on which shared libraries are not allowed to have unresolved
1605 # symbols, this must be set to $(LIBS) (expanded by make). We do this even
1606 # if it is not required, since it creates a dependency of the shared library
1607 # to LIBS. This, in turn, means that applications linking the shared libpython
1608 # don't need to link LIBS explicitly. The default should be only changed
1609 # on systems where this approach causes problems.
1611 AC_MSG_CHECKING(SHLIBS)
1612 case "$ac_sys_system" in
1616 AC_MSG_RESULT($SHLIBS)
1619 # checks for libraries
1620 AC_CHECK_LIB(dl, dlopen) # Dynamic linking for SunOS/Solaris and SYSV
1621 AC_CHECK_LIB(dld, shl_load) # Dynamic linking for HP-UX
1623 # only check for sem_ini if thread support is requested
1624 if test "$with_threads" = "yes" -o -z "$with_threads"; then
1625 AC_SEARCH_LIBS(sem_init, pthread rt posix4) # 'Real Time' functions on Solaris
1626 # posix4 on Solaris 2.6
1627 # pthread (first!) on Linux
1630 # check if we need libintl for locale functions
1631 AC_CHECK_LIB(intl, textdomain,
1632 AC_DEFINE(WITH_LIBINTL, 1,
1633 [Define to 1 if libintl is needed for locale functions.]))
1635 # checks for system dependent C++ extensions support
1636 case "$ac_sys_system" in
1637 AIX*) AC_MSG_CHECKING(for genuine AIX C++ extensions support)
1638 AC_TRY_LINK([#include "/usr/lpp/xlC/include/load.h"],
1639 [loadAndInit("", 0, "")],
1640 [AC_DEFINE(AIX_GENUINE_CPLUSPLUS, 1,
1641 [Define for AIX if your compiler is a genuine IBM xlC/xlC_r
1642 and you want support for AIX C++ shared extension modules.])
1643 AC_MSG_RESULT(yes)],
1644 [AC_MSG_RESULT(no)]);;
1648 # Most SVR4 platforms (e.g. Solaris) need -lsocket and -lnsl.
1649 # BeOS' sockets are stashed in libnet.
1650 AC_CHECK_LIB(nsl, t_open, [LIBS="-lnsl $LIBS"]) # SVR4
1651 AC_CHECK_LIB(socket, socket, [LIBS="-lsocket $LIBS"], [], $LIBS) # SVR4 sockets
1653 case "$ac_sys_system" in
1655 AC_CHECK_LIB(net, socket, [LIBS="-lnet $LIBS"], [], $LIBS) # BeOS
1659 AC_MSG_CHECKING(for --with-libs)
1661 AC_HELP_STRING(--with-libs='lib1 ...', link against additional libs),
1663 AC_MSG_RESULT($withval)
1664 LIBS="$withval $LIBS"
1666 [AC_MSG_RESULT(no)])
1668 # Check for use of the system libffi library
1669 AC_MSG_CHECKING(for --with-system-ffi)
1670 AC_ARG_WITH(system_ffi,
1671 AC_HELP_STRING(--with-system-ffi, build _ctypes module using an installed ffi library))
1673 if test -z "$with_system_ffi"
1674 then with_system_ffi="no"
1676 AC_MSG_RESULT($with_system_ffi)
1678 # Determine if signalmodule should be used.
1679 AC_SUBST(USE_SIGNAL_MODULE)
1680 AC_SUBST(SIGNAL_OBJS)
1681 AC_MSG_CHECKING(for --with-signal-module)
1682 AC_ARG_WITH(signal-module,
1683 AC_HELP_STRING(--with-signal-module, disable/enable signal module))
1685 if test -z "$with_signal_module"
1686 then with_signal_module="yes"
1688 AC_MSG_RESULT($with_signal_module)
1690 if test "${with_signal_module}" = "yes"; then
1691 USE_SIGNAL_MODULE=""
1694 USE_SIGNAL_MODULE="#"
1695 SIGNAL_OBJS="Parser/intrcheck.o Python/sigcheck.o"
1698 # This is used to generate Setup.config
1699 AC_SUBST(USE_THREAD_MODULE)
1700 USE_THREAD_MODULE=""
1702 AC_MSG_CHECKING(for --with-dec-threads)
1704 AC_ARG_WITH(dec-threads,
1705 AC_HELP_STRING(--with-dec-threads, use DEC Alpha/OSF1 thread-safe libraries),
1707 AC_MSG_RESULT($withval)
1709 if test "${with_thread+set}" != set; then
1710 with_thread="$withval";
1712 [AC_MSG_RESULT(no)])
1714 # Templates for things AC_DEFINEd more than once.
1715 # For a single AC_DEFINE, no template is needed.
1716 AH_TEMPLATE(C_THREADS,[Define if you have the Mach cthreads package])
1717 AH_TEMPLATE(_REENTRANT,
1718 [Define to force use of thread-safe errno, h_errno, and other functions])
1719 AH_TEMPLATE(WITH_THREAD,
1720 [Define if you want to compile in rudimentary thread support])
1722 AC_MSG_CHECKING(for --with-threads)
1723 dnl quadrigraphs "@<:@" and "@:>@" produce "[" and "]" in the output
1724 AC_ARG_WITH(threads,
1725 AC_HELP_STRING(--with(out)-threads@<:@=DIRECTORY@:>@, disable/enable thread support))
1727 # --with-thread is deprecated, but check for it anyway
1728 dnl quadrigraphs "@<:@" and "@:>@" produce "[" and "]" in the output
1730 AC_HELP_STRING(--with(out)-thread@<:@=DIRECTORY@:>@, deprecated; use --with(out)-threads),
1731 [with_threads=$with_thread])
1733 if test -z "$with_threads"
1734 then with_threads="yes"
1736 AC_MSG_RESULT($with_threads)
1739 if test "$with_threads" = "no"
1741 USE_THREAD_MODULE="#"
1742 elif test "$ac_cv_pthread_is_default" = yes
1744 AC_DEFINE(WITH_THREAD)
1745 # Defining _REENTRANT on system with POSIX threads should not hurt.
1746 AC_DEFINE(_REENTRANT)
1748 THREADOBJ="Python/thread.o"
1749 elif test "$ac_cv_kpthread" = "yes"
1752 if test "$ac_cv_cxx_thread" = "yes"; then
1753 CXX="$CXX -Kpthread"
1755 AC_DEFINE(WITH_THREAD)
1757 THREADOBJ="Python/thread.o"
1758 elif test "$ac_cv_kthread" = "yes"
1761 if test "$ac_cv_cxx_thread" = "yes"; then
1764 AC_DEFINE(WITH_THREAD)
1766 THREADOBJ="Python/thread.o"
1767 elif test "$ac_cv_pthread" = "yes"
1770 if test "$ac_cv_cxx_thread" = "yes"; then
1773 AC_DEFINE(WITH_THREAD)
1775 THREADOBJ="Python/thread.o"
1777 if test ! -z "$with_threads" -a -d "$with_threads"
1778 then LDFLAGS="$LDFLAGS -L$with_threads"
1780 if test ! -z "$withval" -a -d "$withval"
1781 then LDFLAGS="$LDFLAGS -L$withval"
1784 # According to the POSIX spec, a pthreads implementation must
1785 # define _POSIX_THREADS in unistd.h. Some apparently don't
1786 # (e.g. gnu pth with pthread emulation)
1787 AC_MSG_CHECKING(for _POSIX_THREADS in unistd.h)
1791 #ifdef _POSIX_THREADS
1794 ], unistd_defines_pthreads=yes, unistd_defines_pthreads=no)
1795 AC_MSG_RESULT($unistd_defines_pthreads)
1797 AC_DEFINE(_REENTRANT)
1798 AC_CHECK_HEADER(cthreads.h, [AC_DEFINE(WITH_THREAD)
1799 AC_DEFINE(C_THREADS)
1800 AC_DEFINE(HURD_C_THREADS, 1,
1801 [Define if you are using Mach cthreads directly under /include])
1802 LIBS="$LIBS -lthreads"
1803 THREADOBJ="Python/thread.o"],[
1804 AC_CHECK_HEADER(mach/cthreads.h, [AC_DEFINE(WITH_THREAD)
1805 AC_DEFINE(C_THREADS)
1806 AC_DEFINE(MACH_C_THREADS, 1,
1807 [Define if you are using Mach cthreads under mach /])
1808 THREADOBJ="Python/thread.o"],[
1809 AC_MSG_CHECKING(for --with-pth)
1811 AC_HELP_STRING(--with-pth, use GNU pth threading libraries),
1812 [AC_MSG_RESULT($withval)
1813 AC_DEFINE([WITH_THREAD])
1814 AC_DEFINE([HAVE_PTH], 1,
1815 [Define if you have GNU PTH threads.])
1817 THREADOBJ="Python/thread.o"],
1820 # Just looking for pthread_create in libpthread is not enough:
1821 # on HP/UX, pthread.h renames pthread_create to a different symbol name.
1822 # So we really have to include pthread.h, and then link.
1824 LIBS="$LIBS -lpthread"
1825 AC_MSG_CHECKING([for pthread_create in -lpthread])
1826 AC_TRY_LINK([#include <pthread.h>
1828 void * start_routine (void *arg) { exit (0); }], [
1829 pthread_create (NULL, NULL, start_routine, NULL)], [
1831 AC_DEFINE(WITH_THREAD)
1833 THREADOBJ="Python/thread.o"],[
1835 AC_CHECK_FUNC(pthread_detach, [AC_DEFINE(WITH_THREAD)
1837 THREADOBJ="Python/thread.o"],[
1838 AC_CHECK_HEADER(atheos/threads.h, [AC_DEFINE(WITH_THREAD)
1839 AC_DEFINE(ATHEOS_THREADS, 1,
1840 [Define this if you have AtheOS threads.])
1841 THREADOBJ="Python/thread.o"],[
1842 AC_CHECK_HEADER(kernel/OS.h, [AC_DEFINE(WITH_THREAD)
1843 AC_DEFINE(BEOS_THREADS, 1,
1844 [Define this if you have BeOS threads.])
1845 THREADOBJ="Python/thread.o"],[
1846 AC_CHECK_LIB(pthreads, pthread_create, [AC_DEFINE(WITH_THREAD)
1848 LIBS="$LIBS -lpthreads"
1849 THREADOBJ="Python/thread.o"], [
1850 AC_CHECK_LIB(c_r, pthread_create, [AC_DEFINE(WITH_THREAD)
1853 THREADOBJ="Python/thread.o"], [
1854 AC_CHECK_LIB(pthread, __pthread_create_system, [AC_DEFINE(WITH_THREAD)
1856 LIBS="$LIBS -lpthread"
1857 THREADOBJ="Python/thread.o"], [
1858 AC_CHECK_LIB(cma, pthread_create, [AC_DEFINE(WITH_THREAD)
1861 THREADOBJ="Python/thread.o"],[
1862 USE_THREAD_MODULE="#"])
1863 ])])])])])])])])])])
1865 AC_CHECK_LIB(mpc, usconfig, [AC_DEFINE(WITH_THREAD)
1867 THREADOBJ="Python/thread.o"
1868 USE_THREAD_MODULE=""])
1870 if test "$posix_threads" != "yes"; then
1871 AC_CHECK_LIB(thread, thr_create, [AC_DEFINE(WITH_THREAD)
1872 LIBS="$LIBS -lthread"
1873 THREADOBJ="Python/thread.o"
1874 USE_THREAD_MODULE=""])
1877 if test "$USE_THREAD_MODULE" != "#"
1879 # If the above checks didn't disable threads, (at least) OSF1
1880 # needs this '-threads' argument during linking.
1881 case $ac_sys_system in
1882 OSF1) LDLAST=-threads;;
1887 if test "$posix_threads" = "yes"; then
1888 if test "$unistd_defines_pthreads" = "no"; then
1889 AC_DEFINE(_POSIX_THREADS, 1,
1890 [Define if you have POSIX threads,
1891 and your system does not define that.])
1894 # Bug 662787: Using semaphores causes unexplicable hangs on Solaris 8.
1895 case $ac_sys_system/$ac_sys_release in
1896 SunOS/5.6) AC_DEFINE(HAVE_PTHREAD_DESTRUCTOR, 1,
1897 Defined for Solaris 2.6 bug in pthread header.)
1899 SunOS/5.8) AC_DEFINE(HAVE_BROKEN_POSIX_SEMAPHORES, 1,
1900 Define if the Posix semaphores do not work on your system)
1904 AC_MSG_CHECKING(if PTHREAD_SCOPE_SYSTEM is supported)
1905 AC_CACHE_VAL(ac_cv_pthread_system_supported,
1906 [AC_TRY_RUN([#include <pthread.h>
1907 void *foo(void *parm) {
1911 pthread_attr_t attr;
1913 if (pthread_attr_init(&attr)) exit(-1);
1914 if (pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM)) exit(-1);
1915 if (pthread_create(&id, &attr, foo, NULL)) exit(-1);
1918 ac_cv_pthread_system_supported=yes,
1919 ac_cv_pthread_system_supported=no,
1920 ac_cv_pthread_system_supported=no)
1922 AC_MSG_RESULT($ac_cv_pthread_system_supported)
1923 if test "$ac_cv_pthread_system_supported" = "yes"; then
1924 AC_DEFINE(PTHREAD_SYSTEM_SCHED_SUPPORTED, 1, [Defined if PTHREAD_SCOPE_SYSTEM supported.])
1926 AC_CHECK_FUNCS(pthread_sigmask,
1927 [case $ac_sys_system in
1929 AC_DEFINE(HAVE_BROKEN_PTHREAD_SIGMASK, 1,
1930 [Define if pthread_sigmask() does not work on your system.])
1936 # Check for enable-ipv6
1937 AH_TEMPLATE(ENABLE_IPV6, [Define if --enable-ipv6 is specified])
1938 AC_MSG_CHECKING([if --enable-ipv6 is specified])
1940 [ --enable-ipv6 Enable ipv6 (with ipv4) support
1941 --disable-ipv6 Disable ipv6 support],
1942 [ case "$enableval" in
1947 *) AC_MSG_RESULT(yes)
1948 AC_DEFINE(ENABLE_IPV6)
1954 dnl the check does not work on cross compilation case...
1955 AC_TRY_RUN([ /* AF_INET6 available check */
1956 #include <sys/types.h>
1957 #include <sys/socket.h>
1960 if (socket(AF_INET6, SOCK_STREAM, 0) < 0)
1974 if test "$ipv6" = "yes"; then
1975 AC_MSG_CHECKING(if RFC2553 API is available)
1976 AC_TRY_COMPILE([#include <sys/types.h>
1977 #include <netinet/in.h>],
1978 [struct sockaddr_in6 x;
1982 AC_MSG_RESULT(no, IPv6 disabled)
1986 if test "$ipv6" = "yes"; then
1987 AC_DEFINE(ENABLE_IPV6)
1995 if test "$ipv6" = "yes"; then
1996 AC_MSG_CHECKING([ipv6 stack type])
1997 for i in inria kame linux-glibc linux-inet6 solaris toshiba v6d zeta;
2001 dnl http://www.kame.net/
2003 #include <netinet/in.h>
2004 #ifdef IPV6_INRIA_VERSION
2010 dnl http://www.kame.net/
2012 #include <netinet/in.h>
2018 ipv6libdir=/usr/local/v6/lib
2022 dnl http://www.v6.linux.or.jp/
2024 #include <features.h>
2025 #if defined(__GLIBC__) && ((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 1) || (__GLIBC__ > 2))
2032 dnl http://www.v6.linux.or.jp/
2033 if test -d /usr/inet6; then
2036 ipv6libdir=/usr/inet6/lib
2037 BASECFLAGS="-I/usr/inet6/include $BASECFLAGS"
2041 if test -f /etc/netconfig; then
2042 if /usr/xpg4/bin/grep -q tcp6 /etc/netconfig; then
2050 #include <sys/param.h>
2051 #ifdef _TOSHIBA_INET6
2056 ipv6libdir=/usr/local/v6/lib])
2060 #include </usr/local/v6/include/sys/v6config.h>
2066 ipv6libdir=/usr/local/v6/lib;
2067 BASECFLAGS="-I/usr/local/v6/include $BASECFLAGS"])
2071 #include <sys/param.h>
2072 #ifdef _ZETA_MINAMI_INET6
2077 ipv6libdir=/usr/local/v6/lib])
2080 if test "$ipv6type" != "unknown"; then
2084 AC_MSG_RESULT($ipv6type)
2087 if test "$ipv6" = "yes" -a "$ipv6lib" != "none"; then
2088 if test -d $ipv6libdir -a -f $ipv6libdir/lib$ipv6lib.a; then
2089 LIBS="-L$ipv6libdir -l$ipv6lib $LIBS"
2090 echo "using lib$ipv6lib"
2092 if test $ipv6trylibc = "yes"; then
2095 echo 'Fatal: no $ipv6lib library found. cannot continue.'
2096 echo "You need to fetch lib$ipv6lib.a from appropriate"
2097 echo 'ipv6 kit and compile beforehand.'
2103 # Check for --with-doc-strings
2104 AC_MSG_CHECKING(for --with-doc-strings)
2105 AC_ARG_WITH(doc-strings,
2106 AC_HELP_STRING(--with(out)-doc-strings, disable/enable documentation strings))
2108 if test -z "$with_doc_strings"
2109 then with_doc_strings="yes"
2111 if test "$with_doc_strings" != "no"
2113 AC_DEFINE(WITH_DOC_STRINGS, 1,
2114 [Define if you want documentation strings in extension modules])
2116 AC_MSG_RESULT($with_doc_strings)
2118 # Check for Python-specific malloc support
2119 AC_MSG_CHECKING(for --with-tsc)
2121 [ --with(out)-tsc enable/disable timestamp counter profile], [
2122 if test "$withval" != no
2124 AC_DEFINE(WITH_TSC, 1,
2125 [Define to profile with the Pentium timestamp counter])
2127 else AC_MSG_RESULT(no)
2129 [AC_MSG_RESULT(no)])
2131 # Check for Python-specific malloc support
2132 AC_MSG_CHECKING(for --with-pymalloc)
2133 AC_ARG_WITH(pymalloc,
2134 AC_HELP_STRING(--with(out)-pymalloc, disable/enable specialized mallocs))
2136 if test -z "$with_pymalloc"
2137 then with_pymalloc="yes"
2139 if test "$with_pymalloc" != "no"
2141 AC_DEFINE(WITH_PYMALLOC, 1,
2142 [Define if you want to compile in Python-specific mallocs])
2144 AC_MSG_RESULT($with_pymalloc)
2146 # Check for --with-wctype-functions
2147 AC_MSG_CHECKING(for --with-wctype-functions)
2148 AC_ARG_WITH(wctype-functions,
2149 AC_HELP_STRING(--with-wctype-functions, use wctype.h functions),
2151 if test "$withval" != no
2153 AC_DEFINE(WANT_WCTYPE_FUNCTIONS, 1,
2154 [Define if you want wctype.h functions to be used instead of the
2155 one supplied by Python itself. (see Include/unicodectype.h).])
2157 else AC_MSG_RESULT(no)
2159 [AC_MSG_RESULT(no)])
2161 # -I${DLINCLDIR} is added to the compile rule for importdl.o
2165 # the dlopen() function means we might want to use dynload_shlib.o. some
2166 # platforms, such as AIX, have dlopen(), but don't want to use it.
2167 AC_CHECK_FUNCS(dlopen)
2169 # DYNLOADFILE specifies which dynload_*.o file we will use for dynamic
2170 # loading of modules.
2171 AC_SUBST(DYNLOADFILE)
2172 AC_MSG_CHECKING(DYNLOADFILE)
2173 if test -z "$DYNLOADFILE"
2175 case $ac_sys_system/$ac_sys_release in
2176 AIX*) # Use dynload_shlib.c and dlopen() if we have it; otherwise dynload_aix.c
2177 if test "$ac_cv_func_dlopen" = yes
2178 then DYNLOADFILE="dynload_shlib.o"
2179 else DYNLOADFILE="dynload_aix.o"
2182 BeOS*) DYNLOADFILE="dynload_beos.o";;
2183 hp*|HP*) DYNLOADFILE="dynload_hpux.o";;
2184 # Use dynload_next.c only on 10.2 and below, which don't have native dlopen()
2185 Darwin/@<:@0156@:>@\..*) DYNLOADFILE="dynload_next.o";;
2186 atheos*) DYNLOADFILE="dynload_atheos.o";;
2188 # use dynload_shlib.c and dlopen() if we have it; otherwise stub
2189 # out any dynamic loading
2190 if test "$ac_cv_func_dlopen" = yes
2191 then DYNLOADFILE="dynload_shlib.o"
2192 else DYNLOADFILE="dynload_stub.o"
2197 AC_MSG_RESULT($DYNLOADFILE)
2198 if test "$DYNLOADFILE" != "dynload_stub.o"
2200 AC_DEFINE(HAVE_DYNAMIC_LOADING, 1,
2201 [Defined when any dynamic module loading is enabled.])
2204 # MACHDEP_OBJS can be set to platform-specific object files needed by Python
2206 AC_SUBST(MACHDEP_OBJS)
2207 AC_MSG_CHECKING(MACHDEP_OBJS)
2208 if test -z "$MACHDEP_OBJS"
2210 MACHDEP_OBJS=$extra_machdep_objs
2212 MACHDEP_OBJS="$MACHDEP_OBJS $extra_machdep_objs"
2214 AC_MSG_RESULT(MACHDEP_OBJS)
2216 # checks for library functions
2217 AC_CHECK_FUNCS(alarm bind_textdomain_codeset chown clock confstr ctermid \
2218 execv fork fpathconf ftime ftruncate \
2219 gai_strerror getgroups getlogin getloadavg getpeername getpgid getpid \
2220 getpriority getpwent getspnam getspent getsid getwd \
2221 kill killpg lchown lstat mkfifo mknod mktime \
2222 mremap nice pathconf pause plock poll pthread_init \
2223 putenv readlink realpath \
2224 select setegid seteuid setgid \
2225 setlocale setregid setreuid setsid setpgid setpgrp setuid setvbuf snprintf \
2226 sigaction siginterrupt sigrelse strftime \
2227 sysconf tcgetpgrp tcsetpgrp tempnam timegm times tmpfile tmpnam tmpnam_r \
2228 truncate uname unsetenv utimes waitpid wait3 wait4 wcscoll _getpty)
2230 # For some functions, having a definition is not sufficient, since
2231 # we want to take their address.
2232 AC_MSG_CHECKING(for chroot)
2233 AC_TRY_COMPILE([#include <unistd.h>], void *x=chroot,
2234 AC_DEFINE(HAVE_CHROOT, 1, Define if you have the 'chroot' function.)
2238 AC_MSG_CHECKING(for link)
2239 AC_TRY_COMPILE([#include <unistd.h>], void *x=link,
2240 AC_DEFINE(HAVE_LINK, 1, Define if you have the 'link' function.)
2244 AC_MSG_CHECKING(for symlink)
2245 AC_TRY_COMPILE([#include <unistd.h>], void *x=symlink,
2246 AC_DEFINE(HAVE_SYMLINK, 1, Define if you have the 'symlink' function.)
2250 AC_MSG_CHECKING(for fchdir)
2251 AC_TRY_COMPILE([#include <unistd.h>], void *x=fchdir,
2252 AC_DEFINE(HAVE_FCHDIR, 1, Define if you have the 'fchdir' function.)
2256 AC_MSG_CHECKING(for fsync)
2257 AC_TRY_COMPILE([#include <unistd.h>], void *x=fsync,
2258 AC_DEFINE(HAVE_FSYNC, 1, Define if you have the 'fsync' function.)
2262 AC_MSG_CHECKING(for fdatasync)
2263 AC_TRY_COMPILE([#include <unistd.h>], void *x=fdatasync,
2264 AC_DEFINE(HAVE_FDATASYNC, 1, Define if you have the 'fdatasync' function.)
2269 # On some systems (eg. FreeBSD 5), we would find a definition of the
2270 # functions ctermid_r, setgroups in the library, but no prototype
2271 # (e.g. because we use _XOPEN_SOURCE). See whether we can take their
2272 # address to avoid compiler warnings and potential miscompilations
2273 # because of the missing prototypes.
2275 AC_MSG_CHECKING(for ctermid_r)
2277 #include "confdefs.h"
2279 ], void* p = ctermid_r,
2280 AC_DEFINE(HAVE_CTERMID_R, 1, Define if you have the 'ctermid_r' function.)
2285 AC_MSG_CHECKING(for flock)
2287 #include "confdefs.h"
2288 #include <sys/file.h>
2290 AC_DEFINE(HAVE_FLOCK, 1, Define if you have the 'flock' function.)
2295 AC_MSG_CHECKING(for getpagesize)
2297 #include "confdefs.h"
2299 ], void* p = getpagesize,
2300 AC_DEFINE(HAVE_GETPAGESIZE, 1, Define if you have the 'getpagesize' function.)
2306 AC_CHECK_PROGS(TRUE, true, /bin/true)
2308 dnl On some systems (e.g. Solaris 9), hstrerror and inet_aton are in -lresolv
2309 dnl On others, they are in the C library, so we to take no action
2310 AC_CHECK_LIB(c, inet_aton, [$ac_cv_prog_TRUE],
2311 AC_CHECK_LIB(resolv, inet_aton)
2314 AC_MSG_CHECKING(for hstrerror)
2316 #include "confdefs.h"
2318 ], void* p = hstrerror; hstrerror(0),
2319 AC_DEFINE(HAVE_HSTRERROR, 1, Define if you have the 'hstrerror' function.)
2324 AC_MSG_CHECKING(for inet_aton)
2326 #include "confdefs.h"
2327 #include <sys/types.h>
2328 #include <sys/socket.h>
2329 #include <netinet/in.h>
2330 #include <arpa/inet.h>
2331 ], void* p = inet_aton;inet_aton(0,0),
2332 AC_DEFINE(HAVE_INET_ATON, 1, Define if you have the 'inet_aton' function.)
2337 AC_MSG_CHECKING(for inet_pton)
2339 #include "confdefs.h"
2340 #include <sys/types.h>
2341 #include <sys/socket.h>
2342 #include <netinet/in.h>
2343 #include <arpa/inet.h>
2344 ], void* p = inet_pton,
2345 AC_DEFINE(HAVE_INET_PTON, 1, Define if you have the 'inet_pton' function.)
2350 # On some systems, setgroups is in unistd.h, on others, in grp.h
2351 AC_MSG_CHECKING(for setgroups)
2353 #include "confdefs.h"
2359 void* p = setgroups,
2360 AC_DEFINE(HAVE_SETGROUPS, 1, Define if you have the 'setgroups' function.)
2365 # check for openpty and forkpty
2367 AC_CHECK_FUNCS(openpty,,
2368 AC_CHECK_LIB(util,openpty,
2369 [AC_DEFINE(HAVE_OPENPTY) LIBS="$LIBS -lutil"],
2370 AC_CHECK_LIB(bsd,openpty, [AC_DEFINE(HAVE_OPENPTY) LIBS="$LIBS -lbsd"])
2373 AC_CHECK_FUNCS(forkpty,,
2374 AC_CHECK_LIB(util,forkpty,
2375 [AC_DEFINE(HAVE_FORKPTY) LIBS="$LIBS -lutil"],
2376 AC_CHECK_LIB(bsd,forkpty, [AC_DEFINE(HAVE_FORKPTY) LIBS="$LIBS -lbsd"])
2380 # check for long file support functions
2381 AC_CHECK_FUNCS(fseek64 fseeko fstatvfs ftell64 ftello statvfs)
2383 AC_REPLACE_FUNCS(dup2 getcwd strdup strerror memmove)
2384 AC_CHECK_FUNCS(getpgrp,
2385 AC_TRY_COMPILE([#include <unistd.h>],
2387 AC_DEFINE(GETPGRP_HAVE_ARG, 1,
2388 [Define if getpgrp() must be called as getpgrp(0).])
2391 AC_CHECK_FUNCS(setpgrp,
2392 AC_TRY_COMPILE([#include <unistd.h>],
2394 AC_DEFINE(SETPGRP_HAVE_ARG, 1,
2395 [Define if setpgrp() must be called as setpgrp(0, 0).])
2398 AC_CHECK_FUNCS(gettimeofday,
2399 AC_TRY_COMPILE([#include <sys/time.h>],
2400 [gettimeofday((struct timeval*)0,(struct timezone*)0);], ,
2401 AC_DEFINE(GETTIMEOFDAY_NO_TZ, 1,
2402 [Define if gettimeofday() does not have second (timezone) argument
2403 This is the case on Motorola V4 (R40V4.2)])
2407 AC_MSG_CHECKING(for major, minor, and makedev)
2409 #if defined(MAJOR_IN_MKDEV)
2410 #include <sys/mkdev.h>
2411 #elif defined(MAJOR_IN_SYSMACROS)
2412 #include <sys/sysmacros.h>
2414 #include <sys/types.h>
2417 makedev(major(0),minor(0));
2419 AC_DEFINE(HAVE_DEVICE_MACROS, 1,
2420 [Define to 1 if you have the device macros.])
2426 # On OSF/1 V5.1, getaddrinfo is available, but a define
2427 # for [no]getaddrinfo in netdb.h.
2428 AC_MSG_CHECKING(for getaddrinfo)
2430 #include <sys/types.h>
2431 #include <sys/socket.h>
2435 getaddrinfo(NULL, NULL, NULL, NULL);
2438 AC_MSG_CHECKING(getaddrinfo bug)
2440 #include <sys/types.h>
2443 #include <sys/socket.h>
2444 #include <netinet/in.h>
2448 int passive, gaierr, inet4 = 0, inet6 = 0;
2449 struct addrinfo hints, *ai, *aitop;
2450 char straddr[INET6_ADDRSTRLEN], strport[16];
2452 for (passive = 0; passive <= 1; passive++) {
2453 memset(&hints, 0, sizeof(hints));
2454 hints.ai_family = AF_UNSPEC;
2455 hints.ai_flags = passive ? AI_PASSIVE : 0;
2456 hints.ai_socktype = SOCK_STREAM;
2457 hints.ai_protocol = IPPROTO_TCP;
2458 if ((gaierr = getaddrinfo(NULL, "54321", &hints, &aitop)) != 0) {
2459 (void)gai_strerror(gaierr);
2462 for (ai = aitop; ai; ai = ai->ai_next) {
2463 if (ai->ai_addr == NULL ||
2464 ai->ai_addrlen == 0 ||
2465 getnameinfo(ai->ai_addr, ai->ai_addrlen,
2466 straddr, sizeof(straddr), strport, sizeof(strport),
2467 NI_NUMERICHOST|NI_NUMERICSERV) != 0) {
2470 switch (ai->ai_family) {
2472 if (strcmp(strport, "54321") != 0) {
2476 if (strcmp(straddr, "0.0.0.0") != 0) {
2480 if (strcmp(straddr, "127.0.0.1") != 0) {
2487 if (strcmp(strport, "54321") != 0) {
2491 if (strcmp(straddr, "::") != 0) {
2495 if (strcmp(straddr, "::1") != 0) {
2505 /* another family support? */
2511 if (!(inet4 == 0 || inet4 == 2))
2513 if (!(inet6 == 0 || inet6 == 2))
2517 freeaddrinfo(aitop);
2522 freeaddrinfo(aitop);
2527 buggygetaddrinfo=no,
2528 AC_MSG_RESULT(buggy)
2529 buggygetaddrinfo=yes,
2530 AC_MSG_RESULT(buggy)
2531 buggygetaddrinfo=yes)], [
2533 buggygetaddrinfo=yes
2536 if test "$buggygetaddrinfo" = "yes"; then
2537 if test "$ipv6" = "yes"; then
2538 echo 'Fatal: You must get working getaddrinfo() function.'
2539 echo ' or you can specify "--disable-ipv6"'.
2543 AC_DEFINE(HAVE_GETADDRINFO, 1, [Define if you have the getaddrinfo function.])
2545 AC_CHECK_FUNCS(getnameinfo)
2547 # checks for structures
2551 AC_CHECK_MEMBERS([struct stat.st_rdev])
2552 AC_CHECK_MEMBERS([struct stat.st_blksize])
2553 AC_CHECK_MEMBERS([struct stat.st_flags])
2554 AC_CHECK_MEMBERS([struct stat.st_gen])
2555 AC_CHECK_MEMBERS([struct stat.st_birthtime])
2558 AC_MSG_CHECKING(for time.h that defines altzone)
2559 AC_CACHE_VAL(ac_cv_header_time_altzone,
2560 [AC_TRY_COMPILE([#include <time.h>], [return altzone;],
2561 ac_cv_header_time_altzone=yes,
2562 ac_cv_header_time_altzone=no)])
2563 AC_MSG_RESULT($ac_cv_header_time_altzone)
2564 if test $ac_cv_header_time_altzone = yes; then
2565 AC_DEFINE(HAVE_ALTZONE, 1, [Define this if your time.h defines altzone.])
2569 AC_MSG_CHECKING(whether sys/select.h and sys/time.h may both be included)
2571 #include <sys/types.h>
2572 #include <sys/select.h>
2573 #include <sys/time.h>
2575 AC_DEFINE(SYS_SELECT_WITH_SYS_TIME, 1,
2576 [Define if you can safely include both <sys/select.h> and <sys/time.h>
2577 (which you can't on SCO ODT 3.0).])
2580 AC_MSG_RESULT($was_it_defined)
2582 AC_MSG_CHECKING(for addrinfo)
2583 AC_CACHE_VAL(ac_cv_struct_addrinfo,
2585 # include <netdb.h>],
2586 [struct addrinfo a],
2587 ac_cv_struct_addrinfo=yes,
2588 ac_cv_struct_addrinfo=no))
2589 AC_MSG_RESULT($ac_cv_struct_addrinfo)
2590 if test $ac_cv_struct_addrinfo = yes; then
2591 AC_DEFINE(HAVE_ADDRINFO, 1, [struct addrinfo (netdb.h)])
2594 AC_MSG_CHECKING(for sockaddr_storage)
2595 AC_CACHE_VAL(ac_cv_struct_sockaddr_storage,
2597 # include <sys/types.h>
2598 # include <sys/socket.h>],
2599 [struct sockaddr_storage s],
2600 ac_cv_struct_sockaddr_storage=yes,
2601 ac_cv_struct_sockaddr_storage=no))
2602 AC_MSG_RESULT($ac_cv_struct_sockaddr_storage)
2603 if test $ac_cv_struct_sockaddr_storage = yes; then
2604 AC_DEFINE(HAVE_SOCKADDR_STORAGE, 1, [struct sockaddr_storage (sys/socket.h)])
2607 # checks for compiler characteristics
2613 AC_MSG_CHECKING(for working volatile)
2614 AC_TRY_COMPILE([],[volatile int x; x = 0;], works=yes,
2615 AC_DEFINE(volatile, [], [Define to empty if the keyword does not work.])
2617 AC_MSG_RESULT($works)
2620 AC_MSG_CHECKING(for working signed char)
2621 AC_TRY_COMPILE([], [signed char c;], works=yes,
2622 AC_DEFINE(signed, [], [Define to empty if the keyword does not work.])
2624 AC_MSG_RESULT($works)
2627 AC_MSG_CHECKING(for prototypes)
2628 AC_TRY_COMPILE([int foo(int x) { return 0; }], [return foo(10);],[
2629 AC_DEFINE(HAVE_PROTOTYPES, 1,
2630 [Define if your compiler supports function prototype])
2633 AC_MSG_RESULT($have_prototypes)
2636 AC_MSG_CHECKING(for variable length prototypes and stdarg.h)
2639 int foo(int x, ...) {
2647 ], [return foo(10, "", 3.14);], [
2648 AC_DEFINE(HAVE_STDARG_PROTOTYPES, 1,
2649 [Define if your compiler supports variable length function prototypes
2650 (e.g. void fprintf(FILE *, char *, ...);) *and* <stdarg.h>])
2653 AC_MSG_RESULT($works)
2655 # check for socketpair
2656 AC_MSG_CHECKING(for socketpair)
2658 #include <sys/types.h>
2659 #include <sys/socket.h>
2660 ], void *x=socketpair,
2661 AC_DEFINE(HAVE_SOCKETPAIR, 1, Define if you have the 'socketpair' function.)
2666 # check if sockaddr has sa_len member
2667 AC_MSG_CHECKING(if sockaddr has sa_len member)
2668 AC_TRY_COMPILE([#include <sys/types.h>
2669 #include <sys/socket.h>],
2673 AC_DEFINE(HAVE_SOCKADDR_SA_LEN, 1, [Define if sockaddr has sa_len member]),
2677 AC_MSG_CHECKING(whether va_list is an array)
2679 #ifdef HAVE_STDARG_PROTOTYPES
2682 #include <varargs.h>
2684 ], [va_list list1, list2; list1 = list2;], , [
2685 AC_DEFINE(VA_LIST_IS_ARRAY, 1, [Define if a va_list is an array of some kind])
2686 va_list_is_array=yes
2688 AC_MSG_RESULT($va_list_is_array)
2690 # sigh -- gethostbyname_r is a mess; it can have 3, 5 or 6 arguments :-(
2691 AH_TEMPLATE(HAVE_GETHOSTBYNAME_R,
2692 [Define this if you have some version of gethostbyname_r()])
2694 AC_CHECK_FUNC(gethostbyname_r, [
2695 AC_DEFINE(HAVE_GETHOSTBYNAME_R)
2696 AC_MSG_CHECKING([gethostbyname_r with 6 args])
2698 CFLAGS="$CFLAGS $MY_CPPFLAGS $MY_THREAD_CPPFLAGS $MY_CFLAGS"
2703 struct hostent *he, *res;
2708 (void) gethostbyname_r(name, he, buffer, buflen, &res, &h_errnop)
2710 AC_DEFINE(HAVE_GETHOSTBYNAME_R)
2711 AC_DEFINE(HAVE_GETHOSTBYNAME_R_6_ARG, 1,
2712 [Define this if you have the 6-arg version of gethostbyname_r().])
2716 AC_MSG_CHECKING([gethostbyname_r with 5 args])
2726 (void) gethostbyname_r(name, he, buffer, buflen, &h_errnop)
2728 AC_DEFINE(HAVE_GETHOSTBYNAME_R)
2729 AC_DEFINE(HAVE_GETHOSTBYNAME_R_5_ARG, 1,
2730 [Define this if you have the 5-arg version of gethostbyname_r().])
2734 AC_MSG_CHECKING([gethostbyname_r with 3 args])
2740 struct hostent_data data;
2742 (void) gethostbyname_r(name, he, &data);
2744 AC_DEFINE(HAVE_GETHOSTBYNAME_R)
2745 AC_DEFINE(HAVE_GETHOSTBYNAME_R_3_ARG, 1,
2746 [Define this if you have the 3-arg version of gethostbyname_r().])
2755 AC_CHECK_FUNCS(gethostbyname)
2757 AC_SUBST(HAVE_GETHOSTBYNAME_R_6_ARG)
2758 AC_SUBST(HAVE_GETHOSTBYNAME_R_5_ARG)
2759 AC_SUBST(HAVE_GETHOSTBYNAME_R_3_ARG)
2760 AC_SUBST(HAVE_GETHOSTBYNAME_R)
2761 AC_SUBST(HAVE_GETHOSTBYNAME)
2763 # checks for system services
2766 # Linux requires this for correct f.p. operations
2767 AC_CHECK_FUNC(__fpu_control,
2769 [AC_CHECK_LIB(ieee, __fpu_control)
2772 # Check for --with-fpectl
2773 AC_MSG_CHECKING(for --with-fpectl)
2775 AC_HELP_STRING(--with-fpectl, enable SIGFPE catching),
2777 if test "$withval" != no
2779 AC_DEFINE(WANT_SIGFPE_HANDLER, 1,
2780 [Define if you want SIGFPE handled (see Include/pyfpe.h).])
2782 else AC_MSG_RESULT(no)
2784 [AC_MSG_RESULT(no)])
2786 # check for --with-libm=...
2788 case $ac_sys_system in
2793 AC_MSG_CHECKING(for --with-libm=STRING)
2795 AC_HELP_STRING(--with-libm=STRING, math library),
2797 if test "$withval" = no
2799 AC_MSG_RESULT(force LIBM empty)
2800 elif test "$withval" != yes
2802 AC_MSG_RESULT(set LIBM="$withval")
2803 else AC_MSG_ERROR([proper usage is --with-libm=STRING])
2805 [AC_MSG_RESULT(default LIBM="$LIBM")])
2807 # check for --with-libc=...
2809 AC_MSG_CHECKING(for --with-libc=STRING)
2811 AC_HELP_STRING(--with-libc=STRING, C library),
2813 if test "$withval" = no
2815 AC_MSG_RESULT(force LIBC empty)
2816 elif test "$withval" != yes
2818 AC_MSG_RESULT(set LIBC="$withval")
2819 else AC_MSG_ERROR([proper usage is --with-libc=STRING])
2821 [AC_MSG_RESULT(default LIBC="$LIBC")])
2823 # check for hypot() in math library
2826 AC_REPLACE_FUNCS(hypot)
2830 AC_CHECK_HEADER(wchar.h, [
2831 AC_DEFINE(HAVE_WCHAR_H, 1,
2832 [Define if the compiler provides a wchar.h header file.])
2838 # determine wchar_t size
2839 if test "$wchar_h" = yes
2841 AC_CHECK_SIZEOF(wchar_t, 4, [#include <wchar.h>])
2844 AC_MSG_CHECKING(for UCS-4 tcl)
2848 #if TCL_UTF_MAX != 6
2849 # error "NOT UCS4_TCL"
2851 AC_DEFINE(HAVE_UCS4_TCL, 1, [Define this if you have tcl and TCL_UTF_MAX==6])
2854 AC_MSG_RESULT($have_ucs4_tcl)
2856 # check whether wchar_t is signed or not
2857 if test "$wchar_h" = yes
2859 # check whether wchar_t is signed or not
2860 AC_MSG_CHECKING(whether wchar_t is signed)
2861 AC_CACHE_VAL(ac_cv_wchar_t_signed, [
2866 /* Success: exit code 0 */
2867 exit((((wchar_t) -1) < ((wchar_t) 0)) ? 0 : 1);
2870 ac_cv_wchar_t_signed=yes,
2871 ac_cv_wchar_t_signed=no,
2872 ac_cv_wchar_t_signed=yes)])
2873 AC_MSG_RESULT($ac_cv_wchar_t_signed)
2876 AC_MSG_CHECKING(what type to use for unicode)
2877 dnl quadrigraphs "@<:@" and "@:>@" produce "[" and "]" in the output
2878 AC_ARG_ENABLE(unicode,
2879 AC_HELP_STRING(--enable-unicode@<:@=ucs@<:@24@:>@@:>@, Enable Unicode strings (default is yes)),
2881 [enable_unicode=yes])
2883 if test $enable_unicode = yes
2885 # Without any arguments, Py_UNICODE defaults to two-byte mode
2886 case "$have_ucs4_tcl" in
2887 yes) enable_unicode="ucs4"
2889 *) enable_unicode="ucs2"
2894 AH_TEMPLATE(Py_UNICODE_SIZE,
2895 [Define as the size of the unicode type.])
2896 case "$enable_unicode" in
2897 ucs2) unicode_size="2"
2898 AC_DEFINE(Py_UNICODE_SIZE,2)
2900 ucs4) unicode_size="4"
2901 AC_DEFINE(Py_UNICODE_SIZE,4)
2905 AH_TEMPLATE(PY_UNICODE_TYPE,
2906 [Define as the integral type used for Unicode representation.])
2908 AC_SUBST(UNICODE_OBJS)
2909 if test "$enable_unicode" = "no"
2912 AC_MSG_RESULT(not used)
2914 UNICODE_OBJS="Objects/unicodeobject.o Objects/unicodectype.o"
2915 AC_DEFINE(Py_USING_UNICODE, 1,
2916 [Define if you want to have a Unicode type.])
2918 # wchar_t is only usable if it maps to an unsigned type
2919 if test "$unicode_size" = "$ac_cv_sizeof_wchar_t" \
2920 -a "$ac_cv_wchar_t_signed" = "no"
2922 PY_UNICODE_TYPE="wchar_t"
2923 AC_DEFINE(HAVE_USABLE_WCHAR_T, 1,
2924 [Define if you have a useable wchar_t type defined in wchar.h; useable
2925 means wchar_t must be an unsigned type with at least 16 bits. (see
2926 Include/unicodeobject.h).])
2927 AC_DEFINE(PY_UNICODE_TYPE,wchar_t)
2928 elif test "$ac_cv_sizeof_short" = "$unicode_size"
2930 PY_UNICODE_TYPE="unsigned short"
2931 AC_DEFINE(PY_UNICODE_TYPE,unsigned short)
2932 elif test "$ac_cv_sizeof_long" = "$unicode_size"
2934 PY_UNICODE_TYPE="unsigned long"
2935 AC_DEFINE(PY_UNICODE_TYPE,unsigned long)
2937 PY_UNICODE_TYPE="no type found"
2939 AC_MSG_RESULT($PY_UNICODE_TYPE)
2942 # check for endianness
2944 AH_VERBATIM([WORDS_BIGENDIAN],
2946 /* Define to 1 if your processor stores words with the most significant byte
2947 first (like Motorola and SPARC, unlike Intel and VAX).
2949 The block below does compile-time checking for endianness on platforms
2950 that use GCC and therefore allows compiling fat binaries on OSX by using
2951 '-arch ppc -arch i386' as the compile flags. The phrasing was choosen
2952 such that the configure-result is used on systems that don't use GCC.
2954 #ifdef __BIG_ENDIAN__
2955 #define WORDS_BIGENDIAN 1
2957 #ifndef __LITTLE_ENDIAN__
2958 #undef WORDS_BIGENDIAN
2962 # Check whether right shifting a negative integer extends the sign bit
2963 # or fills with zeros (like the Cray J90, according to Tim Peters).
2964 AC_MSG_CHECKING(whether right shift extends the sign bit)
2965 AC_CACHE_VAL(ac_cv_rshift_extends_sign, [
2969 exit(((-1)>>3 == -1) ? 0 : 1);
2972 ac_cv_rshift_extends_sign=yes,
2973 ac_cv_rshift_extends_sign=no,
2974 ac_cv_rshift_extends_sign=yes)])
2975 AC_MSG_RESULT($ac_cv_rshift_extends_sign)
2976 if test "$ac_cv_rshift_extends_sign" = no
2978 AC_DEFINE(SIGNED_RIGHT_SHIFT_ZERO_FILLS, 1,
2979 [Define if i>>j for signed int i does not extend the sign bit
2983 # check for getc_unlocked and related locking functions
2984 AC_MSG_CHECKING(for getc_unlocked() and friends)
2985 AC_CACHE_VAL(ac_cv_have_getc_unlocked, [
2986 AC_TRY_LINK([#include <stdio.h>],[
2987 FILE *f = fopen("/dev/null", "r");
2991 ], ac_cv_have_getc_unlocked=yes, ac_cv_have_getc_unlocked=no)])
2992 AC_MSG_RESULT($ac_cv_have_getc_unlocked)
2993 if test "$ac_cv_have_getc_unlocked" = yes
2995 AC_DEFINE(HAVE_GETC_UNLOCKED, 1,
2996 [Define this if you have flockfile(), getc_unlocked(), and funlockfile()])
2999 # check where readline lives
3000 # save the value of LIBS so we don't actually link Python with readline
3001 LIBS_no_readline=$LIBS
3002 AC_CHECK_LIB(readline, readline)
3003 if test "$ac_cv_have_readline_readline" = no
3005 AC_CHECK_LIB(termcap, readline)
3008 # check for readline 2.1
3009 AC_CHECK_LIB(readline, rl_callback_handler_install,
3010 AC_DEFINE(HAVE_RL_CALLBACK, 1,
3011 [Define if you have readline 2.1]), , )
3013 # check for readline 2.2
3014 AC_TRY_CPP([#include <readline/readline.h>],
3015 have_readline=yes, have_readline=no)
3016 if test $have_readline = yes
3018 AC_EGREP_HEADER([extern int rl_completion_append_character;],
3019 [readline/readline.h],
3020 AC_DEFINE(HAVE_RL_COMPLETION_APPEND_CHARACTER, 1,
3021 [Define if you have readline 2.2]), )
3024 # check for readline 4.0
3025 AC_CHECK_LIB(readline, rl_pre_input_hook,
3026 AC_DEFINE(HAVE_RL_PRE_INPUT_HOOK, 1,
3027 [Define if you have readline 4.0]), , )
3029 # check for readline 4.2
3030 AC_CHECK_LIB(readline, rl_completion_matches,
3031 AC_DEFINE(HAVE_RL_COMPLETION_MATCHES, 1,
3032 [Define if you have readline 4.2]), , )
3034 # also in readline 4.2
3035 AC_TRY_CPP([#include <readline/readline.h>],
3036 have_readline=yes, have_readline=no)
3037 if test $have_readline = yes
3039 AC_EGREP_HEADER([extern int rl_catch_signals;],
3040 [readline/readline.h],
3041 AC_DEFINE(HAVE_RL_CATCH_SIGNAL, 1,
3042 [Define if you can turn off readline's signal handling.]), )
3045 # End of readline checks: restore LIBS
3046 LIBS=$LIBS_no_readline
3048 AC_MSG_CHECKING(for broken nice())
3049 AC_CACHE_VAL(ac_cv_broken_nice, [
3054 if (val1 != -1 && val1 == nice(2))
3059 ac_cv_broken_nice=yes,
3060 ac_cv_broken_nice=no,
3061 ac_cv_broken_nice=no)])
3062 AC_MSG_RESULT($ac_cv_broken_nice)
3063 if test "$ac_cv_broken_nice" = yes
3065 AC_DEFINE(HAVE_BROKEN_NICE, 1,
3066 [Define if nice() returns success/failure instead of the new priority.])
3069 AC_MSG_CHECKING(for broken poll())
3075 struct pollfd poll_struct = { 42, POLLIN|POLLPRI|POLLOUT, 0 };
3079 int poll_test = poll (&poll_struct, 1, 0);
3085 else if (poll_test == 0 && poll_struct.revents != POLLNVAL)
3095 ac_cv_broken_poll=yes,
3096 ac_cv_broken_poll=no,
3097 ac_cv_broken_poll=no)
3098 AC_MSG_RESULT($ac_cv_broken_poll)
3099 if test "$ac_cv_broken_poll" = yes
3101 AC_DEFINE(HAVE_BROKEN_POLL, 1,
3102 [Define if poll() sets errno on invalid file descriptors.])
3105 # Before we can test tzset, we need to check if struct tm has a tm_zone
3106 # (which is not required by ISO C or UNIX spec) and/or if we support
3110 # check tzset(3) exists and works like we expect it to
3111 AC_MSG_CHECKING(for working tzset())
3112 AC_CACHE_VAL(ac_cv_working_tzset, [
3119 extern char *tzname[];
3124 /* Note that we need to ensure that not only does tzset(3)
3125 do 'something' with localtime, but it works as documented
3126 in the library reference and as expected by the test suite.
3127 This includes making sure that tzname is set properly if
3128 tm->tm_zone does not exist since it is the alternative way
3129 of getting timezone info.
3131 Red Hat 6.2 doesn't understand the southern hemisphere
3132 after New Year's Day.
3135 time_t groundhogday = 1044144000; /* GMT-based */
3136 time_t midyear = groundhogday + (365 * 24 * 3600 / 2);
3140 if (localtime(&groundhogday)->tm_hour != 0)
3143 /* For UTC, tzname[1] is sometimes "", sometimes " " */
3144 if (strcmp(tzname[0], "UTC") ||
3145 (tzname[1][0] != 0 && tzname[1][0] != ' '))
3149 putenv("TZ=EST+5EDT,M4.1.0,M10.5.0");
3151 if (localtime(&groundhogday)->tm_hour != 19)
3154 if (strcmp(tzname[0], "EST") || strcmp(tzname[1], "EDT"))
3158 putenv("TZ=AEST-10AEDT-11,M10.5.0,M3.5.0");
3160 if (localtime(&groundhogday)->tm_hour != 11)
3163 if (strcmp(tzname[0], "AEST") || strcmp(tzname[1], "AEDT"))
3167 #if HAVE_STRUCT_TM_TM_ZONE
3168 if (strcmp(localtime(&groundhogday)->tm_zone, "AEDT"))
3170 if (strcmp(localtime(&midyear)->tm_zone, "AEST"))
3177 ac_cv_working_tzset=yes,
3178 ac_cv_working_tzset=no,
3179 ac_cv_working_tzset=no)])
3180 AC_MSG_RESULT($ac_cv_working_tzset)
3181 if test "$ac_cv_working_tzset" = yes
3183 AC_DEFINE(HAVE_WORKING_TZSET, 1,
3184 [Define if tzset() actually switches the local timezone in a meaningful way.])
3187 # Look for subsecond timestamps in struct stat
3188 AC_MSG_CHECKING(for tv_nsec in struct stat)
3189 AC_CACHE_VAL(ac_cv_stat_tv_nsec,
3190 AC_TRY_COMPILE([#include <sys/stat.h>], [
3192 st.st_mtim.tv_nsec = 1;
3194 ac_cv_stat_tv_nsec=yes,
3195 ac_cv_stat_tv_nsec=no,
3196 ac_cv_stat_tv_nsec=no))
3197 AC_MSG_RESULT($ac_cv_stat_tv_nsec)
3198 if test "$ac_cv_stat_tv_nsec" = yes
3200 AC_DEFINE(HAVE_STAT_TV_NSEC, 1,
3201 [Define if you have struct stat.st_mtim.tv_nsec])
3204 # Look for BSD style subsecond timestamps in struct stat
3205 AC_MSG_CHECKING(for tv_nsec2 in struct stat)
3206 AC_CACHE_VAL(ac_cv_stat_tv_nsec2,
3207 AC_TRY_COMPILE([#include <sys/stat.h>], [
3209 st.st_mtimespec.tv_nsec = 1;
3211 ac_cv_stat_tv_nsec2=yes,
3212 ac_cv_stat_tv_nsec2=no,
3213 ac_cv_stat_tv_nsec2=no))
3214 AC_MSG_RESULT($ac_cv_stat_tv_nsec2)
3215 if test "$ac_cv_stat_tv_nsec2" = yes
3217 AC_DEFINE(HAVE_STAT_TV_NSEC2, 1,
3218 [Define if you have struct stat.st_mtimensec])
3221 # On HP/UX 11.0, mvwdelch is a block with a return statement
3222 AC_MSG_CHECKING(whether mvwdelch is an expression)
3223 AC_CACHE_VAL(ac_cv_mvwdelch_is_expression,
3224 AC_TRY_COMPILE([#include <curses.h>], [
3226 rtn = mvwdelch(0,0,0);
3227 ], ac_cv_mvwdelch_is_expression=yes,
3228 ac_cv_mvwdelch_is_expression=no,
3229 ac_cv_mvwdelch_is_expression=yes))
3230 AC_MSG_RESULT($ac_cv_mvwdelch_is_expression)
3232 if test "$ac_cv_mvwdelch_is_expression" = yes
3234 AC_DEFINE(MVWDELCH_IS_EXPRESSION, 1,
3235 [Define if mvwdelch in curses.h is an expression.])
3238 AC_MSG_CHECKING(whether WINDOW has _flags)
3239 AC_CACHE_VAL(ac_cv_window_has_flags,
3240 AC_TRY_COMPILE([#include <curses.h>], [
3243 ], ac_cv_window_has_flags=yes,
3244 ac_cv_window_has_flags=no,
3245 ac_cv_window_has_flags=no))
3246 AC_MSG_RESULT($ac_cv_window_has_flags)
3249 if test "$ac_cv_window_has_flags" = yes
3251 AC_DEFINE(WINDOW_HAS_FLAGS, 1,
3252 [Define if WINDOW in curses.h offers a field _flags.])
3255 AC_MSG_CHECKING(for /dev/ptmx)
3257 if test -e /dev/ptmx
3260 AC_DEFINE(HAVE_DEV_PTMX, 1,
3261 [Define if we have /dev/ptmx.])
3266 AC_MSG_CHECKING(for /dev/ptc)
3271 AC_DEFINE(HAVE_DEV_PTC, 1,
3272 [Define if we have /dev/ptc.])
3277 AC_MSG_CHECKING(for %zd printf() format support)
3278 AC_TRY_RUN([#include <stdio.h>
3286 if(sprintf(buffer, "%zd", (size_t)123) < 0)
3289 if (strncmp(buffer, "123", 3))
3295 AC_DEFINE(PY_FORMAT_SIZE_T, "z", [Define to printf format modifier for Py_ssize_t])],
3298 AC_CHECK_TYPE(socklen_t,,
3299 AC_DEFINE(socklen_t,int,
3300 Define to `int' if <sys/socket.h> does not define.),[
3301 #ifdef HAVE_SYS_TYPES_H
3302 #include <sys/types.h>
3304 #ifdef HAVE_SYS_SOCKET_H
3305 #include <sys/socket.h>
3309 AC_SUBST(THREADHEADERS)
3311 for h in `(cd $srcdir;echo Python/thread_*.h)`
3313 THREADHEADERS="$THREADHEADERS \$(srcdir)/$h"
3317 SRCDIRS="Parser Grammar Objects Python Modules Mac"
3318 AC_MSG_CHECKING(for build directories)
3319 for dir in $SRCDIRS; do
3320 if test ! -d $dir; then
3326 # generate output files
3327 AC_CONFIG_FILES(Makefile.pre Modules/Setup.config)
3330 echo "creating Modules/Setup"
3331 if test ! -f Modules/Setup
3333 cp $srcdir/Modules/Setup.dist Modules/Setup
3336 echo "creating Modules/Setup.local"
3337 if test ! -f Modules/Setup.local
3339 echo "# Edit this file for local setup changes" >Modules/Setup.local
3342 echo "creating Makefile"
3343 $SHELL $srcdir/Modules/makesetup -c $srcdir/Modules/config.c.in \
3344 -s Modules Modules/Setup.config \
3345 Modules/Setup.local Modules/Setup