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