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