| blob | 6a8bc826906c1e6e69fd33e5b8b413974c30bc4b |
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 defineing 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 curses.h dlfcn.h fcntl.h grp.h \
1070 shadow.h langinfo.h libintl.h ncurses.h poll.h pthread.h \
1071 stropts.h termios.h thread.h \
1072 unistd.h utime.h \
1073 sys/audioio.h sys/bsdtty.h sys/file.h sys/loadavg.h sys/lock.h sys/mkdev.h \
1074 sys/modem.h \
1075 sys/param.h sys/poll.h sys/select.h sys/socket.h sys/statvfs.h sys/time.h \
1076 sys/times.h sys/un.h sys/utsname.h sys/wait.h pty.h libutil.h \
1077 sys/resource.h netpacket/packet.h sysexits.h bluetooth.h \
1078 bluetooth/bluetooth.h)
1079 AC_HEADER_DIRENT
1080 AC_HEADER_MAJOR
1082 # On Solaris, term.h requires curses.h
1083 AC_CHECK_HEADERS(term.h,,,[
1084 #ifdef HAVE_CURSES_H
1085 #include <curses.h>
1086 #endif
1087 ])
1089 # On Linux, netlink.h requires asm/types.h
1090 AC_CHECK_HEADERS(linux/netlink.h,,,[
1091 #ifdef HAVE_ASM_TYPES_H
1092 #include <asm/types.h>
1093 #endif
1094 #ifdef HAVE_SYS_SOCKET_H
1095 #include <sys/socket.h>
1096 #endif
1097 ])
1099 # checks for typedefs
1100 was_it_defined=no
1101 AC_MSG_CHECKING(for clock_t in time.h)
1102 AC_EGREP_HEADER(clock_t, time.h, was_it_defined=yes, [
1103 AC_DEFINE(clock_t, long, [Define to 'long' if <time.h> doesn't define.])
1104 ])
1105 AC_MSG_RESULT($was_it_defined)
1107 # Check whether using makedev requires defining _OSF_SOURCE
1108 AC_MSG_CHECKING(for makedev)
1109 AC_TRY_LINK([#include <sys/types.h> ],
1110 [ makedev(0, 0) ],
1111 ac_cv_has_makedev=yes,
1112 ac_cv_has_makedev=no)
1113 if test "$ac_cv_has_makedev" = "no"; then
1114 # we didn't link, try if _OSF_SOURCE will allow us to link
1115 AC_TRY_LINK([
1116 #define _OSF_SOURCE 1
1117 #include <sys/types.h>
1118 ],
1119 [ makedev(0, 0) ],
1120 ac_cv_has_makedev=yes,
1121 ac_cv_has_makedev=no)
1122 if test "$ac_cv_has_makedev" = "yes"; then
1123 AC_DEFINE(_OSF_SOURCE, 1, [Define _OSF_SOURCE to get the makedev macro.])
1124 fi
1125 fi
1126 AC_MSG_RESULT($ac_cv_has_makedev)
1127 if test "$ac_cv_has_makedev" = "yes"; then
1128 AC_DEFINE(HAVE_MAKEDEV, 1, [Define this if you have the makedev macro.])
1129 fi
1131 # Enabling LFS on Solaris (2.6 to 9) with gcc 2.95 triggers a bug in
1132 # the system headers: If _XOPEN_SOURCE and _LARGEFILE_SOURCE are
1133 # defined, but the compiler does not support pragma redefine_extname,
1134 # and _LARGEFILE64_SOURCE is not defined, the headers refer to 64-bit
1135 # structures (such as rlimit64) without declaring them. As a
1136 # work-around, disable LFS on such configurations
1138 use_lfs=yes
1139 AC_MSG_CHECKING(Solaris LFS bug)
1140 AC_TRY_COMPILE([
1141 #define _LARGEFILE_SOURCE 1
1142 #define _FILE_OFFSET_BITS 64
1143 #include <sys/resource.h>
1144 ],struct rlimit foo;,sol_lfs_bug=no,sol_lfs_bug=yes)
1145 AC_MSG_RESULT($sol_lfs_bug)
1146 if test "$sol_lfs_bug" = "yes"; then
1147 use_lfs=no
1148 fi
1150 if test "$use_lfs" = "yes"; then
1151 # Two defines needed to enable largefile support on various platforms
1152 # These may affect some typedefs
1153 AC_DEFINE(_LARGEFILE_SOURCE, 1,
1154 [This must be defined on some systems to enable large file support.])
1155 AC_DEFINE(_FILE_OFFSET_BITS, 64,
1156 [This must be set to 64 on some systems to enable large file support.])
1157 fi
1159 # Add some code to confdefs.h so that the test for off_t works on SCO
1160 cat >> confdefs.h <<\EOF
1161 #if defined(SCO_DS)
1162 #undef _OFF_T
1163 #endif
1164 EOF
1166 # Type availability checks
1167 AC_TYPE_MODE_T
1168 AC_TYPE_OFF_T
1169 AC_TYPE_PID_T
1170 AC_TYPE_SIGNAL
1171 AC_TYPE_SIZE_T
1172 AC_TYPE_UID_T
1173 AC_CHECK_TYPE(ssize_t,
1174 AC_DEFINE(HAVE_SSIZE_T, 1, Define if your compiler provides ssize_t),,)
1176 # Sizes of various common basic types
1177 # ANSI C requires sizeof(char) == 1, so no need to check it
1178 AC_CHECK_SIZEOF(int, 4)
1179 AC_CHECK_SIZEOF(long, 4)
1180 AC_CHECK_SIZEOF(void *, 4)
1181 AC_CHECK_SIZEOF(short, 2)
1182 AC_CHECK_SIZEOF(float, 4)
1183 AC_CHECK_SIZEOF(double, 8)
1184 AC_CHECK_SIZEOF(fpos_t, 4)
1185 AC_CHECK_SIZEOF(size_t, 4)
1187 AC_MSG_CHECKING(for long long support)
1188 have_long_long=no
1189 AC_TRY_COMPILE([], [long long x; x = (long long)0;], [
1190 AC_DEFINE(HAVE_LONG_LONG, 1, [Define this if you have the type long long.])
1191 have_long_long=yes
1192 ])
1193 AC_MSG_RESULT($have_long_long)
1194 if test "$have_long_long" = yes ; then
1195 AC_CHECK_SIZEOF(long long, 8)
1196 fi
1198 AC_MSG_CHECKING(for uintptr_t support)
1199 have_uintptr_t=no
1200 AC_TRY_COMPILE([], [uintptr_t x; x = (uintptr_t)0;], [
1201 AC_DEFINE(HAVE_UINTPTR_T, 1, [Define this if you have the type uintptr_t.])
1202 have_uintptr_t=yes
1203 ])
1204 AC_MSG_RESULT($have_uintptr_t)
1205 if test "$have_uintptr_t" = yes ; then
1206 AC_CHECK_SIZEOF(uintptr_t, 4)
1207 fi
1209 # Hmph. AC_CHECK_SIZEOF() doesn't include <sys/types.h>.
1210 AC_MSG_CHECKING(size of off_t)
1211 AC_CACHE_VAL(ac_cv_sizeof_off_t,
1212 [AC_TRY_RUN([#include <stdio.h>
1213 #include <sys/types.h>
1214 main()
1215 {
1216 FILE *f=fopen("conftestval", "w");
1217 if (!f) exit(1);
1218 fprintf(f, "%d\n", sizeof(off_t));
1219 exit(0);
1220 }],
1221 ac_cv_sizeof_off_t=`cat conftestval`,
1222 ac_cv_sizeof_off_t=0,
1223 ac_cv_sizeof_off_t=4)
1224 ])
1225 AC_MSG_RESULT($ac_cv_sizeof_off_t)
1226 AC_DEFINE_UNQUOTED(SIZEOF_OFF_T, $ac_cv_sizeof_off_t,
1227 [The number of bytes in an off_t.])
1229 AC_MSG_CHECKING(whether to enable large file support)
1230 if test "$have_long_long" = yes -a \
1231 "$ac_cv_sizeof_off_t" -gt "$ac_cv_sizeof_long" -a \
1232 "$ac_cv_sizeof_long_long" -ge "$ac_cv_sizeof_off_t"; then
1233 AC_DEFINE(HAVE_LARGEFILE_SUPPORT, 1,
1234 [Defined to enable large file support when an off_t is bigger than a long
1235 and long long is available and at least as big as an off_t. You may need
1236 to add some flags for configuration and compilation to enable this mode.
1237 (For Solaris and Linux, the necessary defines are already defined.)])
1238 AC_MSG_RESULT(yes)
1239 else
1240 AC_MSG_RESULT(no)
1241 fi
1243 # AC_CHECK_SIZEOF() doesn't include <time.h>.
1244 AC_MSG_CHECKING(size of time_t)
1245 AC_CACHE_VAL(ac_cv_sizeof_time_t,
1246 [AC_TRY_RUN([#include <stdio.h>
1247 #include <time.h>
1248 main()
1249 {
1250 FILE *f=fopen("conftestval", "w");
1251 if (!f) exit(1);
1252 fprintf(f, "%d\n", sizeof(time_t));
1253 exit(0);
1254 }],
1255 ac_cv_sizeof_time_t=`cat conftestval`,
1256 ac_cv_sizeof_time_t=0,
1257 ac_cv_sizeof_time_t=4)
1258 ])
1259 AC_MSG_RESULT($ac_cv_sizeof_time_t)
1260 AC_DEFINE_UNQUOTED(SIZEOF_TIME_T, $ac_cv_sizeof_time_t,
1261 [The number of bytes in a time_t.])
1264 # if have pthread_t then define SIZEOF_PTHREAD_T
1265 ac_save_cc="$CC"
1266 if test "$ac_cv_kpthread" = "yes"
1267 then CC="$CC -Kpthread"
1268 elif test "$ac_cv_kthread" = "yes"
1269 then CC="$CC -Kthread"
1270 elif test "$ac_cv_pthread" = "yes"
1271 then CC="$CC -pthread"
1272 fi
1273 AC_MSG_CHECKING(for pthread_t)
1274 have_pthread_t=no
1275 AC_TRY_COMPILE([#include <pthread.h>], [pthread_t x; x = *(pthread_t*)0;], have_pthread_t=yes)
1276 AC_MSG_RESULT($have_pthread_t)
1277 if test "$have_pthread_t" = yes ; then
1278 # AC_CHECK_SIZEOF() doesn't include <pthread.h>.
1279 AC_MSG_CHECKING(size of pthread_t)
1280 AC_CACHE_VAL(ac_cv_sizeof_pthread_t,
1281 [AC_TRY_RUN([#include <stdio.h>
1282 #include <pthread.h>
1283 main()
1284 {
1285 FILE *f=fopen("conftestval", "w");
1286 if (!f) exit(1);
1287 fprintf(f, "%d\n", sizeof(pthread_t));
1288 exit(0);
1289 }],
1290 ac_cv_sizeof_pthread_t=`cat conftestval`,
1291 ac_cv_sizeof_pthread_t=0,
1292 ac_cv_sizeof_pthread_t=4)
1293 ])
1294 AC_MSG_RESULT($ac_cv_sizeof_pthread_t)
1295 AC_DEFINE_UNQUOTED(SIZEOF_PTHREAD_T, $ac_cv_sizeof_pthread_t,
1296 [The number of bytes in a pthread_t.])
1297 fi
1298 CC="$ac_save_cc"
1300 AC_MSG_CHECKING(for --enable-toolbox-glue)
1301 AC_ARG_ENABLE(toolbox-glue,
1302 AC_HELP_STRING(--enable-toolbox-glue, disable/enable MacOSX glue code for extensions))
1304 if test -z "$enable_toolbox_glue"
1305 then
1306 case $ac_sys_system/$ac_sys_release in
1307 Darwin/*)
1308 enable_toolbox_glue="yes";;
1309 *)
1310 enable_toolbox_glue="no";;
1311 esac
1312 fi
1313 case "$enable_toolbox_glue" in
1314 yes)
1315 extra_machdep_objs="Python/mactoolboxglue.o"
1316 extra_undefs="-u _PyMac_Error"
1317 AC_DEFINE(USE_TOOLBOX_OBJECT_GLUE, 1,
1318 [Define if you want to use MacPython modules on MacOSX in unix-Python.])
1319 ;;
1320 *)
1321 extra_machdep_objs=""
1322 extra_undefs=""
1323 ;;
1324 esac
1325 AC_MSG_RESULT($enable_toolbox_glue)
1327 AC_SUBST(OTHER_LIBTOOL_OPT)
1328 case $ac_sys_system/$ac_sys_release in
1329 Darwin/@<:@01567@:>@\..*)
1330 OTHER_LIBTOOL_OPT="-prebind -seg1addr 0x10000000"
1331 ;;
1332 Darwin/*)
1333 OTHER_LIBTOOL_OPT=""
1334 ;;
1335 esac
1337 AC_SUBST(LIBTOOL_CRUFT)
1338 case $ac_sys_system/$ac_sys_release in
1339 Darwin/@<:@01567@:>@\..*)
1340 LIBTOOL_CRUFT="-framework System -lcc_dynamic"
1341 if test "${enable_universalsdk}"; then
1342 :
1343 else
1344 LIBTOOL_CRUFT="${LIBTOOL_CRUFT} -arch_only `arch`"
1345 fi
1346 LIBTOOL_CRUFT=$LIBTOOL_CRUFT' -install_name $(PYTHONFRAMEWORKINSTALLDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1347 LIBTOOL_CRUFT=$LIBTOOL_CRUFT' -compatibility_version $(VERSION) -current_version $(VERSION)';;
1348 Darwin/*)
1349 gcc_version=`gcc -v 2>&1 | grep version | cut -d\ -f3`
1350 if test ${gcc_version} '<' 4.0
1351 then
1352 LIBTOOL_CRUFT="-lcc_dynamic"
1353 else
1354 LIBTOOL_CRUFT=""
1355 fi
1356 LIBTOOL_CRUFT=$LIBTOOL_CRUFT" -lSystem -lSystemStubs -arch_only `arch`"
1357 LIBTOOL_CRUFT=$LIBTOOL_CRUFT' -install_name $(PYTHONFRAMEWORKINSTALLDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1358 LIBTOOL_CRUFT=$LIBTOOL_CRUFT' -compatibility_version $(VERSION) -current_version $(VERSION)';;
1359 esac
1361 AC_MSG_CHECKING(for --enable-framework)
1362 if test "$enable_framework"
1363 then
1364 BASECFLAGS="$BASECFLAGS -fno-common -dynamic"
1365 # -F. is needed to allow linking to the framework while
1366 # in the build location.
1367 AC_DEFINE(WITH_NEXT_FRAMEWORK, 1,
1368 [Define if you want to produce an OpenStep/Rhapsody framework
1369 (shared library plus accessory files).])
1370 AC_MSG_RESULT(yes)
1371 else
1372 AC_MSG_RESULT(no)
1373 fi
1375 AC_MSG_CHECKING(for dyld)
1376 case $ac_sys_system/$ac_sys_release in
1377 Darwin/*)
1378 AC_DEFINE(WITH_DYLD, 1,
1379 [Define if you want to use the new-style (Openstep, Rhapsody, MacOS)
1380 dynamic linker (dyld) instead of the old-style (NextStep) dynamic
1381 linker (rld). Dyld is necessary to support frameworks.])
1382 AC_MSG_RESULT(always on for Darwin)
1383 ;;
1384 *)
1385 AC_MSG_RESULT(no)
1386 ;;
1387 esac
1389 # Set info about shared libraries.
1390 AC_SUBST(SO)
1391 AC_SUBST(LDSHARED)
1392 AC_SUBST(BLDSHARED)
1393 AC_SUBST(CCSHARED)
1394 AC_SUBST(LINKFORSHARED)
1395 # SO is the extension of shared libraries `(including the dot!)
1396 # -- usually .so, .sl on HP-UX, .dll on Cygwin
1397 AC_MSG_CHECKING(SO)
1398 if test -z "$SO"
1399 then
1400 case $ac_sys_system in
1401 hp*|HP*)
1402 case `uname -m` in
1403 ia64) SO=.so;;
1404 *) SO=.sl;;
1405 esac
1406 ;;
1407 CYGWIN*) SO=.dll;;
1408 *) SO=.so;;
1409 esac
1410 else
1411 # this might also be a termcap variable, see #610332
1412 echo
1413 echo '====================================================================='
1414 echo '+ +'
1415 echo '+ WARNING: You have set SO in your environment. +'
1416 echo '+ Do you really mean to change the extension for shared libraries? +'
1417 echo '+ Continuing in 10 seconds to let you to ponder. +'
1418 echo '+ +'
1419 echo '====================================================================='
1420 sleep 10
1421 fi
1422 AC_MSG_RESULT($SO)
1423 AC_DEFINE_UNQUOTED(SHLIB_EXT, "$SO", [Define this to be extension of shared libraries (including the dot!).])
1424 # LDSHARED is the ld *command* used to create shared library
1425 # -- "cc -G" on SunOS 5.x, "ld -shared" on IRIX 5
1426 # (Shared libraries in this instance are shared modules to be loaded into
1427 # Python, as opposed to building Python itself as a shared library.)
1428 AC_MSG_CHECKING(LDSHARED)
1429 if test -z "$LDSHARED"
1430 then
1431 case $ac_sys_system/$ac_sys_release in
1432 AIX*)
1433 BLDSHARED="\$(srcdir)/Modules/ld_so_aix \$(CC) -bI:Modules/python.exp"
1434 LDSHARED="\$(BINLIBDEST)/config/ld_so_aix \$(CC) -bI:\$(BINLIBDEST)/config/python.exp"
1435 ;;
1436 BeOS*)
1437 BLDSHARED="\$(srcdir)/Modules/ld_so_beos $LDLIBRARY"
1438 LDSHARED="\$(BINLIBDEST)/config/ld_so_beos \$(LIBDIR)/$LDLIBRARY"
1439 ;;
1440 IRIX/5*) LDSHARED="ld -shared";;
1441 IRIX*/6*) LDSHARED="ld ${SGI_ABI} -shared -all";;
1442 SunOS/5*)
1443 if test "$GCC" = "yes"
1444 then LDSHARED='$(CC) -shared'
1445 else LDSHARED='$(CC) -G';
1446 fi ;;
1447 hp*|HP*) LDSHARED="ld -b";;
1448 OSF*) LDSHARED="ld -shared -expect_unresolved \"*\"";;
1449 Darwin/1.3*)
1450 LDSHARED='$(CC) $(LDFLAGS) -bundle'
1451 if test "$enable_framework" ; then
1452 # Link against the framework. All externals should be defined.
1453 BLDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1454 LDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKPREFIX)/$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1455 else
1456 # No framework. Ignore undefined symbols, assuming they come from Python
1457 LDSHARED="$LDSHARED -undefined suppress"
1458 fi ;;
1459 Darwin/1.4*|Darwin/5.*|Darwin/6.*)
1460 LDSHARED='$(CC) $(LDFLAGS) -bundle'
1461 if test "$enable_framework" ; then
1462 # Link against the framework. All externals should be defined.
1463 BLDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1464 LDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKPREFIX)/$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1465 else
1466 # No framework, use the Python app as bundle-loader
1467 BLDSHARED="$LDSHARED "'-bundle_loader $(BUILDPYTHON)'
1468 LDSHARED="$LDSHARED "'-bundle_loader $(BINDIR)/python$(VERSION)$(EXE)'
1469 fi ;;
1470 Darwin/*)
1471 # Use -undefined dynamic_lookup whenever possible (10.3 and later).
1472 # This allows an extension to be used in any Python
1473 cur_target=`sw_vers -productVersion | sed 's/\(10\.[[0-9]]*\).*/\1/'`
1474 if test ${cur_target} '>' 10.2; then
1475 cur_target=10.3
1476 fi
1477 CONFIGURE_MACOSX_DEPLOYMENT_TARGET=${MACOSX_DEPLOYMENT_TARGET-${cur_target}}
1478 EXPORT_MACOSX_DEPLOYMENT_TARGET=''
1479 if test ${MACOSX_DEPLOYMENT_TARGET-${cur_target}} '>' 10.2
1480 then
1481 if test "${enable_universalsdk}"; then
1482 LDFLAGS="-arch i386 -arch ppc -isysroot ${UNIVERSALSDK} ${LDFLAGS}"
1483 fi
1484 LDSHARED='$(CC) $(LDFLAGS) -bundle -undefined dynamic_lookup'
1485 BLDSHARED="$LDSHARED"
1486 else
1487 LDSHARED='$(CC) $(LDFLAGS) -bundle'
1488 if test "$enable_framework" ; then
1489 # Link against the framework. All externals should be defined.
1490 BLDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1491 LDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKPREFIX)/$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1492 else
1493 # No framework, use the Python app as bundle-loader
1494 BLDSHARED="$LDSHARED "'-bundle_loader $(BUILDPYTHON)'
1495 LDSHARED="$LDSHARED "'-bundle_loader $(BINDIR)/python$(VERSION)$(EXE)'
1496 fi
1497 fi
1498 ;;
1499 Linux*|GNU*) LDSHARED='$(CC) -shared';;
1500 BSD/OS*/4*) LDSHARED="gcc -shared";;
1501 FreeBSD*)
1502 if [[ "`$CC -dM -E - </dev/null | grep __ELF__`" != "" ]]
1503 then
1504 LDSHARED="$CC -shared ${LDFLAGS}"
1505 else
1506 LDSHARED="ld -Bshareable ${LDFLAGS}"
1507 fi;;
1508 OpenBSD*)
1509 if [[ "`$CC -dM -E - </dev/null | grep __ELF__`" != "" ]]
1510 then
1511 LDSHARED='$(CC) -shared $(CCSHARED) ${LDFLAGS}'
1512 else
1513 case `uname -r` in
1514 [[01]].* | 2.[[0-7]] | 2.[[0-7]].*)
1515 LDSHARED="ld -Bshareable ${LDFLAGS}"
1516 ;;
1517 *)
1518 LDSHARED='$(CC) -shared $(CCSHARED) ${LDFLAGS}'
1519 ;;
1520 esac
1521 fi;;
1522 NetBSD*|DragonFly*) LDSHARED="cc -shared ${LDFLAGS}";;
1523 OpenUNIX*|UnixWare*)
1524 if test "$GCC" = "yes"
1525 then LDSHARED='$(CC) -shared'
1526 else LDSHARED='$(CC) -G'
1527 fi;;
1528 SCO_SV*) LDSHARED='$(CC) -Wl,-G,-Bexport';;
1529 Monterey*) LDSHARED="cc -G -dy -Bdynamic -Bexport -L/usr/lib/ia64l64";;
1530 CYGWIN*) LDSHARED="gcc -shared -Wl,--enable-auto-image-base";;
1531 atheos*) LDSHARED="gcc -shared";;
1532 *) LDSHARED="ld";;
1533 esac
1534 fi
1535 AC_MSG_RESULT($LDSHARED)
1536 BLDSHARED=${BLDSHARED-$LDSHARED}
1537 # CCSHARED are the C *flags* used to create objects to go into a shared
1538 # library (module) -- this is only needed for a few systems
1539 AC_MSG_CHECKING(CCSHARED)
1540 if test -z "$CCSHARED"
1541 then
1542 case $ac_sys_system/$ac_sys_release in
1543 SunOS*) if test "$GCC" = yes;
1544 then CCSHARED="-fPIC";
1545 else CCSHARED="-xcode=pic32";
1546 fi;;
1547 hp*|HP*) if test "$GCC" = yes;
1548 then CCSHARED="-fPIC";
1549 else CCSHARED="+z";
1550 fi;;
1551 Linux*|GNU*) CCSHARED="-fPIC";;
1552 BSD/OS*/4*) CCSHARED="-fpic";;
1553 FreeBSD*|NetBSD*|OpenBSD*|DragonFly*) CCSHARED="-fPIC";;
1554 OpenUNIX*|UnixWare*)
1555 if test "$GCC" = "yes"
1556 then CCSHARED="-fPIC"
1557 else CCSHARED="-KPIC"
1558 fi;;
1559 SCO_SV*)
1560 if test "$GCC" = "yes"
1561 then CCSHARED="-fPIC"
1562 else CCSHARED="-Kpic -belf"
1563 fi;;
1564 Monterey*) CCSHARED="-G";;
1565 IRIX*/6*) case $CC in
1566 *gcc*) CCSHARED="-shared";;
1567 *) CCSHARED="";;
1568 esac;;
1569 atheos*) CCSHARED="-fPIC";;
1570 esac
1571 fi
1572 AC_MSG_RESULT($CCSHARED)
1573 # LINKFORSHARED are the flags passed to the $(CC) command that links
1574 # the python executable -- this is only needed for a few systems
1575 AC_MSG_CHECKING(LINKFORSHARED)
1576 if test -z "$LINKFORSHARED"
1577 then
1578 case $ac_sys_system/$ac_sys_release in
1579 AIX*) LINKFORSHARED='-Wl,-bE:Modules/python.exp -lld';;
1580 hp*|HP*)
1581 LINKFORSHARED="-Wl,-E -Wl,+s";;
1582 # LINKFORSHARED="-Wl,-E -Wl,+s -Wl,+b\$(BINLIBDEST)/lib-dynload";;
1583 BSD/OS/4*) LINKFORSHARED="-Xlinker -export-dynamic";;
1584 Linux*|GNU*) LINKFORSHARED="-Xlinker -export-dynamic";;
1585 # -u libsys_s pulls in all symbols in libsys
1586 Darwin/*)
1587 # -u _PyMac_Error is needed to pull in the mac toolbox glue,
1588 # which is
1589 # not used by the core itself but which needs to be in the core so
1590 # that dynamically loaded extension modules have access to it.
1591 # -prebind is no longer used, because it actually seems to give a
1592 # slowdown in stead of a speedup, maybe due to the large number of
1593 # dynamic loads Python does.
1595 LINKFORSHARED="$extra_undefs"
1596 if test "$enable_framework"
1597 then
1598 LINKFORSHARED="$LINKFORSHARED "'$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1599 fi
1600 LINKFORSHARED="$LINKFORSHARED";;
1601 OpenUNIX*|UnixWare*) LINKFORSHARED="-Wl,-Bexport";;
1602 SCO_SV*) LINKFORSHARED="-Wl,-Bexport";;
1603 ReliantUNIX*) LINKFORSHARED="-W1 -Blargedynsym";;
1604 FreeBSD*|NetBSD*|OpenBSD*|DragonFly*)
1605 if [[ "`$CC -dM -E - </dev/null | grep __ELF__`" != "" ]]
1606 then
1607 LINKFORSHARED="-Wl,--export-dynamic"
1608 fi;;
1609 SunOS/5*) case $CC in
1610 *gcc*)
1611 if $CC -Xlinker --help 2>&1 | grep export-dynamic >/dev/null
1612 then
1613 LINKFORSHARED="-Xlinker --export-dynamic"
1614 fi;;
1615 esac;;
1616 CYGWIN*)
1617 if test $enable_shared = "no"
1618 then
1619 LINKFORSHARED='-Wl,--out-implib=$(LDLIBRARY)'
1620 fi;;
1621 esac
1622 fi
1623 AC_MSG_RESULT($LINKFORSHARED)
1625 AC_SUBST(CFLAGSFORSHARED)
1626 AC_MSG_CHECKING(CFLAGSFORSHARED)
1627 if test ! "$LIBRARY" = "$LDLIBRARY"
1628 then
1629 case $ac_sys_system in
1630 CYGWIN*)
1631 # Cygwin needs CCSHARED when building extension DLLs
1632 # but not when building the interpreter DLL.
1633 CFLAGSFORSHARED='';;
1634 *)
1635 CFLAGSFORSHARED='$(CCSHARED)'
1636 esac
1637 fi
1638 AC_MSG_RESULT($CFLAGSFORSHARED)
1640 # SHLIBS are libraries (except -lc and -lm) to link to the python shared
1641 # library (with --enable-shared).
1642 # For platforms on which shared libraries are not allowed to have unresolved
1643 # symbols, this must be set to $(LIBS) (expanded by make). We do this even
1644 # if it is not required, since it creates a dependency of the shared library
1645 # to LIBS. This, in turn, means that applications linking the shared libpython
1646 # don't need to link LIBS explicitly. The default should be only changed
1647 # on systems where this approach causes problems.
1648 AC_SUBST(SHLIBS)
1649 AC_MSG_CHECKING(SHLIBS)
1650 case "$ac_sys_system" in
1651 *)
1652 SHLIBS='$(LIBS)';;
1653 esac
1654 AC_MSG_RESULT($SHLIBS)
1657 # checks for libraries
1658 AC_CHECK_LIB(dl, dlopen) # Dynamic linking for SunOS/Solaris and SYSV
1659 AC_CHECK_LIB(dld, shl_load) # Dynamic linking for HP-UX
1661 # only check for sem_ini if thread support is requested
1662 if test "$with_threads" = "yes" -o -z "$with_threads"; then
1663 AC_SEARCH_LIBS(sem_init, pthread rt posix4) # 'Real Time' functions on Solaris
1664 # posix4 on Solaris 2.6
1665 # pthread (first!) on Linux
1666 fi
1668 # check if we need libintl for locale functions
1669 AC_CHECK_LIB(intl, textdomain,
1670 AC_DEFINE(WITH_LIBINTL, 1,
1671 [Define to 1 if libintl is needed for locale functions.]))
1673 # checks for system dependent C++ extensions support
1674 case "$ac_sys_system" in
1675 AIX*) AC_MSG_CHECKING(for genuine AIX C++ extensions support)
1676 AC_TRY_LINK([#include "/usr/lpp/xlC/include/load.h"],
1677 [loadAndInit("", 0, "")],
1678 [AC_DEFINE(AIX_GENUINE_CPLUSPLUS, 1,
1679 [Define for AIX if your compiler is a genuine IBM xlC/xlC_r
1680 and you want support for AIX C++ shared extension modules.])
1681 AC_MSG_RESULT(yes)],
1682 [AC_MSG_RESULT(no)]);;
1683 *) ;;
1684 esac
1686 # Most SVR4 platforms (e.g. Solaris) need -lsocket and -lnsl.
1687 # BeOS' sockets are stashed in libnet.
1688 AC_CHECK_LIB(nsl, t_open, [LIBS="-lnsl $LIBS"]) # SVR4
1689 AC_CHECK_LIB(socket, socket, [LIBS="-lsocket $LIBS"], [], $LIBS) # SVR4 sockets
1691 case "$ac_sys_system" in
1692 BeOS*)
1693 AC_CHECK_LIB(net, socket, [LIBS="-lnet $LIBS"], [], $LIBS) # BeOS
1694 ;;
1695 esac
1697 AC_MSG_CHECKING(for --with-libs)
1698 AC_ARG_WITH(libs,
1699 AC_HELP_STRING(--with-libs='lib1 ...', link against additional libs),
1700 [
1701 AC_MSG_RESULT($withval)
1702 LIBS="$withval $LIBS"
1703 ],
1704 [AC_MSG_RESULT(no)])
1706 # Check for use of the system libffi library
1707 AC_MSG_CHECKING(for --with-system-ffi)
1708 AC_ARG_WITH(system_ffi,
1709 AC_HELP_STRING(--with-system-ffi, build _ctypes module using an installed ffi library))
1711 if test -z "$with_system_ffi"
1712 then with_system_ffi="no"
1713 fi
1714 AC_MSG_RESULT($with_system_ffi)
1716 # Determine if signalmodule should be used.
1717 AC_SUBST(USE_SIGNAL_MODULE)
1718 AC_SUBST(SIGNAL_OBJS)
1719 AC_MSG_CHECKING(for --with-signal-module)
1720 AC_ARG_WITH(signal-module,
1721 AC_HELP_STRING(--with-signal-module, disable/enable signal module))
1723 if test -z "$with_signal_module"
1724 then with_signal_module="yes"
1725 fi
1726 AC_MSG_RESULT($with_signal_module)
1728 if test "${with_signal_module}" = "yes"; then
1729 USE_SIGNAL_MODULE=""
1730 SIGNAL_OBJS=""
1731 else
1732 USE_SIGNAL_MODULE="#"
1733 SIGNAL_OBJS="Parser/intrcheck.o Python/sigcheck.o"
1734 fi
1736 # This is used to generate Setup.config
1737 AC_SUBST(USE_THREAD_MODULE)
1738 USE_THREAD_MODULE=""
1740 AC_MSG_CHECKING(for --with-dec-threads)
1741 AC_SUBST(LDLAST)
1742 AC_ARG_WITH(dec-threads,
1743 AC_HELP_STRING(--with-dec-threads, use DEC Alpha/OSF1 thread-safe libraries),
1744 [
1745 AC_MSG_RESULT($withval)
1746 LDLAST=-threads
1747 if test "${with_thread+set}" != set; then
1748 with_thread="$withval";
1749 fi],
1750 [AC_MSG_RESULT(no)])
1752 # Templates for things AC_DEFINEd more than once.
1753 # For a single AC_DEFINE, no template is needed.
1754 AH_TEMPLATE(C_THREADS,[Define if you have the Mach cthreads package])
1755 AH_TEMPLATE(_REENTRANT,
1756 [Define to force use of thread-safe errno, h_errno, and other functions])
1757 AH_TEMPLATE(WITH_THREAD,
1758 [Define if you want to compile in rudimentary thread support])
1760 AC_MSG_CHECKING(for --with-threads)
1761 dnl quadrigraphs "@<:@" and "@:>@" produce "[" and "]" in the output
1762 AC_ARG_WITH(threads,
1763 AC_HELP_STRING(--with(out)-threads@<:@=DIRECTORY@:>@, disable/enable thread support))
1765 # --with-thread is deprecated, but check for it anyway
1766 dnl quadrigraphs "@<:@" and "@:>@" produce "[" and "]" in the output
1767 AC_ARG_WITH(thread,
1768 AC_HELP_STRING(--with(out)-thread@<:@=DIRECTORY@:>@, deprecated; use --with(out)-threads),
1769 [with_threads=$with_thread])
1771 if test -z "$with_threads"
1772 then with_threads="yes"
1773 fi
1774 AC_MSG_RESULT($with_threads)
1776 AC_SUBST(THREADOBJ)
1777 if test "$with_threads" = "no"
1778 then
1779 USE_THREAD_MODULE="#"
1780 elif test "$ac_cv_pthread_is_default" = yes
1781 then
1782 AC_DEFINE(WITH_THREAD)
1783 # Defining _REENTRANT on system with POSIX threads should not hurt.
1784 AC_DEFINE(_REENTRANT)
1785 posix_threads=yes
1786 THREADOBJ="Python/thread.o"
1787 elif test "$ac_cv_kpthread" = "yes"
1788 then
1789 CC="$CC -Kpthread"
1790 if test "$ac_cv_cxx_thread" = "yes"; then
1791 CXX="$CXX -Kpthread"
1792 fi
1793 AC_DEFINE(WITH_THREAD)
1794 posix_threads=yes
1795 THREADOBJ="Python/thread.o"
1796 elif test "$ac_cv_kthread" = "yes"
1797 then
1798 CC="$CC -Kthread"
1799 if test "$ac_cv_cxx_thread" = "yes"; then
1800 CXX="$CXX -Kthread"
1801 fi
1802 AC_DEFINE(WITH_THREAD)
1803 posix_threads=yes
1804 THREADOBJ="Python/thread.o"
1805 elif test "$ac_cv_pthread" = "yes"
1806 then
1807 CC="$CC -pthread"
1808 if test "$ac_cv_cxx_thread" = "yes"; then
1809 CXX="$CXX -pthread"
1810 fi
1811 AC_DEFINE(WITH_THREAD)
1812 posix_threads=yes
1813 THREADOBJ="Python/thread.o"
1814 else
1815 if test ! -z "$with_threads" -a -d "$with_threads"
1816 then LDFLAGS="$LDFLAGS -L$with_threads"
1817 fi
1818 if test ! -z "$withval" -a -d "$withval"
1819 then LDFLAGS="$LDFLAGS -L$withval"
1820 fi
1822 # According to the POSIX spec, a pthreads implementation must
1823 # define _POSIX_THREADS in unistd.h. Some apparently don't
1824 # (e.g. gnu pth with pthread emulation)
1825 AC_MSG_CHECKING(for _POSIX_THREADS in unistd.h)
1826 AC_EGREP_CPP(yes,
1827 [
1828 #include <unistd.h>
1829 #ifdef _POSIX_THREADS
1830 yes
1831 #endif
1832 ], unistd_defines_pthreads=yes, unistd_defines_pthreads=no)
1833 AC_MSG_RESULT($unistd_defines_pthreads)
1835 AC_DEFINE(_REENTRANT)
1836 AC_CHECK_HEADER(cthreads.h, [AC_DEFINE(WITH_THREAD)
1837 AC_DEFINE(C_THREADS)
1838 AC_DEFINE(HURD_C_THREADS, 1,
1839 [Define if you are using Mach cthreads directly under /include])
1840 LIBS="$LIBS -lthreads"
1841 THREADOBJ="Python/thread.o"],[
1842 AC_CHECK_HEADER(mach/cthreads.h, [AC_DEFINE(WITH_THREAD)
1843 AC_DEFINE(C_THREADS)
1844 AC_DEFINE(MACH_C_THREADS, 1,
1845 [Define if you are using Mach cthreads under mach /])
1846 THREADOBJ="Python/thread.o"],[
1847 AC_MSG_CHECKING(for --with-pth)
1848 AC_ARG_WITH([pth],
1849 AC_HELP_STRING(--with-pth, use GNU pth threading libraries),
1850 [AC_MSG_RESULT($withval)
1851 AC_DEFINE([WITH_THREAD])
1852 AC_DEFINE([HAVE_PTH], 1,
1853 [Define if you have GNU PTH threads.])
1854 LIBS="-lpth $LIBS"
1855 THREADOBJ="Python/thread.o"],
1856 [AC_MSG_RESULT(no)
1858 # Just looking for pthread_create in libpthread is not enough:
1859 # on HP/UX, pthread.h renames pthread_create to a different symbol name.
1860 # So we really have to include pthread.h, and then link.
1861 _libs=$LIBS
1862 LIBS="$LIBS -lpthread"
1863 AC_MSG_CHECKING([for pthread_create in -lpthread])
1864 AC_TRY_LINK([#include <pthread.h>
1866 void * start_routine (void *arg) { exit (0); }], [
1867 pthread_create (NULL, NULL, start_routine, NULL)], [
1868 AC_MSG_RESULT(yes)
1869 AC_DEFINE(WITH_THREAD)
1870 posix_threads=yes
1871 THREADOBJ="Python/thread.o"],[
1872 LIBS=$_libs
1873 AC_CHECK_FUNC(pthread_detach, [AC_DEFINE(WITH_THREAD)
1874 posix_threads=yes
1875 THREADOBJ="Python/thread.o"],[
1876 AC_CHECK_HEADER(atheos/threads.h, [AC_DEFINE(WITH_THREAD)
1877 AC_DEFINE(ATHEOS_THREADS, 1,
1878 [Define this if you have AtheOS threads.])
1879 THREADOBJ="Python/thread.o"],[
1880 AC_CHECK_HEADER(kernel/OS.h, [AC_DEFINE(WITH_THREAD)
1881 AC_DEFINE(BEOS_THREADS, 1,
1882 [Define this if you have BeOS threads.])
1883 THREADOBJ="Python/thread.o"],[
1884 AC_CHECK_LIB(pthreads, pthread_create, [AC_DEFINE(WITH_THREAD)
1885 posix_threads=yes
1886 LIBS="$LIBS -lpthreads"
1887 THREADOBJ="Python/thread.o"], [
1888 AC_CHECK_LIB(c_r, pthread_create, [AC_DEFINE(WITH_THREAD)
1889 posix_threads=yes
1890 LIBS="$LIBS -lc_r"
1891 THREADOBJ="Python/thread.o"], [
1892 AC_CHECK_LIB(pthread, __pthread_create_system, [AC_DEFINE(WITH_THREAD)
1893 posix_threads=yes
1894 LIBS="$LIBS -lpthread"
1895 THREADOBJ="Python/thread.o"], [
1896 AC_CHECK_LIB(cma, pthread_create, [AC_DEFINE(WITH_THREAD)
1897 posix_threads=yes
1898 LIBS="$LIBS -lcma"
1899 THREADOBJ="Python/thread.o"],[
1900 USE_THREAD_MODULE="#"])
1901 ])])])])])])])])])])
1903 AC_CHECK_LIB(mpc, usconfig, [AC_DEFINE(WITH_THREAD)
1904 LIBS="$LIBS -lmpc"
1905 THREADOBJ="Python/thread.o"
1906 USE_THREAD_MODULE=""])
1908 if test "$posix_threads" != "yes"; then
1909 AC_CHECK_LIB(thread, thr_create, [AC_DEFINE(WITH_THREAD)
1910 LIBS="$LIBS -lthread"
1911 THREADOBJ="Python/thread.o"
1912 USE_THREAD_MODULE=""])
1913 fi
1915 if test "$USE_THREAD_MODULE" != "#"
1916 then
1917 # If the above checks didn't disable threads, (at least) OSF1
1918 # needs this '-threads' argument during linking.
1919 case $ac_sys_system in
1920 OSF1) LDLAST=-threads;;
1921 esac
1922 fi
1923 fi
1925 if test "$posix_threads" = "yes"; then
1926 if test "$unistd_defines_pthreads" = "no"; then
1927 AC_DEFINE(_POSIX_THREADS, 1,
1928 [Define if you have POSIX threads,
1929 and your system does not define that.])
1930 fi
1932 # Bug 662787: Using semaphores causes unexplicable hangs on Solaris 8.
1933 case $ac_sys_system/$ac_sys_release in
1934 SunOS/5.6) AC_DEFINE(HAVE_PTHREAD_DESTRUCTOR, 1,
1935 Defined for Solaris 2.6 bug in pthread header.)
1936 ;;
1937 SunOS/5.8) AC_DEFINE(HAVE_BROKEN_POSIX_SEMAPHORES, 1,
1938 Define if the Posix semaphores do not work on your system)
1939 ;;
1940 esac
1942 AC_MSG_CHECKING(if PTHREAD_SCOPE_SYSTEM is supported)
1943 AC_CACHE_VAL(ac_cv_pthread_system_supported,
1944 [AC_TRY_RUN([#include <pthread.h>
1945 void *foo(void *parm) {
1946 return NULL;
1947 }
1948 main() {
1949 pthread_attr_t attr;
1950 pthread_t id;
1951 if (pthread_attr_init(&attr)) exit(-1);
1952 if (pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM)) exit(-1);
1953 if (pthread_create(&id, &attr, foo, NULL)) exit(-1);
1954 exit(0);
1955 }],
1956 ac_cv_pthread_system_supported=yes,
1957 ac_cv_pthread_system_supported=no,
1958 ac_cv_pthread_system_supported=no)
1959 ])
1960 AC_MSG_RESULT($ac_cv_pthread_system_supported)
1961 if test "$ac_cv_pthread_system_supported" = "yes"; then
1962 AC_DEFINE(PTHREAD_SYSTEM_SCHED_SUPPORTED, 1, [Defined if PTHREAD_SCOPE_SYSTEM supported.])
1963 fi
1964 AC_CHECK_FUNCS(pthread_sigmask,
1965 [case $ac_sys_system in
1966 CYGWIN*)
1967 AC_DEFINE(HAVE_BROKEN_PTHREAD_SIGMASK, 1,
1968 [Define if pthread_sigmask() does not work on your system.])
1969 ;;
1970 esac])
1971 fi
1974 # Check for enable-ipv6
1975 AH_TEMPLATE(ENABLE_IPV6, [Define if --enable-ipv6 is specified])
1976 AC_MSG_CHECKING([if --enable-ipv6 is specified])
1977 AC_ARG_ENABLE(ipv6,
1978 [ --enable-ipv6 Enable ipv6 (with ipv4) support
1979 --disable-ipv6 Disable ipv6 support],
1980 [ case "$enableval" in
1981 no)
1982 AC_MSG_RESULT(no)
1983 ipv6=no
1984 ;;
1985 *) AC_MSG_RESULT(yes)
1986 AC_DEFINE(ENABLE_IPV6)
1987 ipv6=yes
1988 ;;
1989 esac ],
1991 [
1992 dnl the check does not work on cross compilation case...
1993 AC_TRY_RUN([ /* AF_INET6 available check */
1994 #include <sys/types.h>
1995 #include <sys/socket.h>
1996 main()
1997 {
1998 if (socket(AF_INET6, SOCK_STREAM, 0) < 0)
1999 exit(1);
2000 else
2001 exit(0);
2002 }
2003 ],
2004 AC_MSG_RESULT(yes)
2005 ipv6=yes,
2006 AC_MSG_RESULT(no)
2007 ipv6=no,
2008 AC_MSG_RESULT(no)
2009 ipv6=no
2010 )
2012 if test "$ipv6" = "yes"; then
2013 AC_MSG_CHECKING(if RFC2553 API is available)
2014 AC_TRY_COMPILE([#include <sys/types.h>
2015 #include <netinet/in.h>],
2016 [struct sockaddr_in6 x;
2017 x.sin6_scope_id;],
2018 AC_MSG_RESULT(yes)
2019 ipv6=yes,
2020 AC_MSG_RESULT(no, IPv6 disabled)
2021 ipv6=no)
2022 fi
2024 if test "$ipv6" = "yes"; then
2025 AC_DEFINE(ENABLE_IPV6)
2026 fi
2027 ])
2029 ipv6type=unknown
2030 ipv6lib=none
2031 ipv6trylibc=no
2033 if test "$ipv6" = "yes"; then
2034 AC_MSG_CHECKING([ipv6 stack type])
2035 for i in inria kame linux-glibc linux-inet6 solaris toshiba v6d zeta;
2036 do
2037 case $i in
2038 inria)
2039 dnl http://www.kame.net/
2040 AC_EGREP_CPP(yes, [
2041 #include <netinet/in.h>
2042 #ifdef IPV6_INRIA_VERSION
2043 yes
2044 #endif],
2045 [ipv6type=$i])
2046 ;;
2047 kame)
2048 dnl http://www.kame.net/
2049 AC_EGREP_CPP(yes, [
2050 #include <netinet/in.h>
2051 #ifdef __KAME__
2052 yes
2053 #endif],
2054 [ipv6type=$i;
2055 ipv6lib=inet6
2056 ipv6libdir=/usr/local/v6/lib
2057 ipv6trylibc=yes])
2058 ;;
2059 linux-glibc)
2060 dnl http://www.v6.linux.or.jp/
2061 AC_EGREP_CPP(yes, [
2062 #include <features.h>
2063 #if defined(__GLIBC__) && ((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 1) || (__GLIBC__ > 2))
2064 yes
2065 #endif],
2066 [ipv6type=$i;
2067 ipv6trylibc=yes])
2068 ;;
2069 linux-inet6)
2070 dnl http://www.v6.linux.or.jp/
2071 if test -d /usr/inet6; then
2072 ipv6type=$i
2073 ipv6lib=inet6
2074 ipv6libdir=/usr/inet6/lib
2075 BASECFLAGS="-I/usr/inet6/include $BASECFLAGS"
2076 fi
2077 ;;
2078 solaris)
2079 if test -f /etc/netconfig; then
2080 if /usr/xpg4/bin/grep -q tcp6 /etc/netconfig; then
2081 ipv6type=$i
2082 ipv6trylibc=yes
2083 fi
2084 fi
2085 ;;
2086 toshiba)
2087 AC_EGREP_CPP(yes, [
2088 #include <sys/param.h>
2089 #ifdef _TOSHIBA_INET6
2090 yes
2091 #endif],
2092 [ipv6type=$i;
2093 ipv6lib=inet6;
2094 ipv6libdir=/usr/local/v6/lib])
2095 ;;
2096 v6d)
2097 AC_EGREP_CPP(yes, [
2098 #include </usr/local/v6/include/sys/v6config.h>
2099 #ifdef __V6D__
2100 yes
2101 #endif],
2102 [ipv6type=$i;
2103 ipv6lib=v6;
2104 ipv6libdir=/usr/local/v6/lib;
2105 BASECFLAGS="-I/usr/local/v6/include $BASECFLAGS"])
2106 ;;
2107 zeta)
2108 AC_EGREP_CPP(yes, [
2109 #include <sys/param.h>
2110 #ifdef _ZETA_MINAMI_INET6
2111 yes
2112 #endif],
2113 [ipv6type=$i;
2114 ipv6lib=inet6;
2115 ipv6libdir=/usr/local/v6/lib])
2116 ;;
2117 esac
2118 if test "$ipv6type" != "unknown"; then
2119 break
2120 fi
2121 done
2122 AC_MSG_RESULT($ipv6type)
2123 fi
2125 if test "$ipv6" = "yes" -a "$ipv6lib" != "none"; then
2126 if test -d $ipv6libdir -a -f $ipv6libdir/lib$ipv6lib.a; then
2127 LIBS="-L$ipv6libdir -l$ipv6lib $LIBS"
2128 echo "using lib$ipv6lib"
2129 else
2130 if test $ipv6trylibc = "yes"; then
2131 echo "using libc"
2132 else
2133 echo 'Fatal: no $ipv6lib library found. cannot continue.'
2134 echo "You need to fetch lib$ipv6lib.a from appropriate"
2135 echo 'ipv6 kit and compile beforehand.'
2136 exit 1
2137 fi
2138 fi
2139 fi
2141 # Check for --with-doc-strings
2142 AC_MSG_CHECKING(for --with-doc-strings)
2143 AC_ARG_WITH(doc-strings,
2144 AC_HELP_STRING(--with(out)-doc-strings, disable/enable documentation strings))
2146 if test -z "$with_doc_strings"
2147 then with_doc_strings="yes"
2148 fi
2149 if test "$with_doc_strings" != "no"
2150 then
2151 AC_DEFINE(WITH_DOC_STRINGS, 1,
2152 [Define if you want documentation strings in extension modules])
2153 fi
2154 AC_MSG_RESULT($with_doc_strings)
2156 # Check for Python-specific malloc support
2157 AC_MSG_CHECKING(for --with-tsc)
2158 AC_ARG_WITH(tsc,
2159 [ --with(out)-tsc enable/disable timestamp counter profile], [
2160 if test "$withval" != no
2161 then
2162 AC_DEFINE(WITH_TSC, 1,
2163 [Define to profile with the Pentium timestamp counter])
2164 AC_MSG_RESULT(yes)
2165 else AC_MSG_RESULT(no)
2166 fi],
2167 [AC_MSG_RESULT(no)])
2169 # Check for Python-specific malloc support
2170 AC_MSG_CHECKING(for --with-pymalloc)
2171 AC_ARG_WITH(pymalloc,
2172 AC_HELP_STRING(--with(out)-pymalloc, disable/enable specialized mallocs))
2174 if test -z "$with_pymalloc"
2175 then with_pymalloc="yes"
2176 fi
2177 if test "$with_pymalloc" != "no"
2178 then
2179 AC_DEFINE(WITH_PYMALLOC, 1,
2180 [Define if you want to compile in Python-specific mallocs])
2181 fi
2182 AC_MSG_RESULT($with_pymalloc)
2184 # Check for --with-wctype-functions
2185 AC_MSG_CHECKING(for --with-wctype-functions)
2186 AC_ARG_WITH(wctype-functions,
2187 AC_HELP_STRING(--with-wctype-functions, use wctype.h functions),
2188 [
2189 if test "$withval" != no
2190 then
2191 AC_DEFINE(WANT_WCTYPE_FUNCTIONS, 1,
2192 [Define if you want wctype.h functions to be used instead of the
2193 one supplied by Python itself. (see Include/unicodectype.h).])
2194 AC_MSG_RESULT(yes)
2195 else AC_MSG_RESULT(no)
2196 fi],
2197 [AC_MSG_RESULT(no)])
2199 # -I${DLINCLDIR} is added to the compile rule for importdl.o
2200 AC_SUBST(DLINCLDIR)
2201 DLINCLDIR=.
2203 # the dlopen() function means we might want to use dynload_shlib.o. some
2204 # platforms, such as AIX, have dlopen(), but don't want to use it.
2205 AC_CHECK_FUNCS(dlopen)
2207 # DYNLOADFILE specifies which dynload_*.o file we will use for dynamic
2208 # loading of modules.
2209 AC_SUBST(DYNLOADFILE)
2210 AC_MSG_CHECKING(DYNLOADFILE)
2211 if test -z "$DYNLOADFILE"
2212 then
2213 case $ac_sys_system/$ac_sys_release in
2214 AIX*) # Use dynload_shlib.c and dlopen() if we have it; otherwise dynload_aix.c
2215 if test "$ac_cv_func_dlopen" = yes
2216 then DYNLOADFILE="dynload_shlib.o"
2217 else DYNLOADFILE="dynload_aix.o"
2218 fi
2219 ;;
2220 BeOS*) DYNLOADFILE="dynload_beos.o";;
2221 hp*|HP*) DYNLOADFILE="dynload_hpux.o";;
2222 # Use dynload_next.c only on 10.2 and below, which don't have native dlopen()
2223 Darwin/@<:@0156@:>@\..*) DYNLOADFILE="dynload_next.o";;
2224 atheos*) DYNLOADFILE="dynload_atheos.o";;
2225 *)
2226 # use dynload_shlib.c and dlopen() if we have it; otherwise stub
2227 # out any dynamic loading
2228 if test "$ac_cv_func_dlopen" = yes
2229 then DYNLOADFILE="dynload_shlib.o"
2230 else DYNLOADFILE="dynload_stub.o"
2231 fi
2232 ;;
2233 esac
2234 fi
2235 AC_MSG_RESULT($DYNLOADFILE)
2236 if test "$DYNLOADFILE" != "dynload_stub.o"
2237 then
2238 AC_DEFINE(HAVE_DYNAMIC_LOADING, 1,
2239 [Defined when any dynamic module loading is enabled.])
2240 fi
2242 # MACHDEP_OBJS can be set to platform-specific object files needed by Python
2244 AC_SUBST(MACHDEP_OBJS)
2245 AC_MSG_CHECKING(MACHDEP_OBJS)
2246 if test -z "$MACHDEP_OBJS"
2247 then
2248 MACHDEP_OBJS=$extra_machdep_objs
2249 else
2250 MACHDEP_OBJS="$MACHDEP_OBJS $extra_machdep_objs"
2251 fi
2252 AC_MSG_RESULT(MACHDEP_OBJS)
2254 # checks for library functions
2255 AC_CHECK_FUNCS(alarm bind_textdomain_codeset chown clock confstr ctermid \
2256 execv fork fpathconf ftime ftruncate \
2257 gai_strerror getgroups getlogin getloadavg getpeername getpgid getpid \
2258 getpriority getpwent getspnam getspent getsid getwd \
2259 kill killpg lchown lstat mkfifo mknod mktime \
2260 mremap nice pathconf pause plock poll pthread_init \
2261 putenv readlink realpath \
2262 select setegid seteuid setgid \
2263 setlocale setregid setreuid setsid setpgid setpgrp setuid setvbuf snprintf \
2264 sigaction siginterrupt sigrelse strftime \
2265 sysconf tcgetpgrp tcsetpgrp tempnam timegm times tmpfile tmpnam tmpnam_r \
2266 truncate uname unsetenv utimes waitpid wait3 wait4 wcscoll _getpty)
2268 # For some functions, having a definition is not sufficient, since
2269 # we want to take their address.
2270 AC_MSG_CHECKING(for chroot)
2271 AC_TRY_COMPILE([#include <unistd.h>], void *x=chroot,
2272 AC_DEFINE(HAVE_CHROOT, 1, Define if you have the 'chroot' function.)
2273 AC_MSG_RESULT(yes),
2274 AC_MSG_RESULT(no)
2275 )
2276 AC_MSG_CHECKING(for link)
2277 AC_TRY_COMPILE([#include <unistd.h>], void *x=link,
2278 AC_DEFINE(HAVE_LINK, 1, Define if you have the 'link' function.)
2279 AC_MSG_RESULT(yes),
2280 AC_MSG_RESULT(no)
2281 )
2282 AC_MSG_CHECKING(for symlink)
2283 AC_TRY_COMPILE([#include <unistd.h>], void *x=symlink,
2284 AC_DEFINE(HAVE_SYMLINK, 1, Define if you have the 'symlink' function.)
2285 AC_MSG_RESULT(yes),
2286 AC_MSG_RESULT(no)
2287 )
2288 AC_MSG_CHECKING(for fchdir)
2289 AC_TRY_COMPILE([#include <unistd.h>], void *x=fchdir,
2290 AC_DEFINE(HAVE_FCHDIR, 1, Define if you have the 'fchdir' function.)
2291 AC_MSG_RESULT(yes),
2292 AC_MSG_RESULT(no)
2293 )
2294 AC_MSG_CHECKING(for fsync)
2295 AC_TRY_COMPILE([#include <unistd.h>], void *x=fsync,
2296 AC_DEFINE(HAVE_FSYNC, 1, Define if you have the 'fsync' function.)
2297 AC_MSG_RESULT(yes),
2298 AC_MSG_RESULT(no)
2299 )
2300 AC_MSG_CHECKING(for fdatasync)
2301 AC_TRY_COMPILE([#include <unistd.h>], void *x=fdatasync,
2302 AC_DEFINE(HAVE_FDATASYNC, 1, Define if you have the 'fdatasync' function.)
2303 AC_MSG_RESULT(yes),
2304 AC_MSG_RESULT(no)
2305 )
2307 # On some systems (eg. FreeBSD 5), we would find a definition of the
2308 # functions ctermid_r, setgroups in the library, but no prototype
2309 # (e.g. because we use _XOPEN_SOURCE). See whether we can take their
2310 # address to avoid compiler warnings and potential miscompilations
2311 # because of the missing prototypes.
2313 AC_MSG_CHECKING(for ctermid_r)
2314 AC_TRY_COMPILE([
2315 #include "confdefs.h"
2316 #include <stdio.h>
2317 ], void* p = ctermid_r,
2318 AC_DEFINE(HAVE_CTERMID_R, 1, Define if you have the 'ctermid_r' function.)
2319 AC_MSG_RESULT(yes),
2320 AC_MSG_RESULT(no)
2321 )
2323 AC_MSG_CHECKING(for flock)
2324 AC_TRY_COMPILE([
2325 #include "confdefs.h"
2326 #include <sys/file.h>
2327 ], void* p = flock,
2328 AC_DEFINE(HAVE_FLOCK, 1, Define if you have the 'flock' function.)
2329 AC_MSG_RESULT(yes),
2330 AC_MSG_RESULT(no)
2331 )
2333 AC_MSG_CHECKING(for getpagesize)
2334 AC_TRY_COMPILE([
2335 #include "confdefs.h"
2336 #include <unistd.h>
2337 ], void* p = getpagesize,
2338 AC_DEFINE(HAVE_GETPAGESIZE, 1, Define if you have the 'getpagesize' function.)
2339 AC_MSG_RESULT(yes),
2340 AC_MSG_RESULT(no)
2341 )
2343 dnl check for true
2344 AC_CHECK_PROGS(TRUE, true, /bin/true)
2346 dnl On some systems (e.g. Solaris 9), hstrerror and inet_aton are in -lresolv
2347 dnl On others, they are in the C library, so we to take no action
2348 AC_CHECK_LIB(c, inet_aton, [$ac_cv_prog_TRUE],
2349 AC_CHECK_LIB(resolv, inet_aton)
2350 )
2352 AC_MSG_CHECKING(for hstrerror)
2353 AC_TRY_LINK([
2354 #include "confdefs.h"
2355 #include <netdb.h>
2356 ], void* p = hstrerror; hstrerror(0),
2357 AC_DEFINE(HAVE_HSTRERROR, 1, Define if you have the 'hstrerror' function.)
2358 AC_MSG_RESULT(yes),
2359 AC_MSG_RESULT(no)
2360 )
2362 AC_MSG_CHECKING(for inet_aton)
2363 AC_TRY_LINK([
2364 #include "confdefs.h"
2365 #include <sys/types.h>
2366 #include <sys/socket.h>
2367 #include <netinet/in.h>
2368 #include <arpa/inet.h>
2369 ], void* p = inet_aton;inet_aton(0,0),
2370 AC_DEFINE(HAVE_INET_ATON, 1, Define if you have the 'inet_aton' function.)
2371 AC_MSG_RESULT(yes),
2372 AC_MSG_RESULT(no)
2373 )
2375 AC_MSG_CHECKING(for inet_pton)
2376 AC_TRY_COMPILE([
2377 #include "confdefs.h"
2378 #include <sys/types.h>
2379 #include <sys/socket.h>
2380 #include <netinet/in.h>
2381 #include <arpa/inet.h>
2382 ], void* p = inet_pton,
2383 AC_DEFINE(HAVE_INET_PTON, 1, Define if you have the 'inet_pton' function.)
2384 AC_MSG_RESULT(yes),
2385 AC_MSG_RESULT(no)
2386 )
2388 # On some systems, setgroups is in unistd.h, on others, in grp.h
2389 AC_MSG_CHECKING(for setgroups)
2390 AC_TRY_COMPILE([
2391 #include "confdefs.h"
2392 #include <unistd.h>
2393 #ifdef HAVE_GRP_H
2394 #include <grp.h>
2395 #endif
2396 ],
2397 void* p = setgroups,
2398 AC_DEFINE(HAVE_SETGROUPS, 1, Define if you have the 'setgroups' function.)
2399 AC_MSG_RESULT(yes),
2400 AC_MSG_RESULT(no)
2401 )
2403 # check for openpty and forkpty
2405 AC_CHECK_FUNCS(openpty,,
2406 AC_CHECK_LIB(util,openpty,
2407 [AC_DEFINE(HAVE_OPENPTY) LIBS="$LIBS -lutil"],
2408 AC_CHECK_LIB(bsd,openpty, [AC_DEFINE(HAVE_OPENPTY) LIBS="$LIBS -lbsd"])
2409 )
2410 )
2411 AC_CHECK_FUNCS(forkpty,,
2412 AC_CHECK_LIB(util,forkpty,
2413 [AC_DEFINE(HAVE_FORKPTY) LIBS="$LIBS -lutil"],
2414 AC_CHECK_LIB(bsd,forkpty, [AC_DEFINE(HAVE_FORKPTY) LIBS="$LIBS -lbsd"])
2415 )
2416 )
2418 # check for long file support functions
2419 AC_CHECK_FUNCS(fseek64 fseeko fstatvfs ftell64 ftello statvfs)
2421 AC_REPLACE_FUNCS(dup2 getcwd strdup strerror memmove)
2422 AC_CHECK_FUNCS(getpgrp,
2423 AC_TRY_COMPILE([#include <unistd.h>],
2424 [getpgrp(0);],
2425 AC_DEFINE(GETPGRP_HAVE_ARG, 1,
2426 [Define if getpgrp() must be called as getpgrp(0).])
2427 )
2428 )
2429 AC_CHECK_FUNCS(setpgrp,
2430 AC_TRY_COMPILE([#include <unistd.h>],
2431 [setpgrp(0,0);],
2432 AC_DEFINE(SETPGRP_HAVE_ARG, 1,
2433 [Define if setpgrp() must be called as setpgrp(0, 0).])
2434 )
2435 )
2436 AC_CHECK_FUNCS(gettimeofday,
2437 AC_TRY_COMPILE([#include <sys/time.h>],
2438 [gettimeofday((struct timeval*)0,(struct timezone*)0);], ,
2439 AC_DEFINE(GETTIMEOFDAY_NO_TZ, 1,
2440 [Define if gettimeofday() does not have second (timezone) argument
2441 This is the case on Motorola V4 (R40V4.2)])
2442 )
2443 )
2445 AC_MSG_CHECKING(for major, minor, and makedev)
2446 AC_TRY_LINK([
2447 #if defined(MAJOR_IN_MKDEV)
2448 #include <sys/mkdev.h>
2449 #elif defined(MAJOR_IN_SYSMACROS)
2450 #include <sys/sysmacros.h>
2451 #else
2452 #include <sys/types.h>
2453 #endif
2454 ],[
2455 makedev(major(0),minor(0));
2456 ],[
2457 AC_DEFINE(HAVE_DEVICE_MACROS, 1,
2458 [Define to 1 if you have the device macros.])
2459 AC_MSG_RESULT(yes)
2460 ],[
2461 AC_MSG_RESULT(no)
2462 ])
2464 # On OSF/1 V5.1, getaddrinfo is available, but a define
2465 # for [no]getaddrinfo in netdb.h.
2466 AC_MSG_CHECKING(for getaddrinfo)
2467 AC_TRY_LINK([
2468 #include <sys/types.h>
2469 #include <sys/socket.h>
2470 #include <netdb.h>
2471 #include <stdio.h>
2472 ],[
2473 getaddrinfo(NULL, NULL, NULL, NULL);
2474 ], [
2475 AC_MSG_RESULT(yes)
2476 AC_MSG_CHECKING(getaddrinfo bug)
2477 AC_TRY_RUN([
2478 #include <sys/types.h>
2479 #include <netdb.h>
2480 #include <string.h>
2481 #include <sys/socket.h>
2482 #include <netinet/in.h>
2484 main()
2485 {
2486 int passive, gaierr, inet4 = 0, inet6 = 0;
2487 struct addrinfo hints, *ai, *aitop;
2488 char straddr[INET6_ADDRSTRLEN], strport[16];
2490 for (passive = 0; passive <= 1; passive++) {
2491 memset(&hints, 0, sizeof(hints));
2492 hints.ai_family = AF_UNSPEC;
2493 hints.ai_flags = passive ? AI_PASSIVE : 0;
2494 hints.ai_socktype = SOCK_STREAM;
2495 hints.ai_protocol = IPPROTO_TCP;
2496 if ((gaierr = getaddrinfo(NULL, "54321", &hints, &aitop)) != 0) {
2497 (void)gai_strerror(gaierr);
2498 goto bad;
2499 }
2500 for (ai = aitop; ai; ai = ai->ai_next) {
2501 if (ai->ai_addr == NULL ||
2502 ai->ai_addrlen == 0 ||
2503 getnameinfo(ai->ai_addr, ai->ai_addrlen,
2504 straddr, sizeof(straddr), strport, sizeof(strport),
2505 NI_NUMERICHOST|NI_NUMERICSERV) != 0) {
2506 goto bad;
2507 }
2508 switch (ai->ai_family) {
2509 case AF_INET:
2510 if (strcmp(strport, "54321") != 0) {
2511 goto bad;
2512 }
2513 if (passive) {
2514 if (strcmp(straddr, "0.0.0.0") != 0) {
2515 goto bad;
2516 }
2517 } else {
2518 if (strcmp(straddr, "127.0.0.1") != 0) {
2519 goto bad;
2520 }
2521 }
2522 inet4++;
2523 break;
2524 case AF_INET6:
2525 if (strcmp(strport, "54321") != 0) {
2526 goto bad;
2527 }
2528 if (passive) {
2529 if (strcmp(straddr, "::") != 0) {
2530 goto bad;
2531 }
2532 } else {
2533 if (strcmp(straddr, "::1") != 0) {
2534 goto bad;
2535 }
2536 }
2537 inet6++;
2538 break;
2539 case AF_UNSPEC:
2540 goto bad;
2541 break;
2542 default:
2543 /* another family support? */
2544 break;
2545 }
2546 }
2547 }
2549 if (!(inet4 == 0 || inet4 == 2))
2550 goto bad;
2551 if (!(inet6 == 0 || inet6 == 2))
2552 goto bad;
2554 if (aitop)
2555 freeaddrinfo(aitop);
2556 exit(0);
2558 bad:
2559 if (aitop)
2560 freeaddrinfo(aitop);
2561 exit(1);
2562 }
2563 ],
2564 AC_MSG_RESULT(good)
2565 buggygetaddrinfo=no,
2566 AC_MSG_RESULT(buggy)
2567 buggygetaddrinfo=yes,
2568 AC_MSG_RESULT(buggy)
2569 buggygetaddrinfo=yes)], [
2570 AC_MSG_RESULT(no)
2571 buggygetaddrinfo=yes
2572 ])
2574 if test "$buggygetaddrinfo" = "yes"; then
2575 if test "$ipv6" = "yes"; then
2576 echo 'Fatal: You must get working getaddrinfo() function.'
2577 echo ' or you can specify "--disable-ipv6"'.
2578 exit 1
2579 fi
2580 else
2581 AC_DEFINE(HAVE_GETADDRINFO, 1, [Define if you have the getaddrinfo function.])
2582 fi
2583 AC_CHECK_FUNCS(getnameinfo)
2585 # checks for structures
2586 AC_HEADER_TIME
2587 AC_STRUCT_TM
2588 AC_STRUCT_TIMEZONE
2589 AC_CHECK_MEMBERS([struct stat.st_rdev])
2590 AC_CHECK_MEMBERS([struct stat.st_blksize])
2591 AC_CHECK_MEMBERS([struct stat.st_flags])
2592 AC_CHECK_MEMBERS([struct stat.st_gen])
2593 AC_CHECK_MEMBERS([struct stat.st_birthtime])
2594 AC_STRUCT_ST_BLOCKS
2596 AC_MSG_CHECKING(for time.h that defines altzone)
2597 AC_CACHE_VAL(ac_cv_header_time_altzone,
2598 [AC_TRY_COMPILE([#include <time.h>], [return altzone;],
2599 ac_cv_header_time_altzone=yes,
2600 ac_cv_header_time_altzone=no)])
2601 AC_MSG_RESULT($ac_cv_header_time_altzone)
2602 if test $ac_cv_header_time_altzone = yes; then
2603 AC_DEFINE(HAVE_ALTZONE, 1, [Define this if your time.h defines altzone.])
2604 fi
2606 was_it_defined=no
2607 AC_MSG_CHECKING(whether sys/select.h and sys/time.h may both be included)
2608 AC_TRY_COMPILE([
2609 #include <sys/types.h>
2610 #include <sys/select.h>
2611 #include <sys/time.h>
2612 ], [;], [
2613 AC_DEFINE(SYS_SELECT_WITH_SYS_TIME, 1,
2614 [Define if you can safely include both <sys/select.h> and <sys/time.h>
2615 (which you can't on SCO ODT 3.0).])
2616 was_it_defined=yes
2617 ])
2618 AC_MSG_RESULT($was_it_defined)
2620 AC_MSG_CHECKING(for addrinfo)
2621 AC_CACHE_VAL(ac_cv_struct_addrinfo,
2622 AC_TRY_COMPILE([
2623 # include <netdb.h>],
2624 [struct addrinfo a],
2625 ac_cv_struct_addrinfo=yes,
2626 ac_cv_struct_addrinfo=no))
2627 AC_MSG_RESULT($ac_cv_struct_addrinfo)
2628 if test $ac_cv_struct_addrinfo = yes; then
2629 AC_DEFINE(HAVE_ADDRINFO, 1, [struct addrinfo (netdb.h)])
2630 fi
2632 AC_MSG_CHECKING(for sockaddr_storage)
2633 AC_CACHE_VAL(ac_cv_struct_sockaddr_storage,
2634 AC_TRY_COMPILE([
2635 # include <sys/types.h>
2636 # include <sys/socket.h>],
2637 [struct sockaddr_storage s],
2638 ac_cv_struct_sockaddr_storage=yes,
2639 ac_cv_struct_sockaddr_storage=no))
2640 AC_MSG_RESULT($ac_cv_struct_sockaddr_storage)
2641 if test $ac_cv_struct_sockaddr_storage = yes; then
2642 AC_DEFINE(HAVE_SOCKADDR_STORAGE, 1, [struct sockaddr_storage (sys/socket.h)])
2643 fi
2645 # checks for compiler characteristics
2647 AC_C_CHAR_UNSIGNED
2648 AC_C_CONST
2650 works=no
2651 AC_MSG_CHECKING(for working volatile)
2652 AC_TRY_COMPILE([],[volatile int x; x = 0;], works=yes,
2653 AC_DEFINE(volatile, [], [Define to empty if the keyword does not work.])
2654 )
2655 AC_MSG_RESULT($works)
2657 works=no
2658 AC_MSG_CHECKING(for working signed char)
2659 AC_TRY_COMPILE([], [signed char c;], works=yes,
2660 AC_DEFINE(signed, [], [Define to empty if the keyword does not work.])
2661 )
2662 AC_MSG_RESULT($works)
2664 have_prototypes=no
2665 AC_MSG_CHECKING(for prototypes)
2666 AC_TRY_COMPILE([int foo(int x) { return 0; }], [return foo(10);],[
2667 AC_DEFINE(HAVE_PROTOTYPES, 1,
2668 [Define if your compiler supports function prototype])
2669 have_prototypes=yes
2670 ])
2671 AC_MSG_RESULT($have_prototypes)
2673 works=no
2674 AC_MSG_CHECKING(for variable length prototypes and stdarg.h)
2675 AC_TRY_COMPILE([
2676 #include <stdarg.h>
2677 int foo(int x, ...) {
2678 va_list va;
2679 va_start(va, x);
2680 va_arg(va, int);
2681 va_arg(va, char *);
2682 va_arg(va, double);
2683 return 0;
2684 }
2685 ], [return foo(10, "", 3.14);], [
2686 AC_DEFINE(HAVE_STDARG_PROTOTYPES, 1,
2687 [Define if your compiler supports variable length function prototypes
2688 (e.g. void fprintf(FILE *, char *, ...);) *and* <stdarg.h>])
2689 works=yes
2690 ])
2691 AC_MSG_RESULT($works)
2693 # check for socketpair
2694 AC_MSG_CHECKING(for socketpair)
2695 AC_TRY_COMPILE([
2696 #include <sys/types.h>
2697 #include <sys/socket.h>
2698 ], void *x=socketpair,
2699 AC_DEFINE(HAVE_SOCKETPAIR, 1, Define if you have the 'socketpair' function.)
2700 AC_MSG_RESULT(yes),
2701 AC_MSG_RESULT(no)
2702 )
2704 # check if sockaddr has sa_len member
2705 AC_MSG_CHECKING(if sockaddr has sa_len member)
2706 AC_TRY_COMPILE([#include <sys/types.h>
2707 #include <sys/socket.h>],
2708 [struct sockaddr x;
2709 x.sa_len = 0;],
2710 AC_MSG_RESULT(yes)
2711 AC_DEFINE(HAVE_SOCKADDR_SA_LEN, 1, [Define if sockaddr has sa_len member]),
2712 AC_MSG_RESULT(no))
2714 va_list_is_array=no
2715 AC_MSG_CHECKING(whether va_list is an array)
2716 AC_TRY_COMPILE([
2717 #ifdef HAVE_STDARG_PROTOTYPES
2718 #include <stdarg.h>
2719 #else
2720 #include <varargs.h>
2721 #endif
2722 ], [va_list list1, list2; list1 = list2;], , [
2723 AC_DEFINE(VA_LIST_IS_ARRAY, 1, [Define if a va_list is an array of some kind])
2724 va_list_is_array=yes
2725 ])
2726 AC_MSG_RESULT($va_list_is_array)
2728 # sigh -- gethostbyname_r is a mess; it can have 3, 5 or 6 arguments :-(
2729 AH_TEMPLATE(HAVE_GETHOSTBYNAME_R,
2730 [Define this if you have some version of gethostbyname_r()])
2732 AC_CHECK_FUNC(gethostbyname_r, [
2733 AC_DEFINE(HAVE_GETHOSTBYNAME_R)
2734 AC_MSG_CHECKING([gethostbyname_r with 6 args])
2735 OLD_CFLAGS=$CFLAGS
2736 CFLAGS="$CFLAGS $MY_CPPFLAGS $MY_THREAD_CPPFLAGS $MY_CFLAGS"
2737 AC_TRY_COMPILE([
2738 # include <netdb.h>
2739 ], [
2740 char *name;
2741 struct hostent *he, *res;
2742 char buffer[2048];
2743 int buflen = 2048;
2744 int h_errnop;
2746 (void) gethostbyname_r(name, he, buffer, buflen, &res, &h_errnop)
2747 ], [
2748 AC_DEFINE(HAVE_GETHOSTBYNAME_R)
2749 AC_DEFINE(HAVE_GETHOSTBYNAME_R_6_ARG, 1,
2750 [Define this if you have the 6-arg version of gethostbyname_r().])
2751 AC_MSG_RESULT(yes)
2752 ], [
2753 AC_MSG_RESULT(no)
2754 AC_MSG_CHECKING([gethostbyname_r with 5 args])
2755 AC_TRY_COMPILE([
2756 # include <netdb.h>
2757 ], [
2758 char *name;
2759 struct hostent *he;
2760 char buffer[2048];
2761 int buflen = 2048;
2762 int h_errnop;
2764 (void) gethostbyname_r(name, he, buffer, buflen, &h_errnop)
2765 ], [
2766 AC_DEFINE(HAVE_GETHOSTBYNAME_R)
2767 AC_DEFINE(HAVE_GETHOSTBYNAME_R_5_ARG, 1,
2768 [Define this if you have the 5-arg version of gethostbyname_r().])
2769 AC_MSG_RESULT(yes)
2770 ], [
2771 AC_MSG_RESULT(no)
2772 AC_MSG_CHECKING([gethostbyname_r with 3 args])
2773 AC_TRY_COMPILE([
2774 # include <netdb.h>
2775 ], [
2776 char *name;
2777 struct hostent *he;
2778 struct hostent_data data;
2780 (void) gethostbyname_r(name, he, &data);
2781 ], [
2782 AC_DEFINE(HAVE_GETHOSTBYNAME_R)
2783 AC_DEFINE(HAVE_GETHOSTBYNAME_R_3_ARG, 1,
2784 [Define this if you have the 3-arg version of gethostbyname_r().])
2785 AC_MSG_RESULT(yes)
2786 ], [
2787 AC_MSG_RESULT(no)
2788 ])
2789 ])
2790 ])
2791 CFLAGS=$OLD_CFLAGS
2792 ], [
2793 AC_CHECK_FUNCS(gethostbyname)
2794 ])
2795 AC_SUBST(HAVE_GETHOSTBYNAME_R_6_ARG)
2796 AC_SUBST(HAVE_GETHOSTBYNAME_R_5_ARG)
2797 AC_SUBST(HAVE_GETHOSTBYNAME_R_3_ARG)
2798 AC_SUBST(HAVE_GETHOSTBYNAME_R)
2799 AC_SUBST(HAVE_GETHOSTBYNAME)
2801 # checks for system services
2802 # (none yet)
2804 # Linux requires this for correct f.p. operations
2805 AC_CHECK_FUNC(__fpu_control,
2806 [],
2807 [AC_CHECK_LIB(ieee, __fpu_control)
2808 ])
2810 # Check for --with-fpectl
2811 AC_MSG_CHECKING(for --with-fpectl)
2812 AC_ARG_WITH(fpectl,
2813 AC_HELP_STRING(--with-fpectl, enable SIGFPE catching),
2814 [
2815 if test "$withval" != no
2816 then
2817 AC_DEFINE(WANT_SIGFPE_HANDLER, 1,
2818 [Define if you want SIGFPE handled (see Include/pyfpe.h).])
2819 AC_MSG_RESULT(yes)
2820 else AC_MSG_RESULT(no)
2821 fi],
2822 [AC_MSG_RESULT(no)])
2824 # check for --with-libm=...
2825 AC_SUBST(LIBM)
2826 case $ac_sys_system in
2827 Darwin) ;;
2828 BeOS) ;;
2829 *) LIBM=-lm
2830 esac
2831 AC_MSG_CHECKING(for --with-libm=STRING)
2832 AC_ARG_WITH(libm,
2833 AC_HELP_STRING(--with-libm=STRING, math library),
2834 [
2835 if test "$withval" = no
2836 then LIBM=
2837 AC_MSG_RESULT(force LIBM empty)
2838 elif test "$withval" != yes
2839 then LIBM=$withval
2840 AC_MSG_RESULT(set LIBM="$withval")
2841 else AC_MSG_ERROR([proper usage is --with-libm=STRING])
2842 fi],
2843 [AC_MSG_RESULT(default LIBM="$LIBM")])
2845 # check for --with-libc=...
2846 AC_SUBST(LIBC)
2847 AC_MSG_CHECKING(for --with-libc=STRING)
2848 AC_ARG_WITH(libc,
2849 AC_HELP_STRING(--with-libc=STRING, C library),
2850 [
2851 if test "$withval" = no
2852 then LIBC=
2853 AC_MSG_RESULT(force LIBC empty)
2854 elif test "$withval" != yes
2855 then LIBC=$withval
2856 AC_MSG_RESULT(set LIBC="$withval")
2857 else AC_MSG_ERROR([proper usage is --with-libc=STRING])
2858 fi],
2859 [AC_MSG_RESULT(default LIBC="$LIBC")])
2861 # check for hypot() in math library
2862 LIBS_SAVE=$LIBS
2863 LIBS="$LIBS $LIBM"
2864 AC_REPLACE_FUNCS(hypot)
2865 LIBS=$LIBS_SAVE
2867 # check for wchar.h
2868 AC_CHECK_HEADER(wchar.h, [
2869 AC_DEFINE(HAVE_WCHAR_H, 1,
2870 [Define if the compiler provides a wchar.h header file.])
2871 wchar_h="yes"
2872 ],
2873 wchar_h="no"
2874 )
2876 # determine wchar_t size
2877 if test "$wchar_h" = yes
2878 then
2879 AC_CHECK_SIZEOF(wchar_t, 4, [#include <wchar.h>])
2880 fi
2882 AC_MSG_CHECKING(for UCS-4 tcl)
2883 have_ucs4_tcl=no
2884 AC_TRY_COMPILE([
2885 #include <tcl.h>
2886 #if TCL_UTF_MAX != 6
2887 # error "NOT UCS4_TCL"
2888 #endif], [], [
2889 AC_DEFINE(HAVE_UCS4_TCL, 1, [Define this if you have tcl and TCL_UTF_MAX==6])
2890 have_ucs4_tcl=yes
2891 ])
2892 AC_MSG_RESULT($have_ucs4_tcl)
2894 # check whether wchar_t is signed or not
2895 if test "$wchar_h" = yes
2896 then
2897 # check whether wchar_t is signed or not
2898 AC_MSG_CHECKING(whether wchar_t is signed)
2899 AC_CACHE_VAL(ac_cv_wchar_t_signed, [
2900 AC_TRY_RUN([
2901 #include <wchar.h>
2902 int main()
2903 {
2904 /* Success: exit code 0 */
2905 exit((((wchar_t) -1) < ((wchar_t) 0)) ? 0 : 1);
2906 }
2907 ],
2908 ac_cv_wchar_t_signed=yes,
2909 ac_cv_wchar_t_signed=no,
2910 ac_cv_wchar_t_signed=yes)])
2911 AC_MSG_RESULT($ac_cv_wchar_t_signed)
2912 fi
2914 AC_MSG_CHECKING(what type to use for unicode)
2915 dnl quadrigraphs "@<:@" and "@:>@" produce "[" and "]" in the output
2916 AC_ARG_ENABLE(unicode,
2917 AC_HELP_STRING(--enable-unicode@<:@=ucs@<:@24@:>@@:>@, Enable Unicode strings (default is yes)),
2918 [],
2919 [enable_unicode=yes])
2921 if test $enable_unicode = yes
2922 then
2923 # Without any arguments, Py_UNICODE defaults to two-byte mode
2924 case "$have_ucs4_tcl" in
2925 yes) enable_unicode="ucs4"
2926 ;;
2927 *) enable_unicode="ucs2"
2928 ;;
2929 esac
2930 fi
2932 AH_TEMPLATE(Py_UNICODE_SIZE,
2933 [Define as the size of the unicode type.])
2934 case "$enable_unicode" in
2935 ucs2) unicode_size="2"
2936 AC_DEFINE(Py_UNICODE_SIZE,2)
2937 ;;
2938 ucs4) unicode_size="4"
2939 AC_DEFINE(Py_UNICODE_SIZE,4)
2940 ;;
2941 esac
2943 AH_TEMPLATE(PY_UNICODE_TYPE,
2944 [Define as the integral type used for Unicode representation.])
2946 AC_SUBST(UNICODE_OBJS)
2947 if test "$enable_unicode" = "no"
2948 then
2949 UNICODE_OBJS=""
2950 AC_MSG_RESULT(not used)
2951 else
2952 UNICODE_OBJS="Objects/unicodeobject.o Objects/unicodectype.o"
2953 AC_DEFINE(Py_USING_UNICODE, 1,
2954 [Define if you want to have a Unicode type.])
2956 # wchar_t is only usable if it maps to an unsigned type
2957 if test "$unicode_size" = "$ac_cv_sizeof_wchar_t" \
2958 -a "$ac_cv_wchar_t_signed" = "no"
2959 then
2960 PY_UNICODE_TYPE="wchar_t"
2961 AC_DEFINE(HAVE_USABLE_WCHAR_T, 1,
2962 [Define if you have a useable wchar_t type defined in wchar.h; useable
2963 means wchar_t must be an unsigned type with at least 16 bits. (see
2964 Include/unicodeobject.h).])
2965 AC_DEFINE(PY_UNICODE_TYPE,wchar_t)
2966 elif test "$ac_cv_sizeof_short" = "$unicode_size"
2967 then
2968 PY_UNICODE_TYPE="unsigned short"
2969 AC_DEFINE(PY_UNICODE_TYPE,unsigned short)
2970 elif test "$ac_cv_sizeof_long" = "$unicode_size"
2971 then
2972 PY_UNICODE_TYPE="unsigned long"
2973 AC_DEFINE(PY_UNICODE_TYPE,unsigned long)
2974 else
2975 PY_UNICODE_TYPE="no type found"
2976 fi
2977 AC_MSG_RESULT($PY_UNICODE_TYPE)
2978 fi
2980 # check for endianness
2981 AC_C_BIGENDIAN
2982 AH_VERBATIM([WORDS_BIGENDIAN],
2983 [
2984 /* Define to 1 if your processor stores words with the most significant byte
2985 first (like Motorola and SPARC, unlike Intel and VAX).
2987 The block below does compile-time checking for endianness on platforms
2988 that use GCC and therefore allows compiling fat binaries on OSX by using
2989 '-arch ppc -arch i386' as the compile flags. The phrasing was choosen
2990 such that the configure-result is used on systems that don't use GCC.
2991 */
2992 #ifdef __BIG_ENDIAN__
2993 #define WORDS_BIGENDIAN 1
2994 #else
2995 #ifndef __LITTLE_ENDIAN__
2996 #undef WORDS_BIGENDIAN
2997 #endif
2998 #endif])
3000 # Check whether right shifting a negative integer extends the sign bit
3001 # or fills with zeros (like the Cray J90, according to Tim Peters).
3002 AC_MSG_CHECKING(whether right shift extends the sign bit)
3003 AC_CACHE_VAL(ac_cv_rshift_extends_sign, [
3004 AC_TRY_RUN([
3005 int main()
3006 {
3007 exit(((-1)>>3 == -1) ? 0 : 1);
3008 }
3009 ],
3010 ac_cv_rshift_extends_sign=yes,
3011 ac_cv_rshift_extends_sign=no,
3012 ac_cv_rshift_extends_sign=yes)])
3013 AC_MSG_RESULT($ac_cv_rshift_extends_sign)
3014 if test "$ac_cv_rshift_extends_sign" = no
3015 then
3016 AC_DEFINE(SIGNED_RIGHT_SHIFT_ZERO_FILLS, 1,
3017 [Define if i>>j for signed int i does not extend the sign bit
3018 when i < 0])
3019 fi
3021 # check for getc_unlocked and related locking functions
3022 AC_MSG_CHECKING(for getc_unlocked() and friends)
3023 AC_CACHE_VAL(ac_cv_have_getc_unlocked, [
3024 AC_TRY_LINK([#include <stdio.h>],[
3025 FILE *f = fopen("/dev/null", "r");
3026 flockfile(f);
3027 getc_unlocked(f);
3028 funlockfile(f);
3029 ], ac_cv_have_getc_unlocked=yes, ac_cv_have_getc_unlocked=no)])
3030 AC_MSG_RESULT($ac_cv_have_getc_unlocked)
3031 if test "$ac_cv_have_getc_unlocked" = yes
3032 then
3033 AC_DEFINE(HAVE_GETC_UNLOCKED, 1,
3034 [Define this if you have flockfile(), getc_unlocked(), and funlockfile()])
3035 fi
3037 # check where readline lives
3038 # save the value of LIBS so we don't actually link Python with readline
3039 LIBS_no_readline=$LIBS
3040 AC_CHECK_LIB(readline, readline)
3041 if test "$ac_cv_have_readline_readline" = no
3042 then
3043 AC_CHECK_LIB(termcap, readline)
3044 fi
3046 # check for readline 2.1
3047 AC_CHECK_LIB(readline, rl_callback_handler_install,
3048 AC_DEFINE(HAVE_RL_CALLBACK, 1,
3049 [Define if you have readline 2.1]), , )
3051 # check for readline 2.2
3052 AC_TRY_CPP([#include <readline/readline.h>],
3053 have_readline=yes, have_readline=no)
3054 if test $have_readline = yes
3055 then
3056 AC_EGREP_HEADER([extern int rl_completion_append_character;],
3057 [readline/readline.h],
3058 AC_DEFINE(HAVE_RL_COMPLETION_APPEND_CHARACTER, 1,
3059 [Define if you have readline 2.2]), )
3060 fi
3062 # check for readline 4.0
3063 AC_CHECK_LIB(readline, rl_pre_input_hook,
3064 AC_DEFINE(HAVE_RL_PRE_INPUT_HOOK, 1,
3065 [Define if you have readline 4.0]), , )
3067 # check for readline 4.2
3068 AC_CHECK_LIB(readline, rl_completion_matches,
3069 AC_DEFINE(HAVE_RL_COMPLETION_MATCHES, 1,
3070 [Define if you have readline 4.2]), , )
3072 # also in readline 4.2
3073 AC_TRY_CPP([#include <readline/readline.h>],
3074 have_readline=yes, have_readline=no)
3075 if test $have_readline = yes
3076 then
3077 AC_EGREP_HEADER([extern int rl_catch_signals;],
3078 [readline/readline.h],
3079 AC_DEFINE(HAVE_RL_CATCH_SIGNAL, 1,
3080 [Define if you can turn off readline's signal handling.]), )
3081 fi
3083 # End of readline checks: restore LIBS
3084 LIBS=$LIBS_no_readline
3086 AC_MSG_CHECKING(for broken nice())
3087 AC_CACHE_VAL(ac_cv_broken_nice, [
3088 AC_TRY_RUN([
3089 int main()
3090 {
3091 int val1 = nice(1);
3092 if (val1 != -1 && val1 == nice(2))
3093 exit(0);
3094 exit(1);
3095 }
3096 ],
3097 ac_cv_broken_nice=yes,
3098 ac_cv_broken_nice=no,
3099 ac_cv_broken_nice=no)])
3100 AC_MSG_RESULT($ac_cv_broken_nice)
3101 if test "$ac_cv_broken_nice" = yes
3102 then
3103 AC_DEFINE(HAVE_BROKEN_NICE, 1,
3104 [Define if nice() returns success/failure instead of the new priority.])
3105 fi
3107 AC_MSG_CHECKING(for broken poll())
3108 AC_TRY_RUN([
3109 #include <poll.h>
3111 int main (void)
3112 {
3113 struct pollfd poll_struct = { 42, POLLIN|POLLPRI|POLLOUT, 0 };
3115 close (42);
3117 int poll_test = poll (&poll_struct, 1, 0);
3119 if (poll_test < 0)
3120 {
3121 exit(0);
3122 }
3123 else if (poll_test == 0 && poll_struct.revents != POLLNVAL)
3124 {
3125 exit(0);
3126 }
3127 else
3128 {
3129 exit(1);
3130 }
3131 }
3132 ],
3133 ac_cv_broken_poll=yes,
3134 ac_cv_broken_poll=no,
3135 ac_cv_broken_poll=no)
3136 AC_MSG_RESULT($ac_cv_broken_poll)
3137 if test "$ac_cv_broken_poll" = yes
3138 then
3139 AC_DEFINE(HAVE_BROKEN_POLL, 1,
3140 [Define if poll() sets errno on invalid file descriptors.])
3141 fi
3143 # Before we can test tzset, we need to check if struct tm has a tm_zone
3144 # (which is not required by ISO C or UNIX spec) and/or if we support
3145 # tzname[]
3146 AC_STRUCT_TIMEZONE
3148 # check tzset(3) exists and works like we expect it to
3149 AC_MSG_CHECKING(for working tzset())
3150 AC_CACHE_VAL(ac_cv_working_tzset, [
3151 AC_TRY_RUN([
3152 #include <stdlib.h>
3153 #include <time.h>
3154 #include <string.h>
3156 #if HAVE_TZNAME
3157 extern char *tzname[];
3158 #endif
3160 int main()
3161 {
3162 /* Note that we need to ensure that not only does tzset(3)
3163 do 'something' with localtime, but it works as documented
3164 in the library reference and as expected by the test suite.
3165 This includes making sure that tzname is set properly if
3166 tm->tm_zone does not exist since it is the alternative way
3167 of getting timezone info.
3169 Red Hat 6.2 doesn't understand the southern hemisphere
3170 after New Year's Day.
3171 */
3173 time_t groundhogday = 1044144000; /* GMT-based */
3174 time_t midyear = groundhogday + (365 * 24 * 3600 / 2);
3176 putenv("TZ=UTC+0");
3177 tzset();
3178 if (localtime(&groundhogday)->tm_hour != 0)
3179 exit(1);
3180 #if HAVE_TZNAME
3181 /* For UTC, tzname[1] is sometimes "", sometimes " " */
3182 if (strcmp(tzname[0], "UTC") ||
3183 (tzname[1][0] != 0 && tzname[1][0] != ' '))
3184 exit(1);
3185 #endif
3187 putenv("TZ=EST+5EDT,M4.1.0,M10.5.0");
3188 tzset();
3189 if (localtime(&groundhogday)->tm_hour != 19)
3190 exit(1);
3191 #if HAVE_TZNAME
3192 if (strcmp(tzname[0], "EST") || strcmp(tzname[1], "EDT"))
3193 exit(1);
3194 #endif
3196 putenv("TZ=AEST-10AEDT-11,M10.5.0,M3.5.0");
3197 tzset();
3198 if (localtime(&groundhogday)->tm_hour != 11)
3199 exit(1);
3200 #if HAVE_TZNAME
3201 if (strcmp(tzname[0], "AEST") || strcmp(tzname[1], "AEDT"))
3202 exit(1);
3203 #endif
3205 #if HAVE_STRUCT_TM_TM_ZONE
3206 if (strcmp(localtime(&groundhogday)->tm_zone, "AEDT"))
3207 exit(1);
3208 if (strcmp(localtime(&midyear)->tm_zone, "AEST"))
3209 exit(1);
3210 #endif
3212 exit(0);
3213 }
3214 ],
3215 ac_cv_working_tzset=yes,
3216 ac_cv_working_tzset=no,
3217 ac_cv_working_tzset=no)])
3218 AC_MSG_RESULT($ac_cv_working_tzset)
3219 if test "$ac_cv_working_tzset" = yes
3220 then
3221 AC_DEFINE(HAVE_WORKING_TZSET, 1,
3222 [Define if tzset() actually switches the local timezone in a meaningful way.])
3223 fi
3225 # Look for subsecond timestamps in struct stat
3226 AC_MSG_CHECKING(for tv_nsec in struct stat)
3227 AC_CACHE_VAL(ac_cv_stat_tv_nsec,
3228 AC_TRY_COMPILE([#include <sys/stat.h>], [
3229 struct stat st;
3230 st.st_mtim.tv_nsec = 1;
3231 ],
3232 ac_cv_stat_tv_nsec=yes,
3233 ac_cv_stat_tv_nsec=no,
3234 ac_cv_stat_tv_nsec=no))
3235 AC_MSG_RESULT($ac_cv_stat_tv_nsec)
3236 if test "$ac_cv_stat_tv_nsec" = yes
3237 then
3238 AC_DEFINE(HAVE_STAT_TV_NSEC, 1,
3239 [Define if you have struct stat.st_mtim.tv_nsec])
3240 fi
3242 # Look for BSD style subsecond timestamps in struct stat
3243 AC_MSG_CHECKING(for tv_nsec2 in struct stat)
3244 AC_CACHE_VAL(ac_cv_stat_tv_nsec2,
3245 AC_TRY_COMPILE([#include <sys/stat.h>], [
3246 struct stat st;
3247 st.st_mtimespec.tv_nsec = 1;
3248 ],
3249 ac_cv_stat_tv_nsec2=yes,
3250 ac_cv_stat_tv_nsec2=no,
3251 ac_cv_stat_tv_nsec2=no))
3252 AC_MSG_RESULT($ac_cv_stat_tv_nsec2)
3253 if test "$ac_cv_stat_tv_nsec2" = yes
3254 then
3255 AC_DEFINE(HAVE_STAT_TV_NSEC2, 1,
3256 [Define if you have struct stat.st_mtimensec])
3257 fi
3259 # On HP/UX 11.0, mvwdelch is a block with a return statement
3260 AC_MSG_CHECKING(whether mvwdelch is an expression)
3261 AC_CACHE_VAL(ac_cv_mvwdelch_is_expression,
3262 AC_TRY_COMPILE([#include <curses.h>], [
3263 int rtn;
3264 rtn = mvwdelch(0,0,0);
3265 ], ac_cv_mvwdelch_is_expression=yes,
3266 ac_cv_mvwdelch_is_expression=no,
3267 ac_cv_mvwdelch_is_expression=yes))
3268 AC_MSG_RESULT($ac_cv_mvwdelch_is_expression)
3270 if test "$ac_cv_mvwdelch_is_expression" = yes
3271 then
3272 AC_DEFINE(MVWDELCH_IS_EXPRESSION, 1,
3273 [Define if mvwdelch in curses.h is an expression.])
3274 fi
3276 AC_MSG_CHECKING(whether WINDOW has _flags)
3277 AC_CACHE_VAL(ac_cv_window_has_flags,
3278 AC_TRY_COMPILE([#include <curses.h>], [
3279 WINDOW *w;
3280 w->_flags = 0;
3281 ], ac_cv_window_has_flags=yes,
3282 ac_cv_window_has_flags=no,
3283 ac_cv_window_has_flags=no))
3284 AC_MSG_RESULT($ac_cv_window_has_flags)
3287 if test "$ac_cv_window_has_flags" = yes
3288 then
3289 AC_DEFINE(WINDOW_HAS_FLAGS, 1,
3290 [Define if WINDOW in curses.h offers a field _flags.])
3291 fi
3293 AC_MSG_CHECKING(for /dev/ptmx)
3295 if test -e /dev/ptmx
3296 then
3297 AC_MSG_RESULT(yes)
3298 AC_DEFINE(HAVE_DEV_PTMX, 1,
3299 [Define if we have /dev/ptmx.])
3300 else
3301 AC_MSG_RESULT(no)
3302 fi
3304 AC_MSG_CHECKING(for /dev/ptc)
3306 if test -e /dev/ptc
3307 then
3308 AC_MSG_RESULT(yes)
3309 AC_DEFINE(HAVE_DEV_PTC, 1,
3310 [Define if we have /dev/ptc.])
3311 else
3312 AC_MSG_RESULT(no)
3313 fi
3315 AC_MSG_CHECKING(for %zd printf() format support)
3316 AC_TRY_RUN([#include <stdio.h>
3317 #include <stddef.h>
3318 #include <string.h>
3320 int main()
3321 {
3322 char buffer[4];
3324 if(sprintf(buffer, "%zd", (size_t)123) < 0)
3325 return 1;
3327 if (strncmp(buffer, "123", 3))
3328 return 1;
3330 return 0;
3331 }],
3332 [AC_MSG_RESULT(yes)
3333 AC_DEFINE(PY_FORMAT_SIZE_T, "z", [Define to printf format modifier for Py_ssize_t])],
3334 AC_MSG_RESULT(no))
3336 AC_CHECK_TYPE(socklen_t,,
3337 AC_DEFINE(socklen_t,int,
3338 Define to `int' if <sys/socket.h> does not define.),[
3339 #ifdef HAVE_SYS_TYPES_H
3340 #include <sys/types.h>
3341 #endif
3342 #ifdef HAVE_SYS_SOCKET_H
3343 #include <sys/socket.h>
3344 #endif
3345 ])
3347 AC_SUBST(THREADHEADERS)
3349 for h in `(cd $srcdir;echo Python/thread_*.h)`
3350 do
3351 THREADHEADERS="$THREADHEADERS \$(srcdir)/$h"
3352 done
3354 AC_SUBST(SRCDIRS)
3355 SRCDIRS="Parser Grammar Objects Python Modules Mac"
3356 AC_MSG_CHECKING(for build directories)
3357 for dir in $SRCDIRS; do
3358 if test ! -d $dir; then
3359 mkdir $dir
3360 fi
3361 done
3362 AC_MSG_RESULT(done)
3364 # generate output files
3365 AC_CONFIG_FILES(Makefile.pre Modules/Setup.config)
3366 AC_OUTPUT
3368 echo "creating Modules/Setup"
3369 if test ! -f Modules/Setup
3370 then
3371 cp $srcdir/Modules/Setup.dist Modules/Setup
3372 fi
3374 echo "creating Modules/Setup.local"
3375 if test ! -f Modules/Setup.local
3376 then
3377 echo "# Edit this file for local setup changes" >Modules/Setup.local
3378 fi
3380 echo "creating Makefile"
3381 $SHELL $srcdir/Modules/makesetup -c $srcdir/Modules/config.c.in \
3382 -s Modules Modules/Setup.config \
3383 Modules/Setup.local Modules/Setup
3384 mv config.c Modules