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