| blob | 1b7b57e0a8bba495bca6e4b5d49327c9790fde48 |
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$)
7 AC_PREREQ(2.59)
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.
14 AH_TOP([
15 #ifndef Py_PYCONFIG_H
16 #define Py_PYCONFIG_H
17 ])
18 AH_BOTTOM([
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 */
22 #endif
24 #endif /*Py_PYCONFIG_H*/
25 ])
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
30 rm confdefs.h
31 mv confdefs.h.new confdefs.h
33 AC_SUBST(VERSION)
34 VERSION=PYTHON_VERSION
36 AC_SUBST(SOVERSION)
37 SOVERSION=1.0
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
45 # them.
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
50 # them.
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.
60 AC_SUBST(CONFIG_ARGS)
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)),
65 [
66 case $enableval in
67 yes)
68 enableval=/Developer/SDKs/MacOSX10.4u.sdk
69 ;;
70 esac
71 case $enableval in
72 no)
73 UNIVERSALSDK=
74 enable_universalsdk=
75 ;;
76 *)
77 UNIVERSALSDK=$enableval
78 ;;
79 esac
80 ],[
81 UNIVERSALSDK=
82 enable_universalsdk=
83 ])
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),
89 [
90 case $enableval in
91 yes)
92 enableval=/Library/Frameworks
93 esac
94 case $enableval in
95 no)
96 PYTHONFRAMEWORK=
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}"
106 else
107 FRAMEWORKUNIXTOOLSPREFIX="${prefix}"
108 fi
109 enable_framework=
110 ;;
111 *)
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}"
122 else
123 FRAMEWORKUNIXTOOLSPREFIX="${prefix}"
124 fi
125 prefix=$PYTHONFRAMEWORKINSTALLDIR/Versions/$VERSION
127 # Add makefiles for Mac specific code to the list of output
128 # files:
129 AC_CONFIG_FILES(Mac/Makefile)
130 AC_CONFIG_FILES(Mac/PythonLauncher/Makefile)
131 AC_CONFIG_FILES(Mac/IDLE/Makefile)
132 esac
133 ],[
134 PYTHONFRAMEWORK=
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}"
144 else
145 FRAMEWORKUNIXTOOLSPREFIX="${prefix}"
146 fi
147 enable_framework=
148 ])
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)
159 ##AC_ARG_WITH(dyld,
160 ## AC_HELP_STRING(--with-dyld,
161 ## Use (OpenStep|Rhapsody) dynamic linker))
162 ##
163 # Set name for machine-dependent library files
164 AC_SUBST(MACHDEP)
165 AC_MSG_CHECKING(MACHDEP)
166 if test -z "$MACHDEP"
167 then
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`
172 else
173 ac_sys_release=`uname -r`
174 fi
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"
181 case $MACHDEP in
182 cygwin*) MACHDEP="cygwin";;
183 darwin*) MACHDEP="darwin";;
184 atheos*) MACHDEP="atheos";;
185 irix646) MACHDEP="irix6";;
186 '') MACHDEP="unknown";;
187 esac
188 fi
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.
208 SunOS/5.6)
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.
217 SCO_SV/3.2)
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.
228 AIX/4)
229 define_xopen_source=no;;
230 AIX/5)
231 if test `uname -r` -eq 1; then
232 define_xopen_source=no
233 fi
234 ;;
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
239 Darwin/@<:@78@:>@.*)
240 define_xopen_source=no
241 ;;
243 esac
245 if test $define_xopen_source = yes
246 then
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
250 # compiler
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)
255 ;;
256 *)
257 AC_DEFINE(_XOPEN_SOURCE, 600,
258 Define to the level of X/Open that your system supports)
259 ;;
260 esac
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
269 SunOS/5.10)
270 ;;
271 *)
272 AC_DEFINE(_XOPEN_SOURCE_EXTENDED, 1,
273 Define to activate Unix95-and-earlier features)
274 ;;
275 esac
277 AC_DEFINE(_POSIX_C_SOURCE, 200112L, Define to activate features from IEEE Stds 1003.1-2001)
279 fi
281 #
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.
285 #
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.
289 #
290 AC_SUBST(SGI_ABI)
291 if test ! -z "$SGI_ABI"
292 then
293 CC="cc $SGI_ABI"
294 LDFLAGS="$SGI_ABI $LDFLAGS"
295 MACHDEP=`echo "${MACHDEP}${SGI_ABI}" | sed 's/ *//g'`
296 fi
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"
304 then
305 case $MACHDEP in
306 darwin)
307 EXTRAPLATDIR="\$(PLATMACDIRS)"
308 EXTRAMACHDEPPATH="\$(PLATMACPATH)"
309 ;;
310 *)
311 EXTRAPLATDIR=""
312 EXTRAMACHDEPPATH=""
313 ;;
314 esac
315 fi
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
320 # needs to check it
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)
337 AC_ARG_WITH(gcc,
338 AC_HELP_STRING(--without-gcc,never use gcc),
339 [
340 case $withval in
341 no) CC=cc
342 without_gcc=yes;;
343 yes) CC=gcc
344 without_gcc=no;;
345 *) CC=$withval
346 without_gcc=$withval;;
347 esac], [
348 case $ac_sys_system in
349 AIX*) CC=cc_r
350 without_gcc=;;
351 BeOS*)
352 case $BE_HOST_CPU in
353 ppc)
354 CC=mwcc
355 without_gcc=yes
356 BASECFLAGS="$BASECFLAGS -export pragma"
357 OPT="$OPT -O"
358 LDFLAGS="$LDFLAGS -nodup"
359 ;;
360 x86)
361 CC=gcc
362 without_gcc=no
363 OPT="$OPT -O"
364 ;;
365 *)
366 AC_MSG_ERROR([Unknown BeOS platform "$BE_HOST_CPU"])
367 ;;
368 esac
369 AR="\$(srcdir)/Modules/ar_beos"
370 RANLIB=:
371 ;;
372 Monterey*)
373 RANLIB=:
374 without_gcc=;;
375 *) without_gcc=no;;
376 esac])
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"
381 then
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)])
384 fi
386 AC_PROG_CC
388 AC_SUBST(CXX)
389 AC_SUBST(MAINCC)
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]),
394 [
396 case $withval in
397 no) with_cxx_main=no
398 MAINCC='$(CC)';;
399 yes) with_cxx_main=yes
400 MAINCC='$(CXX)';;
401 *) with_cxx_main=yes
402 MAINCC=$withval
403 if test -z "$CXX"
404 then
405 CXX=$withval
406 fi;;
407 esac], [
408 with_cxx_main=no
409 MAINCC='$(CC)'
410 ])
411 AC_MSG_RESULT($with_cxx_main)
413 preset_cxx="$CXX"
414 if test -z "$CXX"
415 then
416 case "$CC" in
417 gcc) AC_PATH_PROG(CXX, [g++], [g++], [notfound]) ;;
418 cc) AC_PATH_PROG(CXX, [c++], [c++], [notfound]) ;;
419 esac
420 if test "$CXX" = "notfound"
421 then
422 CXX=""
423 fi
424 fi
425 if test -z "$CXX"
426 then
427 AC_CHECK_PROGS(CXX, $CCC c++ g++ gcc CC cxx cc++ cl, notfound)
428 if test "$CXX" = "notfound"
429 then
430 CXX=""
431 fi
432 fi
433 if test "$preset_cxx" != "$CXX"
434 then
435 AC_MSG_WARN([
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.
439 ])
440 fi
443 # checks for UNIX variants that set C preprocessor variables
444 AC_AIX
446 # Check for unsupported systems
447 case $ac_sys_system/$ac_sys_release in
448 Linux*/1*)
449 echo This system \($ac_sys_system/$ac_sys_release\) is no longer supported.
450 echo See README for details.
451 exit 1;;
452 esac
454 AC_EXEEXT
455 AC_MSG_CHECKING(for --with-suffix)
456 AC_ARG_WITH(suffix,
457 AC_HELP_STRING(--with-suffix=.exe, set executable suffix),
458 [
459 case $withval in
460 no) EXEEXT=;;
461 yes) EXEEXT=.exe;;
462 *) EXEEXT=$withval;;
463 esac])
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
472 fi
474 if test -d casesensitivetestdir
475 then
476 AC_MSG_RESULT(yes)
477 BUILDEXEEXT=.exe
478 else
479 AC_MSG_RESULT(no)
480 BUILDEXEEXT=$EXEEXT
481 fi
482 rmdir CaseSensitiveTestDir
484 case $MACHDEP in
485 bsdos*)
486 case $CC in
487 gcc) CC="$CC -D_HAVE_BSDI";;
488 esac;;
489 esac
491 case $ac_sys_system in
492 hp*|HP*)
493 case $CC in
494 cc|*/cc) CC="$CC -Ae";;
495 esac;;
496 Monterey*)
497 case $CC in
498 cc) CC="$CC -Wl,-Bexport";;
499 esac;;
500 SunOS*)
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.])
503 ;;
504 esac
507 AC_SUBST(LIBRARY)
508 AC_MSG_CHECKING(LIBRARY)
509 if test -z "$LIBRARY"
510 then
511 LIBRARY='libpython$(VERSION).a'
512 fi
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.
523 #
524 # RUNSHARED is used to run shared python without installed libraries
525 #
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
528 AC_SUBST(LDLIBRARY)
529 AC_SUBST(DLLLIBRARY)
530 AC_SUBST(BLDLIBRARY)
531 AC_SUBST(LDLIBRARYDIR)
532 AC_SUBST(INSTSONAME)
533 AC_SUBST(RUNSHARED)
534 LDLIBRARY="$LIBRARY"
535 BLDLIBRARY='$(LDLIBRARY)'
536 INSTSONAME='$(LDLIBRARY)'
537 DLLLIBRARY=''
538 LDLIBRARYDIR=''
539 RUNSHARED=''
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
546 # linking.
547 AC_SUBST(LINKCC)
548 AC_MSG_CHECKING(LINKCC)
549 if test -z "$LINKCC"
550 then
551 LINKCC='$(PURIFY) $(MAINCC)'
552 case $ac_sys_system in
553 AIX*)
554 exp_extra="\"\""
555 if test $ac_sys_release -ge 5 -o \
556 $ac_sys_release -eq 4 -a `uname -r` -ge 2 ; then
557 exp_extra="."
558 fi
559 LINKCC="\$(srcdir)/Modules/makexp_aix Modules/python.exp $exp_extra \$(LIBRARY); $LINKCC";;
560 Monterey64*)
561 LINKCC="$LINKCC -L/usr/lib/ia64l64";;
562 esac
563 fi
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"
571 then
572 case $ac_sys_system in
573 CYGWIN* | atheos*)
574 enable_shared="yes";;
575 *)
576 enable_shared="no";;
577 esac
578 fi
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),
584 [ac_save_cc="$CC"
585 CC="$CC -pg"
586 AC_TRY_RUN([int main() { return 0; }],
587 ac_enable_profiling="yes",
588 ac_enable_profiling="no",
589 ac_enable_profiling="no")
590 CC="$ac_save_cc"])
591 AC_MSG_RESULT($ac_enable_profiling)
593 case "$ac_enable_profiling" in
594 "yes")
595 BASECFLAGS="-pg $BASECFLAGS"
596 LDFLAGS="-pg $LDFLAGS"
597 ;;
598 esac
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"
609 then
610 LDLIBRARY='$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
611 RUNSHARED=DYLD_FRAMEWORK_PATH="`pwd`:$DYLD_FRAMEWORK_PATH"
612 BLDLIBRARY=''
613 else
614 BLDLIBRARY='$(LDLIBRARY)'
615 fi
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
621 BeOS*)
622 LDLIBRARY='libpython$(VERSION).so'
623 ;;
624 CYGWIN*)
625 LDLIBRARY='libpython$(VERSION).dll.a'
626 DLLLIBRARY='libpython$(VERSION).dll'
627 ;;
628 SunOS*)
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
633 ;;
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
639 FreeBSD*)
640 SOVERSION=`echo $SOVERSION|cut -d "." -f 1`
641 ;;
642 esac
643 INSTSONAME="$LDLIBRARY".$SOVERSION
644 ;;
645 hp*|HP*)
646 case `uname -m` in
647 ia64)
648 LDLIBRARY='libpython$(VERSION).so'
649 ;;
650 *)
651 LDLIBRARY='libpython$(VERSION).sl'
652 ;;
653 esac
654 BLDLIBRARY='-Wl,+b,$(LIBDIR) -L. -lpython$(VERSION)'
655 RUNSHARED=SHLIB_PATH=`pwd`:${SHLIB_PATH}
656 ;;
657 OSF*)
658 LDLIBRARY='libpython$(VERSION).so'
659 BLDLIBRARY='-rpath $(LIBDIR) -L. -lpython$(VERSION)'
660 RUNSHARED=LD_LIBRARY_PATH=`pwd`:${LD_LIBRARY_PATH}
661 ;;
662 atheos*)
663 LDLIBRARY='libpython$(VERSION).so'
664 BLDLIBRARY='-L. -lpython$(VERSION)'
665 RUNSHARED=DLL_PATH=`pwd`:${DLL_PATH:-/atheos/sys/libs:/atheos/autolnk/lib}
666 ;;
667 esac
668 else # shared is disabled
669 case $ac_sys_system in
670 CYGWIN*)
671 BLDLIBRARY='$(LIBRARY)'
672 LDLIBRARY='libpython$(VERSION).dll.a'
673 ;;
674 esac
675 fi
677 AC_MSG_RESULT($LDLIBRARY)
679 AC_PROG_RANLIB
680 AC_SUBST(AR)
681 AC_CHECK_PROGS(AR, ar aal, ar)
683 AC_SUBST(SVNVERSION)
684 AC_CHECK_PROG(SVNVERSION, svnversion, found, not-found)
685 if test $SVNVERSION = found
686 then
687 SVNVERSION="svnversion \$(srcdir)"
688 else
689 SVNVERSION="echo exported"
690 fi
692 case $MACHDEP in
693 bsdos*|hp*|HP*)
694 # install -d does not work on BSDI or HP-UX
695 if test -z "$INSTALL"
696 then
697 INSTALL="${srcdir}/install-sh -c"
698 fi
699 esac
700 AC_PROG_INSTALL
702 # Not every filesystem supports hard links
703 AC_SUBST(LN)
704 if test -z "$LN" ; then
705 case $ac_sys_system in
706 BeOS*) LN="ln -s";;
707 CYGWIN*) LN="ln -s";;
708 atheos*) LN="ln -s";;
709 *) LN=ln;;
710 esac
711 fi
713 # Check for --with-pydebug
714 AC_MSG_CHECKING(for --with-pydebug)
715 AC_ARG_WITH(pydebug,
716 AC_HELP_STRING(--with-pydebug, build with Py_DEBUG defined),
717 [
718 if test "$withval" != no
719 then
720 AC_DEFINE(Py_DEBUG, 1,
721 [Define if you want to build an interpreter with many run-time checks.])
722 AC_MSG_RESULT(yes);
723 Py_DEBUG='true'
724 else AC_MSG_RESULT(no); Py_DEBUG='false'
725 fi],
726 [AC_MSG_RESULT(no)])
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
739 # user set OPT.
741 # tweak OPT based on compiler and platform, only if the user didn't set
742 # it on the command line
743 AC_SUBST(OPT)
744 if test -z "$OPT"
745 then
746 case $GCC in
747 yes)
748 if test "$CC" != 'g++' ; then
749 STRICT_PROTO="-Wstrict-prototypes"
750 fi
751 case $ac_cv_prog_cc_g in
752 yes)
753 if test "$Py_DEBUG" = 'true' ; then
754 # Optimization messes up debuggers, so turn it off for
755 # debug builds.
756 OPT="-g -Wall $STRICT_PROTO"
757 else
758 OPT="-g -O3 -Wall $STRICT_PROTO"
759 fi
760 ;;
761 *)
762 OPT="-O3 -Wall $STRICT_PROTO"
763 ;;
764 esac
765 case $ac_sys_system in
766 SCO_SV*) OPT="$OPT -m486 -DSCO5"
767 ;;
768 esac
769 ;;
771 *)
772 OPT="-O"
773 ;;
774 esac
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
779 Monterey*)
780 OPT=""
781 ;;
782 esac
784 fi
786 AC_SUBST(BASECFLAGS)
787 # tweak BASECFLAGS based on compiler and platform
788 case $GCC in
789 yes)
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)
794 ac_save_cc="$CC"
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)
800 CC="$ac_save_cc"
801 AC_MSG_RESULT($ac_cv_no_strict_aliasing_ok)
802 if test $ac_cv_no_strict_aliasing_ok = yes
803 then
804 BASECFLAGS="$BASECFLAGS -fno-strict-aliasing"
805 fi
806 case $ac_sys_system in
807 SCO_SV*)
808 BASECFLAGS="$BASECFLAGS -m486 -DSCO5"
809 ;;
810 # is there any other compiler on Darwin besides gcc?
811 Darwin*)
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}"
815 fi
817 ;;
818 OSF*)
819 BASECFLAGS="$BASECFLAGS -mieee"
820 ;;
821 esac
822 ;;
824 *)
825 case $ac_sys_system in
826 OpenUNIX*|UnixWare*)
827 BASECFLAGS="$BASECFLAGS -K pentium,host,inline,loop_unroll,alloca "
828 ;;
829 OSF*)
830 BASECFLAGS="$BASECFLAGS -ieee -std"
831 ;;
832 SCO_SV*)
833 BASECFLAGS="$BASECFLAGS -belf -Ki486 -DSCO5"
834 ;;
835 esac
836 ;;
837 esac
839 if test "$Py_DEBUG" = 'true'; then
840 :
841 else
842 OPT="-DNDEBUG $OPT"
843 fi
845 if test "$ac_arch_flags"
846 then
847 BASECFLAGS="$BASECFLAGS $ac_arch_flags"
848 fi
850 # disable check for icc since it seems to pass, but generates a warning
851 if test "$CC" = icc
852 then
853 ac_cv_opt_olimit_ok=no
854 fi
856 AC_MSG_CHECKING(whether $CC accepts -OPT:Olimit=0)
857 AC_CACHE_VAL(ac_cv_opt_olimit_ok,
858 [ac_save_cc="$CC"
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)
864 CC="$ac_save_cc"])
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
870 # environment?
871 Darwin*)
872 ;;
873 *)
874 BASECFLAGS="$BASECFLAGS -OPT:Olimit=0"
875 ;;
876 esac
877 else
878 AC_MSG_CHECKING(whether $CC accepts -Olimit 1500)
879 AC_CACHE_VAL(ac_cv_olimit_ok,
880 [ac_save_cc="$CC"
881 CC="$CC -Olimit 1500"
882 AC_TRY_RUN([int main() { return 0; }],
883 ac_cv_olimit_ok=yes,
884 ac_cv_olimit_ok=no,
885 ac_cv_olimit_ok=no)
886 CC="$ac_save_cc"])
887 AC_MSG_RESULT($ac_cv_olimit_ok)
888 if test $ac_cv_olimit_ok = yes; then
889 BASECFLAGS="$BASECFLAGS -Olimit 1500"
890 fi
891 fi
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,
900 [AC_TRY_RUN([
901 #include <pthread.h>
903 void* routine(void* p){return NULL;}
905 int main(){
906 pthread_t p;
907 if(pthread_create(&p,NULL,routine,NULL)!=0)
908 return 1;
909 (void)pthread_detach(p);
910 return 0;
911 }
912 ],
913 [
914 ac_cv_pthread_is_default=yes
915 ac_cv_kthread=no
916 ac_cv_pthread=no
917 ],
918 ac_cv_pthread_is_default=no,
919 ac_cv_pthread_is_default=no)
920 ])
921 AC_MSG_RESULT($ac_cv_pthread_is_default)
924 if test $ac_cv_pthread_is_default = yes
925 then
926 ac_cv_kpthread=no
927 else
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,
935 [ac_save_cc="$CC"
936 CC="$CC -Kpthread"
937 AC_TRY_RUN([
938 #include <pthread.h>
940 void* routine(void* p){return NULL;}
942 int main(){
943 pthread_t p;
944 if(pthread_create(&p,NULL,routine,NULL)!=0)
945 return 1;
946 (void)pthread_detach(p);
947 return 0;
948 }
949 ],
950 ac_cv_kpthread=yes,
951 ac_cv_kpthread=no,
952 ac_cv_kpthread=no)
953 CC="$ac_save_cc"])
954 AC_MSG_RESULT($ac_cv_kpthread)
955 fi
957 if test $ac_cv_kpthread = no -a $ac_cv_pthread_is_default = no
958 then
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,
966 [ac_save_cc="$CC"
967 CC="$CC -Kthread"
968 AC_TRY_RUN([
969 #include <pthread.h>
971 void* routine(void* p){return NULL;}
973 int main(){
974 pthread_t p;
975 if(pthread_create(&p,NULL,routine,NULL)!=0)
976 return 1;
977 (void)pthread_detach(p);
978 return 0;
979 }
980 ],
981 ac_cv_kthread=yes,
982 ac_cv_kthread=no,
983 ac_cv_kthread=no)
984 CC="$ac_save_cc"])
985 AC_MSG_RESULT($ac_cv_kthread)
986 fi
988 if test $ac_cv_kthread = no -a $ac_cv_pthread_is_default = no
989 then
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,
997 [ac_save_cc="$CC"
998 CC="$CC -pthread"
999 AC_TRY_RUN([
1000 #include <pthread.h>
1002 void* routine(void* p){return NULL;}
1004 int main(){
1005 pthread_t p;
1006 if(pthread_create(&p,NULL,routine,NULL)!=0)
1007 return 1;
1008 (void)pthread_detach(p);
1009 return 0;
1010 }
1011 ],
1012 ac_cv_pthread=yes,
1013 ac_cv_pthread=no,
1014 ac_cv_pthread=no)
1015 CC="$ac_save_cc"])
1016 AC_MSG_RESULT($ac_cv_pthread)
1017 fi
1019 # If we have set a CC compiler flag for thread support then
1020 # check if it works for CXX, too.
1021 ac_cv_cxx_thread=no
1022 if test ! -z "$CXX"
1023 then
1024 AC_MSG_CHECKING(whether $CXX also accepts flags for thread support)
1025 ac_save_cxx="$CXX"
1027 if test "$ac_cv_kpthread" = "yes"
1028 then
1029 CXX="$CXX -Kpthread"
1030 ac_cv_cxx_thread=yes
1031 elif test "$ac_cv_kthread" = "yes"
1032 then
1033 CXX="$CXX -Kthread"
1034 ac_cv_cxx_thread=yes
1035 elif test "$ac_cv_pthread" = "yes"
1036 then
1037 CXX="$CXX -pthread"
1038 ac_cv_cxx_thread=yes
1039 fi
1041 if test $ac_cv_cxx_thread = yes
1042 then
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
1047 then
1048 ac_cv_cxx_thread=yes
1049 else
1050 ac_cv_cxx_thread=no
1051 fi
1052 rm -fr conftest*
1053 fi
1054 AC_MSG_RESULT($ac_cv_cxx_thread)
1055 fi
1056 CXX="$ac_save_cxx"
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}
1062 dnl int foo;
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
1068 AC_HEADER_STDC
1069 AC_CHECK_HEADERS(asm/types.h conio.h curses.h direct.h dlfcn.h errno.h \
1070 fcntl.h grp.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 \
1073 unistd.h utime.h \
1074 sys/audioio.h sys/bsdtty.h sys/file.h sys/loadavg.h sys/lock.h sys/mkdev.h \
1075 sys/modem.h \
1076 sys/param.h sys/poll.h sys/select.h sys/socket.h sys/statvfs.h sys/stat.h \
1077 sys/time.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)
1081 AC_HEADER_DIRENT
1082 AC_HEADER_MAJOR
1084 # On Solaris, term.h requires curses.h
1085 AC_CHECK_HEADERS(term.h,,,[
1086 #ifdef HAVE_CURSES_H
1087 #include <curses.h>
1088 #endif
1089 ])
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>
1095 #endif
1096 #ifdef HAVE_SYS_SOCKET_H
1097 #include <sys/socket.h>
1098 #endif
1099 ])
1101 # checks for typedefs
1102 was_it_defined=no
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.])
1106 ])
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> ],
1112 [ makedev(0, 0) ],
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
1117 AC_TRY_LINK([
1118 #define _OSF_SOURCE 1
1119 #include <sys/types.h>
1120 ],
1121 [ makedev(0, 0) ],
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.])
1126 fi
1127 fi
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.])
1131 fi
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
1140 use_lfs=yes
1141 AC_MSG_CHECKING(Solaris LFS bug)
1142 AC_TRY_COMPILE([
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
1149 use_lfs=no
1150 fi
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.])
1159 fi
1161 # Add some code to confdefs.h so that the test for off_t works on SCO
1162 cat >> confdefs.h <<\EOF
1163 #if defined(SCO_DS)
1164 #undef _OFF_T
1165 #endif
1166 EOF
1168 # Type availability checks
1169 AC_TYPE_MODE_T
1170 AC_TYPE_OFF_T
1171 AC_TYPE_PID_T
1172 AC_TYPE_SIGNAL
1173 AC_TYPE_SIZE_T
1174 AC_TYPE_UID_T
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)
1190 have_long_long=no
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.])
1193 have_long_long=yes
1194 ])
1195 AC_MSG_RESULT($have_long_long)
1196 if test "$have_long_long" = yes ; then
1197 AC_CHECK_SIZEOF(long long, 8)
1198 fi
1200 AC_MSG_CHECKING(for uintptr_t support)
1201 have_uintptr_t=no
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.])
1204 have_uintptr_t=yes
1205 ])
1206 AC_MSG_RESULT($have_uintptr_t)
1207 if test "$have_uintptr_t" = yes ; then
1208 AC_CHECK_SIZEOF(uintptr_t, 4)
1209 fi
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>
1216 main()
1217 {
1218 FILE *f=fopen("conftestval", "w");
1219 if (!f) exit(1);
1220 fprintf(f, "%d\n", sizeof(off_t));
1221 exit(0);
1222 }],
1223 ac_cv_sizeof_off_t=`cat conftestval`,
1224 ac_cv_sizeof_off_t=0,
1225 ac_cv_sizeof_off_t=4)
1226 ])
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.)])
1240 AC_MSG_RESULT(yes)
1241 else
1242 AC_MSG_RESULT(no)
1243 fi
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>
1249 #include <time.h>
1250 main()
1251 {
1252 FILE *f=fopen("conftestval", "w");
1253 if (!f) exit(1);
1254 fprintf(f, "%d\n", sizeof(time_t));
1255 exit(0);
1256 }],
1257 ac_cv_sizeof_time_t=`cat conftestval`,
1258 ac_cv_sizeof_time_t=0,
1259 ac_cv_sizeof_time_t=4)
1260 ])
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
1267 ac_save_cc="$CC"
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"
1274 fi
1275 AC_MSG_CHECKING(for pthread_t)
1276 have_pthread_t=no
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>
1285 main()
1286 {
1287 FILE *f=fopen("conftestval", "w");
1288 if (!f) exit(1);
1289 fprintf(f, "%d\n", sizeof(pthread_t));
1290 exit(0);
1291 }],
1292 ac_cv_sizeof_pthread_t=`cat conftestval`,
1293 ac_cv_sizeof_pthread_t=0,
1294 ac_cv_sizeof_pthread_t=4)
1295 ])
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.])
1299 fi
1300 CC="$ac_save_cc"
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"
1307 then
1308 case $ac_sys_system/$ac_sys_release in
1309 Darwin/*)
1310 enable_toolbox_glue="yes";;
1311 *)
1312 enable_toolbox_glue="no";;
1313 esac
1314 fi
1315 case "$enable_toolbox_glue" in
1316 yes)
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.])
1321 ;;
1322 *)
1323 extra_machdep_objs=""
1324 extra_undefs=""
1325 ;;
1326 esac
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"
1333 ;;
1334 Darwin/*)
1335 OTHER_LIBTOOL_OPT=""
1336 ;;
1337 esac
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
1344 :
1345 else
1346 LIBTOOL_CRUFT="${LIBTOOL_CRUFT} -arch_only `arch`"
1347 fi
1348 LIBTOOL_CRUFT=$LIBTOOL_CRUFT' -install_name $(PYTHONFRAMEWORKINSTALLDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1349 LIBTOOL_CRUFT=$LIBTOOL_CRUFT' -compatibility_version $(VERSION) -current_version $(VERSION)';;
1350 Darwin/*)
1351 gcc_version=`gcc -v 2>&1 | grep version | cut -d\ -f3`
1352 if test ${gcc_version} '<' 4.0
1353 then
1354 LIBTOOL_CRUFT="-lcc_dynamic"
1355 else
1356 LIBTOOL_CRUFT=""
1357 fi
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)';;
1361 esac
1363 AC_MSG_CHECKING(for --enable-framework)
1364 if test "$enable_framework"
1365 then
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).])
1372 AC_MSG_RESULT(yes)
1373 else
1374 AC_MSG_RESULT(no)
1375 fi
1377 AC_MSG_CHECKING(for dyld)
1378 case $ac_sys_system/$ac_sys_release in
1379 Darwin/*)
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)
1385 ;;
1386 *)
1387 AC_MSG_RESULT(no)
1388 ;;
1389 esac
1391 # Set info about shared libraries.
1392 AC_SUBST(SO)
1393 AC_SUBST(LDSHARED)
1394 AC_SUBST(BLDSHARED)
1395 AC_SUBST(CCSHARED)
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
1399 AC_MSG_CHECKING(SO)
1400 if test -z "$SO"
1401 then
1402 case $ac_sys_system in
1403 hp*|HP*)
1404 case `uname -m` in
1405 ia64) SO=.so;;
1406 *) SO=.sl;;
1407 esac
1408 ;;
1409 CYGWIN*) SO=.dll;;
1410 *) SO=.so;;
1411 esac
1412 else
1413 # this might also be a termcap variable, see #610332
1414 echo
1415 echo '====================================================================='
1416 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. +'
1420 echo '+ +'
1421 echo '====================================================================='
1422 sleep 10
1423 fi
1424 AC_MSG_RESULT($SO)
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"
1432 then
1433 case $ac_sys_system/$ac_sys_release in
1434 AIX*)
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"
1437 ;;
1438 BeOS*)
1439 BLDSHARED="\$(srcdir)/Modules/ld_so_beos $LDLIBRARY"
1440 LDSHARED="\$(BINLIBDEST)/config/ld_so_beos \$(LIBDIR)/$LDLIBRARY"
1441 ;;
1442 IRIX/5*) LDSHARED="ld -shared";;
1443 IRIX*/6*) LDSHARED="ld ${SGI_ABI} -shared -all";;
1444 SunOS/5*)
1445 if test "$GCC" = "yes"
1446 then LDSHARED='$(CC) -shared'
1447 else LDSHARED='$(CC) -G';
1448 fi ;;
1449 hp*|HP*) LDSHARED="ld -b";;
1450 OSF*) LDSHARED="ld -shared -expect_unresolved \"*\"";;
1451 Darwin/1.3*)
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)'
1457 else
1458 # No framework. Ignore undefined symbols, assuming they come from Python
1459 LDSHARED="$LDSHARED -undefined suppress"
1460 fi ;;
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)'
1467 else
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)'
1471 fi ;;
1472 Darwin/*)
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
1477 cur_target=10.3
1478 fi
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
1482 then
1483 if test "${enable_universalsdk}"; then
1484 LDFLAGS="-arch i386 -arch ppc -isysroot ${UNIVERSALSDK} ${LDFLAGS}"
1485 fi
1486 LDSHARED='$(CC) $(LDFLAGS) -bundle -undefined dynamic_lookup'
1487 BLDSHARED="$LDSHARED"
1488 else
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)'
1494 else
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)'
1498 fi
1499 fi
1500 ;;
1501 Linux*|GNU*) LDSHARED='$(CC) -shared';;
1502 BSD/OS*/4*) LDSHARED="gcc -shared";;
1503 FreeBSD*)
1504 if [[ "`$CC -dM -E - </dev/null | grep __ELF__`" != "" ]]
1505 then
1506 LDSHARED="$CC -shared ${LDFLAGS}"
1507 else
1508 LDSHARED="ld -Bshareable ${LDFLAGS}"
1509 fi;;
1510 OpenBSD*)
1511 if [[ "`$CC -dM -E - </dev/null | grep __ELF__`" != "" ]]
1512 then
1513 LDSHARED='$(CC) -shared $(CCSHARED) ${LDFLAGS}'
1514 else
1515 case `uname -r` in
1516 [[01]].* | 2.[[0-7]] | 2.[[0-7]].*)
1517 LDSHARED="ld -Bshareable ${LDFLAGS}"
1518 ;;
1519 *)
1520 LDSHARED='$(CC) -shared $(CCSHARED) ${LDFLAGS}'
1521 ;;
1522 esac
1523 fi;;
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'
1529 fi;;
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";;
1534 *) LDSHARED="ld";;
1535 esac
1536 fi
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"
1543 then
1544 case $ac_sys_system/$ac_sys_release in
1545 SunOS*) if test "$GCC" = yes;
1546 then CCSHARED="-fPIC";
1547 else CCSHARED="-xcode=pic32";
1548 fi;;
1549 hp*|HP*) if test "$GCC" = yes;
1550 then CCSHARED="-fPIC";
1551 else CCSHARED="+z";
1552 fi;;
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"
1560 fi;;
1561 SCO_SV*)
1562 if test "$GCC" = "yes"
1563 then CCSHARED="-fPIC"
1564 else CCSHARED="-Kpic -belf"
1565 fi;;
1566 Monterey*) CCSHARED="-G";;
1567 IRIX*/6*) case $CC in
1568 *gcc*) CCSHARED="-shared";;
1569 *) CCSHARED="";;
1570 esac;;
1571 atheos*) CCSHARED="-fPIC";;
1572 esac
1573 fi
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"
1579 then
1580 case $ac_sys_system/$ac_sys_release in
1581 AIX*) LINKFORSHARED='-Wl,-bE:Modules/python.exp -lld';;
1582 hp*|HP*)
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
1588 Darwin/*)
1589 # -u _PyMac_Error is needed to pull in the mac toolbox glue,
1590 # which is
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"
1599 then
1600 LINKFORSHARED="$LINKFORSHARED "'$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1601 fi
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__`" != "" ]]
1608 then
1609 LINKFORSHARED="-Wl,--export-dynamic"
1610 fi;;
1611 SunOS/5*) case $CC in
1612 *gcc*)
1613 if $CC -Xlinker --help 2>&1 | grep export-dynamic >/dev/null
1614 then
1615 LINKFORSHARED="-Xlinker --export-dynamic"
1616 fi;;
1617 esac;;
1618 CYGWIN*)
1619 if test $enable_shared = "no"
1620 then
1621 LINKFORSHARED='-Wl,--out-implib=$(LDLIBRARY)'
1622 fi;;
1623 esac
1624 fi
1625 AC_MSG_RESULT($LINKFORSHARED)
1627 AC_SUBST(CFLAGSFORSHARED)
1628 AC_MSG_CHECKING(CFLAGSFORSHARED)
1629 if test ! "$LIBRARY" = "$LDLIBRARY"
1630 then
1631 case $ac_sys_system in
1632 CYGWIN*)
1633 # Cygwin needs CCSHARED when building extension DLLs
1634 # but not when building the interpreter DLL.
1635 CFLAGSFORSHARED='';;
1636 *)
1637 CFLAGSFORSHARED='$(CCSHARED)'
1638 esac
1639 fi
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.
1650 AC_SUBST(SHLIBS)
1651 AC_MSG_CHECKING(SHLIBS)
1652 case "$ac_sys_system" in
1653 *)
1654 SHLIBS='$(LIBS)';;
1655 esac
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
1668 fi
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)]);;
1685 *) ;;
1686 esac
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
1694 BeOS*)
1695 AC_CHECK_LIB(net, socket, [LIBS="-lnet $LIBS"], [], $LIBS) # BeOS
1696 ;;
1697 esac
1699 AC_MSG_CHECKING(for --with-libs)
1700 AC_ARG_WITH(libs,
1701 AC_HELP_STRING(--with-libs='lib1 ...', link against additional libs),
1702 [
1703 AC_MSG_RESULT($withval)
1704 LIBS="$withval $LIBS"
1705 ],
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"
1715 fi
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"
1727 fi
1728 AC_MSG_RESULT($with_signal_module)
1730 if test "${with_signal_module}" = "yes"; then
1731 USE_SIGNAL_MODULE=""
1732 SIGNAL_OBJS=""
1733 else
1734 USE_SIGNAL_MODULE="#"
1735 SIGNAL_OBJS="Parser/intrcheck.o Python/sigcheck.o"
1736 fi
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)
1743 AC_SUBST(LDLAST)
1744 AC_ARG_WITH(dec-threads,
1745 AC_HELP_STRING(--with-dec-threads, use DEC Alpha/OSF1 thread-safe libraries),
1746 [
1747 AC_MSG_RESULT($withval)
1748 LDLAST=-threads
1749 if test "${with_thread+set}" != set; then
1750 with_thread="$withval";
1751 fi],
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
1769 AC_ARG_WITH(thread,
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"
1775 fi
1776 AC_MSG_RESULT($with_threads)
1778 AC_SUBST(THREADOBJ)
1779 if test "$with_threads" = "no"
1780 then
1781 USE_THREAD_MODULE="#"
1782 elif test "$ac_cv_pthread_is_default" = yes
1783 then
1784 AC_DEFINE(WITH_THREAD)
1785 # Defining _REENTRANT on system with POSIX threads should not hurt.
1786 AC_DEFINE(_REENTRANT)
1787 posix_threads=yes
1788 THREADOBJ="Python/thread.o"
1789 elif test "$ac_cv_kpthread" = "yes"
1790 then
1791 CC="$CC -Kpthread"
1792 if test "$ac_cv_cxx_thread" = "yes"; then
1793 CXX="$CXX -Kpthread"
1794 fi
1795 AC_DEFINE(WITH_THREAD)
1796 posix_threads=yes
1797 THREADOBJ="Python/thread.o"
1798 elif test "$ac_cv_kthread" = "yes"
1799 then
1800 CC="$CC -Kthread"
1801 if test "$ac_cv_cxx_thread" = "yes"; then
1802 CXX="$CXX -Kthread"
1803 fi
1804 AC_DEFINE(WITH_THREAD)
1805 posix_threads=yes
1806 THREADOBJ="Python/thread.o"
1807 elif test "$ac_cv_pthread" = "yes"
1808 then
1809 CC="$CC -pthread"
1810 if test "$ac_cv_cxx_thread" = "yes"; then
1811 CXX="$CXX -pthread"
1812 fi
1813 AC_DEFINE(WITH_THREAD)
1814 posix_threads=yes
1815 THREADOBJ="Python/thread.o"
1816 else
1817 if test ! -z "$with_threads" -a -d "$with_threads"
1818 then LDFLAGS="$LDFLAGS -L$with_threads"
1819 fi
1820 if test ! -z "$withval" -a -d "$withval"
1821 then LDFLAGS="$LDFLAGS -L$withval"
1822 fi
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)
1828 AC_EGREP_CPP(yes,
1829 [
1830 #include <unistd.h>
1831 #ifdef _POSIX_THREADS
1832 yes
1833 #endif
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)
1850 AC_ARG_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.])
1856 LIBS="-lpth $LIBS"
1857 THREADOBJ="Python/thread.o"],
1858 [AC_MSG_RESULT(no)
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.
1863 _libs=$LIBS
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)], [
1870 AC_MSG_RESULT(yes)
1871 AC_DEFINE(WITH_THREAD)
1872 posix_threads=yes
1873 THREADOBJ="Python/thread.o"],[
1874 LIBS=$_libs
1875 AC_CHECK_FUNC(pthread_detach, [AC_DEFINE(WITH_THREAD)
1876 posix_threads=yes
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)
1887 posix_threads=yes
1888 LIBS="$LIBS -lpthreads"
1889 THREADOBJ="Python/thread.o"], [
1890 AC_CHECK_LIB(c_r, pthread_create, [AC_DEFINE(WITH_THREAD)
1891 posix_threads=yes
1892 LIBS="$LIBS -lc_r"
1893 THREADOBJ="Python/thread.o"], [
1894 AC_CHECK_LIB(pthread, __pthread_create_system, [AC_DEFINE(WITH_THREAD)
1895 posix_threads=yes
1896 LIBS="$LIBS -lpthread"
1897 THREADOBJ="Python/thread.o"], [
1898 AC_CHECK_LIB(cma, pthread_create, [AC_DEFINE(WITH_THREAD)
1899 posix_threads=yes
1900 LIBS="$LIBS -lcma"
1901 THREADOBJ="Python/thread.o"],[
1902 USE_THREAD_MODULE="#"])
1903 ])])])])])])])])])])
1905 AC_CHECK_LIB(mpc, usconfig, [AC_DEFINE(WITH_THREAD)
1906 LIBS="$LIBS -lmpc"
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=""])
1915 fi
1917 if test "$USE_THREAD_MODULE" != "#"
1918 then
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;;
1923 esac
1924 fi
1925 fi
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.])
1932 fi
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.)
1938 ;;
1939 SunOS/5.8) AC_DEFINE(HAVE_BROKEN_POSIX_SEMAPHORES, 1,
1940 Define if the Posix semaphores do not work on your system)
1941 ;;
1942 esac
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) {
1948 return NULL;
1949 }
1950 main() {
1951 pthread_attr_t attr;
1952 pthread_t id;
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);
1956 exit(0);
1957 }],
1958 ac_cv_pthread_system_supported=yes,
1959 ac_cv_pthread_system_supported=no,
1960 ac_cv_pthread_system_supported=no)
1961 ])
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.])
1965 fi
1966 AC_CHECK_FUNCS(pthread_sigmask,
1967 [case $ac_sys_system in
1968 CYGWIN*)
1969 AC_DEFINE(HAVE_BROKEN_PTHREAD_SIGMASK, 1,
1970 [Define if pthread_sigmask() does not work on your system.])
1971 ;;
1972 esac])
1973 fi
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])
1979 AC_ARG_ENABLE(ipv6,
1980 [ --enable-ipv6 Enable ipv6 (with ipv4) support
1981 --disable-ipv6 Disable ipv6 support],
1982 [ case "$enableval" in
1983 no)
1984 AC_MSG_RESULT(no)
1985 ipv6=no
1986 ;;
1987 *) AC_MSG_RESULT(yes)
1988 AC_DEFINE(ENABLE_IPV6)
1989 ipv6=yes
1990 ;;
1991 esac ],
1993 [
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>
1998 main()
1999 {
2000 if (socket(AF_INET6, SOCK_STREAM, 0) < 0)
2001 exit(1);
2002 else
2003 exit(0);
2004 }
2005 ],
2006 AC_MSG_RESULT(yes)
2007 ipv6=yes,
2008 AC_MSG_RESULT(no)
2009 ipv6=no,
2010 AC_MSG_RESULT(no)
2011 ipv6=no
2012 )
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;
2019 x.sin6_scope_id;],
2020 AC_MSG_RESULT(yes)
2021 ipv6=yes,
2022 AC_MSG_RESULT(no, IPv6 disabled)
2023 ipv6=no)
2024 fi
2026 if test "$ipv6" = "yes"; then
2027 AC_DEFINE(ENABLE_IPV6)
2028 fi
2029 ])
2031 ipv6type=unknown
2032 ipv6lib=none
2033 ipv6trylibc=no
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;
2038 do
2039 case $i in
2040 inria)
2041 dnl http://www.kame.net/
2042 AC_EGREP_CPP(yes, [
2043 #include <netinet/in.h>
2044 #ifdef IPV6_INRIA_VERSION
2045 yes
2046 #endif],
2047 [ipv6type=$i])
2048 ;;
2049 kame)
2050 dnl http://www.kame.net/
2051 AC_EGREP_CPP(yes, [
2052 #include <netinet/in.h>
2053 #ifdef __KAME__
2054 yes
2055 #endif],
2056 [ipv6type=$i;
2057 ipv6lib=inet6
2058 ipv6libdir=/usr/local/v6/lib
2059 ipv6trylibc=yes])
2060 ;;
2061 linux-glibc)
2062 dnl http://www.v6.linux.or.jp/
2063 AC_EGREP_CPP(yes, [
2064 #include <features.h>
2065 #if defined(__GLIBC__) && ((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 1) || (__GLIBC__ > 2))
2066 yes
2067 #endif],
2068 [ipv6type=$i;
2069 ipv6trylibc=yes])
2070 ;;
2071 linux-inet6)
2072 dnl http://www.v6.linux.or.jp/
2073 if test -d /usr/inet6; then
2074 ipv6type=$i
2075 ipv6lib=inet6
2076 ipv6libdir=/usr/inet6/lib
2077 BASECFLAGS="-I/usr/inet6/include $BASECFLAGS"
2078 fi
2079 ;;
2080 solaris)
2081 if test -f /etc/netconfig; then
2082 if /usr/xpg4/bin/grep -q tcp6 /etc/netconfig; then
2083 ipv6type=$i
2084 ipv6trylibc=yes
2085 fi
2086 fi
2087 ;;
2088 toshiba)
2089 AC_EGREP_CPP(yes, [
2090 #include <sys/param.h>
2091 #ifdef _TOSHIBA_INET6
2092 yes
2093 #endif],
2094 [ipv6type=$i;
2095 ipv6lib=inet6;
2096 ipv6libdir=/usr/local/v6/lib])
2097 ;;
2098 v6d)
2099 AC_EGREP_CPP(yes, [
2100 #include </usr/local/v6/include/sys/v6config.h>
2101 #ifdef __V6D__
2102 yes
2103 #endif],
2104 [ipv6type=$i;
2105 ipv6lib=v6;
2106 ipv6libdir=/usr/local/v6/lib;
2107 BASECFLAGS="-I/usr/local/v6/include $BASECFLAGS"])
2108 ;;
2109 zeta)
2110 AC_EGREP_CPP(yes, [
2111 #include <sys/param.h>
2112 #ifdef _ZETA_MINAMI_INET6
2113 yes
2114 #endif],
2115 [ipv6type=$i;
2116 ipv6lib=inet6;
2117 ipv6libdir=/usr/local/v6/lib])
2118 ;;
2119 esac
2120 if test "$ipv6type" != "unknown"; then
2121 break
2122 fi
2123 done
2124 AC_MSG_RESULT($ipv6type)
2125 fi
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"
2131 else
2132 if test $ipv6trylibc = "yes"; then
2133 echo "using libc"
2134 else
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.'
2138 exit 1
2139 fi
2140 fi
2141 fi
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"
2150 fi
2151 if test "$with_doc_strings" != "no"
2152 then
2153 AC_DEFINE(WITH_DOC_STRINGS, 1,
2154 [Define if you want documentation strings in extension modules])
2155 fi
2156 AC_MSG_RESULT($with_doc_strings)
2158 # Check for Python-specific malloc support
2159 AC_MSG_CHECKING(for --with-tsc)
2160 AC_ARG_WITH(tsc,
2161 [ --with(out)-tsc enable/disable timestamp counter profile], [
2162 if test "$withval" != no
2163 then
2164 AC_DEFINE(WITH_TSC, 1,
2165 [Define to profile with the Pentium timestamp counter])
2166 AC_MSG_RESULT(yes)
2167 else AC_MSG_RESULT(no)
2168 fi],
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"
2178 fi
2179 if test "$with_pymalloc" != "no"
2180 then
2181 AC_DEFINE(WITH_PYMALLOC, 1,
2182 [Define if you want to compile in Python-specific mallocs])
2183 fi
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),
2190 [
2191 if test "$withval" != no
2192 then
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).])
2196 AC_MSG_RESULT(yes)
2197 else AC_MSG_RESULT(no)
2198 fi],
2199 [AC_MSG_RESULT(no)])
2201 # -I${DLINCLDIR} is added to the compile rule for importdl.o
2202 AC_SUBST(DLINCLDIR)
2203 DLINCLDIR=.
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"
2214 then
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"
2220 fi
2221 ;;
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";;
2227 *)
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"
2233 fi
2234 ;;
2235 esac
2236 fi
2237 AC_MSG_RESULT($DYNLOADFILE)
2238 if test "$DYNLOADFILE" != "dynload_stub.o"
2239 then
2240 AC_DEFINE(HAVE_DYNAMIC_LOADING, 1,
2241 [Defined when any dynamic module loading is enabled.])
2242 fi
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"
2249 then
2250 MACHDEP_OBJS=$extra_machdep_objs
2251 else
2252 MACHDEP_OBJS="$MACHDEP_OBJS $extra_machdep_objs"
2253 fi
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.)
2275 AC_MSG_RESULT(yes),
2276 AC_MSG_RESULT(no)
2277 )
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.)
2281 AC_MSG_RESULT(yes),
2282 AC_MSG_RESULT(no)
2283 )
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.)
2287 AC_MSG_RESULT(yes),
2288 AC_MSG_RESULT(no)
2289 )
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.)
2293 AC_MSG_RESULT(yes),
2294 AC_MSG_RESULT(no)
2295 )
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.)
2299 AC_MSG_RESULT(yes),
2300 AC_MSG_RESULT(no)
2301 )
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.)
2305 AC_MSG_RESULT(yes),
2306 AC_MSG_RESULT(no)
2307 )
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)
2316 AC_TRY_COMPILE([
2317 #include "confdefs.h"
2318 #include <stdio.h>
2319 ], void* p = ctermid_r,
2320 AC_DEFINE(HAVE_CTERMID_R, 1, Define if you have the 'ctermid_r' function.)
2321 AC_MSG_RESULT(yes),
2322 AC_MSG_RESULT(no)
2323 )
2325 AC_MSG_CHECKING(for flock)
2326 AC_TRY_COMPILE([
2327 #include "confdefs.h"
2328 #include <sys/file.h>
2329 ], void* p = flock,
2330 AC_DEFINE(HAVE_FLOCK, 1, Define if you have the 'flock' function.)
2331 AC_MSG_RESULT(yes),
2332 AC_MSG_RESULT(no)
2333 )
2335 AC_MSG_CHECKING(for getpagesize)
2336 AC_TRY_COMPILE([
2337 #include "confdefs.h"
2338 #include <unistd.h>
2339 ], void* p = getpagesize,
2340 AC_DEFINE(HAVE_GETPAGESIZE, 1, Define if you have the 'getpagesize' function.)
2341 AC_MSG_RESULT(yes),
2342 AC_MSG_RESULT(no)
2343 )
2345 dnl check for true
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)
2352 )
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)
2358 AC_TRY_LINK([
2359 #include "confdefs.h"
2360 #include <netdb.h>
2361 ], void* p = hstrerror; hstrerror(0),
2362 AC_DEFINE(HAVE_HSTRERROR, 1, Define if you have the 'hstrerror' function.)
2363 AC_MSG_RESULT(yes),
2364 AC_MSG_RESULT(no)
2365 )
2367 AC_MSG_CHECKING(for inet_aton)
2368 AC_TRY_LINK([
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.)
2376 AC_MSG_RESULT(yes),
2377 AC_MSG_RESULT(no)
2378 )
2380 AC_MSG_CHECKING(for inet_pton)
2381 AC_TRY_COMPILE([
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.)
2389 AC_MSG_RESULT(yes),
2390 AC_MSG_RESULT(no)
2391 )
2393 # On some systems, setgroups is in unistd.h, on others, in grp.h
2394 AC_MSG_CHECKING(for setgroups)
2395 AC_TRY_COMPILE([
2396 #include "confdefs.h"
2397 #include <unistd.h>
2398 #ifdef HAVE_GRP_H
2399 #include <grp.h>
2400 #endif
2401 ],
2402 void* p = setgroups,
2403 AC_DEFINE(HAVE_SETGROUPS, 1, Define if you have the 'setgroups' function.)
2404 AC_MSG_RESULT(yes),
2405 AC_MSG_RESULT(no)
2406 )
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"])
2414 )
2415 )
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"])
2420 )
2421 )
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>],
2429 [getpgrp(0);],
2430 AC_DEFINE(GETPGRP_HAVE_ARG, 1,
2431 [Define if getpgrp() must be called as getpgrp(0).])
2432 )
2433 )
2434 AC_CHECK_FUNCS(setpgrp,
2435 AC_TRY_COMPILE([#include <unistd.h>],
2436 [setpgrp(0,0);],
2437 AC_DEFINE(SETPGRP_HAVE_ARG, 1,
2438 [Define if setpgrp() must be called as setpgrp(0, 0).])
2439 )
2440 )
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)])
2447 )
2448 )
2450 AC_MSG_CHECKING(for major, minor, and makedev)
2451 AC_TRY_LINK([
2452 #if defined(MAJOR_IN_MKDEV)
2453 #include <sys/mkdev.h>
2454 #elif defined(MAJOR_IN_SYSMACROS)
2455 #include <sys/sysmacros.h>
2456 #else
2457 #include <sys/types.h>
2458 #endif
2459 ],[
2460 makedev(major(0),minor(0));
2461 ],[
2462 AC_DEFINE(HAVE_DEVICE_MACROS, 1,
2463 [Define to 1 if you have the device macros.])
2464 AC_MSG_RESULT(yes)
2465 ],[
2466 AC_MSG_RESULT(no)
2467 ])
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)
2472 AC_TRY_LINK([
2473 #include <sys/types.h>
2474 #include <sys/socket.h>
2475 #include <netdb.h>
2476 #include <stdio.h>
2477 ],[
2478 getaddrinfo(NULL, NULL, NULL, NULL);
2479 ], [
2480 AC_MSG_RESULT(yes)
2481 AC_MSG_CHECKING(getaddrinfo bug)
2482 AC_TRY_RUN([
2483 #include <sys/types.h>
2484 #include <netdb.h>
2485 #include <string.h>
2486 #include <sys/socket.h>
2487 #include <netinet/in.h>
2489 main()
2490 {
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);
2503 goto bad;
2504 }
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) {
2511 goto bad;
2512 }
2513 switch (ai->ai_family) {
2514 case AF_INET:
2515 if (strcmp(strport, "54321") != 0) {
2516 goto bad;
2517 }
2518 if (passive) {
2519 if (strcmp(straddr, "0.0.0.0") != 0) {
2520 goto bad;
2521 }
2522 } else {
2523 if (strcmp(straddr, "127.0.0.1") != 0) {
2524 goto bad;
2525 }
2526 }
2527 inet4++;
2528 break;
2529 case AF_INET6:
2530 if (strcmp(strport, "54321") != 0) {
2531 goto bad;
2532 }
2533 if (passive) {
2534 if (strcmp(straddr, "::") != 0) {
2535 goto bad;
2536 }
2537 } else {
2538 if (strcmp(straddr, "::1") != 0) {
2539 goto bad;
2540 }
2541 }
2542 inet6++;
2543 break;
2544 case AF_UNSPEC:
2545 goto bad;
2546 break;
2547 default:
2548 /* another family support? */
2549 break;
2550 }
2551 }
2552 }
2554 if (!(inet4 == 0 || inet4 == 2))
2555 goto bad;
2556 if (!(inet6 == 0 || inet6 == 2))
2557 goto bad;
2559 if (aitop)
2560 freeaddrinfo(aitop);
2561 exit(0);
2563 bad:
2564 if (aitop)
2565 freeaddrinfo(aitop);
2566 exit(1);
2567 }
2568 ],
2569 AC_MSG_RESULT(good)
2570 buggygetaddrinfo=no,
2571 AC_MSG_RESULT(buggy)
2572 buggygetaddrinfo=yes,
2573 AC_MSG_RESULT(buggy)
2574 buggygetaddrinfo=yes)], [
2575 AC_MSG_RESULT(no)
2576 buggygetaddrinfo=yes
2577 ])
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"'.
2583 exit 1
2584 fi
2585 else
2586 AC_DEFINE(HAVE_GETADDRINFO, 1, [Define if you have the getaddrinfo function.])
2587 fi
2588 AC_CHECK_FUNCS(getnameinfo)
2590 # checks for structures
2591 AC_HEADER_TIME
2592 AC_STRUCT_TM
2593 AC_STRUCT_TIMEZONE
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])
2599 AC_STRUCT_ST_BLOCKS
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.])
2609 fi
2611 was_it_defined=no
2612 AC_MSG_CHECKING(whether sys/select.h and sys/time.h may both be included)
2613 AC_TRY_COMPILE([
2614 #include <sys/types.h>
2615 #include <sys/select.h>
2616 #include <sys/time.h>
2617 ], [;], [
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).])
2621 was_it_defined=yes
2622 ])
2623 AC_MSG_RESULT($was_it_defined)
2625 AC_MSG_CHECKING(for addrinfo)
2626 AC_CACHE_VAL(ac_cv_struct_addrinfo,
2627 AC_TRY_COMPILE([
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)])
2635 fi
2637 AC_MSG_CHECKING(for sockaddr_storage)
2638 AC_CACHE_VAL(ac_cv_struct_sockaddr_storage,
2639 AC_TRY_COMPILE([
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)])
2648 fi
2650 # checks for compiler characteristics
2652 AC_C_CHAR_UNSIGNED
2653 AC_C_CONST
2655 works=no
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.])
2659 )
2660 AC_MSG_RESULT($works)
2662 works=no
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.])
2666 )
2667 AC_MSG_RESULT($works)
2669 have_prototypes=no
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])
2674 have_prototypes=yes
2675 ])
2676 AC_MSG_RESULT($have_prototypes)
2678 works=no
2679 AC_MSG_CHECKING(for variable length prototypes and stdarg.h)
2680 AC_TRY_COMPILE([
2681 #include <stdarg.h>
2682 int foo(int x, ...) {
2683 va_list va;
2684 va_start(va, x);
2685 va_arg(va, int);
2686 va_arg(va, char *);
2687 va_arg(va, double);
2688 return 0;
2689 }
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>])
2694 works=yes
2695 ])
2696 AC_MSG_RESULT($works)
2698 # check for socketpair
2699 AC_MSG_CHECKING(for socketpair)
2700 AC_TRY_COMPILE([
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.)
2705 AC_MSG_RESULT(yes),
2706 AC_MSG_RESULT(no)
2707 )
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>],
2713 [struct sockaddr x;
2714 x.sa_len = 0;],
2715 AC_MSG_RESULT(yes)
2716 AC_DEFINE(HAVE_SOCKADDR_SA_LEN, 1, [Define if sockaddr has sa_len member]),
2717 AC_MSG_RESULT(no))
2719 va_list_is_array=no
2720 AC_MSG_CHECKING(whether va_list is an array)
2721 AC_TRY_COMPILE([
2722 #ifdef HAVE_STDARG_PROTOTYPES
2723 #include <stdarg.h>
2724 #else
2725 #include <varargs.h>
2726 #endif
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
2730 ])
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])
2740 OLD_CFLAGS=$CFLAGS
2741 CFLAGS="$CFLAGS $MY_CPPFLAGS $MY_THREAD_CPPFLAGS $MY_CFLAGS"
2742 AC_TRY_COMPILE([
2743 # include <netdb.h>
2744 ], [
2745 char *name;
2746 struct hostent *he, *res;
2747 char buffer[2048];
2748 int buflen = 2048;
2749 int h_errnop;
2751 (void) gethostbyname_r(name, he, buffer, buflen, &res, &h_errnop)
2752 ], [
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().])
2756 AC_MSG_RESULT(yes)
2757 ], [
2758 AC_MSG_RESULT(no)
2759 AC_MSG_CHECKING([gethostbyname_r with 5 args])
2760 AC_TRY_COMPILE([
2761 # include <netdb.h>
2762 ], [
2763 char *name;
2764 struct hostent *he;
2765 char buffer[2048];
2766 int buflen = 2048;
2767 int h_errnop;
2769 (void) gethostbyname_r(name, he, buffer, buflen, &h_errnop)
2770 ], [
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().])
2774 AC_MSG_RESULT(yes)
2775 ], [
2776 AC_MSG_RESULT(no)
2777 AC_MSG_CHECKING([gethostbyname_r with 3 args])
2778 AC_TRY_COMPILE([
2779 # include <netdb.h>
2780 ], [
2781 char *name;
2782 struct hostent *he;
2783 struct hostent_data data;
2785 (void) gethostbyname_r(name, he, &data);
2786 ], [
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().])
2790 AC_MSG_RESULT(yes)
2791 ], [
2792 AC_MSG_RESULT(no)
2793 ])
2794 ])
2795 ])
2796 CFLAGS=$OLD_CFLAGS
2797 ], [
2798 AC_CHECK_FUNCS(gethostbyname)
2799 ])
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
2807 # (none yet)
2809 # Linux requires this for correct f.p. operations
2810 AC_CHECK_FUNC(__fpu_control,
2811 [],
2812 [AC_CHECK_LIB(ieee, __fpu_control)
2813 ])
2815 # Check for --with-fpectl
2816 AC_MSG_CHECKING(for --with-fpectl)
2817 AC_ARG_WITH(fpectl,
2818 AC_HELP_STRING(--with-fpectl, enable SIGFPE catching),
2819 [
2820 if test "$withval" != no
2821 then
2822 AC_DEFINE(WANT_SIGFPE_HANDLER, 1,
2823 [Define if you want SIGFPE handled (see Include/pyfpe.h).])
2824 AC_MSG_RESULT(yes)
2825 else AC_MSG_RESULT(no)
2826 fi],
2827 [AC_MSG_RESULT(no)])
2829 # check for --with-libm=...
2830 AC_SUBST(LIBM)
2831 case $ac_sys_system in
2832 Darwin) ;;
2833 BeOS) ;;
2834 *) LIBM=-lm
2835 esac
2836 AC_MSG_CHECKING(for --with-libm=STRING)
2837 AC_ARG_WITH(libm,
2838 AC_HELP_STRING(--with-libm=STRING, math library),
2839 [
2840 if test "$withval" = no
2841 then LIBM=
2842 AC_MSG_RESULT(force LIBM empty)
2843 elif test "$withval" != yes
2844 then LIBM=$withval
2845 AC_MSG_RESULT(set LIBM="$withval")
2846 else AC_MSG_ERROR([proper usage is --with-libm=STRING])
2847 fi],
2848 [AC_MSG_RESULT(default LIBM="$LIBM")])
2850 # check for --with-libc=...
2851 AC_SUBST(LIBC)
2852 AC_MSG_CHECKING(for --with-libc=STRING)
2853 AC_ARG_WITH(libc,
2854 AC_HELP_STRING(--with-libc=STRING, C library),
2855 [
2856 if test "$withval" = no
2857 then LIBC=
2858 AC_MSG_RESULT(force LIBC empty)
2859 elif test "$withval" != yes
2860 then LIBC=$withval
2861 AC_MSG_RESULT(set LIBC="$withval")
2862 else AC_MSG_ERROR([proper usage is --with-libc=STRING])
2863 fi],
2864 [AC_MSG_RESULT(default LIBC="$LIBC")])
2866 # check for hypot() in math library
2867 LIBS_SAVE=$LIBS
2868 LIBS="$LIBS $LIBM"
2869 AC_REPLACE_FUNCS(hypot)
2870 LIBS=$LIBS_SAVE
2872 # check for wchar.h
2873 AC_CHECK_HEADER(wchar.h, [
2874 AC_DEFINE(HAVE_WCHAR_H, 1,
2875 [Define if the compiler provides a wchar.h header file.])
2876 wchar_h="yes"
2877 ],
2878 wchar_h="no"
2879 )
2881 # determine wchar_t size
2882 if test "$wchar_h" = yes
2883 then
2884 AC_CHECK_SIZEOF(wchar_t, 4, [#include <wchar.h>])
2885 fi
2887 AC_MSG_CHECKING(for UCS-4 tcl)
2888 have_ucs4_tcl=no
2889 AC_TRY_COMPILE([
2890 #include <tcl.h>
2891 #if TCL_UTF_MAX != 6
2892 # error "NOT UCS4_TCL"
2893 #endif], [], [
2894 AC_DEFINE(HAVE_UCS4_TCL, 1, [Define this if you have tcl and TCL_UTF_MAX==6])
2895 have_ucs4_tcl=yes
2896 ])
2897 AC_MSG_RESULT($have_ucs4_tcl)
2899 # check whether wchar_t is signed or not
2900 if test "$wchar_h" = yes
2901 then
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, [
2905 AC_TRY_RUN([
2906 #include <wchar.h>
2907 int main()
2908 {
2909 /* Success: exit code 0 */
2910 exit((((wchar_t) -1) < ((wchar_t) 0)) ? 0 : 1);
2911 }
2912 ],
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)
2917 fi
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)),
2923 [],
2924 [enable_unicode=yes])
2926 if test $enable_unicode = yes
2927 then
2928 # Without any arguments, Py_UNICODE defaults to two-byte mode
2929 case "$have_ucs4_tcl" in
2930 yes) enable_unicode="ucs4"
2931 ;;
2932 *) enable_unicode="ucs2"
2933 ;;
2934 esac
2935 fi
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)
2942 ;;
2943 ucs4) unicode_size="4"
2944 AC_DEFINE(Py_UNICODE_SIZE,4)
2945 ;;
2946 esac
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"
2953 then
2954 UNICODE_OBJS=""
2955 AC_MSG_RESULT(not used)
2956 else
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"
2964 then
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"
2972 then
2973 PY_UNICODE_TYPE="unsigned short"
2974 AC_DEFINE(PY_UNICODE_TYPE,unsigned short)
2975 elif test "$ac_cv_sizeof_long" = "$unicode_size"
2976 then
2977 PY_UNICODE_TYPE="unsigned long"
2978 AC_DEFINE(PY_UNICODE_TYPE,unsigned long)
2979 else
2980 PY_UNICODE_TYPE="no type found"
2981 fi
2982 AC_MSG_RESULT($PY_UNICODE_TYPE)
2983 fi
2985 # check for endianness
2986 AC_C_BIGENDIAN
2987 AH_VERBATIM([WORDS_BIGENDIAN],
2988 [
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.
2996 */
2997 #ifdef __BIG_ENDIAN__
2998 #define WORDS_BIGENDIAN 1
2999 #else
3000 #ifndef __LITTLE_ENDIAN__
3001 #undef WORDS_BIGENDIAN
3002 #endif
3003 #endif])
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, [
3009 AC_TRY_RUN([
3010 int main()
3011 {
3012 exit(((-1)>>3 == -1) ? 0 : 1);
3013 }
3014 ],
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
3020 then
3021 AC_DEFINE(SIGNED_RIGHT_SHIFT_ZERO_FILLS, 1,
3022 [Define if i>>j for signed int i does not extend the sign bit
3023 when i < 0])
3024 fi
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");
3031 flockfile(f);
3032 getc_unlocked(f);
3033 funlockfile(f);
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
3037 then
3038 AC_DEFINE(HAVE_GETC_UNLOCKED, 1,
3039 [Define this if you have flockfile(), getc_unlocked(), and funlockfile()])
3040 fi
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
3047 then
3048 AC_CHECK_LIB(termcap, readline)
3049 fi
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
3060 then
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]), )
3065 fi
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
3081 then
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.]), )
3086 fi
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, [
3093 AC_TRY_RUN([
3094 int main()
3095 {
3096 int val1 = nice(1);
3097 if (val1 != -1 && val1 == nice(2))
3098 exit(0);
3099 exit(1);
3100 }
3101 ],
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
3107 then
3108 AC_DEFINE(HAVE_BROKEN_NICE, 1,
3109 [Define if nice() returns success/failure instead of the new priority.])
3110 fi
3112 AC_MSG_CHECKING(for broken poll())
3113 AC_TRY_RUN([
3114 #include <poll.h>
3116 int main (void)
3117 {
3118 struct pollfd poll_struct = { 42, POLLIN|POLLPRI|POLLOUT, 0 };
3120 close (42);
3122 int poll_test = poll (&poll_struct, 1, 0);
3124 if (poll_test < 0)
3125 {
3126 exit(0);
3127 }
3128 else if (poll_test == 0 && poll_struct.revents != POLLNVAL)
3129 {
3130 exit(0);
3131 }
3132 else
3133 {
3134 exit(1);
3135 }
3136 }
3137 ],
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
3143 then
3144 AC_DEFINE(HAVE_BROKEN_POLL, 1,
3145 [Define if poll() sets errno on invalid file descriptors.])
3146 fi
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
3150 # tzname[]
3151 AC_STRUCT_TIMEZONE
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, [
3156 AC_TRY_RUN([
3157 #include <stdlib.h>
3158 #include <time.h>
3159 #include <string.h>
3161 #if HAVE_TZNAME
3162 extern char *tzname[];
3163 #endif
3165 int main()
3166 {
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.
3176 */
3178 time_t groundhogday = 1044144000; /* GMT-based */
3179 time_t midyear = groundhogday + (365 * 24 * 3600 / 2);
3181 putenv("TZ=UTC+0");
3182 tzset();
3183 if (localtime(&groundhogday)->tm_hour != 0)
3184 exit(1);
3185 #if HAVE_TZNAME
3186 /* For UTC, tzname[1] is sometimes "", sometimes " " */
3187 if (strcmp(tzname[0], "UTC") ||
3188 (tzname[1][0] != 0 && tzname[1][0] != ' '))
3189 exit(1);
3190 #endif
3192 putenv("TZ=EST+5EDT,M4.1.0,M10.5.0");
3193 tzset();
3194 if (localtime(&groundhogday)->tm_hour != 19)
3195 exit(1);
3196 #if HAVE_TZNAME
3197 if (strcmp(tzname[0], "EST") || strcmp(tzname[1], "EDT"))
3198 exit(1);
3199 #endif
3201 putenv("TZ=AEST-10AEDT-11,M10.5.0,M3.5.0");
3202 tzset();
3203 if (localtime(&groundhogday)->tm_hour != 11)
3204 exit(1);
3205 #if HAVE_TZNAME
3206 if (strcmp(tzname[0], "AEST") || strcmp(tzname[1], "AEDT"))
3207 exit(1);
3208 #endif
3210 #if HAVE_STRUCT_TM_TM_ZONE
3211 if (strcmp(localtime(&groundhogday)->tm_zone, "AEDT"))
3212 exit(1);
3213 if (strcmp(localtime(&midyear)->tm_zone, "AEST"))
3214 exit(1);
3215 #endif
3217 exit(0);
3218 }
3219 ],
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
3225 then
3226 AC_DEFINE(HAVE_WORKING_TZSET, 1,
3227 [Define if tzset() actually switches the local timezone in a meaningful way.])
3228 fi
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>], [
3234 struct stat st;
3235 st.st_mtim.tv_nsec = 1;
3236 ],
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
3242 then
3243 AC_DEFINE(HAVE_STAT_TV_NSEC, 1,
3244 [Define if you have struct stat.st_mtim.tv_nsec])
3245 fi
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>], [
3251 struct stat st;
3252 st.st_mtimespec.tv_nsec = 1;
3253 ],
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
3259 then
3260 AC_DEFINE(HAVE_STAT_TV_NSEC2, 1,
3261 [Define if you have struct stat.st_mtimensec])
3262 fi
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>], [
3268 int rtn;
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
3276 then
3277 AC_DEFINE(MVWDELCH_IS_EXPRESSION, 1,
3278 [Define if mvwdelch in curses.h is an expression.])
3279 fi
3281 AC_MSG_CHECKING(whether WINDOW has _flags)
3282 AC_CACHE_VAL(ac_cv_window_has_flags,
3283 AC_TRY_COMPILE([#include <curses.h>], [
3284 WINDOW *w;
3285 w->_flags = 0;
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
3293 then
3294 AC_DEFINE(WINDOW_HAS_FLAGS, 1,
3295 [Define if WINDOW in curses.h offers a field _flags.])
3296 fi
3298 AC_MSG_CHECKING(for /dev/ptmx)
3300 if test -e /dev/ptmx
3301 then
3302 AC_MSG_RESULT(yes)
3303 AC_DEFINE(HAVE_DEV_PTMX, 1,
3304 [Define if we have /dev/ptmx.])
3305 else
3306 AC_MSG_RESULT(no)
3307 fi
3309 AC_MSG_CHECKING(for /dev/ptc)
3311 if test -e /dev/ptc
3312 then
3313 AC_MSG_RESULT(yes)
3314 AC_DEFINE(HAVE_DEV_PTC, 1,
3315 [Define if we have /dev/ptc.])
3316 else
3317 AC_MSG_RESULT(no)
3318 fi
3320 AC_MSG_CHECKING(for %zd printf() format support)
3321 AC_TRY_RUN([#include <stdio.h>
3322 #include <stddef.h>
3323 #include <string.h>
3325 int main()
3326 {
3327 char buffer[4];
3329 if(sprintf(buffer, "%zd", (size_t)123) < 0)
3330 return 1;
3332 if (strncmp(buffer, "123", 3))
3333 return 1;
3335 return 0;
3336 }],
3337 [AC_MSG_RESULT(yes)
3338 AC_DEFINE(PY_FORMAT_SIZE_T, "z", [Define to printf format modifier for Py_ssize_t])],
3339 AC_MSG_RESULT(no))
3341 AC_CHECK_TYPE(socklen_t,,
3342 AC_DEFINE(socklen_t,int,
3343 Define to `int' if <sys/socket.h> does not define.),[
3344 #ifdef HAVE_SYS_TYPES_H
3345 #include <sys/types.h>
3346 #endif
3347 #ifdef HAVE_SYS_SOCKET_H
3348 #include <sys/socket.h>
3349 #endif
3350 ])
3352 AC_SUBST(THREADHEADERS)
3354 for h in `(cd $srcdir;echo Python/thread_*.h)`
3355 do
3356 THREADHEADERS="$THREADHEADERS \$(srcdir)/$h"
3357 done
3359 AC_SUBST(SRCDIRS)
3360 SRCDIRS="Parser Grammar Objects Python Modules Mac"
3361 AC_MSG_CHECKING(for build directories)
3362 for dir in $SRCDIRS; do
3363 if test ! -d $dir; then
3364 mkdir $dir
3365 fi
3366 done
3367 AC_MSG_RESULT(done)
3369 # generate output files
3370 AC_CONFIG_FILES(Makefile.pre Modules/Setup.config)
3371 AC_OUTPUT
3373 echo "creating Modules/Setup"
3374 if test ! -f Modules/Setup
3375 then
3376 cp $srcdir/Modules/Setup.dist Modules/Setup
3377 fi
3379 echo "creating Modules/Setup.local"
3380 if test ! -f Modules/Setup.local
3381 then
3382 echo "# Edit this file for local setup changes" >Modules/Setup.local
3383 fi
3385 echo "creating Makefile"
3386 $SHELL $srcdir/Modules/makesetup -c $srcdir/Modules/config.c.in \
3387 -s Modules Modules/Setup.config \
3388 Modules/Setup.local Modules/Setup
3389 mv config.c Modules