| blob | 010844e440fc7f59b003be9d43838ae922ffac74 |
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 enable_framework=
103 ;;
104 *)
105 PYTHONFRAMEWORK=Python
106 PYTHONFRAMEWORKDIR=Python.framework
107 PYTHONFRAMEWORKPREFIX=$enableval
108 PYTHONFRAMEWORKINSTALLDIR=$PYTHONFRAMEWORKPREFIX/$PYTHONFRAMEWORKDIR
109 FRAMEWORKINSTALLFIRST="frameworkinstallstructure"
110 FRAMEWORKINSTALLLAST="frameworkinstallmaclib frameworkinstallapps frameworkinstallunixtools"
111 prefix=$PYTHONFRAMEWORKINSTALLDIR/Versions/$VERSION
113 # Add makefiles for Mac specific code to the list of output
114 # files:
115 AC_CONFIG_FILES(Mac/OSX/Makefile)
116 AC_CONFIG_FILES(Mac/OSX/PythonLauncher/Makefile)
117 AC_CONFIG_FILES(Mac/OSX/IDLE/Makefile)
118 esac
119 ],[
120 PYTHONFRAMEWORK=
121 PYTHONFRAMEWORKDIR=no-framework
122 PYTHONFRAMEWORKPREFIX=
123 PYTHONFRAMEWORKINSTALLDIR=
124 FRAMEWORKINSTALLFIRST=
125 FRAMEWORKINSTALLLAST=
126 enable_framework=
127 ])
128 AC_SUBST(PYTHONFRAMEWORK)
129 AC_SUBST(PYTHONFRAMEWORKDIR)
130 AC_SUBST(PYTHONFRAMEWORKPREFIX)
131 AC_SUBST(PYTHONFRAMEWORKINSTALLDIR)
132 AC_SUBST(FRAMEWORKINSTALLFIRST)
133 AC_SUBST(FRAMEWORKINSTALLLAST)
135 ##AC_ARG_WITH(dyld,
136 ## AC_HELP_STRING(--with-dyld,
137 ## Use (OpenStep|Rhapsody) dynamic linker))
138 ##
139 # Set name for machine-dependent library files
140 AC_SUBST(MACHDEP)
141 AC_MSG_CHECKING(MACHDEP)
142 if test -z "$MACHDEP"
143 then
144 ac_sys_system=`uname -s`
145 if test "$ac_sys_system" = "AIX" -o "$ac_sys_system" = "Monterey64" \
146 -o "$ac_sys_system" = "UnixWare" -o "$ac_sys_system" = "OpenUNIX"; then
147 ac_sys_release=`uname -v`
148 else
149 ac_sys_release=`uname -r`
150 fi
151 ac_md_system=`echo $ac_sys_system |
152 tr -d '[/ ]' | tr '[[A-Z]]' '[[a-z]]'`
153 ac_md_release=`echo $ac_sys_release |
154 tr -d '[/ ]' | sed 's/^[[A-Z]]\.//' | sed 's/\..*//'`
155 MACHDEP="$ac_md_system$ac_md_release"
157 case $MACHDEP in
158 cygwin*) MACHDEP="cygwin";;
159 darwin*) MACHDEP="darwin";;
160 atheos*) MACHDEP="atheos";;
161 irix646) MACHDEP="irix6";;
162 '') MACHDEP="unknown";;
163 esac
164 fi
166 # Some systems cannot stand _XOPEN_SOURCE being defined at all; they
167 # disable features if it is defined, without any means to access these
168 # features as extensions. For these systems, we skip the definition of
169 # _XOPEN_SOURCE. Before adding a system to the list to gain access to
170 # some feature, make sure there is no alternative way to access this
171 # feature. Also, when using wildcards, make sure you have verified the
172 # need for not defining _XOPEN_SOURCE on all systems matching the
173 # wildcard, and that the wildcard does not include future systems
174 # (which may remove their limitations).
175 dnl quadrigraphs "@<:@" and "@:>@" produce "[" and "]" in the output
176 case $ac_sys_system/$ac_sys_release in
177 # On OpenBSD, select(2) is not available if _XOPEN_SOURCE is defined,
178 # even though select is a POSIX function. Reported by J. Ribbens.
179 # Reconfirmed for OpenBSD 3.3 by Zachary Hamm, for 3.4 by Jason Ish.
180 OpenBSD/2.* | OpenBSD/3.@<:@012345678@:>@)
181 define_xopen_source=no;;
182 # On Solaris 2.6, sys/wait.h is inconsistent in the usage
183 # of union __?sigval. Reported by Stuart Bishop.
184 SunOS/5.6)
185 define_xopen_source=no;;
186 # On UnixWare 7, u_long is never defined with _XOPEN_SOURCE,
187 # but used in /usr/include/netinet/tcp.h. Reported by Tim Rice.
188 # Reconfirmed for 7.1.4 by Martin v. Loewis.
189 OpenUNIX/8.0.0| UnixWare/7.1.@<:@0-4@:>@)
190 define_xopen_source=no;;
191 # On OpenServer 5, u_short is never defined with _XOPEN_SOURCE,
192 # but used in struct sockaddr.sa_family. Reported by Tim Rice.
193 SCO_SV/3.2)
194 define_xopen_source=no;;
195 # On FreeBSD 4.8 and MacOS X 10.2, a bug in ncurses.h means that
196 # it craps out if _XOPEN_EXTENDED_SOURCE is defined. Apparently,
197 # this is fixed in 10.3, which identifies itself as Darwin/7.*
198 # This should hopefully be fixed in FreeBSD 4.9
199 FreeBSD/4.8* | Darwin/6* )
200 define_xopen_source=no;;
201 # On AIX 4 and 5.1, mbstate_t is defined only when _XOPEN_SOURCE == 500 but
202 # used in wcsnrtombs() and mbsnrtowcs() even if _XOPEN_SOURCE is not defined
203 # or has another value. By not (re)defining it, the defaults come in place.
204 AIX/4)
205 define_xopen_source=no;;
206 AIX/5)
207 if test `uname -r` -eq 1; then
208 define_xopen_source=no
209 fi
210 ;;
211 # On Mac OS X 10.4, defining _POSIX_C_SOURCE or _XOPEN_SOURCE
212 # disables platform specific features beyond repair.
213 # On Mac OS X 10.3, defining _POSIX_C_SOURCE or _XOPEN_SOURCE
214 # has no effect, don't bother defineing them
215 Darwin/@<:@78@:>@.*)
216 define_xopen_source=no
217 ;;
219 esac
221 if test $define_xopen_source = yes
222 then
223 # On Solaris w/ g++ it appears that _XOPEN_SOURCE has to be
224 # defined precisely as g++ defines it
225 # Furthermore, on Solaris 10, XPG6 requires the use of a C99
226 # compiler
227 case $ac_sys_system/$ac_sys_release in
228 SunOS/5.8|SunOS/5.9|SunOS/5.10)
229 AC_DEFINE(_XOPEN_SOURCE, 500,
230 Define to the level of X/Open that your system supports)
231 ;;
232 *)
233 AC_DEFINE(_XOPEN_SOURCE, 600,
234 Define to the level of X/Open that your system supports)
235 ;;
236 esac
238 # On Tru64 Unix 4.0F, defining _XOPEN_SOURCE also requires
239 # definition of _XOPEN_SOURCE_EXTENDED and _POSIX_C_SOURCE, or else
240 # several APIs are not declared. Since this is also needed in some
241 # cases for HP-UX, we define it globally.
242 # except for Solaris 10, where it must not be defined,
243 # as it implies XPG4.2
244 case $ac_sys_system/$ac_sys_release in
245 SunOS/5.10)
246 ;;
247 *)
248 AC_DEFINE(_XOPEN_SOURCE_EXTENDED, 1,
249 Define to activate Unix95-and-earlier features)
250 ;;
251 esac
253 AC_DEFINE(_POSIX_C_SOURCE, 200112L, Define to activate features from IEEE Stds 1003.1-2001)
255 fi
257 #
258 # SGI compilers allow the specification of the both the ABI and the
259 # ISA on the command line. Depending on the values of these switches,
260 # different and often incompatable code will be generated.
261 #
262 # The SGI_ABI variable can be used to modify the CC and LDFLAGS and
263 # thus supply support for various ABI/ISA combinations. The MACHDEP
264 # variable is also adjusted.
265 #
266 AC_SUBST(SGI_ABI)
267 if test ! -z "$SGI_ABI"
268 then
269 CC="cc $SGI_ABI"
270 LDFLAGS="$SGI_ABI $LDFLAGS"
271 MACHDEP=`echo "${MACHDEP}${SGI_ABI}" | sed 's/ *//g'`
272 fi
273 AC_MSG_RESULT($MACHDEP)
275 # And add extra plat-mac for darwin
276 AC_SUBST(EXTRAPLATDIR)
277 AC_SUBST(EXTRAMACHDEPPATH)
278 AC_MSG_CHECKING(EXTRAPLATDIR)
279 if test -z "$EXTRAPLATDIR"
280 then
281 case $MACHDEP in
282 darwin)
283 EXTRAPLATDIR="\$(PLATMACDIRS)"
284 EXTRAMACHDEPPATH="\$(PLATMACPATH)"
285 ;;
286 *)
287 EXTRAPLATDIR=""
288 EXTRAMACHDEPPATH=""
289 ;;
290 esac
291 fi
292 AC_MSG_RESULT($EXTRAPLATDIR)
294 # Record the configure-time value of MACOSX_DEPLOYMENT_TARGET,
295 # it may influence the way we can build extensions, so distutils
296 # needs to check it
297 AC_SUBST(CONFIGURE_MACOSX_DEPLOYMENT_TARGET)
298 AC_SUBST(EXPORT_MACOSX_DEPLOYMENT_TARGET)
299 CONFIGURE_MACOSX_DEPLOYMENT_TARGET=
300 EXPORT_MACOSX_DEPLOYMENT_TARGET='#'
302 # checks for alternative programs
304 # compiler flags are generated in two sets, BASECFLAGS and OPT. OPT is just
305 # for debug/optimization stuff. BASECFLAGS is for flags that are required
306 # just to get things to compile and link. Users are free to override OPT
307 # when running configure or make. The build should not break if they do.
308 # BASECFLAGS should generally not be messed with, however.
310 # XXX shouldn't some/most/all of this code be merged with the stuff later
311 # on that fiddles with OPT and BASECFLAGS?
312 AC_MSG_CHECKING(for --without-gcc)
313 AC_ARG_WITH(gcc,
314 AC_HELP_STRING(--without-gcc,never use gcc),
315 [
316 case $withval in
317 no) CC=cc
318 without_gcc=yes;;
319 yes) CC=gcc
320 without_gcc=no;;
321 *) CC=$withval
322 without_gcc=$withval;;
323 esac], [
324 case $ac_sys_system in
325 AIX*) CC=cc_r
326 without_gcc=;;
327 BeOS*)
328 case $BE_HOST_CPU in
329 ppc)
330 CC=mwcc
331 without_gcc=yes
332 BASECFLAGS="$BASECFLAGS -export pragma"
333 OPT="$OPT -O"
334 LDFLAGS="$LDFLAGS -nodup"
335 ;;
336 x86)
337 CC=gcc
338 without_gcc=no
339 OPT="$OPT -O"
340 ;;
341 *)
342 AC_MSG_ERROR([Unknown BeOS platform "$BE_HOST_CPU"])
343 ;;
344 esac
345 AR="\$(srcdir)/Modules/ar_beos"
346 RANLIB=:
347 ;;
348 Monterey*)
349 RANLIB=:
350 without_gcc=;;
351 *) without_gcc=no;;
352 esac])
353 AC_MSG_RESULT($without_gcc)
355 # If the user switches compilers, we can't believe the cache
356 if test ! -z "$ac_cv_prog_CC" -a ! -z "$CC" -a "$CC" != "$ac_cv_prog_CC"
357 then
358 AC_MSG_ERROR([cached CC is different -- throw away $cache_file
359 (it is also a good idea to do 'make clean' before compiling)])
360 fi
362 AC_PROG_CC
364 AC_SUBST(CXX)
365 AC_SUBST(MAINCC)
366 AC_MSG_CHECKING(for --with-cxx-main=<compiler>)
367 AC_ARG_WITH(cxx_main,
368 AC_HELP_STRING([--with-cxx-main=<compiler>],
369 [compile main() and link python executable with C++ compiler]),
370 [
372 case $withval in
373 no) with_cxx_main=no
374 MAINCC='$(CC)';;
375 yes) with_cxx_main=yes
376 MAINCC='$(CXX)';;
377 *) with_cxx_main=yes
378 MAINCC=$withval
379 if test -z "$CXX"
380 then
381 CXX=$withval
382 fi;;
383 esac], [
384 with_cxx_main=no
385 MAINCC='$(CC)'
386 ])
387 AC_MSG_RESULT($with_cxx_main)
389 preset_cxx="$CXX"
390 if test -z "$CXX"
391 then
392 case "$CC" in
393 gcc) AC_PATH_PROG(CXX, [g++], [g++], [notfound]) ;;
394 cc) AC_PATH_PROG(CXX, [c++], [c++], [notfound]) ;;
395 esac
396 if test "$CXX" = "notfound"
397 then
398 CXX=""
399 fi
400 fi
401 if test -z "$CXX"
402 then
403 AC_CHECK_PROGS(CXX, $CCC c++ g++ gcc CC cxx cc++ cl, notfound)
404 if test "$CXX" = "notfound"
405 then
406 CXX=""
407 fi
408 fi
409 if test "$preset_cxx" != "$CXX"
410 then
411 AC_MSG_WARN([
413 By default, distutils will build C++ extension modules with "$CXX".
414 If this is not intended, then set CXX on the configure command line.
415 ])
416 fi
419 # checks for UNIX variants that set C preprocessor variables
420 AC_AIX
422 # Check for unsupported systems
423 case $ac_sys_system/$ac_sys_release in
424 Linux*/1*)
425 echo This system \($ac_sys_system/$ac_sys_release\) is no longer supported.
426 echo See README for details.
427 exit 1;;
428 esac
430 AC_EXEEXT
431 AC_MSG_CHECKING(for --with-suffix)
432 AC_ARG_WITH(suffix,
433 AC_HELP_STRING(--with-suffix=.exe, set executable suffix),
434 [
435 case $withval in
436 no) EXEEXT=;;
437 yes) EXEEXT=.exe;;
438 *) EXEEXT=$withval;;
439 esac])
440 AC_MSG_RESULT($EXEEXT)
442 # Test whether we're running on a non-case-sensitive system, in which
443 # case we give a warning if no ext is given
444 AC_SUBST(BUILDEXEEXT)
445 AC_MSG_CHECKING(for case-insensitive build directory)
446 if test ! -d CaseSensitiveTestDir; then
447 mkdir CaseSensitiveTestDir
448 fi
450 if test -d casesensitivetestdir
451 then
452 AC_MSG_RESULT(yes)
453 BUILDEXEEXT=.exe
454 else
455 AC_MSG_RESULT(no)
456 BUILDEXEEXT=$EXEEXT
457 fi
458 rmdir CaseSensitiveTestDir
460 case $MACHDEP in
461 bsdos*)
462 case $CC in
463 gcc) CC="$CC -D_HAVE_BSDI";;
464 esac;;
465 esac
467 case $ac_sys_system in
468 hp*|HP*)
469 case $CC in
470 cc|*/cc) CC="$CC -Ae";;
471 esac;;
472 Monterey*)
473 case $CC in
474 cc) CC="$CC -Wl,-Bexport";;
475 esac;;
476 SunOS*)
477 # Some functions have a prototype only with that define, e.g. confstr
478 AC_DEFINE(__EXTENSIONS__, 1, [Defined on Solaris to see additional function prototypes.])
479 ;;
480 esac
483 AC_SUBST(LIBRARY)
484 AC_MSG_CHECKING(LIBRARY)
485 if test -z "$LIBRARY"
486 then
487 LIBRARY='libpython$(VERSION).a'
488 fi
489 AC_MSG_RESULT($LIBRARY)
491 # LDLIBRARY is the name of the library to link against (as opposed to the
492 # name of the library into which to insert object files). BLDLIBRARY is also
493 # the library to link against, usually. On Mac OS X frameworks, BLDLIBRARY
494 # is blank as the main program is not linked directly against LDLIBRARY.
495 # LDLIBRARYDIR is the path to LDLIBRARY, which is made in a subdirectory. On
496 # systems without shared libraries, LDLIBRARY is the same as LIBRARY
497 # (defined in the Makefiles). On Cygwin LDLIBRARY is the import library,
498 # DLLLIBRARY is the shared (i.e., DLL) library.
499 #
500 # RUNSHARED is used to run shared python without installed libraries
501 #
502 # INSTSONAME is the name of the shared library that will be use to install
503 # on the system - some systems like version suffix, others don't
504 AC_SUBST(LDLIBRARY)
505 AC_SUBST(DLLLIBRARY)
506 AC_SUBST(BLDLIBRARY)
507 AC_SUBST(LDLIBRARYDIR)
508 AC_SUBST(INSTSONAME)
509 AC_SUBST(RUNSHARED)
510 LDLIBRARY="$LIBRARY"
511 BLDLIBRARY='$(LDLIBRARY)'
512 INSTSONAME='$(LDLIBRARY)'
513 DLLLIBRARY=''
514 LDLIBRARYDIR=''
515 RUNSHARED=''
517 # LINKCC is the command that links the python executable -- default is $(CC).
518 # If CXX is set, and if it is needed to link a main function that was
519 # compiled with CXX, LINKCC is CXX instead. Always using CXX is undesirable:
520 # python might then depend on the C++ runtime
521 # This is altered for AIX in order to build the export list before
522 # linking.
523 AC_SUBST(LINKCC)
524 AC_MSG_CHECKING(LINKCC)
525 if test -z "$LINKCC"
526 then
527 LINKCC='$(PURIFY) $(MAINCC)'
528 case $ac_sys_system in
529 AIX*)
530 exp_extra="\"\""
531 if test $ac_sys_release -ge 5 -o \
532 $ac_sys_release -eq 4 -a `uname -r` -ge 2 ; then
533 exp_extra="."
534 fi
535 LINKCC="\$(srcdir)/Modules/makexp_aix Modules/python.exp $exp_extra \$(LIBRARY); $LINKCC";;
536 Monterey64*)
537 LINKCC="$LINKCC -L/usr/lib/ia64l64";;
538 esac
539 fi
540 AC_MSG_RESULT($LINKCC)
542 AC_MSG_CHECKING(for --enable-shared)
543 AC_ARG_ENABLE(shared,
544 AC_HELP_STRING(--enable-shared, disable/enable building shared python library))
546 if test -z "$enable_shared"
547 then
548 case $ac_sys_system in
549 CYGWIN* | atheos*)
550 enable_shared="yes";;
551 *)
552 enable_shared="no";;
553 esac
554 fi
555 AC_MSG_RESULT($enable_shared)
557 AC_MSG_CHECKING(for --enable-profiling)
558 AC_ARG_ENABLE(profiling,
559 AC_HELP_STRING(--enable-profiling, enable C-level code profiling),
560 [ac_save_cc="$CC"
561 CC="$CC -pg"
562 AC_TRY_RUN([int main() { return 0; }],
563 ac_enable_profiling="yes",
564 ac_enable_profiling="no",
565 ac_enable_profiling="no")
566 CC="$ac_save_cc"])
567 AC_MSG_RESULT($ac_enable_profiling)
569 case "$ac_enable_profiling" in
570 "yes")
571 BASECFLAGS="-pg $BASECFLAGS"
572 LDFLAGS="-pg $LDFLAGS"
573 ;;
574 esac
576 AC_MSG_CHECKING(LDLIBRARY)
578 # MacOSX framework builds need more magic. LDLIBRARY is the dynamic
579 # library that we build, but we do not want to link against it (we
580 # will find it with a -framework option). For this reason there is an
581 # extra variable BLDLIBRARY against which Python and the extension
582 # modules are linked, BLDLIBRARY. This is normally the same as
583 # LDLIBRARY, but empty for MacOSX framework builds.
584 if test "$enable_framework"
585 then
586 LDLIBRARY='$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
587 RUNSHARED=DYLD_FRAMEWORK_PATH="`pwd`:$DYLD_FRAMEWORK_PATH"
588 BLDLIBRARY=''
589 else
590 BLDLIBRARY='$(LDLIBRARY)'
591 fi
593 # Other platforms follow
594 if test $enable_shared = "yes"; then
595 AC_DEFINE(Py_ENABLE_SHARED, 1, [Defined if Python is built as a shared library.])
596 case $ac_sys_system in
597 BeOS*)
598 LDLIBRARY='libpython$(VERSION).so'
599 ;;
600 CYGWIN*)
601 LDLIBRARY='libpython$(VERSION).dll.a'
602 DLLLIBRARY='libpython$(VERSION).dll'
603 ;;
604 SunOS*)
605 LDLIBRARY='libpython$(VERSION).so'
606 BLDLIBRARY='-Wl,-R,$(LIBDIR) -L. -lpython$(VERSION)'
607 RUNSHARED=LD_LIBRARY_PATH=`pwd`:${LD_LIBRARY_PATH}
608 INSTSONAME="$LDLIBRARY".$SOVERSION
609 ;;
610 Linux*|GNU*|NetBSD*|FreeBSD*|DragonFly*)
611 LDLIBRARY='libpython$(VERSION).so'
612 BLDLIBRARY='-L. -lpython$(VERSION)'
613 RUNSHARED=LD_LIBRARY_PATH=`pwd`:${LD_LIBRARY_PATH}
614 case $ac_sys_system in
615 FreeBSD*)
616 SOVERSION=`echo $SOVERSION|cut -d "." -f 1`
617 ;;
618 esac
619 INSTSONAME="$LDLIBRARY".$SOVERSION
620 ;;
621 hp*|HP*)
622 case `uname -m` in
623 ia64)
624 LDLIBRARY='libpython$(VERSION).so'
625 ;;
626 *)
627 LDLIBRARY='libpython$(VERSION).sl'
628 ;;
629 esac
630 BLDLIBRARY='-Wl,+b,$(LIBDIR) -L. -lpython$(VERSION)'
631 RUNSHARED=SHLIB_PATH=`pwd`:${SHLIB_PATH}
632 ;;
633 OSF*)
634 LDLIBRARY='libpython$(VERSION).so'
635 BLDLIBRARY='-rpath $(LIBDIR) -L. -lpython$(VERSION)'
636 RUNSHARED=LD_LIBRARY_PATH=`pwd`:${LD_LIBRARY_PATH}
637 ;;
638 atheos*)
639 LDLIBRARY='libpython$(VERSION).so'
640 BLDLIBRARY='-L. -lpython$(VERSION)'
641 RUNSHARED=DLL_PATH=`pwd`:${DLL_PATH:-/atheos/sys/libs:/atheos/autolnk/lib}
642 ;;
643 esac
644 else # shared is disabled
645 case $ac_sys_system in
646 CYGWIN*)
647 BLDLIBRARY='$(LIBRARY)'
648 LDLIBRARY='libpython$(VERSION).dll.a'
649 ;;
650 esac
651 fi
653 AC_MSG_RESULT($LDLIBRARY)
655 AC_PROG_RANLIB
656 AC_SUBST(AR)
657 AC_CHECK_PROGS(AR, ar aal, ar)
659 AC_SUBST(SVNVERSION)
660 AC_CHECK_PROG(SVNVERSION, svnversion, found, not-found)
661 if test $SVNVERSION = found
662 then
663 SVNVERSION="svnversion \$(srcdir)"
664 else
665 SVNVERSION="echo exported"
666 fi
668 case $MACHDEP in
669 bsdos*|hp*|HP*)
670 # install -d does not work on BSDI or HP-UX
671 if test -z "$INSTALL"
672 then
673 INSTALL="${srcdir}/install-sh -c"
674 fi
675 esac
676 AC_PROG_INSTALL
678 # Not every filesystem supports hard links
679 AC_SUBST(LN)
680 if test -z "$LN" ; then
681 case $ac_sys_system in
682 BeOS*) LN="ln -s";;
683 CYGWIN*) LN="ln -s";;
684 atheos*) LN="ln -s";;
685 *) LN=ln;;
686 esac
687 fi
689 # Check for --with-pydebug
690 AC_MSG_CHECKING(for --with-pydebug)
691 AC_ARG_WITH(pydebug,
692 AC_HELP_STRING(--with-pydebug, build with Py_DEBUG defined),
693 [
694 if test "$withval" != no
695 then
696 AC_DEFINE(Py_DEBUG, 1,
697 [Define if you want to build an interpreter with many run-time checks.])
698 AC_MSG_RESULT(yes);
699 Py_DEBUG='true'
700 else AC_MSG_RESULT(no); Py_DEBUG='false'
701 fi],
702 [AC_MSG_RESULT(no)])
704 # XXX Shouldn't the code above that fiddles with BASECFLAGS and OPT be
705 # merged with this chunk of code?
707 # Optimizer/debugger flags
708 # ------------------------
709 # (The following bit of code is complicated enough - please keep things
710 # indented properly. Just pretend you're editing Python code. ;-)
712 # There are two parallel sets of case statements below, one that checks to
713 # see if OPT was set and one that does BASECFLAGS setting based upon
714 # compiler and platform. BASECFLAGS tweaks need to be made even if the
715 # user set OPT.
717 # tweak OPT based on compiler and platform, only if the user didn't set
718 # it on the command line
719 AC_SUBST(OPT)
720 if test -z "$OPT"
721 then
722 case $GCC in
723 yes)
724 if test "$CC" != 'g++' ; then
725 STRICT_PROTO="-Wstrict-prototypes"
726 fi
727 case $ac_cv_prog_cc_g in
728 yes)
729 if test "$Py_DEBUG" = 'true' ; then
730 # Optimization messes up debuggers, so turn it off for
731 # debug builds.
732 OPT="-g -Wall $STRICT_PROTO"
733 else
734 OPT="-g -O3 -Wall $STRICT_PROTO"
735 fi
736 ;;
737 *)
738 OPT="-O3 -Wall $STRICT_PROTO"
739 ;;
740 esac
741 case $ac_sys_system in
742 SCO_SV*) OPT="$OPT -m486 -DSCO5"
743 ;;
744 esac
745 ;;
747 *)
748 OPT="-O"
749 ;;
750 esac
752 # The current (beta) Monterey compiler dies with optimizations
753 # XXX what is Monterey? Does it still die w/ -O? Can we get rid of this?
754 case $ac_sys_system in
755 Monterey*)
756 OPT=""
757 ;;
758 esac
760 fi
762 AC_SUBST(BASECFLAGS)
763 # tweak BASECFLAGS based on compiler and platform
764 case $GCC in
765 yes)
766 # Python violates C99 rules, by casting between incompatible
767 # pointer types. GCC may generate bad code as a result of that,
768 # so use -fno-strict-aliasing if supported.
769 AC_MSG_CHECKING(whether $CC accepts -fno-strict-aliasing)
770 ac_save_cc="$CC"
771 CC="$CC -fno-strict-aliasing"
772 AC_TRY_RUN([int main() { return 0; }],
773 ac_cv_no_strict_aliasing_ok=yes,
774 ac_cv_no_strict_aliasing_ok=no,
775 ac_cv_no_strict_aliasing_ok=no)
776 CC="$ac_save_cc"
777 AC_MSG_RESULT($ac_cv_no_strict_aliasing_ok)
778 if test $ac_cv_no_strict_aliasing_ok = yes
779 then
780 BASECFLAGS="$BASECFLAGS -fno-strict-aliasing"
781 fi
782 case $ac_sys_system in
783 SCO_SV*)
784 BASECFLAGS="$BASECFLAGS -m486 -DSCO5"
785 ;;
786 # is there any other compiler on Darwin besides gcc?
787 Darwin*)
788 BASECFLAGS="$BASECFLAGS -Wno-long-double -no-cpp-precomp -mno-fused-madd"
789 if test "${enable_universalsdk}"; then
790 BASECFLAGS="-arch ppc -arch i386 -isysroot ${UNIVERSALSDK} ${BASECFLAGS}"
791 fi
793 ;;
794 OSF*)
795 BASECFLAGS="$BASECFLAGS -mieee"
796 ;;
797 esac
798 ;;
800 *)
801 case $ac_sys_system in
802 OpenUNIX*|UnixWare*)
803 BASECFLAGS="$BASECFLAGS -K pentium,host,inline,loop_unroll,alloca "
804 ;;
805 OSF*)
806 BASECFLAGS="$BASECFLAGS -ieee -std"
807 ;;
808 SCO_SV*)
809 BASECFLAGS="$BASECFLAGS -belf -Ki486 -DSCO5"
810 ;;
811 esac
812 ;;
813 esac
815 if test "$Py_DEBUG" = 'true'; then
816 :
817 else
818 OPT="-DNDEBUG $OPT"
819 fi
821 if test "$ac_arch_flags"
822 then
823 BASECFLAGS="$BASECFLAGS $ac_arch_flags"
824 fi
826 # disable check for icc since it seems to pass, but generates a warning
827 if test "$CC" = icc
828 then
829 ac_cv_opt_olimit_ok=no
830 fi
832 AC_MSG_CHECKING(whether $CC accepts -OPT:Olimit=0)
833 AC_CACHE_VAL(ac_cv_opt_olimit_ok,
834 [ac_save_cc="$CC"
835 CC="$CC -OPT:Olimit=0"
836 AC_TRY_RUN([int main() { return 0; }],
837 ac_cv_opt_olimit_ok=yes,
838 ac_cv_opt_olimit_ok=no,
839 ac_cv_opt_olimit_ok=no)
840 CC="$ac_save_cc"])
841 AC_MSG_RESULT($ac_cv_opt_olimit_ok)
842 if test $ac_cv_opt_olimit_ok = yes; then
843 case $ac_sys_system in
844 # XXX is this branch needed? On MacOSX 10.2.2 the result of the
845 # olimit_ok test is "no". Is it "yes" in some other Darwin-esque
846 # environment?
847 Darwin*)
848 ;;
849 *)
850 BASECFLAGS="$BASECFLAGS -OPT:Olimit=0"
851 ;;
852 esac
853 else
854 AC_MSG_CHECKING(whether $CC accepts -Olimit 1500)
855 AC_CACHE_VAL(ac_cv_olimit_ok,
856 [ac_save_cc="$CC"
857 CC="$CC -Olimit 1500"
858 AC_TRY_RUN([int main() { return 0; }],
859 ac_cv_olimit_ok=yes,
860 ac_cv_olimit_ok=no,
861 ac_cv_olimit_ok=no)
862 CC="$ac_save_cc"])
863 AC_MSG_RESULT($ac_cv_olimit_ok)
864 if test $ac_cv_olimit_ok = yes; then
865 BASECFLAGS="$BASECFLAGS -Olimit 1500"
866 fi
867 fi
869 # On some compilers, pthreads are available without further options
870 # (e.g. MacOS X). On some of these systems, the compiler will not
871 # complain if unaccepted options are passed (e.g. gcc on Mac OS X).
872 # So we have to see first whether pthreads are available without
873 # options before we can check whether -Kpthread improves anything.
874 AC_MSG_CHECKING(whether pthreads are available without options)
875 AC_CACHE_VAL(ac_cv_pthread_is_default,
876 [AC_TRY_RUN([
877 #include <pthread.h>
879 void* routine(void* p){return NULL;}
881 int main(){
882 pthread_t p;
883 if(pthread_create(&p,NULL,routine,NULL)!=0)
884 return 1;
885 (void)pthread_detach(p);
886 return 0;
887 }
888 ],
889 [
890 ac_cv_pthread_is_default=yes
891 ac_cv_kthread=no
892 ac_cv_pthread=no
893 ],
894 ac_cv_pthread_is_default=no,
895 ac_cv_pthread_is_default=no)
896 ])
897 AC_MSG_RESULT($ac_cv_pthread_is_default)
900 if test $ac_cv_pthread_is_default = yes
901 then
902 ac_cv_kpthread=no
903 else
904 # -Kpthread, if available, provides the right #defines
905 # and linker options to make pthread_create available
906 # Some compilers won't report that they do not support -Kpthread,
907 # so we need to run a program to see whether it really made the
908 # function available.
909 AC_MSG_CHECKING(whether $CC accepts -Kpthread)
910 AC_CACHE_VAL(ac_cv_kpthread,
911 [ac_save_cc="$CC"
912 CC="$CC -Kpthread"
913 AC_TRY_RUN([
914 #include <pthread.h>
916 void* routine(void* p){return NULL;}
918 int main(){
919 pthread_t p;
920 if(pthread_create(&p,NULL,routine,NULL)!=0)
921 return 1;
922 (void)pthread_detach(p);
923 return 0;
924 }
925 ],
926 ac_cv_kpthread=yes,
927 ac_cv_kpthread=no,
928 ac_cv_kpthread=no)
929 CC="$ac_save_cc"])
930 AC_MSG_RESULT($ac_cv_kpthread)
931 fi
933 if test $ac_cv_kpthread = no -a $ac_cv_pthread_is_default = no
934 then
935 # -Kthread, if available, provides the right #defines
936 # and linker options to make pthread_create available
937 # Some compilers won't report that they do not support -Kthread,
938 # so we need to run a program to see whether it really made the
939 # function available.
940 AC_MSG_CHECKING(whether $CC accepts -Kthread)
941 AC_CACHE_VAL(ac_cv_kthread,
942 [ac_save_cc="$CC"
943 CC="$CC -Kthread"
944 AC_TRY_RUN([
945 #include <pthread.h>
947 void* routine(void* p){return NULL;}
949 int main(){
950 pthread_t p;
951 if(pthread_create(&p,NULL,routine,NULL)!=0)
952 return 1;
953 (void)pthread_detach(p);
954 return 0;
955 }
956 ],
957 ac_cv_kthread=yes,
958 ac_cv_kthread=no,
959 ac_cv_kthread=no)
960 CC="$ac_save_cc"])
961 AC_MSG_RESULT($ac_cv_kthread)
962 fi
964 if test $ac_cv_kthread = no -a $ac_cv_pthread_is_default = no
965 then
966 # -pthread, if available, provides the right #defines
967 # and linker options to make pthread_create available
968 # Some compilers won't report that they do not support -pthread,
969 # so we need to run a program to see whether it really made the
970 # function available.
971 AC_MSG_CHECKING(whether $CC accepts -pthread)
972 AC_CACHE_VAL(ac_cv_thread,
973 [ac_save_cc="$CC"
974 CC="$CC -pthread"
975 AC_TRY_RUN([
976 #include <pthread.h>
978 void* routine(void* p){return NULL;}
980 int main(){
981 pthread_t p;
982 if(pthread_create(&p,NULL,routine,NULL)!=0)
983 return 1;
984 (void)pthread_detach(p);
985 return 0;
986 }
987 ],
988 ac_cv_pthread=yes,
989 ac_cv_pthread=no,
990 ac_cv_pthread=no)
991 CC="$ac_save_cc"])
992 AC_MSG_RESULT($ac_cv_pthread)
993 fi
995 # If we have set a CC compiler flag for thread support then
996 # check if it works for CXX, too.
997 ac_cv_cxx_thread=no
998 if test ! -z "$CXX"
999 then
1000 AC_MSG_CHECKING(whether $CXX also accepts flags for thread support)
1001 ac_save_cxx="$CXX"
1003 if test "$ac_cv_kpthread" = "yes"
1004 then
1005 CXX="$CXX -Kpthread"
1006 ac_cv_cxx_thread=yes
1007 elif test "$ac_cv_kthread" = "yes"
1008 then
1009 CXX="$CXX -Kthread"
1010 ac_cv_cxx_thread=yes
1011 elif test "$ac_cv_pthread" = "yes"
1012 then
1013 CXX="$CXX -pthread"
1014 ac_cv_cxx_thread=yes
1015 fi
1017 if test $ac_cv_cxx_thread = yes
1018 then
1019 echo 'void foo();int main(){foo();}void foo(){}' > conftest.$ac_ext
1020 $CXX -c conftest.$ac_ext 2>&5
1021 if $CXX -o conftest$ac_exeext conftest.$ac_objext 2>&5 \
1022 && test -s conftest$ac_exeext && ./conftest$ac_exeext
1023 then
1024 ac_cv_cxx_thread=yes
1025 else
1026 ac_cv_cxx_thread=no
1027 fi
1028 rm -fr conftest*
1029 fi
1030 AC_MSG_RESULT($ac_cv_cxx_thread)
1031 fi
1032 CXX="$ac_save_cxx"
1034 dnl # check for ANSI or K&R ("traditional") preprocessor
1035 dnl AC_MSG_CHECKING(for C preprocessor type)
1036 dnl AC_TRY_COMPILE([
1037 dnl #define spam(name, doc) {#name, &name, #name "() -- " doc}
1038 dnl int foo;
1039 dnl struct {char *name; int *addr; char *doc;} desc = spam(foo, "something");
1040 dnl ], [;], cpp_type=ansi, AC_DEFINE(HAVE_OLD_CPP) cpp_type=traditional)
1041 dnl AC_MSG_RESULT($cpp_type)
1043 # checks for header files
1044 AC_HEADER_STDC
1045 AC_CHECK_HEADERS(asm/types.h curses.h dlfcn.h fcntl.h grp.h \
1046 shadow.h langinfo.h libintl.h ncurses.h poll.h pthread.h \
1047 stropts.h termios.h thread.h \
1048 unistd.h utime.h \
1049 sys/audioio.h sys/bsdtty.h sys/file.h sys/loadavg.h sys/lock.h sys/mkdev.h \
1050 sys/modem.h \
1051 sys/param.h sys/poll.h sys/select.h sys/socket.h sys/statvfs.h sys/time.h \
1052 sys/times.h sys/un.h sys/utsname.h sys/wait.h pty.h libutil.h \
1053 sys/resource.h netpacket/packet.h sysexits.h bluetooth.h \
1054 bluetooth/bluetooth.h)
1055 AC_HEADER_DIRENT
1056 AC_HEADER_MAJOR
1058 # On Solaris, term.h requires curses.h
1059 AC_CHECK_HEADERS(term.h,,,[
1060 #ifdef HAVE_CURSES_H
1061 #include <curses.h>
1062 #endif
1063 ])
1065 # On Linux, netlink.h requires asm/types.h
1066 AC_CHECK_HEADERS(linux/netlink.h,,,[
1067 #ifdef HAVE_ASM_TYPES_H
1068 #include <asm/types.h>
1069 #endif
1070 #ifdef HAVE_SYS_SOCKET_H
1071 #include <sys/socket.h>
1072 #endif
1073 ])
1075 # checks for typedefs
1076 was_it_defined=no
1077 AC_MSG_CHECKING(for clock_t in time.h)
1078 AC_EGREP_HEADER(clock_t, time.h, was_it_defined=yes, [
1079 AC_DEFINE(clock_t, long, [Define to 'long' if <time.h> doesn't define.])
1080 ])
1081 AC_MSG_RESULT($was_it_defined)
1083 # Check whether using makedev requires defining _OSF_SOURCE
1084 AC_MSG_CHECKING(for makedev)
1085 AC_TRY_LINK([#include <sys/types.h> ],
1086 [ makedev(0, 0) ],
1087 ac_cv_has_makedev=yes,
1088 ac_cv_has_makedev=no)
1089 if test "$ac_cv_has_makedev" = "no"; then
1090 # we didn't link, try if _OSF_SOURCE will allow us to link
1091 AC_TRY_LINK([
1092 #define _OSF_SOURCE 1
1093 #include <sys/types.h>
1094 ],
1095 [ makedev(0, 0) ],
1096 ac_cv_has_makedev=yes,
1097 ac_cv_has_makedev=no)
1098 if test "$ac_cv_has_makedev" = "yes"; then
1099 AC_DEFINE(_OSF_SOURCE, 1, [Define _OSF_SOURCE to get the makedev macro.])
1100 fi
1101 fi
1102 AC_MSG_RESULT($ac_cv_has_makedev)
1103 if test "$ac_cv_has_makedev" = "yes"; then
1104 AC_DEFINE(HAVE_MAKEDEV, 1, [Define this if you have the makedev macro.])
1105 fi
1107 # Enabling LFS on Solaris (2.6 to 9) with gcc 2.95 triggers a bug in
1108 # the system headers: If _XOPEN_SOURCE and _LARGEFILE_SOURCE are
1109 # defined, but the compiler does not support pragma redefine_extname,
1110 # and _LARGEFILE64_SOURCE is not defined, the headers refer to 64-bit
1111 # structures (such as rlimit64) without declaring them. As a
1112 # work-around, disable LFS on such configurations
1114 use_lfs=yes
1115 AC_MSG_CHECKING(Solaris LFS bug)
1116 AC_TRY_COMPILE([
1117 #define _LARGEFILE_SOURCE 1
1118 #define _FILE_OFFSET_BITS 64
1119 #include <sys/resource.h>
1120 ],struct rlimit foo;,sol_lfs_bug=no,sol_lfs_bug=yes)
1121 AC_MSG_RESULT($sol_lfs_bug)
1122 if test "$sol_lfs_bug" = "yes"; then
1123 use_lfs=no
1124 fi
1126 if test "$use_lfs" = "yes"; then
1127 # Two defines needed to enable largefile support on various platforms
1128 # These may affect some typedefs
1129 AC_DEFINE(_LARGEFILE_SOURCE, 1,
1130 [This must be defined on some systems to enable large file support.])
1131 AC_DEFINE(_FILE_OFFSET_BITS, 64,
1132 [This must be set to 64 on some systems to enable large file support.])
1133 fi
1135 # Add some code to confdefs.h so that the test for off_t works on SCO
1136 cat >> confdefs.h <<\EOF
1137 #if defined(SCO_DS)
1138 #undef _OFF_T
1139 #endif
1140 EOF
1142 # Type availability checks
1143 AC_TYPE_MODE_T
1144 AC_TYPE_OFF_T
1145 AC_TYPE_PID_T
1146 AC_TYPE_SIGNAL
1147 AC_TYPE_SIZE_T
1148 AC_TYPE_UID_T
1149 AC_CHECK_TYPE(ssize_t,
1150 AC_DEFINE(HAVE_SSIZE_T, 1, Define if your compiler provides ssize_t),,)
1152 # Sizes of various common basic types
1153 # ANSI C requires sizeof(char) == 1, so no need to check it
1154 AC_CHECK_SIZEOF(int, 4)
1155 AC_CHECK_SIZEOF(long, 4)
1156 AC_CHECK_SIZEOF(void *, 4)
1157 AC_CHECK_SIZEOF(short, 2)
1158 AC_CHECK_SIZEOF(float, 4)
1159 AC_CHECK_SIZEOF(double, 8)
1160 AC_CHECK_SIZEOF(fpos_t, 4)
1161 AC_CHECK_SIZEOF(size_t, 4)
1163 AC_MSG_CHECKING(for long long support)
1164 have_long_long=no
1165 AC_TRY_COMPILE([], [long long x; x = (long long)0;], [
1166 AC_DEFINE(HAVE_LONG_LONG, 1, [Define this if you have the type long long.])
1167 have_long_long=yes
1168 ])
1169 AC_MSG_RESULT($have_long_long)
1170 if test "$have_long_long" = yes ; then
1171 AC_CHECK_SIZEOF(long long, 8)
1172 fi
1174 AC_MSG_CHECKING(for uintptr_t support)
1175 have_uintptr_t=no
1176 AC_TRY_COMPILE([], [uintptr_t x; x = (uintptr_t)0;], [
1177 AC_DEFINE(HAVE_UINTPTR_T, 1, [Define this if you have the type uintptr_t.])
1178 have_uintptr_t=yes
1179 ])
1180 AC_MSG_RESULT($have_uintptr_t)
1181 if test "$have_uintptr_t" = yes ; then
1182 AC_CHECK_SIZEOF(uintptr_t, 4)
1183 fi
1185 # Hmph. AC_CHECK_SIZEOF() doesn't include <sys/types.h>.
1186 AC_MSG_CHECKING(size of off_t)
1187 AC_CACHE_VAL(ac_cv_sizeof_off_t,
1188 [AC_TRY_RUN([#include <stdio.h>
1189 #include <sys/types.h>
1190 main()
1191 {
1192 FILE *f=fopen("conftestval", "w");
1193 if (!f) exit(1);
1194 fprintf(f, "%d\n", sizeof(off_t));
1195 exit(0);
1196 }],
1197 ac_cv_sizeof_off_t=`cat conftestval`,
1198 ac_cv_sizeof_off_t=0,
1199 ac_cv_sizeof_off_t=4)
1200 ])
1201 AC_MSG_RESULT($ac_cv_sizeof_off_t)
1202 AC_DEFINE_UNQUOTED(SIZEOF_OFF_T, $ac_cv_sizeof_off_t,
1203 [The number of bytes in an off_t.])
1205 AC_MSG_CHECKING(whether to enable large file support)
1206 if test "$have_long_long" = yes -a \
1207 "$ac_cv_sizeof_off_t" -gt "$ac_cv_sizeof_long" -a \
1208 "$ac_cv_sizeof_long_long" -ge "$ac_cv_sizeof_off_t"; then
1209 AC_DEFINE(HAVE_LARGEFILE_SUPPORT, 1,
1210 [Defined to enable large file support when an off_t is bigger than a long
1211 and long long is available and at least as big as an off_t. You may need
1212 to add some flags for configuration and compilation to enable this mode.
1213 (For Solaris and Linux, the necessary defines are already defined.)])
1214 AC_MSG_RESULT(yes)
1215 else
1216 AC_MSG_RESULT(no)
1217 fi
1219 # AC_CHECK_SIZEOF() doesn't include <time.h>.
1220 AC_MSG_CHECKING(size of time_t)
1221 AC_CACHE_VAL(ac_cv_sizeof_time_t,
1222 [AC_TRY_RUN([#include <stdio.h>
1223 #include <time.h>
1224 main()
1225 {
1226 FILE *f=fopen("conftestval", "w");
1227 if (!f) exit(1);
1228 fprintf(f, "%d\n", sizeof(time_t));
1229 exit(0);
1230 }],
1231 ac_cv_sizeof_time_t=`cat conftestval`,
1232 ac_cv_sizeof_time_t=0,
1233 ac_cv_sizeof_time_t=4)
1234 ])
1235 AC_MSG_RESULT($ac_cv_sizeof_time_t)
1236 AC_DEFINE_UNQUOTED(SIZEOF_TIME_T, $ac_cv_sizeof_time_t,
1237 [The number of bytes in a time_t.])
1240 # if have pthread_t then define SIZEOF_PTHREAD_T
1241 ac_save_cc="$CC"
1242 if test "$ac_cv_kpthread" = "yes"
1243 then CC="$CC -Kpthread"
1244 elif test "$ac_cv_kthread" = "yes"
1245 then CC="$CC -Kthread"
1246 elif test "$ac_cv_pthread" = "yes"
1247 then CC="$CC -pthread"
1248 fi
1249 AC_MSG_CHECKING(for pthread_t)
1250 have_pthread_t=no
1251 AC_TRY_COMPILE([#include <pthread.h>], [pthread_t x; x = *(pthread_t*)0;], have_pthread_t=yes)
1252 AC_MSG_RESULT($have_pthread_t)
1253 if test "$have_pthread_t" = yes ; then
1254 # AC_CHECK_SIZEOF() doesn't include <pthread.h>.
1255 AC_MSG_CHECKING(size of pthread_t)
1256 AC_CACHE_VAL(ac_cv_sizeof_pthread_t,
1257 [AC_TRY_RUN([#include <stdio.h>
1258 #include <pthread.h>
1259 main()
1260 {
1261 FILE *f=fopen("conftestval", "w");
1262 if (!f) exit(1);
1263 fprintf(f, "%d\n", sizeof(pthread_t));
1264 exit(0);
1265 }],
1266 ac_cv_sizeof_pthread_t=`cat conftestval`,
1267 ac_cv_sizeof_pthread_t=0,
1268 ac_cv_sizeof_pthread_t=4)
1269 ])
1270 AC_MSG_RESULT($ac_cv_sizeof_pthread_t)
1271 AC_DEFINE_UNQUOTED(SIZEOF_PTHREAD_T, $ac_cv_sizeof_pthread_t,
1272 [The number of bytes in a pthread_t.])
1273 fi
1274 CC="$ac_save_cc"
1276 AC_MSG_CHECKING(for --enable-toolbox-glue)
1277 AC_ARG_ENABLE(toolbox-glue,
1278 AC_HELP_STRING(--enable-toolbox-glue, disable/enable MacOSX glue code for extensions))
1280 if test -z "$enable_toolbox_glue"
1281 then
1282 case $ac_sys_system/$ac_sys_release in
1283 Darwin/*)
1284 enable_toolbox_glue="yes";;
1285 *)
1286 enable_toolbox_glue="no";;
1287 esac
1288 fi
1289 case "$enable_toolbox_glue" in
1290 yes)
1291 extra_machdep_objs="Python/mactoolboxglue.o"
1292 extra_undefs="-u _PyMac_Error"
1293 AC_DEFINE(USE_TOOLBOX_OBJECT_GLUE, 1,
1294 [Define if you want to use MacPython modules on MacOSX in unix-Python.])
1295 ;;
1296 *)
1297 extra_machdep_objs=""
1298 extra_undefs=""
1299 ;;
1300 esac
1301 AC_MSG_RESULT($enable_toolbox_glue)
1303 AC_SUBST(OTHER_LIBTOOL_OPT)
1304 case $ac_sys_system/$ac_sys_release in
1305 Darwin/@<:@01567@:>@\..*)
1306 OTHER_LIBTOOL_OPT="-prebind -seg1addr 0x10000000"
1307 ;;
1308 Darwin/*)
1309 OTHER_LIBTOOL_OPT=""
1310 ;;
1311 esac
1313 AC_SUBST(LIBTOOL_CRUFT)
1314 case $ac_sys_system/$ac_sys_release in
1315 Darwin/@<:@01567@:>@\..*)
1316 LIBTOOL_CRUFT="-framework System -lcc_dynamic"
1317 if test "${enable_universalsdk}"; then
1318 :
1319 else
1320 LIBTOOL_CRUFT="${LIBTOOL_CRUFT} -arch_only `arch`"
1321 fi
1322 LIBTOOL_CRUFT=$LIBTOOL_CRUFT' -install_name $(PYTHONFRAMEWORKINSTALLDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1323 LIBTOOL_CRUFT=$LIBTOOL_CRUFT' -compatibility_version $(VERSION) -current_version $(VERSION)';;
1324 Darwin/*)
1325 gcc_version=`gcc -v 2>&1 | grep version | cut -d\ -f3`
1326 if test ${gcc_version} '<' 4.0
1327 then
1328 LIBTOOL_CRUFT="-lcc_dynamic"
1329 else
1330 LIBTOOL_CRUFT=""
1331 fi
1332 LIBTOOL_CRUFT=$LIBTOOL_CRUFT" -lSystem -lSystemStubs -arch_only `arch`"
1333 LIBTOOL_CRUFT=$LIBTOOL_CRUFT' -install_name $(PYTHONFRAMEWORKINSTALLDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1334 LIBTOOL_CRUFT=$LIBTOOL_CRUFT' -compatibility_version $(VERSION) -current_version $(VERSION)';;
1335 esac
1337 AC_MSG_CHECKING(for --enable-framework)
1338 if test "$enable_framework"
1339 then
1340 BASECFLAGS="$BASECFLAGS -fno-common -dynamic"
1341 # -F. is needed to allow linking to the framework while
1342 # in the build location.
1343 AC_DEFINE(WITH_NEXT_FRAMEWORK, 1,
1344 [Define if you want to produce an OpenStep/Rhapsody framework
1345 (shared library plus accessory files).])
1346 AC_MSG_RESULT(yes)
1347 else
1348 AC_MSG_RESULT(no)
1349 fi
1351 AC_MSG_CHECKING(for dyld)
1352 case $ac_sys_system/$ac_sys_release in
1353 Darwin/*)
1354 AC_DEFINE(WITH_DYLD, 1,
1355 [Define if you want to use the new-style (Openstep, Rhapsody, MacOS)
1356 dynamic linker (dyld) instead of the old-style (NextStep) dynamic
1357 linker (rld). Dyld is necessary to support frameworks.])
1358 AC_MSG_RESULT(always on for Darwin)
1359 ;;
1360 *)
1361 AC_MSG_RESULT(no)
1362 ;;
1363 esac
1365 # Set info about shared libraries.
1366 AC_SUBST(SO)
1367 AC_SUBST(LDSHARED)
1368 AC_SUBST(BLDSHARED)
1369 AC_SUBST(CCSHARED)
1370 AC_SUBST(LINKFORSHARED)
1371 # SO is the extension of shared libraries `(including the dot!)
1372 # -- usually .so, .sl on HP-UX, .dll on Cygwin
1373 AC_MSG_CHECKING(SO)
1374 if test -z "$SO"
1375 then
1376 case $ac_sys_system in
1377 hp*|HP*)
1378 case `uname -m` in
1379 ia64) SO=.so;;
1380 *) SO=.sl;;
1381 esac
1382 ;;
1383 CYGWIN*) SO=.dll;;
1384 *) SO=.so;;
1385 esac
1386 else
1387 # this might also be a termcap variable, see #610332
1388 echo
1389 echo '====================================================================='
1390 echo '+ +'
1391 echo '+ WARNING: You have set SO in your environment. +'
1392 echo '+ Do you really mean to change the extension for shared libraries? +'
1393 echo '+ Continuing in 10 seconds to let you to ponder. +'
1394 echo '+ +'
1395 echo '====================================================================='
1396 sleep 10
1397 fi
1398 AC_MSG_RESULT($SO)
1399 AC_DEFINE_UNQUOTED(SHLIB_EXT, "$SO", [Define this to be extension of shared libraries (including the dot!).])
1400 # LDSHARED is the ld *command* used to create shared library
1401 # -- "cc -G" on SunOS 5.x, "ld -shared" on IRIX 5
1402 # (Shared libraries in this instance are shared modules to be loaded into
1403 # Python, as opposed to building Python itself as a shared library.)
1404 AC_MSG_CHECKING(LDSHARED)
1405 if test -z "$LDSHARED"
1406 then
1407 case $ac_sys_system/$ac_sys_release in
1408 AIX*)
1409 BLDSHARED="\$(srcdir)/Modules/ld_so_aix \$(CC) -bI:Modules/python.exp"
1410 LDSHARED="\$(BINLIBDEST)/config/ld_so_aix \$(CC) -bI:\$(BINLIBDEST)/config/python.exp"
1411 ;;
1412 BeOS*)
1413 BLDSHARED="\$(srcdir)/Modules/ld_so_beos $LDLIBRARY"
1414 LDSHARED="\$(BINLIBDEST)/config/ld_so_beos \$(LIBDIR)/$LDLIBRARY"
1415 ;;
1416 IRIX/5*) LDSHARED="ld -shared";;
1417 IRIX*/6*) LDSHARED="ld ${SGI_ABI} -shared -all";;
1418 SunOS/5*)
1419 if test "$GCC" = "yes"
1420 then LDSHARED='$(CC) -shared'
1421 else LDSHARED='$(CC) -G';
1422 fi ;;
1423 hp*|HP*) LDSHARED="ld -b";;
1424 OSF*) LDSHARED="ld -shared -expect_unresolved \"*\"";;
1425 Darwin/1.3*)
1426 LDSHARED='$(CC) $(LDFLAGS) -bundle'
1427 if test "$enable_framework" ; then
1428 # Link against the framework. All externals should be defined.
1429 BLDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1430 LDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKPREFIX)/$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1431 else
1432 # No framework. Ignore undefined symbols, assuming they come from Python
1433 LDSHARED="$LDSHARED -undefined suppress"
1434 fi ;;
1435 Darwin/1.4*|Darwin/5.*|Darwin/6.*)
1436 LDSHARED='$(CC) $(LDFLAGS) -bundle'
1437 if test "$enable_framework" ; then
1438 # Link against the framework. All externals should be defined.
1439 BLDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1440 LDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKPREFIX)/$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1441 else
1442 # No framework, use the Python app as bundle-loader
1443 BLDSHARED="$LDSHARED "'-bundle_loader $(BUILDPYTHON)'
1444 LDSHARED="$LDSHARED "'-bundle_loader $(BINDIR)/python$(VERSION)$(EXE)'
1445 fi ;;
1446 Darwin/*)
1447 # Use -undefined dynamic_lookup whenever possible (10.3 and later).
1448 # This allows an extension to be used in any Python
1449 cur_target=`sw_vers -productVersion | sed 's/\(10\.[[0-9]]*\).*/\1/'`
1450 if test ${cur_target} '>' 10.2; then
1451 cur_target=10.3
1452 fi
1453 CONFIGURE_MACOSX_DEPLOYMENT_TARGET=${MACOSX_DEPLOYMENT_TARGET-${cur_target}}
1454 EXPORT_MACOSX_DEPLOYMENT_TARGET=''
1455 if test ${MACOSX_DEPLOYMENT_TARGET-${cur_target}} '>' 10.2
1456 then
1457 if test "${enable_universalsdk}"; then
1458 LDFLAGS="-arch i386 -arch ppc -isysroot ${UNIVERSALSDK} ${LDFLAGS}"
1459 fi
1460 LDSHARED='$(CC) $(LDFLAGS) -bundle -undefined dynamic_lookup'
1461 BLDSHARED="$LDSHARED"
1462 else
1463 LDSHARED='$(CC) $(LDFLAGS) -bundle'
1464 if test "$enable_framework" ; then
1465 # Link against the framework. All externals should be defined.
1466 BLDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1467 LDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKPREFIX)/$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1468 else
1469 # No framework, use the Python app as bundle-loader
1470 BLDSHARED="$LDSHARED "'-bundle_loader $(BUILDPYTHON)'
1471 LDSHARED="$LDSHARED "'-bundle_loader $(BINDIR)/python$(VERSION)$(EXE)'
1472 fi
1473 fi
1474 ;;
1475 Linux*|GNU*) LDSHARED='$(CC) -shared';;
1476 BSD/OS*/4*) LDSHARED="gcc -shared";;
1477 OpenBSD*|FreeBSD*)
1478 if [[ "`$CC -dM -E - </dev/null | grep __ELF__`" != "" ]]
1479 then
1480 LDSHARED="$CC -shared ${LDFLAGS}"
1481 else
1482 LDSHARED="ld -Bshareable ${LDFLAGS}"
1483 fi;;
1484 NetBSD*|DragonFly*) LDSHARED="cc -shared ${LDFLAGS}";;
1485 OpenUNIX*|UnixWare*)
1486 if test "$GCC" = "yes"
1487 then LDSHARED='$(CC) -shared'
1488 else LDSHARED='$(CC) -G'
1489 fi;;
1490 SCO_SV*) LDSHARED='$(CC) -Wl,-G,-Bexport';;
1491 Monterey*) LDSHARED="cc -G -dy -Bdynamic -Bexport -L/usr/lib/ia64l64";;
1492 CYGWIN*) LDSHARED="gcc -shared -Wl,--enable-auto-image-base";;
1493 atheos*) LDSHARED="gcc -shared";;
1494 *) LDSHARED="ld";;
1495 esac
1496 fi
1497 AC_MSG_RESULT($LDSHARED)
1498 BLDSHARED=${BLDSHARED-$LDSHARED}
1499 # CCSHARED are the C *flags* used to create objects to go into a shared
1500 # library (module) -- this is only needed for a few systems
1501 AC_MSG_CHECKING(CCSHARED)
1502 if test -z "$CCSHARED"
1503 then
1504 case $ac_sys_system/$ac_sys_release in
1505 SunOS*) if test "$GCC" = yes;
1506 then CCSHARED="-fPIC";
1507 else CCSHARED="-xcode=pic32";
1508 fi;;
1509 hp*|HP*) if test "$GCC" = yes;
1510 then CCSHARED="-fPIC";
1511 else CCSHARED="+z";
1512 fi;;
1513 Linux*|GNU*) CCSHARED="-fPIC";;
1514 BSD/OS*/4*) CCSHARED="-fpic";;
1515 FreeBSD*|NetBSD*|OpenBSD*|DragonFly*) CCSHARED="-fPIC";;
1516 OpenUNIX*|UnixWare*)
1517 if test "$GCC" = "yes"
1518 then CCSHARED="-fPIC"
1519 else CCSHARED="-KPIC"
1520 fi;;
1521 SCO_SV*)
1522 if test "$GCC" = "yes"
1523 then CCSHARED="-fPIC"
1524 else CCSHARED="-Kpic -belf"
1525 fi;;
1526 Monterey*) CCSHARED="-G";;
1527 IRIX*/6*) case $CC in
1528 *gcc*) CCSHARED="-shared";;
1529 *) CCSHARED="";;
1530 esac;;
1531 atheos*) CCSHARED="-fPIC";;
1532 esac
1533 fi
1534 AC_MSG_RESULT($CCSHARED)
1535 # LINKFORSHARED are the flags passed to the $(CC) command that links
1536 # the python executable -- this is only needed for a few systems
1537 AC_MSG_CHECKING(LINKFORSHARED)
1538 if test -z "$LINKFORSHARED"
1539 then
1540 case $ac_sys_system/$ac_sys_release in
1541 AIX*) LINKFORSHARED='-Wl,-bE:Modules/python.exp -lld';;
1542 hp*|HP*)
1543 LINKFORSHARED="-Wl,-E -Wl,+s";;
1544 # LINKFORSHARED="-Wl,-E -Wl,+s -Wl,+b\$(BINLIBDEST)/lib-dynload";;
1545 BSD/OS/4*) LINKFORSHARED="-Xlinker -export-dynamic";;
1546 Linux*|GNU*) LINKFORSHARED="-Xlinker -export-dynamic";;
1547 # -u libsys_s pulls in all symbols in libsys
1548 Darwin/*)
1549 # -u _PyMac_Error is needed to pull in the mac toolbox glue,
1550 # which is
1551 # not used by the core itself but which needs to be in the core so
1552 # that dynamically loaded extension modules have access to it.
1553 # -prebind is no longer used, because it actually seems to give a
1554 # slowdown in stead of a speedup, maybe due to the large number of
1555 # dynamic loads Python does.
1557 LINKFORSHARED="$extra_undefs"
1558 if test "$enable_framework"
1559 then
1560 LINKFORSHARED="$LINKFORSHARED "'$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1561 fi
1562 LINKFORSHARED="$LINKFORSHARED";;
1563 OpenUNIX*|UnixWare*) LINKFORSHARED="-Wl,-Bexport";;
1564 SCO_SV*) LINKFORSHARED="-Wl,-Bexport";;
1565 ReliantUNIX*) LINKFORSHARED="-W1 -Blargedynsym";;
1566 FreeBSD*|NetBSD*|OpenBSD*|DragonFly*)
1567 if [[ "`$CC -dM -E - </dev/null | grep __ELF__`" != "" ]]
1568 then
1569 LINKFORSHARED="-Wl,--export-dynamic"
1570 fi;;
1571 SunOS/5*) case $CC in
1572 *gcc*)
1573 if $CC -Xlinker --help 2>&1 | grep export-dynamic >/dev/null
1574 then
1575 LINKFORSHARED="-Xlinker --export-dynamic"
1576 fi;;
1577 esac;;
1578 CYGWIN*)
1579 if test $enable_shared = "no"
1580 then
1581 LINKFORSHARED='-Wl,--out-implib=$(LDLIBRARY)'
1582 fi;;
1583 esac
1584 fi
1585 AC_MSG_RESULT($LINKFORSHARED)
1587 AC_SUBST(CFLAGSFORSHARED)
1588 AC_MSG_CHECKING(CFLAGSFORSHARED)
1589 if test ! "$LIBRARY" = "$LDLIBRARY"
1590 then
1591 case $ac_sys_system in
1592 CYGWIN*)
1593 # Cygwin needs CCSHARED when building extension DLLs
1594 # but not when building the interpreter DLL.
1595 CFLAGSFORSHARED='';;
1596 *)
1597 CFLAGSFORSHARED='$(CCSHARED)'
1598 esac
1599 fi
1600 AC_MSG_RESULT($CFLAGSFORSHARED)
1602 # SHLIBS are libraries (except -lc and -lm) to link to the python shared
1603 # library (with --enable-shared).
1604 # For platforms on which shared libraries are not allowed to have unresolved
1605 # symbols, this must be set to $(LIBS) (expanded by make). We do this even
1606 # if it is not required, since it creates a dependency of the shared library
1607 # to LIBS. This, in turn, means that applications linking the shared libpython
1608 # don't need to link LIBS explicitly. The default should be only changed
1609 # on systems where this approach causes problems.
1610 AC_SUBST(SHLIBS)
1611 AC_MSG_CHECKING(SHLIBS)
1612 case "$ac_sys_system" in
1613 *)
1614 SHLIBS='$(LIBS)';;
1615 esac
1616 AC_MSG_RESULT($SHLIBS)
1619 # checks for libraries
1620 AC_CHECK_LIB(dl, dlopen) # Dynamic linking for SunOS/Solaris and SYSV
1621 AC_CHECK_LIB(dld, shl_load) # Dynamic linking for HP-UX
1623 # only check for sem_ini if thread support is requested
1624 if test "$with_threads" = "yes" -o -z "$with_threads"; then
1625 AC_SEARCH_LIBS(sem_init, pthread rt posix4) # 'Real Time' functions on Solaris
1626 # posix4 on Solaris 2.6
1627 # pthread (first!) on Linux
1628 fi
1630 # check if we need libintl for locale functions
1631 AC_CHECK_LIB(intl, textdomain,
1632 AC_DEFINE(WITH_LIBINTL, 1,
1633 [Define to 1 if libintl is needed for locale functions.]))
1635 # checks for system dependent C++ extensions support
1636 case "$ac_sys_system" in
1637 AIX*) AC_MSG_CHECKING(for genuine AIX C++ extensions support)
1638 AC_TRY_LINK([#include "/usr/lpp/xlC/include/load.h"],
1639 [loadAndInit("", 0, "")],
1640 [AC_DEFINE(AIX_GENUINE_CPLUSPLUS, 1,
1641 [Define for AIX if your compiler is a genuine IBM xlC/xlC_r
1642 and you want support for AIX C++ shared extension modules.])
1643 AC_MSG_RESULT(yes)],
1644 [AC_MSG_RESULT(no)]);;
1645 *) ;;
1646 esac
1648 # Most SVR4 platforms (e.g. Solaris) need -lsocket and -lnsl.
1649 # BeOS' sockets are stashed in libnet.
1650 AC_CHECK_LIB(nsl, t_open, [LIBS="-lnsl $LIBS"]) # SVR4
1651 AC_CHECK_LIB(socket, socket, [LIBS="-lsocket $LIBS"], [], $LIBS) # SVR4 sockets
1653 case "$ac_sys_system" in
1654 BeOS*)
1655 AC_CHECK_LIB(net, socket, [LIBS="-lnet $LIBS"], [], $LIBS) # BeOS
1656 ;;
1657 esac
1659 AC_MSG_CHECKING(for --with-libs)
1660 AC_ARG_WITH(libs,
1661 AC_HELP_STRING(--with-libs='lib1 ...', link against additional libs),
1662 [
1663 AC_MSG_RESULT($withval)
1664 LIBS="$withval $LIBS"
1665 ],
1666 [AC_MSG_RESULT(no)])
1668 # Check for use of the system libffi library
1669 AC_MSG_CHECKING(for --with-system-ffi)
1670 AC_ARG_WITH(system_ffi,
1671 AC_HELP_STRING(--with-system-ffi, build _ctypes module using an installed ffi library))
1673 if test -z "$with_system_ffi"
1674 then with_system_ffi="no"
1675 fi
1676 AC_MSG_RESULT($with_system_ffi)
1678 # Determine if signalmodule should be used.
1679 AC_SUBST(USE_SIGNAL_MODULE)
1680 AC_SUBST(SIGNAL_OBJS)
1681 AC_MSG_CHECKING(for --with-signal-module)
1682 AC_ARG_WITH(signal-module,
1683 AC_HELP_STRING(--with-signal-module, disable/enable signal module))
1685 if test -z "$with_signal_module"
1686 then with_signal_module="yes"
1687 fi
1688 AC_MSG_RESULT($with_signal_module)
1690 if test "${with_signal_module}" = "yes"; then
1691 USE_SIGNAL_MODULE=""
1692 SIGNAL_OBJS=""
1693 else
1694 USE_SIGNAL_MODULE="#"
1695 SIGNAL_OBJS="Parser/intrcheck.o Python/sigcheck.o"
1696 fi
1698 # This is used to generate Setup.config
1699 AC_SUBST(USE_THREAD_MODULE)
1700 USE_THREAD_MODULE=""
1702 AC_MSG_CHECKING(for --with-dec-threads)
1703 AC_SUBST(LDLAST)
1704 AC_ARG_WITH(dec-threads,
1705 AC_HELP_STRING(--with-dec-threads, use DEC Alpha/OSF1 thread-safe libraries),
1706 [
1707 AC_MSG_RESULT($withval)
1708 LDLAST=-threads
1709 if test "${with_thread+set}" != set; then
1710 with_thread="$withval";
1711 fi],
1712 [AC_MSG_RESULT(no)])
1714 # Templates for things AC_DEFINEd more than once.
1715 # For a single AC_DEFINE, no template is needed.
1716 AH_TEMPLATE(C_THREADS,[Define if you have the Mach cthreads package])
1717 AH_TEMPLATE(_REENTRANT,
1718 [Define to force use of thread-safe errno, h_errno, and other functions])
1719 AH_TEMPLATE(WITH_THREAD,
1720 [Define if you want to compile in rudimentary thread support])
1722 AC_MSG_CHECKING(for --with-threads)
1723 dnl quadrigraphs "@<:@" and "@:>@" produce "[" and "]" in the output
1724 AC_ARG_WITH(threads,
1725 AC_HELP_STRING(--with(out)-threads@<:@=DIRECTORY@:>@, disable/enable thread support))
1727 # --with-thread is deprecated, but check for it anyway
1728 dnl quadrigraphs "@<:@" and "@:>@" produce "[" and "]" in the output
1729 AC_ARG_WITH(thread,
1730 AC_HELP_STRING(--with(out)-thread@<:@=DIRECTORY@:>@, deprecated; use --with(out)-threads),
1731 [with_threads=$with_thread])
1733 if test -z "$with_threads"
1734 then with_threads="yes"
1735 fi
1736 AC_MSG_RESULT($with_threads)
1738 AC_SUBST(THREADOBJ)
1739 if test "$with_threads" = "no"
1740 then
1741 USE_THREAD_MODULE="#"
1742 elif test "$ac_cv_pthread_is_default" = yes
1743 then
1744 AC_DEFINE(WITH_THREAD)
1745 # Defining _REENTRANT on system with POSIX threads should not hurt.
1746 AC_DEFINE(_REENTRANT)
1747 posix_threads=yes
1748 THREADOBJ="Python/thread.o"
1749 elif test "$ac_cv_kpthread" = "yes"
1750 then
1751 CC="$CC -Kpthread"
1752 if test "$ac_cv_cxx_thread" = "yes"; then
1753 CXX="$CXX -Kpthread"
1754 fi
1755 AC_DEFINE(WITH_THREAD)
1756 posix_threads=yes
1757 THREADOBJ="Python/thread.o"
1758 elif test "$ac_cv_kthread" = "yes"
1759 then
1760 CC="$CC -Kthread"
1761 if test "$ac_cv_cxx_thread" = "yes"; then
1762 CXX="$CXX -Kthread"
1763 fi
1764 AC_DEFINE(WITH_THREAD)
1765 posix_threads=yes
1766 THREADOBJ="Python/thread.o"
1767 elif test "$ac_cv_pthread" = "yes"
1768 then
1769 CC="$CC -pthread"
1770 if test "$ac_cv_cxx_thread" = "yes"; then
1771 CXX="$CXX -pthread"
1772 fi
1773 AC_DEFINE(WITH_THREAD)
1774 posix_threads=yes
1775 THREADOBJ="Python/thread.o"
1776 else
1777 if test ! -z "$with_threads" -a -d "$with_threads"
1778 then LDFLAGS="$LDFLAGS -L$with_threads"
1779 fi
1780 if test ! -z "$withval" -a -d "$withval"
1781 then LDFLAGS="$LDFLAGS -L$withval"
1782 fi
1784 # According to the POSIX spec, a pthreads implementation must
1785 # define _POSIX_THREADS in unistd.h. Some apparently don't
1786 # (e.g. gnu pth with pthread emulation)
1787 AC_MSG_CHECKING(for _POSIX_THREADS in unistd.h)
1788 AC_EGREP_CPP(yes,
1789 [
1790 #include <unistd.h>
1791 #ifdef _POSIX_THREADS
1792 yes
1793 #endif
1794 ], unistd_defines_pthreads=yes, unistd_defines_pthreads=no)
1795 AC_MSG_RESULT($unistd_defines_pthreads)
1797 AC_DEFINE(_REENTRANT)
1798 AC_CHECK_HEADER(cthreads.h, [AC_DEFINE(WITH_THREAD)
1799 AC_DEFINE(C_THREADS)
1800 AC_DEFINE(HURD_C_THREADS, 1,
1801 [Define if you are using Mach cthreads directly under /include])
1802 LIBS="$LIBS -lthreads"
1803 THREADOBJ="Python/thread.o"],[
1804 AC_CHECK_HEADER(mach/cthreads.h, [AC_DEFINE(WITH_THREAD)
1805 AC_DEFINE(C_THREADS)
1806 AC_DEFINE(MACH_C_THREADS, 1,
1807 [Define if you are using Mach cthreads under mach /])
1808 THREADOBJ="Python/thread.o"],[
1809 AC_MSG_CHECKING(for --with-pth)
1810 AC_ARG_WITH([pth],
1811 AC_HELP_STRING(--with-pth, use GNU pth threading libraries),
1812 [AC_MSG_RESULT($withval)
1813 AC_DEFINE([WITH_THREAD])
1814 AC_DEFINE([HAVE_PTH], 1,
1815 [Define if you have GNU PTH threads.])
1816 LIBS="-lpth $LIBS"
1817 THREADOBJ="Python/thread.o"],
1818 [AC_MSG_RESULT(no)
1820 # Just looking for pthread_create in libpthread is not enough:
1821 # on HP/UX, pthread.h renames pthread_create to a different symbol name.
1822 # So we really have to include pthread.h, and then link.
1823 _libs=$LIBS
1824 LIBS="$LIBS -lpthread"
1825 AC_MSG_CHECKING([for pthread_create in -lpthread])
1826 AC_TRY_LINK([#include <pthread.h>
1828 void * start_routine (void *arg) { exit (0); }], [
1829 pthread_create (NULL, NULL, start_routine, NULL)], [
1830 AC_MSG_RESULT(yes)
1831 AC_DEFINE(WITH_THREAD)
1832 posix_threads=yes
1833 THREADOBJ="Python/thread.o"],[
1834 LIBS=$_libs
1835 AC_CHECK_FUNC(pthread_detach, [AC_DEFINE(WITH_THREAD)
1836 posix_threads=yes
1837 THREADOBJ="Python/thread.o"],[
1838 AC_CHECK_HEADER(atheos/threads.h, [AC_DEFINE(WITH_THREAD)
1839 AC_DEFINE(ATHEOS_THREADS, 1,
1840 [Define this if you have AtheOS threads.])
1841 THREADOBJ="Python/thread.o"],[
1842 AC_CHECK_HEADER(kernel/OS.h, [AC_DEFINE(WITH_THREAD)
1843 AC_DEFINE(BEOS_THREADS, 1,
1844 [Define this if you have BeOS threads.])
1845 THREADOBJ="Python/thread.o"],[
1846 AC_CHECK_LIB(pthreads, pthread_create, [AC_DEFINE(WITH_THREAD)
1847 posix_threads=yes
1848 LIBS="$LIBS -lpthreads"
1849 THREADOBJ="Python/thread.o"], [
1850 AC_CHECK_LIB(c_r, pthread_create, [AC_DEFINE(WITH_THREAD)
1851 posix_threads=yes
1852 LIBS="$LIBS -lc_r"
1853 THREADOBJ="Python/thread.o"], [
1854 AC_CHECK_LIB(pthread, __pthread_create_system, [AC_DEFINE(WITH_THREAD)
1855 posix_threads=yes
1856 LIBS="$LIBS -lpthread"
1857 THREADOBJ="Python/thread.o"], [
1858 AC_CHECK_LIB(cma, pthread_create, [AC_DEFINE(WITH_THREAD)
1859 posix_threads=yes
1860 LIBS="$LIBS -lcma"
1861 THREADOBJ="Python/thread.o"],[
1862 USE_THREAD_MODULE="#"])
1863 ])])])])])])])])])])
1865 AC_CHECK_LIB(mpc, usconfig, [AC_DEFINE(WITH_THREAD)
1866 LIBS="$LIBS -lmpc"
1867 THREADOBJ="Python/thread.o"
1868 USE_THREAD_MODULE=""])
1870 if test "$posix_threads" != "yes"; then
1871 AC_CHECK_LIB(thread, thr_create, [AC_DEFINE(WITH_THREAD)
1872 LIBS="$LIBS -lthread"
1873 THREADOBJ="Python/thread.o"
1874 USE_THREAD_MODULE=""])
1875 fi
1877 if test "$USE_THREAD_MODULE" != "#"
1878 then
1879 # If the above checks didn't disable threads, (at least) OSF1
1880 # needs this '-threads' argument during linking.
1881 case $ac_sys_system in
1882 OSF1) LDLAST=-threads;;
1883 esac
1884 fi
1885 fi
1887 if test "$posix_threads" = "yes"; then
1888 if test "$unistd_defines_pthreads" = "no"; then
1889 AC_DEFINE(_POSIX_THREADS, 1,
1890 [Define if you have POSIX threads,
1891 and your system does not define that.])
1892 fi
1894 # Bug 662787: Using semaphores causes unexplicable hangs on Solaris 8.
1895 case $ac_sys_system/$ac_sys_release in
1896 SunOS/5.6) AC_DEFINE(HAVE_PTHREAD_DESTRUCTOR, 1,
1897 Defined for Solaris 2.6 bug in pthread header.)
1898 ;;
1899 SunOS/5.8) AC_DEFINE(HAVE_BROKEN_POSIX_SEMAPHORES, 1,
1900 Define if the Posix semaphores do not work on your system)
1901 ;;
1902 esac
1904 AC_MSG_CHECKING(if PTHREAD_SCOPE_SYSTEM is supported)
1905 AC_CACHE_VAL(ac_cv_pthread_system_supported,
1906 [AC_TRY_RUN([#include <pthread.h>
1907 void *foo(void *parm) {
1908 return NULL;
1909 }
1910 main() {
1911 pthread_attr_t attr;
1912 pthread_t id;
1913 if (pthread_attr_init(&attr)) exit(-1);
1914 if (pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM)) exit(-1);
1915 if (pthread_create(&id, &attr, foo, NULL)) exit(-1);
1916 exit(0);
1917 }],
1918 ac_cv_pthread_system_supported=yes,
1919 ac_cv_pthread_system_supported=no,
1920 ac_cv_pthread_system_supported=no)
1921 ])
1922 AC_MSG_RESULT($ac_cv_pthread_system_supported)
1923 if test "$ac_cv_pthread_system_supported" = "yes"; then
1924 AC_DEFINE(PTHREAD_SYSTEM_SCHED_SUPPORTED, 1, [Defined if PTHREAD_SCOPE_SYSTEM supported.])
1925 fi
1926 AC_CHECK_FUNCS(pthread_sigmask,
1927 [case $ac_sys_system in
1928 CYGWIN*)
1929 AC_DEFINE(HAVE_BROKEN_PTHREAD_SIGMASK, 1,
1930 [Define if pthread_sigmask() does not work on your system.])
1931 ;;
1932 esac])
1933 fi
1936 # Check for enable-ipv6
1937 AH_TEMPLATE(ENABLE_IPV6, [Define if --enable-ipv6 is specified])
1938 AC_MSG_CHECKING([if --enable-ipv6 is specified])
1939 AC_ARG_ENABLE(ipv6,
1940 [ --enable-ipv6 Enable ipv6 (with ipv4) support
1941 --disable-ipv6 Disable ipv6 support],
1942 [ case "$enableval" in
1943 no)
1944 AC_MSG_RESULT(no)
1945 ipv6=no
1946 ;;
1947 *) AC_MSG_RESULT(yes)
1948 AC_DEFINE(ENABLE_IPV6)
1949 ipv6=yes
1950 ;;
1951 esac ],
1953 [
1954 dnl the check does not work on cross compilation case...
1955 AC_TRY_RUN([ /* AF_INET6 available check */
1956 #include <sys/types.h>
1957 #include <sys/socket.h>
1958 main()
1959 {
1960 if (socket(AF_INET6, SOCK_STREAM, 0) < 0)
1961 exit(1);
1962 else
1963 exit(0);
1964 }
1965 ],
1966 AC_MSG_RESULT(yes)
1967 ipv6=yes,
1968 AC_MSG_RESULT(no)
1969 ipv6=no,
1970 AC_MSG_RESULT(no)
1971 ipv6=no
1972 )
1974 if test "$ipv6" = "yes"; then
1975 AC_MSG_CHECKING(if RFC2553 API is available)
1976 AC_TRY_COMPILE([#include <sys/types.h>
1977 #include <netinet/in.h>],
1978 [struct sockaddr_in6 x;
1979 x.sin6_scope_id;],
1980 AC_MSG_RESULT(yes)
1981 ipv6=yes,
1982 AC_MSG_RESULT(no, IPv6 disabled)
1983 ipv6=no)
1984 fi
1986 if test "$ipv6" = "yes"; then
1987 AC_DEFINE(ENABLE_IPV6)
1988 fi
1989 ])
1991 ipv6type=unknown
1992 ipv6lib=none
1993 ipv6trylibc=no
1995 if test "$ipv6" = "yes"; then
1996 AC_MSG_CHECKING([ipv6 stack type])
1997 for i in inria kame linux-glibc linux-inet6 solaris toshiba v6d zeta;
1998 do
1999 case $i in
2000 inria)
2001 dnl http://www.kame.net/
2002 AC_EGREP_CPP(yes, [
2003 #include <netinet/in.h>
2004 #ifdef IPV6_INRIA_VERSION
2005 yes
2006 #endif],
2007 [ipv6type=$i])
2008 ;;
2009 kame)
2010 dnl http://www.kame.net/
2011 AC_EGREP_CPP(yes, [
2012 #include <netinet/in.h>
2013 #ifdef __KAME__
2014 yes
2015 #endif],
2016 [ipv6type=$i;
2017 ipv6lib=inet6
2018 ipv6libdir=/usr/local/v6/lib
2019 ipv6trylibc=yes])
2020 ;;
2021 linux-glibc)
2022 dnl http://www.v6.linux.or.jp/
2023 AC_EGREP_CPP(yes, [
2024 #include <features.h>
2025 #if defined(__GLIBC__) && ((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 1) || (__GLIBC__ > 2))
2026 yes
2027 #endif],
2028 [ipv6type=$i;
2029 ipv6trylibc=yes])
2030 ;;
2031 linux-inet6)
2032 dnl http://www.v6.linux.or.jp/
2033 if test -d /usr/inet6; then
2034 ipv6type=$i
2035 ipv6lib=inet6
2036 ipv6libdir=/usr/inet6/lib
2037 BASECFLAGS="-I/usr/inet6/include $BASECFLAGS"
2038 fi
2039 ;;
2040 solaris)
2041 if test -f /etc/netconfig; then
2042 if /usr/xpg4/bin/grep -q tcp6 /etc/netconfig; then
2043 ipv6type=$i
2044 ipv6trylibc=yes
2045 fi
2046 fi
2047 ;;
2048 toshiba)
2049 AC_EGREP_CPP(yes, [
2050 #include <sys/param.h>
2051 #ifdef _TOSHIBA_INET6
2052 yes
2053 #endif],
2054 [ipv6type=$i;
2055 ipv6lib=inet6;
2056 ipv6libdir=/usr/local/v6/lib])
2057 ;;
2058 v6d)
2059 AC_EGREP_CPP(yes, [
2060 #include </usr/local/v6/include/sys/v6config.h>
2061 #ifdef __V6D__
2062 yes
2063 #endif],
2064 [ipv6type=$i;
2065 ipv6lib=v6;
2066 ipv6libdir=/usr/local/v6/lib;
2067 BASECFLAGS="-I/usr/local/v6/include $BASECFLAGS"])
2068 ;;
2069 zeta)
2070 AC_EGREP_CPP(yes, [
2071 #include <sys/param.h>
2072 #ifdef _ZETA_MINAMI_INET6
2073 yes
2074 #endif],
2075 [ipv6type=$i;
2076 ipv6lib=inet6;
2077 ipv6libdir=/usr/local/v6/lib])
2078 ;;
2079 esac
2080 if test "$ipv6type" != "unknown"; then
2081 break
2082 fi
2083 done
2084 AC_MSG_RESULT($ipv6type)
2085 fi
2087 if test "$ipv6" = "yes" -a "$ipv6lib" != "none"; then
2088 if test -d $ipv6libdir -a -f $ipv6libdir/lib$ipv6lib.a; then
2089 LIBS="-L$ipv6libdir -l$ipv6lib $LIBS"
2090 echo "using lib$ipv6lib"
2091 else
2092 if test $ipv6trylibc = "yes"; then
2093 echo "using libc"
2094 else
2095 echo 'Fatal: no $ipv6lib library found. cannot continue.'
2096 echo "You need to fetch lib$ipv6lib.a from appropriate"
2097 echo 'ipv6 kit and compile beforehand.'
2098 exit 1
2099 fi
2100 fi
2101 fi
2103 # Check for --with-doc-strings
2104 AC_MSG_CHECKING(for --with-doc-strings)
2105 AC_ARG_WITH(doc-strings,
2106 AC_HELP_STRING(--with(out)-doc-strings, disable/enable documentation strings))
2108 if test -z "$with_doc_strings"
2109 then with_doc_strings="yes"
2110 fi
2111 if test "$with_doc_strings" != "no"
2112 then
2113 AC_DEFINE(WITH_DOC_STRINGS, 1,
2114 [Define if you want documentation strings in extension modules])
2115 fi
2116 AC_MSG_RESULT($with_doc_strings)
2118 # Check for Python-specific malloc support
2119 AC_MSG_CHECKING(for --with-tsc)
2120 AC_ARG_WITH(tsc,
2121 [ --with(out)-tsc enable/disable timestamp counter profile], [
2122 if test "$withval" != no
2123 then
2124 AC_DEFINE(WITH_TSC, 1,
2125 [Define to profile with the Pentium timestamp counter])
2126 AC_MSG_RESULT(yes)
2127 else AC_MSG_RESULT(no)
2128 fi],
2129 [AC_MSG_RESULT(no)])
2131 # Check for Python-specific malloc support
2132 AC_MSG_CHECKING(for --with-pymalloc)
2133 AC_ARG_WITH(pymalloc,
2134 AC_HELP_STRING(--with(out)-pymalloc, disable/enable specialized mallocs))
2136 if test -z "$with_pymalloc"
2137 then with_pymalloc="yes"
2138 fi
2139 if test "$with_pymalloc" != "no"
2140 then
2141 AC_DEFINE(WITH_PYMALLOC, 1,
2142 [Define if you want to compile in Python-specific mallocs])
2143 fi
2144 AC_MSG_RESULT($with_pymalloc)
2146 # Check for --with-wctype-functions
2147 AC_MSG_CHECKING(for --with-wctype-functions)
2148 AC_ARG_WITH(wctype-functions,
2149 AC_HELP_STRING(--with-wctype-functions, use wctype.h functions),
2150 [
2151 if test "$withval" != no
2152 then
2153 AC_DEFINE(WANT_WCTYPE_FUNCTIONS, 1,
2154 [Define if you want wctype.h functions to be used instead of the
2155 one supplied by Python itself. (see Include/unicodectype.h).])
2156 AC_MSG_RESULT(yes)
2157 else AC_MSG_RESULT(no)
2158 fi],
2159 [AC_MSG_RESULT(no)])
2161 # -I${DLINCLDIR} is added to the compile rule for importdl.o
2162 AC_SUBST(DLINCLDIR)
2163 DLINCLDIR=.
2165 # the dlopen() function means we might want to use dynload_shlib.o. some
2166 # platforms, such as AIX, have dlopen(), but don't want to use it.
2167 AC_CHECK_FUNCS(dlopen)
2169 # DYNLOADFILE specifies which dynload_*.o file we will use for dynamic
2170 # loading of modules.
2171 AC_SUBST(DYNLOADFILE)
2172 AC_MSG_CHECKING(DYNLOADFILE)
2173 if test -z "$DYNLOADFILE"
2174 then
2175 case $ac_sys_system/$ac_sys_release in
2176 AIX*) # Use dynload_shlib.c and dlopen() if we have it; otherwise dynload_aix.c
2177 if test "$ac_cv_func_dlopen" = yes
2178 then DYNLOADFILE="dynload_shlib.o"
2179 else DYNLOADFILE="dynload_aix.o"
2180 fi
2181 ;;
2182 BeOS*) DYNLOADFILE="dynload_beos.o";;
2183 hp*|HP*) DYNLOADFILE="dynload_hpux.o";;
2184 # Use dynload_next.c only on 10.2 and below, which don't have native dlopen()
2185 Darwin/@<:@0156@:>@\..*) DYNLOADFILE="dynload_next.o";;
2186 atheos*) DYNLOADFILE="dynload_atheos.o";;
2187 *)
2188 # use dynload_shlib.c and dlopen() if we have it; otherwise stub
2189 # out any dynamic loading
2190 if test "$ac_cv_func_dlopen" = yes
2191 then DYNLOADFILE="dynload_shlib.o"
2192 else DYNLOADFILE="dynload_stub.o"
2193 fi
2194 ;;
2195 esac
2196 fi
2197 AC_MSG_RESULT($DYNLOADFILE)
2198 if test "$DYNLOADFILE" != "dynload_stub.o"
2199 then
2200 AC_DEFINE(HAVE_DYNAMIC_LOADING, 1,
2201 [Defined when any dynamic module loading is enabled.])
2202 fi
2204 # MACHDEP_OBJS can be set to platform-specific object files needed by Python
2206 AC_SUBST(MACHDEP_OBJS)
2207 AC_MSG_CHECKING(MACHDEP_OBJS)
2208 if test -z "$MACHDEP_OBJS"
2209 then
2210 MACHDEP_OBJS=$extra_machdep_objs
2211 else
2212 MACHDEP_OBJS="$MACHDEP_OBJS $extra_machdep_objs"
2213 fi
2214 AC_MSG_RESULT(MACHDEP_OBJS)
2216 # checks for library functions
2217 AC_CHECK_FUNCS(alarm bind_textdomain_codeset chown clock confstr ctermid \
2218 execv fork fpathconf ftime ftruncate \
2219 gai_strerror getgroups getlogin getloadavg getpeername getpgid getpid \
2220 getpriority getpwent getspnam getspent getsid getwd \
2221 kill killpg lchown lstat mkfifo mknod mktime \
2222 mremap nice pathconf pause plock poll pthread_init \
2223 putenv readlink realpath \
2224 select setegid seteuid setgid \
2225 setlocale setregid setreuid setsid setpgid setpgrp setuid setvbuf snprintf \
2226 sigaction siginterrupt sigrelse strftime \
2227 sysconf tcgetpgrp tcsetpgrp tempnam timegm times tmpfile tmpnam tmpnam_r \
2228 truncate uname unsetenv utimes waitpid wait3 wait4 wcscoll _getpty)
2230 # For some functions, having a definition is not sufficient, since
2231 # we want to take their address.
2232 AC_MSG_CHECKING(for chroot)
2233 AC_TRY_COMPILE([#include <unistd.h>], void *x=chroot,
2234 AC_DEFINE(HAVE_CHROOT, 1, Define if you have the 'chroot' function.)
2235 AC_MSG_RESULT(yes),
2236 AC_MSG_RESULT(no)
2237 )
2238 AC_MSG_CHECKING(for link)
2239 AC_TRY_COMPILE([#include <unistd.h>], void *x=link,
2240 AC_DEFINE(HAVE_LINK, 1, Define if you have the 'link' function.)
2241 AC_MSG_RESULT(yes),
2242 AC_MSG_RESULT(no)
2243 )
2244 AC_MSG_CHECKING(for symlink)
2245 AC_TRY_COMPILE([#include <unistd.h>], void *x=symlink,
2246 AC_DEFINE(HAVE_SYMLINK, 1, Define if you have the 'symlink' function.)
2247 AC_MSG_RESULT(yes),
2248 AC_MSG_RESULT(no)
2249 )
2250 AC_MSG_CHECKING(for fchdir)
2251 AC_TRY_COMPILE([#include <unistd.h>], void *x=fchdir,
2252 AC_DEFINE(HAVE_FCHDIR, 1, Define if you have the 'fchdir' function.)
2253 AC_MSG_RESULT(yes),
2254 AC_MSG_RESULT(no)
2255 )
2256 AC_MSG_CHECKING(for fsync)
2257 AC_TRY_COMPILE([#include <unistd.h>], void *x=fsync,
2258 AC_DEFINE(HAVE_FSYNC, 1, Define if you have the 'fsync' function.)
2259 AC_MSG_RESULT(yes),
2260 AC_MSG_RESULT(no)
2261 )
2262 AC_MSG_CHECKING(for fdatasync)
2263 AC_TRY_COMPILE([#include <unistd.h>], void *x=fdatasync,
2264 AC_DEFINE(HAVE_FDATASYNC, 1, Define if you have the 'fdatasync' function.)
2265 AC_MSG_RESULT(yes),
2266 AC_MSG_RESULT(no)
2267 )
2269 # On some systems (eg. FreeBSD 5), we would find a definition of the
2270 # functions ctermid_r, setgroups in the library, but no prototype
2271 # (e.g. because we use _XOPEN_SOURCE). See whether we can take their
2272 # address to avoid compiler warnings and potential miscompilations
2273 # because of the missing prototypes.
2275 AC_MSG_CHECKING(for ctermid_r)
2276 AC_TRY_COMPILE([
2277 #include "confdefs.h"
2278 #include <stdio.h>
2279 ], void* p = ctermid_r,
2280 AC_DEFINE(HAVE_CTERMID_R, 1, Define if you have the 'ctermid_r' function.)
2281 AC_MSG_RESULT(yes),
2282 AC_MSG_RESULT(no)
2283 )
2285 AC_MSG_CHECKING(for flock)
2286 AC_TRY_COMPILE([
2287 #include "confdefs.h"
2288 #include <sys/file.h>
2289 ], void* p = flock,
2290 AC_DEFINE(HAVE_FLOCK, 1, Define if you have the 'flock' function.)
2291 AC_MSG_RESULT(yes),
2292 AC_MSG_RESULT(no)
2293 )
2295 AC_MSG_CHECKING(for getpagesize)
2296 AC_TRY_COMPILE([
2297 #include "confdefs.h"
2298 #include <unistd.h>
2299 ], void* p = getpagesize,
2300 AC_DEFINE(HAVE_GETPAGESIZE, 1, Define if you have the 'getpagesize' function.)
2301 AC_MSG_RESULT(yes),
2302 AC_MSG_RESULT(no)
2303 )
2305 dnl check for true
2306 AC_CHECK_PROGS(TRUE, true, /bin/true)
2308 dnl On some systems (e.g. Solaris 9), hstrerror and inet_aton are in -lresolv
2309 dnl On others, they are in the C library, so we to take no action
2310 AC_CHECK_LIB(c, inet_aton, [$ac_cv_prog_TRUE],
2311 AC_CHECK_LIB(resolv, inet_aton)
2312 )
2314 AC_MSG_CHECKING(for hstrerror)
2315 AC_TRY_LINK([
2316 #include "confdefs.h"
2317 #include <netdb.h>
2318 ], void* p = hstrerror; hstrerror(0),
2319 AC_DEFINE(HAVE_HSTRERROR, 1, Define if you have the 'hstrerror' function.)
2320 AC_MSG_RESULT(yes),
2321 AC_MSG_RESULT(no)
2322 )
2324 AC_MSG_CHECKING(for inet_aton)
2325 AC_TRY_LINK([
2326 #include "confdefs.h"
2327 #include <sys/types.h>
2328 #include <sys/socket.h>
2329 #include <netinet/in.h>
2330 #include <arpa/inet.h>
2331 ], void* p = inet_aton;inet_aton(0,0),
2332 AC_DEFINE(HAVE_INET_ATON, 1, Define if you have the 'inet_aton' function.)
2333 AC_MSG_RESULT(yes),
2334 AC_MSG_RESULT(no)
2335 )
2337 AC_MSG_CHECKING(for inet_pton)
2338 AC_TRY_COMPILE([
2339 #include "confdefs.h"
2340 #include <sys/types.h>
2341 #include <sys/socket.h>
2342 #include <netinet/in.h>
2343 #include <arpa/inet.h>
2344 ], void* p = inet_pton,
2345 AC_DEFINE(HAVE_INET_PTON, 1, Define if you have the 'inet_pton' function.)
2346 AC_MSG_RESULT(yes),
2347 AC_MSG_RESULT(no)
2348 )
2350 # On some systems, setgroups is in unistd.h, on others, in grp.h
2351 AC_MSG_CHECKING(for setgroups)
2352 AC_TRY_COMPILE([
2353 #include "confdefs.h"
2354 #include <unistd.h>
2355 #ifdef HAVE_GRP_H
2356 #include <grp.h>
2357 #endif
2358 ],
2359 void* p = setgroups,
2360 AC_DEFINE(HAVE_SETGROUPS, 1, Define if you have the 'setgroups' function.)
2361 AC_MSG_RESULT(yes),
2362 AC_MSG_RESULT(no)
2363 )
2365 # check for openpty and forkpty
2367 AC_CHECK_FUNCS(openpty,,
2368 AC_CHECK_LIB(util,openpty,
2369 [AC_DEFINE(HAVE_OPENPTY) LIBS="$LIBS -lutil"],
2370 AC_CHECK_LIB(bsd,openpty, [AC_DEFINE(HAVE_OPENPTY) LIBS="$LIBS -lbsd"])
2371 )
2372 )
2373 AC_CHECK_FUNCS(forkpty,,
2374 AC_CHECK_LIB(util,forkpty,
2375 [AC_DEFINE(HAVE_FORKPTY) LIBS="$LIBS -lutil"],
2376 AC_CHECK_LIB(bsd,forkpty, [AC_DEFINE(HAVE_FORKPTY) LIBS="$LIBS -lbsd"])
2377 )
2378 )
2380 # check for long file support functions
2381 AC_CHECK_FUNCS(fseek64 fseeko fstatvfs ftell64 ftello statvfs)
2383 AC_REPLACE_FUNCS(dup2 getcwd strdup strerror memmove)
2384 AC_CHECK_FUNCS(getpgrp,
2385 AC_TRY_COMPILE([#include <unistd.h>],
2386 [getpgrp(0);],
2387 AC_DEFINE(GETPGRP_HAVE_ARG, 1,
2388 [Define if getpgrp() must be called as getpgrp(0).])
2389 )
2390 )
2391 AC_CHECK_FUNCS(setpgrp,
2392 AC_TRY_COMPILE([#include <unistd.h>],
2393 [setpgrp(0,0);],
2394 AC_DEFINE(SETPGRP_HAVE_ARG, 1,
2395 [Define if setpgrp() must be called as setpgrp(0, 0).])
2396 )
2397 )
2398 AC_CHECK_FUNCS(gettimeofday,
2399 AC_TRY_COMPILE([#include <sys/time.h>],
2400 [gettimeofday((struct timeval*)0,(struct timezone*)0);], ,
2401 AC_DEFINE(GETTIMEOFDAY_NO_TZ, 1,
2402 [Define if gettimeofday() does not have second (timezone) argument
2403 This is the case on Motorola V4 (R40V4.2)])
2404 )
2405 )
2407 AC_MSG_CHECKING(for major, minor, and makedev)
2408 AC_TRY_LINK([
2409 #if defined(MAJOR_IN_MKDEV)
2410 #include <sys/mkdev.h>
2411 #elif defined(MAJOR_IN_SYSMACROS)
2412 #include <sys/sysmacros.h>
2413 #else
2414 #include <sys/types.h>
2415 #endif
2416 ],[
2417 makedev(major(0),minor(0));
2418 ],[
2419 AC_DEFINE(HAVE_DEVICE_MACROS, 1,
2420 [Define to 1 if you have the device macros.])
2421 AC_MSG_RESULT(yes)
2422 ],[
2423 AC_MSG_RESULT(no)
2424 ])
2426 # On OSF/1 V5.1, getaddrinfo is available, but a define
2427 # for [no]getaddrinfo in netdb.h.
2428 AC_MSG_CHECKING(for getaddrinfo)
2429 AC_TRY_LINK([
2430 #include <sys/types.h>
2431 #include <sys/socket.h>
2432 #include <netdb.h>
2433 #include <stdio.h>
2434 ],[
2435 getaddrinfo(NULL, NULL, NULL, NULL);
2436 ], [
2437 AC_MSG_RESULT(yes)
2438 AC_MSG_CHECKING(getaddrinfo bug)
2439 AC_TRY_RUN([
2440 #include <sys/types.h>
2441 #include <netdb.h>
2442 #include <string.h>
2443 #include <sys/socket.h>
2444 #include <netinet/in.h>
2446 main()
2447 {
2448 int passive, gaierr, inet4 = 0, inet6 = 0;
2449 struct addrinfo hints, *ai, *aitop;
2450 char straddr[INET6_ADDRSTRLEN], strport[16];
2452 for (passive = 0; passive <= 1; passive++) {
2453 memset(&hints, 0, sizeof(hints));
2454 hints.ai_family = AF_UNSPEC;
2455 hints.ai_flags = passive ? AI_PASSIVE : 0;
2456 hints.ai_socktype = SOCK_STREAM;
2457 hints.ai_protocol = IPPROTO_TCP;
2458 if ((gaierr = getaddrinfo(NULL, "54321", &hints, &aitop)) != 0) {
2459 (void)gai_strerror(gaierr);
2460 goto bad;
2461 }
2462 for (ai = aitop; ai; ai = ai->ai_next) {
2463 if (ai->ai_addr == NULL ||
2464 ai->ai_addrlen == 0 ||
2465 getnameinfo(ai->ai_addr, ai->ai_addrlen,
2466 straddr, sizeof(straddr), strport, sizeof(strport),
2467 NI_NUMERICHOST|NI_NUMERICSERV) != 0) {
2468 goto bad;
2469 }
2470 switch (ai->ai_family) {
2471 case AF_INET:
2472 if (strcmp(strport, "54321") != 0) {
2473 goto bad;
2474 }
2475 if (passive) {
2476 if (strcmp(straddr, "0.0.0.0") != 0) {
2477 goto bad;
2478 }
2479 } else {
2480 if (strcmp(straddr, "127.0.0.1") != 0) {
2481 goto bad;
2482 }
2483 }
2484 inet4++;
2485 break;
2486 case AF_INET6:
2487 if (strcmp(strport, "54321") != 0) {
2488 goto bad;
2489 }
2490 if (passive) {
2491 if (strcmp(straddr, "::") != 0) {
2492 goto bad;
2493 }
2494 } else {
2495 if (strcmp(straddr, "::1") != 0) {
2496 goto bad;
2497 }
2498 }
2499 inet6++;
2500 break;
2501 case AF_UNSPEC:
2502 goto bad;
2503 break;
2504 default:
2505 /* another family support? */
2506 break;
2507 }
2508 }
2509 }
2511 if (!(inet4 == 0 || inet4 == 2))
2512 goto bad;
2513 if (!(inet6 == 0 || inet6 == 2))
2514 goto bad;
2516 if (aitop)
2517 freeaddrinfo(aitop);
2518 exit(0);
2520 bad:
2521 if (aitop)
2522 freeaddrinfo(aitop);
2523 exit(1);
2524 }
2525 ],
2526 AC_MSG_RESULT(good)
2527 buggygetaddrinfo=no,
2528 AC_MSG_RESULT(buggy)
2529 buggygetaddrinfo=yes,
2530 AC_MSG_RESULT(buggy)
2531 buggygetaddrinfo=yes)], [
2532 AC_MSG_RESULT(no)
2533 buggygetaddrinfo=yes
2534 ])
2536 if test "$buggygetaddrinfo" = "yes"; then
2537 if test "$ipv6" = "yes"; then
2538 echo 'Fatal: You must get working getaddrinfo() function.'
2539 echo ' or you can specify "--disable-ipv6"'.
2540 exit 1
2541 fi
2542 else
2543 AC_DEFINE(HAVE_GETADDRINFO, 1, [Define if you have the getaddrinfo function.])
2544 fi
2545 AC_CHECK_FUNCS(getnameinfo)
2547 # checks for structures
2548 AC_HEADER_TIME
2549 AC_STRUCT_TM
2550 AC_STRUCT_TIMEZONE
2551 AC_CHECK_MEMBERS([struct stat.st_rdev])
2552 AC_CHECK_MEMBERS([struct stat.st_blksize])
2553 AC_CHECK_MEMBERS([struct stat.st_flags])
2554 AC_CHECK_MEMBERS([struct stat.st_gen])
2555 AC_CHECK_MEMBERS([struct stat.st_birthtime])
2556 AC_STRUCT_ST_BLOCKS
2558 AC_MSG_CHECKING(for time.h that defines altzone)
2559 AC_CACHE_VAL(ac_cv_header_time_altzone,
2560 [AC_TRY_COMPILE([#include <time.h>], [return altzone;],
2561 ac_cv_header_time_altzone=yes,
2562 ac_cv_header_time_altzone=no)])
2563 AC_MSG_RESULT($ac_cv_header_time_altzone)
2564 if test $ac_cv_header_time_altzone = yes; then
2565 AC_DEFINE(HAVE_ALTZONE, 1, [Define this if your time.h defines altzone.])
2566 fi
2568 was_it_defined=no
2569 AC_MSG_CHECKING(whether sys/select.h and sys/time.h may both be included)
2570 AC_TRY_COMPILE([
2571 #include <sys/types.h>
2572 #include <sys/select.h>
2573 #include <sys/time.h>
2574 ], [;], [
2575 AC_DEFINE(SYS_SELECT_WITH_SYS_TIME, 1,
2576 [Define if you can safely include both <sys/select.h> and <sys/time.h>
2577 (which you can't on SCO ODT 3.0).])
2578 was_it_defined=yes
2579 ])
2580 AC_MSG_RESULT($was_it_defined)
2582 AC_MSG_CHECKING(for addrinfo)
2583 AC_CACHE_VAL(ac_cv_struct_addrinfo,
2584 AC_TRY_COMPILE([
2585 # include <netdb.h>],
2586 [struct addrinfo a],
2587 ac_cv_struct_addrinfo=yes,
2588 ac_cv_struct_addrinfo=no))
2589 AC_MSG_RESULT($ac_cv_struct_addrinfo)
2590 if test $ac_cv_struct_addrinfo = yes; then
2591 AC_DEFINE(HAVE_ADDRINFO, 1, [struct addrinfo (netdb.h)])
2592 fi
2594 AC_MSG_CHECKING(for sockaddr_storage)
2595 AC_CACHE_VAL(ac_cv_struct_sockaddr_storage,
2596 AC_TRY_COMPILE([
2597 # include <sys/types.h>
2598 # include <sys/socket.h>],
2599 [struct sockaddr_storage s],
2600 ac_cv_struct_sockaddr_storage=yes,
2601 ac_cv_struct_sockaddr_storage=no))
2602 AC_MSG_RESULT($ac_cv_struct_sockaddr_storage)
2603 if test $ac_cv_struct_sockaddr_storage = yes; then
2604 AC_DEFINE(HAVE_SOCKADDR_STORAGE, 1, [struct sockaddr_storage (sys/socket.h)])
2605 fi
2607 # checks for compiler characteristics
2609 AC_C_CHAR_UNSIGNED
2610 AC_C_CONST
2612 works=no
2613 AC_MSG_CHECKING(for working volatile)
2614 AC_TRY_COMPILE([],[volatile int x; x = 0;], works=yes,
2615 AC_DEFINE(volatile, [], [Define to empty if the keyword does not work.])
2616 )
2617 AC_MSG_RESULT($works)
2619 works=no
2620 AC_MSG_CHECKING(for working signed char)
2621 AC_TRY_COMPILE([], [signed char c;], works=yes,
2622 AC_DEFINE(signed, [], [Define to empty if the keyword does not work.])
2623 )
2624 AC_MSG_RESULT($works)
2626 have_prototypes=no
2627 AC_MSG_CHECKING(for prototypes)
2628 AC_TRY_COMPILE([int foo(int x) { return 0; }], [return foo(10);],[
2629 AC_DEFINE(HAVE_PROTOTYPES, 1,
2630 [Define if your compiler supports function prototype])
2631 have_prototypes=yes
2632 ])
2633 AC_MSG_RESULT($have_prototypes)
2635 works=no
2636 AC_MSG_CHECKING(for variable length prototypes and stdarg.h)
2637 AC_TRY_COMPILE([
2638 #include <stdarg.h>
2639 int foo(int x, ...) {
2640 va_list va;
2641 va_start(va, x);
2642 va_arg(va, int);
2643 va_arg(va, char *);
2644 va_arg(va, double);
2645 return 0;
2646 }
2647 ], [return foo(10, "", 3.14);], [
2648 AC_DEFINE(HAVE_STDARG_PROTOTYPES, 1,
2649 [Define if your compiler supports variable length function prototypes
2650 (e.g. void fprintf(FILE *, char *, ...);) *and* <stdarg.h>])
2651 works=yes
2652 ])
2653 AC_MSG_RESULT($works)
2655 # check for socketpair
2656 AC_MSG_CHECKING(for socketpair)
2657 AC_TRY_COMPILE([
2658 #include <sys/types.h>
2659 #include <sys/socket.h>
2660 ], void *x=socketpair,
2661 AC_DEFINE(HAVE_SOCKETPAIR, 1, Define if you have the 'socketpair' function.)
2662 AC_MSG_RESULT(yes),
2663 AC_MSG_RESULT(no)
2664 )
2666 # check if sockaddr has sa_len member
2667 AC_MSG_CHECKING(if sockaddr has sa_len member)
2668 AC_TRY_COMPILE([#include <sys/types.h>
2669 #include <sys/socket.h>],
2670 [struct sockaddr x;
2671 x.sa_len = 0;],
2672 AC_MSG_RESULT(yes)
2673 AC_DEFINE(HAVE_SOCKADDR_SA_LEN, 1, [Define if sockaddr has sa_len member]),
2674 AC_MSG_RESULT(no))
2676 va_list_is_array=no
2677 AC_MSG_CHECKING(whether va_list is an array)
2678 AC_TRY_COMPILE([
2679 #ifdef HAVE_STDARG_PROTOTYPES
2680 #include <stdarg.h>
2681 #else
2682 #include <varargs.h>
2683 #endif
2684 ], [va_list list1, list2; list1 = list2;], , [
2685 AC_DEFINE(VA_LIST_IS_ARRAY, 1, [Define if a va_list is an array of some kind])
2686 va_list_is_array=yes
2687 ])
2688 AC_MSG_RESULT($va_list_is_array)
2690 # sigh -- gethostbyname_r is a mess; it can have 3, 5 or 6 arguments :-(
2691 AH_TEMPLATE(HAVE_GETHOSTBYNAME_R,
2692 [Define this if you have some version of gethostbyname_r()])
2694 AC_CHECK_FUNC(gethostbyname_r, [
2695 AC_DEFINE(HAVE_GETHOSTBYNAME_R)
2696 AC_MSG_CHECKING([gethostbyname_r with 6 args])
2697 OLD_CFLAGS=$CFLAGS
2698 CFLAGS="$CFLAGS $MY_CPPFLAGS $MY_THREAD_CPPFLAGS $MY_CFLAGS"
2699 AC_TRY_COMPILE([
2700 # include <netdb.h>
2701 ], [
2702 char *name;
2703 struct hostent *he, *res;
2704 char buffer[2048];
2705 int buflen = 2048;
2706 int h_errnop;
2708 (void) gethostbyname_r(name, he, buffer, buflen, &res, &h_errnop)
2709 ], [
2710 AC_DEFINE(HAVE_GETHOSTBYNAME_R)
2711 AC_DEFINE(HAVE_GETHOSTBYNAME_R_6_ARG, 1,
2712 [Define this if you have the 6-arg version of gethostbyname_r().])
2713 AC_MSG_RESULT(yes)
2714 ], [
2715 AC_MSG_RESULT(no)
2716 AC_MSG_CHECKING([gethostbyname_r with 5 args])
2717 AC_TRY_COMPILE([
2718 # include <netdb.h>
2719 ], [
2720 char *name;
2721 struct hostent *he;
2722 char buffer[2048];
2723 int buflen = 2048;
2724 int h_errnop;
2726 (void) gethostbyname_r(name, he, buffer, buflen, &h_errnop)
2727 ], [
2728 AC_DEFINE(HAVE_GETHOSTBYNAME_R)
2729 AC_DEFINE(HAVE_GETHOSTBYNAME_R_5_ARG, 1,
2730 [Define this if you have the 5-arg version of gethostbyname_r().])
2731 AC_MSG_RESULT(yes)
2732 ], [
2733 AC_MSG_RESULT(no)
2734 AC_MSG_CHECKING([gethostbyname_r with 3 args])
2735 AC_TRY_COMPILE([
2736 # include <netdb.h>
2737 ], [
2738 char *name;
2739 struct hostent *he;
2740 struct hostent_data data;
2742 (void) gethostbyname_r(name, he, &data);
2743 ], [
2744 AC_DEFINE(HAVE_GETHOSTBYNAME_R)
2745 AC_DEFINE(HAVE_GETHOSTBYNAME_R_3_ARG, 1,
2746 [Define this if you have the 3-arg version of gethostbyname_r().])
2747 AC_MSG_RESULT(yes)
2748 ], [
2749 AC_MSG_RESULT(no)
2750 ])
2751 ])
2752 ])
2753 CFLAGS=$OLD_CFLAGS
2754 ], [
2755 AC_CHECK_FUNCS(gethostbyname)
2756 ])
2757 AC_SUBST(HAVE_GETHOSTBYNAME_R_6_ARG)
2758 AC_SUBST(HAVE_GETHOSTBYNAME_R_5_ARG)
2759 AC_SUBST(HAVE_GETHOSTBYNAME_R_3_ARG)
2760 AC_SUBST(HAVE_GETHOSTBYNAME_R)
2761 AC_SUBST(HAVE_GETHOSTBYNAME)
2763 # checks for system services
2764 # (none yet)
2766 # Linux requires this for correct f.p. operations
2767 AC_CHECK_FUNC(__fpu_control,
2768 [],
2769 [AC_CHECK_LIB(ieee, __fpu_control)
2770 ])
2772 # Check for --with-fpectl
2773 AC_MSG_CHECKING(for --with-fpectl)
2774 AC_ARG_WITH(fpectl,
2775 AC_HELP_STRING(--with-fpectl, enable SIGFPE catching),
2776 [
2777 if test "$withval" != no
2778 then
2779 AC_DEFINE(WANT_SIGFPE_HANDLER, 1,
2780 [Define if you want SIGFPE handled (see Include/pyfpe.h).])
2781 AC_MSG_RESULT(yes)
2782 else AC_MSG_RESULT(no)
2783 fi],
2784 [AC_MSG_RESULT(no)])
2786 # check for --with-libm=...
2787 AC_SUBST(LIBM)
2788 case $ac_sys_system in
2789 Darwin) ;;
2790 BeOS) ;;
2791 *) LIBM=-lm
2792 esac
2793 AC_MSG_CHECKING(for --with-libm=STRING)
2794 AC_ARG_WITH(libm,
2795 AC_HELP_STRING(--with-libm=STRING, math library),
2796 [
2797 if test "$withval" = no
2798 then LIBM=
2799 AC_MSG_RESULT(force LIBM empty)
2800 elif test "$withval" != yes
2801 then LIBM=$withval
2802 AC_MSG_RESULT(set LIBM="$withval")
2803 else AC_MSG_ERROR([proper usage is --with-libm=STRING])
2804 fi],
2805 [AC_MSG_RESULT(default LIBM="$LIBM")])
2807 # check for --with-libc=...
2808 AC_SUBST(LIBC)
2809 AC_MSG_CHECKING(for --with-libc=STRING)
2810 AC_ARG_WITH(libc,
2811 AC_HELP_STRING(--with-libc=STRING, C library),
2812 [
2813 if test "$withval" = no
2814 then LIBC=
2815 AC_MSG_RESULT(force LIBC empty)
2816 elif test "$withval" != yes
2817 then LIBC=$withval
2818 AC_MSG_RESULT(set LIBC="$withval")
2819 else AC_MSG_ERROR([proper usage is --with-libc=STRING])
2820 fi],
2821 [AC_MSG_RESULT(default LIBC="$LIBC")])
2823 # check for hypot() in math library
2824 LIBS_SAVE=$LIBS
2825 LIBS="$LIBS $LIBM"
2826 AC_REPLACE_FUNCS(hypot)
2827 LIBS=$LIBS_SAVE
2829 # check for wchar.h
2830 AC_CHECK_HEADER(wchar.h, [
2831 AC_DEFINE(HAVE_WCHAR_H, 1,
2832 [Define if the compiler provides a wchar.h header file.])
2833 wchar_h="yes"
2834 ],
2835 wchar_h="no"
2836 )
2838 # determine wchar_t size
2839 if test "$wchar_h" = yes
2840 then
2841 AC_CHECK_SIZEOF(wchar_t, 4, [#include <wchar.h>])
2842 fi
2844 AC_MSG_CHECKING(for UCS-4 tcl)
2845 have_ucs4_tcl=no
2846 AC_TRY_COMPILE([
2847 #include <tcl.h>
2848 #if TCL_UTF_MAX != 6
2849 # error "NOT UCS4_TCL"
2850 #endif], [], [
2851 AC_DEFINE(HAVE_UCS4_TCL, 1, [Define this if you have tcl and TCL_UTF_MAX==6])
2852 have_ucs4_tcl=yes
2853 ])
2854 AC_MSG_RESULT($have_ucs4_tcl)
2856 # check whether wchar_t is signed or not
2857 if test "$wchar_h" = yes
2858 then
2859 # check whether wchar_t is signed or not
2860 AC_MSG_CHECKING(whether wchar_t is signed)
2861 AC_CACHE_VAL(ac_cv_wchar_t_signed, [
2862 AC_TRY_RUN([
2863 #include <wchar.h>
2864 int main()
2865 {
2866 /* Success: exit code 0 */
2867 exit((((wchar_t) -1) < ((wchar_t) 0)) ? 0 : 1);
2868 }
2869 ],
2870 ac_cv_wchar_t_signed=yes,
2871 ac_cv_wchar_t_signed=no,
2872 ac_cv_wchar_t_signed=yes)])
2873 AC_MSG_RESULT($ac_cv_wchar_t_signed)
2874 fi
2876 AC_MSG_CHECKING(what type to use for unicode)
2877 dnl quadrigraphs "@<:@" and "@:>@" produce "[" and "]" in the output
2878 AC_ARG_ENABLE(unicode,
2879 AC_HELP_STRING(--enable-unicode@<:@=ucs@<:@24@:>@@:>@, Enable Unicode strings (default is yes)),
2880 [],
2881 [enable_unicode=yes])
2883 if test $enable_unicode = yes
2884 then
2885 # Without any arguments, Py_UNICODE defaults to two-byte mode
2886 case "$have_ucs4_tcl" in
2887 yes) enable_unicode="ucs4"
2888 ;;
2889 *) enable_unicode="ucs2"
2890 ;;
2891 esac
2892 fi
2894 AH_TEMPLATE(Py_UNICODE_SIZE,
2895 [Define as the size of the unicode type.])
2896 case "$enable_unicode" in
2897 ucs2) unicode_size="2"
2898 AC_DEFINE(Py_UNICODE_SIZE,2)
2899 ;;
2900 ucs4) unicode_size="4"
2901 AC_DEFINE(Py_UNICODE_SIZE,4)
2902 ;;
2903 esac
2905 AH_TEMPLATE(PY_UNICODE_TYPE,
2906 [Define as the integral type used for Unicode representation.])
2908 AC_SUBST(UNICODE_OBJS)
2909 if test "$enable_unicode" = "no"
2910 then
2911 UNICODE_OBJS=""
2912 AC_MSG_RESULT(not used)
2913 else
2914 UNICODE_OBJS="Objects/unicodeobject.o Objects/unicodectype.o"
2915 AC_DEFINE(Py_USING_UNICODE, 1,
2916 [Define if you want to have a Unicode type.])
2918 # wchar_t is only usable if it maps to an unsigned type
2919 if test "$unicode_size" = "$ac_cv_sizeof_wchar_t" \
2920 -a "$ac_cv_wchar_t_signed" = "no"
2921 then
2922 PY_UNICODE_TYPE="wchar_t"
2923 AC_DEFINE(HAVE_USABLE_WCHAR_T, 1,
2924 [Define if you have a useable wchar_t type defined in wchar.h; useable
2925 means wchar_t must be an unsigned type with at least 16 bits. (see
2926 Include/unicodeobject.h).])
2927 AC_DEFINE(PY_UNICODE_TYPE,wchar_t)
2928 elif test "$ac_cv_sizeof_short" = "$unicode_size"
2929 then
2930 PY_UNICODE_TYPE="unsigned short"
2931 AC_DEFINE(PY_UNICODE_TYPE,unsigned short)
2932 elif test "$ac_cv_sizeof_long" = "$unicode_size"
2933 then
2934 PY_UNICODE_TYPE="unsigned long"
2935 AC_DEFINE(PY_UNICODE_TYPE,unsigned long)
2936 else
2937 PY_UNICODE_TYPE="no type found"
2938 fi
2939 AC_MSG_RESULT($PY_UNICODE_TYPE)
2940 fi
2942 # check for endianness
2943 AC_C_BIGENDIAN
2944 AH_VERBATIM([WORDS_BIGENDIAN],
2945 [
2946 /* Define to 1 if your processor stores words with the most significant byte
2947 first (like Motorola and SPARC, unlike Intel and VAX).
2949 The block below does compile-time checking for endianness on platforms
2950 that use GCC and therefore allows compiling fat binaries on OSX by using
2951 '-arch ppc -arch i386' as the compile flags. The phrasing was choosen
2952 such that the configure-result is used on systems that don't use GCC.
2953 */
2954 #ifdef __BIG_ENDIAN__
2955 #define WORDS_BIGENDIAN 1
2956 #else
2957 #ifndef __LITTLE_ENDIAN__
2958 #undef WORDS_BIGENDIAN
2959 #endif
2960 #endif])
2962 # Check whether right shifting a negative integer extends the sign bit
2963 # or fills with zeros (like the Cray J90, according to Tim Peters).
2964 AC_MSG_CHECKING(whether right shift extends the sign bit)
2965 AC_CACHE_VAL(ac_cv_rshift_extends_sign, [
2966 AC_TRY_RUN([
2967 int main()
2968 {
2969 exit(((-1)>>3 == -1) ? 0 : 1);
2970 }
2971 ],
2972 ac_cv_rshift_extends_sign=yes,
2973 ac_cv_rshift_extends_sign=no,
2974 ac_cv_rshift_extends_sign=yes)])
2975 AC_MSG_RESULT($ac_cv_rshift_extends_sign)
2976 if test "$ac_cv_rshift_extends_sign" = no
2977 then
2978 AC_DEFINE(SIGNED_RIGHT_SHIFT_ZERO_FILLS, 1,
2979 [Define if i>>j for signed int i does not extend the sign bit
2980 when i < 0])
2981 fi
2983 # check for getc_unlocked and related locking functions
2984 AC_MSG_CHECKING(for getc_unlocked() and friends)
2985 AC_CACHE_VAL(ac_cv_have_getc_unlocked, [
2986 AC_TRY_LINK([#include <stdio.h>],[
2987 FILE *f = fopen("/dev/null", "r");
2988 flockfile(f);
2989 getc_unlocked(f);
2990 funlockfile(f);
2991 ], ac_cv_have_getc_unlocked=yes, ac_cv_have_getc_unlocked=no)])
2992 AC_MSG_RESULT($ac_cv_have_getc_unlocked)
2993 if test "$ac_cv_have_getc_unlocked" = yes
2994 then
2995 AC_DEFINE(HAVE_GETC_UNLOCKED, 1,
2996 [Define this if you have flockfile(), getc_unlocked(), and funlockfile()])
2997 fi
2999 # check where readline lives
3000 # save the value of LIBS so we don't actually link Python with readline
3001 LIBS_no_readline=$LIBS
3002 AC_CHECK_LIB(readline, readline)
3003 if test "$ac_cv_have_readline_readline" = no
3004 then
3005 AC_CHECK_LIB(termcap, readline)
3006 fi
3008 # check for readline 2.1
3009 AC_CHECK_LIB(readline, rl_callback_handler_install,
3010 AC_DEFINE(HAVE_RL_CALLBACK, 1,
3011 [Define if you have readline 2.1]), , )
3013 # check for readline 2.2
3014 AC_TRY_CPP([#include <readline/readline.h>],
3015 have_readline=yes, have_readline=no)
3016 if test $have_readline = yes
3017 then
3018 AC_EGREP_HEADER([extern int rl_completion_append_character;],
3019 [readline/readline.h],
3020 AC_DEFINE(HAVE_RL_COMPLETION_APPEND_CHARACTER, 1,
3021 [Define if you have readline 2.2]), )
3022 fi
3024 # check for readline 4.0
3025 AC_CHECK_LIB(readline, rl_pre_input_hook,
3026 AC_DEFINE(HAVE_RL_PRE_INPUT_HOOK, 1,
3027 [Define if you have readline 4.0]), , )
3029 # check for readline 4.2
3030 AC_CHECK_LIB(readline, rl_completion_matches,
3031 AC_DEFINE(HAVE_RL_COMPLETION_MATCHES, 1,
3032 [Define if you have readline 4.2]), , )
3034 # also in readline 4.2
3035 AC_TRY_CPP([#include <readline/readline.h>],
3036 have_readline=yes, have_readline=no)
3037 if test $have_readline = yes
3038 then
3039 AC_EGREP_HEADER([extern int rl_catch_signals;],
3040 [readline/readline.h],
3041 AC_DEFINE(HAVE_RL_CATCH_SIGNAL, 1,
3042 [Define if you can turn off readline's signal handling.]), )
3043 fi
3045 # End of readline checks: restore LIBS
3046 LIBS=$LIBS_no_readline
3048 AC_MSG_CHECKING(for broken nice())
3049 AC_CACHE_VAL(ac_cv_broken_nice, [
3050 AC_TRY_RUN([
3051 int main()
3052 {
3053 int val1 = nice(1);
3054 if (val1 != -1 && val1 == nice(2))
3055 exit(0);
3056 exit(1);
3057 }
3058 ],
3059 ac_cv_broken_nice=yes,
3060 ac_cv_broken_nice=no,
3061 ac_cv_broken_nice=no)])
3062 AC_MSG_RESULT($ac_cv_broken_nice)
3063 if test "$ac_cv_broken_nice" = yes
3064 then
3065 AC_DEFINE(HAVE_BROKEN_NICE, 1,
3066 [Define if nice() returns success/failure instead of the new priority.])
3067 fi
3069 AC_MSG_CHECKING(for broken poll())
3070 AC_TRY_RUN([
3071 #include <poll.h>
3073 int main (void)
3074 {
3075 struct pollfd poll_struct = { 42, POLLIN|POLLPRI|POLLOUT, 0 };
3077 close (42);
3079 int poll_test = poll (&poll_struct, 1, 0);
3081 if (poll_test < 0)
3082 {
3083 exit(0);
3084 }
3085 else if (poll_test == 0 && poll_struct.revents != POLLNVAL)
3086 {
3087 exit(0);
3088 }
3089 else
3090 {
3091 exit(1);
3092 }
3093 }
3094 ],
3095 ac_cv_broken_poll=yes,
3096 ac_cv_broken_poll=no,
3097 ac_cv_broken_poll=no)
3098 AC_MSG_RESULT($ac_cv_broken_poll)
3099 if test "$ac_cv_broken_poll" = yes
3100 then
3101 AC_DEFINE(HAVE_BROKEN_POLL, 1,
3102 [Define if poll() sets errno on invalid file descriptors.])
3103 fi
3105 # Before we can test tzset, we need to check if struct tm has a tm_zone
3106 # (which is not required by ISO C or UNIX spec) and/or if we support
3107 # tzname[]
3108 AC_STRUCT_TIMEZONE
3110 # check tzset(3) exists and works like we expect it to
3111 AC_MSG_CHECKING(for working tzset())
3112 AC_CACHE_VAL(ac_cv_working_tzset, [
3113 AC_TRY_RUN([
3114 #include <stdlib.h>
3115 #include <time.h>
3116 #include <string.h>
3118 #if HAVE_TZNAME
3119 extern char *tzname[];
3120 #endif
3122 int main()
3123 {
3124 /* Note that we need to ensure that not only does tzset(3)
3125 do 'something' with localtime, but it works as documented
3126 in the library reference and as expected by the test suite.
3127 This includes making sure that tzname is set properly if
3128 tm->tm_zone does not exist since it is the alternative way
3129 of getting timezone info.
3131 Red Hat 6.2 doesn't understand the southern hemisphere
3132 after New Year's Day.
3133 */
3135 time_t groundhogday = 1044144000; /* GMT-based */
3136 time_t midyear = groundhogday + (365 * 24 * 3600 / 2);
3138 putenv("TZ=UTC+0");
3139 tzset();
3140 if (localtime(&groundhogday)->tm_hour != 0)
3141 exit(1);
3142 #if HAVE_TZNAME
3143 /* For UTC, tzname[1] is sometimes "", sometimes " " */
3144 if (strcmp(tzname[0], "UTC") ||
3145 (tzname[1][0] != 0 && tzname[1][0] != ' '))
3146 exit(1);
3147 #endif
3149 putenv("TZ=EST+5EDT,M4.1.0,M10.5.0");
3150 tzset();
3151 if (localtime(&groundhogday)->tm_hour != 19)
3152 exit(1);
3153 #if HAVE_TZNAME
3154 if (strcmp(tzname[0], "EST") || strcmp(tzname[1], "EDT"))
3155 exit(1);
3156 #endif
3158 putenv("TZ=AEST-10AEDT-11,M10.5.0,M3.5.0");
3159 tzset();
3160 if (localtime(&groundhogday)->tm_hour != 11)
3161 exit(1);
3162 #if HAVE_TZNAME
3163 if (strcmp(tzname[0], "AEST") || strcmp(tzname[1], "AEDT"))
3164 exit(1);
3165 #endif
3167 #if HAVE_STRUCT_TM_TM_ZONE
3168 if (strcmp(localtime(&groundhogday)->tm_zone, "AEDT"))
3169 exit(1);
3170 if (strcmp(localtime(&midyear)->tm_zone, "AEST"))
3171 exit(1);
3172 #endif
3174 exit(0);
3175 }
3176 ],
3177 ac_cv_working_tzset=yes,
3178 ac_cv_working_tzset=no,
3179 ac_cv_working_tzset=no)])
3180 AC_MSG_RESULT($ac_cv_working_tzset)
3181 if test "$ac_cv_working_tzset" = yes
3182 then
3183 AC_DEFINE(HAVE_WORKING_TZSET, 1,
3184 [Define if tzset() actually switches the local timezone in a meaningful way.])
3185 fi
3187 # Look for subsecond timestamps in struct stat
3188 AC_MSG_CHECKING(for tv_nsec in struct stat)
3189 AC_CACHE_VAL(ac_cv_stat_tv_nsec,
3190 AC_TRY_COMPILE([#include <sys/stat.h>], [
3191 struct stat st;
3192 st.st_mtim.tv_nsec = 1;
3193 ],
3194 ac_cv_stat_tv_nsec=yes,
3195 ac_cv_stat_tv_nsec=no,
3196 ac_cv_stat_tv_nsec=no))
3197 AC_MSG_RESULT($ac_cv_stat_tv_nsec)
3198 if test "$ac_cv_stat_tv_nsec" = yes
3199 then
3200 AC_DEFINE(HAVE_STAT_TV_NSEC, 1,
3201 [Define if you have struct stat.st_mtim.tv_nsec])
3202 fi
3204 # Look for BSD style subsecond timestamps in struct stat
3205 AC_MSG_CHECKING(for tv_nsec2 in struct stat)
3206 AC_CACHE_VAL(ac_cv_stat_tv_nsec2,
3207 AC_TRY_COMPILE([#include <sys/stat.h>], [
3208 struct stat st;
3209 st.st_mtimespec.tv_nsec = 1;
3210 ],
3211 ac_cv_stat_tv_nsec2=yes,
3212 ac_cv_stat_tv_nsec2=no,
3213 ac_cv_stat_tv_nsec2=no))
3214 AC_MSG_RESULT($ac_cv_stat_tv_nsec2)
3215 if test "$ac_cv_stat_tv_nsec2" = yes
3216 then
3217 AC_DEFINE(HAVE_STAT_TV_NSEC2, 1,
3218 [Define if you have struct stat.st_mtimensec])
3219 fi
3221 # On HP/UX 11.0, mvwdelch is a block with a return statement
3222 AC_MSG_CHECKING(whether mvwdelch is an expression)
3223 AC_CACHE_VAL(ac_cv_mvwdelch_is_expression,
3224 AC_TRY_COMPILE([#include <curses.h>], [
3225 int rtn;
3226 rtn = mvwdelch(0,0,0);
3227 ], ac_cv_mvwdelch_is_expression=yes,
3228 ac_cv_mvwdelch_is_expression=no,
3229 ac_cv_mvwdelch_is_expression=yes))
3230 AC_MSG_RESULT($ac_cv_mvwdelch_is_expression)
3232 if test "$ac_cv_mvwdelch_is_expression" = yes
3233 then
3234 AC_DEFINE(MVWDELCH_IS_EXPRESSION, 1,
3235 [Define if mvwdelch in curses.h is an expression.])
3236 fi
3238 AC_MSG_CHECKING(whether WINDOW has _flags)
3239 AC_CACHE_VAL(ac_cv_window_has_flags,
3240 AC_TRY_COMPILE([#include <curses.h>], [
3241 WINDOW *w;
3242 w->_flags = 0;
3243 ], ac_cv_window_has_flags=yes,
3244 ac_cv_window_has_flags=no,
3245 ac_cv_window_has_flags=no))
3246 AC_MSG_RESULT($ac_cv_window_has_flags)
3249 if test "$ac_cv_window_has_flags" = yes
3250 then
3251 AC_DEFINE(WINDOW_HAS_FLAGS, 1,
3252 [Define if WINDOW in curses.h offers a field _flags.])
3253 fi
3255 AC_MSG_CHECKING(for /dev/ptmx)
3257 if test -e /dev/ptmx
3258 then
3259 AC_MSG_RESULT(yes)
3260 AC_DEFINE(HAVE_DEV_PTMX, 1,
3261 [Define if we have /dev/ptmx.])
3262 else
3263 AC_MSG_RESULT(no)
3264 fi
3266 AC_MSG_CHECKING(for /dev/ptc)
3268 if test -e /dev/ptc
3269 then
3270 AC_MSG_RESULT(yes)
3271 AC_DEFINE(HAVE_DEV_PTC, 1,
3272 [Define if we have /dev/ptc.])
3273 else
3274 AC_MSG_RESULT(no)
3275 fi
3277 AC_MSG_CHECKING(for %zd printf() format support)
3278 AC_TRY_RUN([#include <stdio.h>
3279 #include <stddef.h>
3280 #include <string.h>
3282 int main()
3283 {
3284 char buffer[4];
3286 if(sprintf(buffer, "%zd", (size_t)123) < 0)
3287 return 1;
3289 if (strncmp(buffer, "123", 3))
3290 return 1;
3292 return 0;
3293 }],
3294 [AC_MSG_RESULT(yes)
3295 AC_DEFINE(PY_FORMAT_SIZE_T, "z", [Define to printf format modifier for Py_ssize_t])],
3296 AC_MSG_RESULT(no))
3298 AC_CHECK_TYPE(socklen_t,,
3299 AC_DEFINE(socklen_t,int,
3300 Define to `int' if <sys/socket.h> does not define.),[
3301 #ifdef HAVE_SYS_TYPES_H
3302 #include <sys/types.h>
3303 #endif
3304 #ifdef HAVE_SYS_SOCKET_H
3305 #include <sys/socket.h>
3306 #endif
3307 ])
3309 AC_SUBST(THREADHEADERS)
3311 for h in `(cd $srcdir;echo Python/thread_*.h)`
3312 do
3313 THREADHEADERS="$THREADHEADERS \$(srcdir)/$h"
3314 done
3316 AC_SUBST(SRCDIRS)
3317 SRCDIRS="Parser Grammar Objects Python Modules Mac"
3318 AC_MSG_CHECKING(for build directories)
3319 for dir in $SRCDIRS; do
3320 if test ! -d $dir; then
3321 mkdir $dir
3322 fi
3323 done
3324 AC_MSG_RESULT(done)
3326 # generate output files
3327 AC_CONFIG_FILES(Makefile.pre Modules/Setup.config)
3328 AC_OUTPUT
3330 echo "creating Modules/Setup"
3331 if test ! -f Modules/Setup
3332 then
3333 cp $srcdir/Modules/Setup.dist Modules/Setup
3334 fi
3336 echo "creating Modules/Setup.local"
3337 if test ! -f Modules/Setup.local
3338 then
3339 echo "# Edit this file for local setup changes" >Modules/Setup.local
3340 fi
3342 echo "creating Makefile"
3343 $SHELL $srcdir/Modules/makesetup -c $srcdir/Modules/config.c.in \
3344 -s Modules Modules/Setup.config \
3345 Modules/Setup.local Modules/Setup
3346 mv config.c Modules