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