| blob | e9b28bc69afbdccc990d463cf96c673a76728c20 |
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://bugs.python.org/)
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 # GNULD is set to "yes" if the GNU linker is used. If this goes wrong
651 # make sure we default having it set to "no": this is used by
652 # distutils.unixccompiler to know if it should add --enable-new-dtags
653 # to linker command lines, and failing to detect GNU ld simply results
654 # in the same bahaviour as before.
655 AC_SUBST(GNULD)
656 AC_MSG_CHECKING(for GNU ld)
657 ac_prog=ld
658 if test "$GCC" = yes; then
659 ac_prog=`$CC -print-prog-name=ld`
660 fi
661 case `"$ac_prog" -V 2>&1 < /dev/null` in
662 *GNU*)
663 GNULD=yes;;
664 *)
665 GNULD=no;;
666 esac
667 AC_MSG_RESULT($GNULD)
669 AC_MSG_CHECKING(for --enable-shared)
670 AC_ARG_ENABLE(shared,
671 AC_HELP_STRING(--enable-shared, disable/enable building shared python library))
673 if test -z "$enable_shared"
674 then
675 case $ac_sys_system in
676 CYGWIN* | atheos*)
677 enable_shared="yes";;
678 *)
679 enable_shared="no";;
680 esac
681 fi
682 AC_MSG_RESULT($enable_shared)
684 AC_MSG_CHECKING(for --enable-profiling)
685 AC_ARG_ENABLE(profiling,
686 AC_HELP_STRING(--enable-profiling, enable C-level code profiling),
687 [ac_save_cc="$CC"
688 CC="$CC -pg"
689 AC_TRY_RUN([int main() { return 0; }],
690 ac_enable_profiling="yes",
691 ac_enable_profiling="no",
692 ac_enable_profiling="no")
693 CC="$ac_save_cc"])
694 AC_MSG_RESULT($ac_enable_profiling)
696 case "$ac_enable_profiling" in
697 "yes")
698 BASECFLAGS="-pg $BASECFLAGS"
699 LDFLAGS="-pg $LDFLAGS"
700 ;;
701 esac
703 AC_MSG_CHECKING(LDLIBRARY)
705 # MacOSX framework builds need more magic. LDLIBRARY is the dynamic
706 # library that we build, but we do not want to link against it (we
707 # will find it with a -framework option). For this reason there is an
708 # extra variable BLDLIBRARY against which Python and the extension
709 # modules are linked, BLDLIBRARY. This is normally the same as
710 # LDLIBRARY, but empty for MacOSX framework builds.
711 if test "$enable_framework"
712 then
713 LDLIBRARY='$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
714 RUNSHARED=DYLD_FRAMEWORK_PATH="`pwd`:$DYLD_FRAMEWORK_PATH"
715 BLDLIBRARY=''
716 else
717 BLDLIBRARY='$(LDLIBRARY)'
718 fi
720 # Other platforms follow
721 if test $enable_shared = "yes"; then
722 AC_DEFINE(Py_ENABLE_SHARED, 1, [Defined if Python is built as a shared library.])
723 case $ac_sys_system in
724 BeOS*)
725 LDLIBRARY='libpython$(VERSION).so'
726 ;;
727 CYGWIN*)
728 LDLIBRARY='libpython$(VERSION).dll.a'
729 DLLLIBRARY='libpython$(VERSION).dll'
730 ;;
731 SunOS*)
732 LDLIBRARY='libpython$(VERSION).so'
733 BLDLIBRARY='-Wl,-R,$(LIBDIR) -L. -lpython$(VERSION)'
734 RUNSHARED=LD_LIBRARY_PATH=`pwd`:${LD_LIBRARY_PATH}
735 INSTSONAME="$LDLIBRARY".$SOVERSION
736 ;;
737 Linux*|GNU*|NetBSD*|FreeBSD*|DragonFly*)
738 LDLIBRARY='libpython$(VERSION).so'
739 BLDLIBRARY='-L. -lpython$(VERSION)'
740 RUNSHARED=LD_LIBRARY_PATH=`pwd`:${LD_LIBRARY_PATH}
741 case $ac_sys_system in
742 FreeBSD*)
743 SOVERSION=`echo $SOVERSION|cut -d "." -f 1`
744 ;;
745 esac
746 INSTSONAME="$LDLIBRARY".$SOVERSION
747 ;;
748 hp*|HP*)
749 case `uname -m` in
750 ia64)
751 LDLIBRARY='libpython$(VERSION).so'
752 ;;
753 *)
754 LDLIBRARY='libpython$(VERSION).sl'
755 ;;
756 esac
757 BLDLIBRARY='-Wl,+b,$(LIBDIR) -L. -lpython$(VERSION)'
758 RUNSHARED=SHLIB_PATH=`pwd`:${SHLIB_PATH}
759 ;;
760 OSF*)
761 LDLIBRARY='libpython$(VERSION).so'
762 BLDLIBRARY='-rpath $(LIBDIR) -L. -lpython$(VERSION)'
763 RUNSHARED=LD_LIBRARY_PATH=`pwd`:${LD_LIBRARY_PATH}
764 ;;
765 atheos*)
766 LDLIBRARY='libpython$(VERSION).so'
767 BLDLIBRARY='-L. -lpython$(VERSION)'
768 RUNSHARED=DLL_PATH=`pwd`:${DLL_PATH:-/atheos/sys/libs:/atheos/autolnk/lib}
769 ;;
770 Darwin*)
771 LDLIBRARY='libpython$(VERSION).dylib'
772 BLDLIBRARY='-L. -lpython$(VERSION)'
773 RUNSHARED='DYLD_LIBRARY_PATH=`pwd`:${DYLD_LIBRARY_PATH}'
774 ;;
776 esac
777 else # shared is disabled
778 case $ac_sys_system in
779 CYGWIN*)
780 BLDLIBRARY='$(LIBRARY)'
781 LDLIBRARY='libpython$(VERSION).dll.a'
782 ;;
783 esac
784 fi
786 AC_MSG_RESULT($LDLIBRARY)
788 AC_PROG_RANLIB
789 AC_SUBST(AR)
790 AC_CHECK_PROGS(AR, ar aal, ar)
792 # tweak ARFLAGS only if the user didn't set it on the command line
793 AC_SUBST(ARFLAGS)
794 if test -z "$ARFLAGS"
795 then
796 ARFLAGS="rc"
797 fi
799 AC_SUBST(SVNVERSION)
800 AC_CHECK_PROG(SVNVERSION, svnversion, found, not-found)
801 if test $SVNVERSION = found
802 then
803 SVNVERSION="svnversion \$(srcdir)"
804 else
805 SVNVERSION="echo Unversioned directory"
806 fi
808 case $MACHDEP in
809 bsdos*|hp*|HP*)
810 # install -d does not work on BSDI or HP-UX
811 if test -z "$INSTALL"
812 then
813 INSTALL="${srcdir}/install-sh -c"
814 fi
815 esac
816 AC_PROG_INSTALL
818 # Not every filesystem supports hard links
819 AC_SUBST(LN)
820 if test -z "$LN" ; then
821 case $ac_sys_system in
822 BeOS*) LN="ln -s";;
823 CYGWIN*) LN="ln -s";;
824 atheos*) LN="ln -s";;
825 *) LN=ln;;
826 esac
827 fi
829 # Check for --with-pydebug
830 AC_MSG_CHECKING(for --with-pydebug)
831 AC_ARG_WITH(pydebug,
832 AC_HELP_STRING(--with-pydebug, build with Py_DEBUG defined),
833 [
834 if test "$withval" != no
835 then
836 AC_DEFINE(Py_DEBUG, 1,
837 [Define if you want to build an interpreter with many run-time checks.])
838 AC_MSG_RESULT(yes);
839 Py_DEBUG='true'
840 else AC_MSG_RESULT(no); Py_DEBUG='false'
841 fi],
842 [AC_MSG_RESULT(no)])
844 # XXX Shouldn't the code above that fiddles with BASECFLAGS and OPT be
845 # merged with this chunk of code?
847 # Optimizer/debugger flags
848 # ------------------------
849 # (The following bit of code is complicated enough - please keep things
850 # indented properly. Just pretend you're editing Python code. ;-)
852 # There are two parallel sets of case statements below, one that checks to
853 # see if OPT was set and one that does BASECFLAGS setting based upon
854 # compiler and platform. BASECFLAGS tweaks need to be made even if the
855 # user set OPT.
857 # tweak OPT based on compiler and platform, only if the user didn't set
858 # it on the command line
859 AC_SUBST(OPT)
860 if test -z "$OPT"
861 then
862 case $GCC in
863 yes)
864 if test "$CC" != 'g++' ; then
865 STRICT_PROTO="-Wstrict-prototypes"
866 fi
867 # For gcc 4.x we need to use -fwrapv so lets check if its supported
868 if "$CC" -v --help 2>/dev/null |grep -- -fwrapv > /dev/null; then
869 WRAP="-fwrapv"
870 fi
871 case $ac_cv_prog_cc_g in
872 yes)
873 if test "$Py_DEBUG" = 'true' ; then
874 # Optimization messes up debuggers, so turn it off for
875 # debug builds.
876 OPT="-g -Wall $STRICT_PROTO"
877 else
878 OPT="-g $WRAP -O3 -Wall $STRICT_PROTO"
879 fi
880 ;;
881 *)
882 OPT="-O3 -Wall $STRICT_PROTO"
883 ;;
884 esac
885 case $ac_sys_system in
886 SCO_SV*) OPT="$OPT -m486 -DSCO5"
887 ;;
888 esac
889 ;;
891 *)
892 OPT="-O"
893 ;;
894 esac
896 # The current (beta) Monterey compiler dies with optimizations
897 # XXX what is Monterey? Does it still die w/ -O? Can we get rid of this?
898 case $ac_sys_system in
899 Monterey*)
900 OPT=""
901 ;;
902 esac
904 fi
906 AC_SUBST(BASECFLAGS)
908 # The -arch flags for universal builds on OSX
909 UNIVERSAL_ARCH_FLAGS=
910 AC_SUBST(UNIVERSAL_ARCH_FLAGS)
912 # tweak BASECFLAGS based on compiler and platform
913 case $GCC in
914 yes)
915 # Python violates C99 rules, by casting between incompatible
916 # pointer types. GCC may generate bad code as a result of that,
917 # so use -fno-strict-aliasing if supported.
918 AC_MSG_CHECKING(whether $CC accepts -fno-strict-aliasing)
919 ac_save_cc="$CC"
920 CC="$CC -fno-strict-aliasing"
921 AC_TRY_RUN([int main() { return 0; }],
922 ac_cv_no_strict_aliasing_ok=yes,
923 ac_cv_no_strict_aliasing_ok=no,
924 ac_cv_no_strict_aliasing_ok=no)
925 CC="$ac_save_cc"
926 AC_MSG_RESULT($ac_cv_no_strict_aliasing_ok)
927 if test $ac_cv_no_strict_aliasing_ok = yes
928 then
929 BASECFLAGS="$BASECFLAGS -fno-strict-aliasing"
930 fi
932 # if using gcc on alpha, use -mieee to get (near) full IEEE 754
933 # support. Without this, treatment of subnormals doesn't follow
934 # the standard.
935 case $ac_sys_machine in
936 alpha*)
937 BASECFLAGS="$BASECFLAGS -mieee"
938 ;;
939 esac
941 case $ac_sys_system in
942 SCO_SV*)
943 BASECFLAGS="$BASECFLAGS -m486 -DSCO5"
944 ;;
945 # is there any other compiler on Darwin besides gcc?
946 Darwin*)
947 # -Wno-long-double, -no-cpp-precomp, and -mno-fused-madd
948 # used to be here, but non-Apple gcc doesn't accept them.
951 if test "${enable_universalsdk}"; then
952 UNIVERSAL_ARCH_FLAGS=""
953 if test "$UNIVERSAL_ARCHS" = "32-bit" ; then
954 UNIVERSAL_ARCH_FLAGS="-arch ppc -arch i386"
955 ARCH_RUN_32BIT=""
957 elif test "$UNIVERSAL_ARCHS" = "64-bit" ; then
958 UNIVERSAL_ARCH_FLAGS="-arch ppc64 -arch x86_64"
960 elif test "$UNIVERSAL_ARCHS" = "all" ; then
961 UNIVERSAL_ARCH_FLAGS="-arch i386 -arch ppc -arch ppc64 -arch x86_64"
962 ARCH_RUN_32BIT="arch -i386 -ppc"
964 else
965 AC_MSG_ERROR([proper usage is --with-universalarch=32-bit|64-bit|all])
967 fi
970 BASECFLAGS="${UNIVERSAL_ARCH_FLAGS} -isysroot ${UNIVERSALSDK} ${BASECFLAGS}"
971 tgt=`sw_vers -productVersion | sed 's/\(10\.[[0-9]]*\).*/\1/'`
972 if test "${UNIVERSALSDK}" != "/" -a "${tgt}" '>' '10.4' ; then
973 CFLAGS="${UNIVERSAL_ARCH_FLAGS} -isysroot ${UNIVERSALSDK} ${CFLAGS}"
974 fi
975 fi
977 # Calculate the right deployment target for this build.
978 #
979 cur_target=`sw_vers -productVersion | sed 's/\(10\.[[0-9]]*\).*/\1/'`
980 if test ${cur_target} '>' 10.2; then
981 cur_target=10.3
982 fi
983 if test "${UNIVERSAL_ARCHS}" = "all"; then
984 # Ensure that the default platform for a 4-way
985 # universal build is OSX 10.5, that's the first
986 # OS release where 4-way builds make sense.
987 cur_target='10.5'
988 fi
989 CONFIGURE_MACOSX_DEPLOYMENT_TARGET=${MACOSX_DEPLOYMENT_TARGET-${cur_target}}
991 # Make sure that MACOSX_DEPLOYMENT_TARGET is set in the
992 # environment with a value that is the same as what we'll use
993 # in the Makefile to ensure that we'll get the same compiler
994 # environment during configure and build time.
995 MACOSX_DEPLOYMENT_TARGET="$CONFIGURE_MACOSX_DEPLOYMENT_TARGET"
996 export MACOSX_DEPLOYMENT_TARGET
997 EXPORT_MACOSX_DEPLOYMENT_TARGET=''
999 ;;
1000 OSF*)
1001 BASECFLAGS="$BASECFLAGS -mieee"
1002 ;;
1003 esac
1004 ;;
1006 *)
1007 case $ac_sys_system in
1008 OpenUNIX*|UnixWare*)
1009 BASECFLAGS="$BASECFLAGS -K pentium,host,inline,loop_unroll,alloca "
1010 ;;
1011 OSF*)
1012 BASECFLAGS="$BASECFLAGS -ieee -std"
1013 ;;
1014 SCO_SV*)
1015 BASECFLAGS="$BASECFLAGS -belf -Ki486 -DSCO5"
1016 ;;
1017 esac
1018 ;;
1019 esac
1021 if test "$Py_DEBUG" = 'true'; then
1022 :
1023 else
1024 OPT="-DNDEBUG $OPT"
1025 fi
1027 if test "$ac_arch_flags"
1028 then
1029 BASECFLAGS="$BASECFLAGS $ac_arch_flags"
1030 fi
1032 # disable check for icc since it seems to pass, but generates a warning
1033 if test "$CC" = icc
1034 then
1035 ac_cv_opt_olimit_ok=no
1036 fi
1038 AC_MSG_CHECKING(whether $CC accepts -OPT:Olimit=0)
1039 AC_CACHE_VAL(ac_cv_opt_olimit_ok,
1040 [ac_save_cc="$CC"
1041 CC="$CC -OPT:Olimit=0"
1042 AC_TRY_RUN([int main() { return 0; }],
1043 ac_cv_opt_olimit_ok=yes,
1044 ac_cv_opt_olimit_ok=no,
1045 ac_cv_opt_olimit_ok=no)
1046 CC="$ac_save_cc"])
1047 AC_MSG_RESULT($ac_cv_opt_olimit_ok)
1048 if test $ac_cv_opt_olimit_ok = yes; then
1049 case $ac_sys_system in
1050 # XXX is this branch needed? On MacOSX 10.2.2 the result of the
1051 # olimit_ok test is "no". Is it "yes" in some other Darwin-esque
1052 # environment?
1053 Darwin*)
1054 ;;
1055 *)
1056 BASECFLAGS="$BASECFLAGS -OPT:Olimit=0"
1057 ;;
1058 esac
1059 else
1060 AC_MSG_CHECKING(whether $CC accepts -Olimit 1500)
1061 AC_CACHE_VAL(ac_cv_olimit_ok,
1062 [ac_save_cc="$CC"
1063 CC="$CC -Olimit 1500"
1064 AC_TRY_RUN([int main() { return 0; }],
1065 ac_cv_olimit_ok=yes,
1066 ac_cv_olimit_ok=no,
1067 ac_cv_olimit_ok=no)
1068 CC="$ac_save_cc"])
1069 AC_MSG_RESULT($ac_cv_olimit_ok)
1070 if test $ac_cv_olimit_ok = yes; then
1071 BASECFLAGS="$BASECFLAGS -Olimit 1500"
1072 fi
1073 fi
1075 # Check whether GCC supports PyArg_ParseTuple format
1076 if test "$GCC" = "yes"
1077 then
1078 AC_MSG_CHECKING(whether gcc supports ParseTuple __format__)
1079 save_CFLAGS=$CFLAGS
1080 CFLAGS="$CFLAGS -Werror"
1081 AC_TRY_COMPILE([
1082 void f(char*,...)__attribute((format(PyArg_ParseTuple, 1, 2)));
1083 ],,
1084 AC_DEFINE(HAVE_ATTRIBUTE_FORMAT_PARSETUPLE, 1, [Define if GCC supports __attribute__((format(PyArg_ParseTuple, 2, 3)))])
1085 AC_MSG_RESULT(yes),
1086 AC_MSG_RESULT(no)
1087 )
1088 CFLAGS=$save_CFLAGS
1089 fi
1091 # On some compilers, pthreads are available without further options
1092 # (e.g. MacOS X). On some of these systems, the compiler will not
1093 # complain if unaccepted options are passed (e.g. gcc on Mac OS X).
1094 # So we have to see first whether pthreads are available without
1095 # options before we can check whether -Kpthread improves anything.
1096 AC_MSG_CHECKING(whether pthreads are available without options)
1097 AC_CACHE_VAL(ac_cv_pthread_is_default,
1098 [AC_TRY_RUN([
1099 #include <pthread.h>
1101 void* routine(void* p){return NULL;}
1103 int main(){
1104 pthread_t p;
1105 if(pthread_create(&p,NULL,routine,NULL)!=0)
1106 return 1;
1107 (void)pthread_detach(p);
1108 return 0;
1109 }
1110 ],
1111 [
1112 ac_cv_pthread_is_default=yes
1113 ac_cv_kthread=no
1114 ac_cv_pthread=no
1115 ],
1116 ac_cv_pthread_is_default=no,
1117 ac_cv_pthread_is_default=no)
1118 ])
1119 AC_MSG_RESULT($ac_cv_pthread_is_default)
1122 if test $ac_cv_pthread_is_default = yes
1123 then
1124 ac_cv_kpthread=no
1125 else
1126 # -Kpthread, if available, provides the right #defines
1127 # and linker options to make pthread_create available
1128 # Some compilers won't report that they do not support -Kpthread,
1129 # so we need to run a program to see whether it really made the
1130 # function available.
1131 AC_MSG_CHECKING(whether $CC accepts -Kpthread)
1132 AC_CACHE_VAL(ac_cv_kpthread,
1133 [ac_save_cc="$CC"
1134 CC="$CC -Kpthread"
1135 AC_TRY_RUN([
1136 #include <pthread.h>
1138 void* routine(void* p){return NULL;}
1140 int main(){
1141 pthread_t p;
1142 if(pthread_create(&p,NULL,routine,NULL)!=0)
1143 return 1;
1144 (void)pthread_detach(p);
1145 return 0;
1146 }
1147 ],
1148 ac_cv_kpthread=yes,
1149 ac_cv_kpthread=no,
1150 ac_cv_kpthread=no)
1151 CC="$ac_save_cc"])
1152 AC_MSG_RESULT($ac_cv_kpthread)
1153 fi
1155 if test $ac_cv_kpthread = no -a $ac_cv_pthread_is_default = no
1156 then
1157 # -Kthread, if available, provides the right #defines
1158 # and linker options to make pthread_create available
1159 # Some compilers won't report that they do not support -Kthread,
1160 # so we need to run a program to see whether it really made the
1161 # function available.
1162 AC_MSG_CHECKING(whether $CC accepts -Kthread)
1163 AC_CACHE_VAL(ac_cv_kthread,
1164 [ac_save_cc="$CC"
1165 CC="$CC -Kthread"
1166 AC_TRY_RUN([
1167 #include <pthread.h>
1169 void* routine(void* p){return NULL;}
1171 int main(){
1172 pthread_t p;
1173 if(pthread_create(&p,NULL,routine,NULL)!=0)
1174 return 1;
1175 (void)pthread_detach(p);
1176 return 0;
1177 }
1178 ],
1179 ac_cv_kthread=yes,
1180 ac_cv_kthread=no,
1181 ac_cv_kthread=no)
1182 CC="$ac_save_cc"])
1183 AC_MSG_RESULT($ac_cv_kthread)
1184 fi
1186 if test $ac_cv_kthread = no -a $ac_cv_pthread_is_default = no
1187 then
1188 # -pthread, if available, provides the right #defines
1189 # and linker options to make pthread_create available
1190 # Some compilers won't report that they do not support -pthread,
1191 # so we need to run a program to see whether it really made the
1192 # function available.
1193 AC_MSG_CHECKING(whether $CC accepts -pthread)
1194 AC_CACHE_VAL(ac_cv_thread,
1195 [ac_save_cc="$CC"
1196 CC="$CC -pthread"
1197 AC_TRY_RUN([
1198 #include <pthread.h>
1200 void* routine(void* p){return NULL;}
1202 int main(){
1203 pthread_t p;
1204 if(pthread_create(&p,NULL,routine,NULL)!=0)
1205 return 1;
1206 (void)pthread_detach(p);
1207 return 0;
1208 }
1209 ],
1210 ac_cv_pthread=yes,
1211 ac_cv_pthread=no,
1212 ac_cv_pthread=no)
1213 CC="$ac_save_cc"])
1214 AC_MSG_RESULT($ac_cv_pthread)
1215 fi
1217 # If we have set a CC compiler flag for thread support then
1218 # check if it works for CXX, too.
1219 ac_cv_cxx_thread=no
1220 if test ! -z "$CXX"
1221 then
1222 AC_MSG_CHECKING(whether $CXX also accepts flags for thread support)
1223 ac_save_cxx="$CXX"
1225 if test "$ac_cv_kpthread" = "yes"
1226 then
1227 CXX="$CXX -Kpthread"
1228 ac_cv_cxx_thread=yes
1229 elif test "$ac_cv_kthread" = "yes"
1230 then
1231 CXX="$CXX -Kthread"
1232 ac_cv_cxx_thread=yes
1233 elif test "$ac_cv_pthread" = "yes"
1234 then
1235 CXX="$CXX -pthread"
1236 ac_cv_cxx_thread=yes
1237 fi
1239 if test $ac_cv_cxx_thread = yes
1240 then
1241 echo 'void foo();int main(){foo();}void foo(){}' > conftest.$ac_ext
1242 $CXX -c conftest.$ac_ext 2>&5
1243 if $CXX -o conftest$ac_exeext conftest.$ac_objext 2>&5 \
1244 && test -s conftest$ac_exeext && ./conftest$ac_exeext
1245 then
1246 ac_cv_cxx_thread=yes
1247 else
1248 ac_cv_cxx_thread=no
1249 fi
1250 rm -fr conftest*
1251 fi
1252 AC_MSG_RESULT($ac_cv_cxx_thread)
1253 fi
1254 CXX="$ac_save_cxx"
1256 dnl # check for ANSI or K&R ("traditional") preprocessor
1257 dnl AC_MSG_CHECKING(for C preprocessor type)
1258 dnl AC_TRY_COMPILE([
1259 dnl #define spam(name, doc) {#name, &name, #name "() -- " doc}
1260 dnl int foo;
1261 dnl struct {char *name; int *addr; char *doc;} desc = spam(foo, "something");
1262 dnl ], [;], cpp_type=ansi, AC_DEFINE(HAVE_OLD_CPP) cpp_type=traditional)
1263 dnl AC_MSG_RESULT($cpp_type)
1265 # checks for header files
1266 AC_HEADER_STDC
1267 AC_CHECK_HEADERS(asm/types.h conio.h curses.h direct.h dlfcn.h errno.h \
1268 fcntl.h grp.h \
1269 ieeefp.h io.h langinfo.h libintl.h ncurses.h poll.h process.h pthread.h \
1270 shadow.h signal.h stdint.h stropts.h termios.h thread.h \
1271 unistd.h utime.h \
1272 sys/audioio.h sys/bsdtty.h sys/epoll.h sys/event.h sys/file.h sys/loadavg.h \
1273 sys/lock.h sys/mkdev.h sys/modem.h \
1274 sys/param.h sys/poll.h sys/select.h sys/socket.h sys/statvfs.h sys/stat.h \
1275 sys/termio.h sys/time.h \
1276 sys/times.h sys/types.h sys/un.h sys/utsname.h sys/wait.h pty.h libutil.h \
1277 sys/resource.h netpacket/packet.h sysexits.h bluetooth.h \
1278 bluetooth/bluetooth.h linux/tipc.h)
1279 AC_HEADER_DIRENT
1280 AC_HEADER_MAJOR
1282 # On Solaris, term.h requires curses.h
1283 AC_CHECK_HEADERS(term.h,,,[
1284 #ifdef HAVE_CURSES_H
1285 #include <curses.h>
1286 #endif
1287 ])
1289 # On Linux, netlink.h requires asm/types.h
1290 AC_CHECK_HEADERS(linux/netlink.h,,,[
1291 #ifdef HAVE_ASM_TYPES_H
1292 #include <asm/types.h>
1293 #endif
1294 #ifdef HAVE_SYS_SOCKET_H
1295 #include <sys/socket.h>
1296 #endif
1297 ])
1299 # checks for typedefs
1300 was_it_defined=no
1301 AC_MSG_CHECKING(for clock_t in time.h)
1302 AC_EGREP_HEADER(clock_t, time.h, was_it_defined=yes, [
1303 AC_DEFINE(clock_t, long, [Define to 'long' if <time.h> doesn't define.])
1304 ])
1305 AC_MSG_RESULT($was_it_defined)
1307 # Check whether using makedev requires defining _OSF_SOURCE
1308 AC_MSG_CHECKING(for makedev)
1309 AC_TRY_LINK([#include <sys/types.h> ],
1310 [ makedev(0, 0) ],
1311 ac_cv_has_makedev=yes,
1312 ac_cv_has_makedev=no)
1313 if test "$ac_cv_has_makedev" = "no"; then
1314 # we didn't link, try if _OSF_SOURCE will allow us to link
1315 AC_TRY_LINK([
1316 #define _OSF_SOURCE 1
1317 #include <sys/types.h>
1318 ],
1319 [ makedev(0, 0) ],
1320 ac_cv_has_makedev=yes,
1321 ac_cv_has_makedev=no)
1322 if test "$ac_cv_has_makedev" = "yes"; then
1323 AC_DEFINE(_OSF_SOURCE, 1, [Define _OSF_SOURCE to get the makedev macro.])
1324 fi
1325 fi
1326 AC_MSG_RESULT($ac_cv_has_makedev)
1327 if test "$ac_cv_has_makedev" = "yes"; then
1328 AC_DEFINE(HAVE_MAKEDEV, 1, [Define this if you have the makedev macro.])
1329 fi
1331 # Enabling LFS on Solaris (2.6 to 9) with gcc 2.95 triggers a bug in
1332 # the system headers: If _XOPEN_SOURCE and _LARGEFILE_SOURCE are
1333 # defined, but the compiler does not support pragma redefine_extname,
1334 # and _LARGEFILE64_SOURCE is not defined, the headers refer to 64-bit
1335 # structures (such as rlimit64) without declaring them. As a
1336 # work-around, disable LFS on such configurations
1338 use_lfs=yes
1339 AC_MSG_CHECKING(Solaris LFS bug)
1340 AC_TRY_COMPILE([
1341 #define _LARGEFILE_SOURCE 1
1342 #define _FILE_OFFSET_BITS 64
1343 #include <sys/resource.h>
1344 ],struct rlimit foo;,sol_lfs_bug=no,sol_lfs_bug=yes)
1345 AC_MSG_RESULT($sol_lfs_bug)
1346 if test "$sol_lfs_bug" = "yes"; then
1347 use_lfs=no
1348 fi
1350 if test "$use_lfs" = "yes"; then
1351 # Two defines needed to enable largefile support on various platforms
1352 # These may affect some typedefs
1353 AC_DEFINE(_LARGEFILE_SOURCE, 1,
1354 [This must be defined on some systems to enable large file support.])
1355 AC_DEFINE(_FILE_OFFSET_BITS, 64,
1356 [This must be set to 64 on some systems to enable large file support.])
1357 fi
1359 # Add some code to confdefs.h so that the test for off_t works on SCO
1360 cat >> confdefs.h <<\EOF
1361 #if defined(SCO_DS)
1362 #undef _OFF_T
1363 #endif
1364 EOF
1366 # Type availability checks
1367 AC_TYPE_MODE_T
1368 AC_TYPE_OFF_T
1369 AC_TYPE_PID_T
1370 AC_TYPE_SIGNAL
1371 AC_TYPE_SIZE_T
1372 AC_TYPE_UID_T
1373 AC_TYPE_UINT32_T
1374 AC_TYPE_UINT64_T
1375 AC_TYPE_INT32_T
1376 AC_TYPE_INT64_T
1377 AC_CHECK_TYPE(ssize_t,
1378 AC_DEFINE(HAVE_SSIZE_T, 1, Define if your compiler provides ssize_t),,)
1380 # Sizes of various common basic types
1381 # ANSI C requires sizeof(char) == 1, so no need to check it
1382 AC_CHECK_SIZEOF(int, 4)
1383 AC_CHECK_SIZEOF(long, 4)
1384 AC_CHECK_SIZEOF(void *, 4)
1385 AC_CHECK_SIZEOF(short, 2)
1386 AC_CHECK_SIZEOF(float, 4)
1387 AC_CHECK_SIZEOF(double, 8)
1388 AC_CHECK_SIZEOF(fpos_t, 4)
1389 AC_CHECK_SIZEOF(size_t, 4)
1390 AC_CHECK_SIZEOF(pid_t, 4)
1392 AC_MSG_CHECKING(for long long support)
1393 have_long_long=no
1394 AC_TRY_COMPILE([], [long long x; x = (long long)0;], [
1395 AC_DEFINE(HAVE_LONG_LONG, 1, [Define this if you have the type long long.])
1396 have_long_long=yes
1397 ])
1398 AC_MSG_RESULT($have_long_long)
1399 if test "$have_long_long" = yes ; then
1400 AC_CHECK_SIZEOF(long long, 8)
1401 fi
1403 AC_MSG_CHECKING(for long double support)
1404 have_long_double=no
1405 AC_TRY_COMPILE([], [long double x; x = (long double)0.;], [
1406 AC_DEFINE(HAVE_LONG_DOUBLE, 1, [Define this if you have the type long double.])
1407 have_long_double=yes
1408 ])
1409 AC_MSG_RESULT($have_long_double)
1410 if test "$have_long_double" = yes ; then
1411 AC_CHECK_SIZEOF(long double, 12)
1412 fi
1414 AC_MSG_CHECKING(for _Bool support)
1415 have_c99_bool=no
1416 AC_TRY_COMPILE([], [_Bool x; x = (_Bool)0;], [
1417 AC_DEFINE(HAVE_C99_BOOL, 1, [Define this if you have the type _Bool.])
1418 have_c99_bool=yes
1419 ])
1420 AC_MSG_RESULT($have_c99_bool)
1421 if test "$have_c99_bool" = yes ; then
1422 AC_CHECK_SIZEOF(_Bool, 1)
1423 fi
1425 AC_CHECK_TYPES(uintptr_t,
1426 [AC_CHECK_SIZEOF(uintptr_t, 4)],
1427 [], [#ifdef HAVE_STDINT_H
1428 #include <stdint.h>
1429 #endif])
1432 # Hmph. AC_CHECK_SIZEOF() doesn't include <sys/types.h>.
1433 AC_MSG_CHECKING(size of off_t)
1434 AC_CACHE_VAL(ac_cv_sizeof_off_t,
1435 [AC_TRY_RUN([#include <stdio.h>
1436 #include <sys/types.h>
1437 main()
1438 {
1439 FILE *f=fopen("conftestval", "w");
1440 if (!f) exit(1);
1441 fprintf(f, "%d\n", sizeof(off_t));
1442 exit(0);
1443 }],
1444 ac_cv_sizeof_off_t=`cat conftestval`,
1445 ac_cv_sizeof_off_t=0,
1446 ac_cv_sizeof_off_t=4)
1447 ])
1448 AC_MSG_RESULT($ac_cv_sizeof_off_t)
1449 AC_DEFINE_UNQUOTED(SIZEOF_OFF_T, $ac_cv_sizeof_off_t,
1450 [The number of bytes in an off_t.])
1452 AC_MSG_CHECKING(whether to enable large file support)
1453 if test "$have_long_long" = yes -a \
1454 "$ac_cv_sizeof_off_t" -gt "$ac_cv_sizeof_long" -a \
1455 "$ac_cv_sizeof_long_long" -ge "$ac_cv_sizeof_off_t"; then
1456 AC_DEFINE(HAVE_LARGEFILE_SUPPORT, 1,
1457 [Defined to enable large file support when an off_t is bigger than a long
1458 and long long is available and at least as big as an off_t. You may need
1459 to add some flags for configuration and compilation to enable this mode.
1460 (For Solaris and Linux, the necessary defines are already defined.)])
1461 AC_MSG_RESULT(yes)
1462 else
1463 AC_MSG_RESULT(no)
1464 fi
1466 # AC_CHECK_SIZEOF() doesn't include <time.h>.
1467 AC_MSG_CHECKING(size of time_t)
1468 AC_CACHE_VAL(ac_cv_sizeof_time_t,
1469 [AC_TRY_RUN([#include <stdio.h>
1470 #include <time.h>
1471 main()
1472 {
1473 FILE *f=fopen("conftestval", "w");
1474 if (!f) exit(1);
1475 fprintf(f, "%d\n", sizeof(time_t));
1476 exit(0);
1477 }],
1478 ac_cv_sizeof_time_t=`cat conftestval`,
1479 ac_cv_sizeof_time_t=0,
1480 ac_cv_sizeof_time_t=4)
1481 ])
1482 AC_MSG_RESULT($ac_cv_sizeof_time_t)
1483 AC_DEFINE_UNQUOTED(SIZEOF_TIME_T, $ac_cv_sizeof_time_t,
1484 [The number of bytes in a time_t.])
1487 # if have pthread_t then define SIZEOF_PTHREAD_T
1488 ac_save_cc="$CC"
1489 if test "$ac_cv_kpthread" = "yes"
1490 then CC="$CC -Kpthread"
1491 elif test "$ac_cv_kthread" = "yes"
1492 then CC="$CC -Kthread"
1493 elif test "$ac_cv_pthread" = "yes"
1494 then CC="$CC -pthread"
1495 fi
1496 AC_MSG_CHECKING(for pthread_t)
1497 have_pthread_t=no
1498 AC_TRY_COMPILE([#include <pthread.h>], [pthread_t x; x = *(pthread_t*)0;], have_pthread_t=yes)
1499 AC_MSG_RESULT($have_pthread_t)
1500 if test "$have_pthread_t" = yes ; then
1501 # AC_CHECK_SIZEOF() doesn't include <pthread.h>.
1502 AC_MSG_CHECKING(size of pthread_t)
1503 AC_CACHE_VAL(ac_cv_sizeof_pthread_t,
1504 [AC_TRY_RUN([#include <stdio.h>
1505 #include <pthread.h>
1506 main()
1507 {
1508 FILE *f=fopen("conftestval", "w");
1509 if (!f) exit(1);
1510 fprintf(f, "%d\n", sizeof(pthread_t));
1511 exit(0);
1512 }],
1513 ac_cv_sizeof_pthread_t=`cat conftestval`,
1514 ac_cv_sizeof_pthread_t=0,
1515 ac_cv_sizeof_pthread_t=4)
1516 ])
1517 AC_MSG_RESULT($ac_cv_sizeof_pthread_t)
1518 AC_DEFINE_UNQUOTED(SIZEOF_PTHREAD_T, $ac_cv_sizeof_pthread_t,
1519 [The number of bytes in a pthread_t.])
1520 fi
1521 CC="$ac_save_cc"
1523 AC_MSG_CHECKING(for --enable-toolbox-glue)
1524 AC_ARG_ENABLE(toolbox-glue,
1525 AC_HELP_STRING(--enable-toolbox-glue, disable/enable MacOSX glue code for extensions))
1527 if test -z "$enable_toolbox_glue"
1528 then
1529 case $ac_sys_system/$ac_sys_release in
1530 Darwin/*)
1531 enable_toolbox_glue="yes";;
1532 *)
1533 enable_toolbox_glue="no";;
1534 esac
1535 fi
1536 case "$enable_toolbox_glue" in
1537 yes)
1538 extra_machdep_objs="Python/mactoolboxglue.o"
1539 extra_undefs="-u _PyMac_Error"
1540 AC_DEFINE(USE_TOOLBOX_OBJECT_GLUE, 1,
1541 [Define if you want to use MacPython modules on MacOSX in unix-Python.])
1542 ;;
1543 *)
1544 extra_machdep_objs=""
1545 extra_undefs=""
1546 ;;
1547 esac
1548 AC_MSG_RESULT($enable_toolbox_glue)
1551 AC_SUBST(OTHER_LIBTOOL_OPT)
1552 case $ac_sys_system/$ac_sys_release in
1553 Darwin/@<:@01567@:>@\..*)
1554 OTHER_LIBTOOL_OPT="-prebind -seg1addr 0x10000000"
1555 ;;
1556 Darwin/*)
1557 OTHER_LIBTOOL_OPT=""
1558 ;;
1559 esac
1561 AC_SUBST(LIBTOOL_CRUFT)
1562 case $ac_sys_system/$ac_sys_release in
1563 Darwin/@<:@01567@:>@\..*)
1564 LIBTOOL_CRUFT="-framework System -lcc_dynamic"
1565 if test "${enable_universalsdk}"; then
1566 :
1567 else
1568 LIBTOOL_CRUFT="${LIBTOOL_CRUFT} -arch_only `arch`"
1569 fi
1570 LIBTOOL_CRUFT=$LIBTOOL_CRUFT' -install_name $(PYTHONFRAMEWORKINSTALLDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1571 LIBTOOL_CRUFT=$LIBTOOL_CRUFT' -compatibility_version $(VERSION) -current_version $(VERSION)';;
1572 Darwin/*)
1573 gcc_version=`gcc -v 2>&1 | grep version | cut -d\ -f3`
1574 if test ${gcc_version} '<' 4.0
1575 then
1576 LIBTOOL_CRUFT="-lcc_dynamic"
1577 else
1578 LIBTOOL_CRUFT=""
1579 fi
1580 LIBTOOL_CRUFT=$LIBTOOL_CRUFT" -lSystem -lSystemStubs -arch_only `arch`"
1581 LIBTOOL_CRUFT=$LIBTOOL_CRUFT' -install_name $(PYTHONFRAMEWORKINSTALLDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1582 LIBTOOL_CRUFT=$LIBTOOL_CRUFT' -compatibility_version $(VERSION) -current_version $(VERSION)';;
1583 esac
1585 AC_MSG_CHECKING(for --enable-framework)
1586 if test "$enable_framework"
1587 then
1588 BASECFLAGS="$BASECFLAGS -fno-common -dynamic"
1589 # -F. is needed to allow linking to the framework while
1590 # in the build location.
1591 AC_DEFINE(WITH_NEXT_FRAMEWORK, 1,
1592 [Define if you want to produce an OpenStep/Rhapsody framework
1593 (shared library plus accessory files).])
1594 AC_MSG_RESULT(yes)
1595 if test $enable_shared = "yes"
1596 then
1597 AC_MSG_ERROR([Specifying both --enable-shared and --enable-framework is not supported, use only --enable-framework instead])
1598 fi
1599 else
1600 AC_MSG_RESULT(no)
1601 fi
1603 AC_MSG_CHECKING(for dyld)
1604 case $ac_sys_system/$ac_sys_release in
1605 Darwin/*)
1606 AC_DEFINE(WITH_DYLD, 1,
1607 [Define if you want to use the new-style (Openstep, Rhapsody, MacOS)
1608 dynamic linker (dyld) instead of the old-style (NextStep) dynamic
1609 linker (rld). Dyld is necessary to support frameworks.])
1610 AC_MSG_RESULT(always on for Darwin)
1611 ;;
1612 *)
1613 AC_MSG_RESULT(no)
1614 ;;
1615 esac
1617 # Set info about shared libraries.
1618 AC_SUBST(SO)
1619 AC_SUBST(LDSHARED)
1620 AC_SUBST(BLDSHARED)
1621 AC_SUBST(CCSHARED)
1622 AC_SUBST(LINKFORSHARED)
1623 # SO is the extension of shared libraries `(including the dot!)
1624 # -- usually .so, .sl on HP-UX, .dll on Cygwin
1625 AC_MSG_CHECKING(SO)
1626 if test -z "$SO"
1627 then
1628 case $ac_sys_system in
1629 hp*|HP*)
1630 case `uname -m` in
1631 ia64) SO=.so;;
1632 *) SO=.sl;;
1633 esac
1634 ;;
1635 CYGWIN*) SO=.dll;;
1636 *) SO=.so;;
1637 esac
1638 else
1639 # this might also be a termcap variable, see #610332
1640 echo
1641 echo '====================================================================='
1642 echo '+ +'
1643 echo '+ WARNING: You have set SO in your environment. +'
1644 echo '+ Do you really mean to change the extension for shared libraries? +'
1645 echo '+ Continuing in 10 seconds to let you to ponder. +'
1646 echo '+ +'
1647 echo '====================================================================='
1648 sleep 10
1649 fi
1650 AC_MSG_RESULT($SO)
1652 AC_DEFINE_UNQUOTED(SHLIB_EXT, "$SO", [Define this to be extension of shared libraries (including the dot!).])
1653 # LDSHARED is the ld *command* used to create shared library
1654 # -- "cc -G" on SunOS 5.x, "ld -shared" on IRIX 5
1655 # (Shared libraries in this instance are shared modules to be loaded into
1656 # Python, as opposed to building Python itself as a shared library.)
1657 AC_MSG_CHECKING(LDSHARED)
1658 if test -z "$LDSHARED"
1659 then
1660 case $ac_sys_system/$ac_sys_release in
1661 AIX*)
1662 BLDSHARED="\$(srcdir)/Modules/ld_so_aix \$(CC) -bI:Modules/python.exp"
1663 LDSHARED="\$(BINLIBDEST)/config/ld_so_aix \$(CC) -bI:\$(BINLIBDEST)/config/python.exp"
1664 ;;
1665 BeOS*)
1666 BLDSHARED="\$(srcdir)/Modules/ld_so_beos $LDLIBRARY"
1667 LDSHARED="\$(BINLIBDEST)/config/ld_so_beos \$(LIBDIR)/$LDLIBRARY"
1668 ;;
1669 IRIX/5*) LDSHARED="ld -shared";;
1670 IRIX*/6*) LDSHARED="ld ${SGI_ABI} -shared -all";;
1671 SunOS/5*)
1672 if test "$GCC" = "yes"
1673 then LDSHARED='$(CC) -shared'
1674 else LDSHARED='$(CC) -G';
1675 fi ;;
1676 hp*|HP*)
1677 if test "$GCC" = "yes"
1678 then LDSHARED='$(CC) -shared'
1679 else LDSHARED='ld -b';
1680 fi ;;
1681 OSF*) LDSHARED="ld -shared -expect_unresolved \"*\"";;
1682 Darwin/1.3*)
1683 LDSHARED='$(CC) $(LDFLAGS) -bundle'
1684 if test "$enable_framework" ; then
1685 # Link against the framework. All externals should be defined.
1686 BLDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1687 LDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKPREFIX)/$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1688 else
1689 # No framework. Ignore undefined symbols, assuming they come from Python
1690 LDSHARED="$LDSHARED -undefined suppress"
1691 fi ;;
1692 Darwin/1.4*|Darwin/5.*|Darwin/6.*)
1693 LDSHARED='$(CC) $(LDFLAGS) -bundle'
1694 if test "$enable_framework" ; then
1695 # Link against the framework. All externals should be defined.
1696 BLDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1697 LDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKPREFIX)/$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1698 else
1699 # No framework, use the Python app as bundle-loader
1700 BLDSHARED="$LDSHARED "'-bundle_loader $(BUILDPYTHON)'
1701 LDSHARED="$LDSHARED "'-bundle_loader $(BINDIR)/python$(VERSION)$(EXE)'
1702 fi ;;
1703 Darwin/*)
1704 # Use -undefined dynamic_lookup whenever possible (10.3 and later).
1705 # This allows an extension to be used in any Python
1707 if test ${MACOSX_DEPLOYMENT_TARGET} '>' 10.2
1708 then
1709 if test "${enable_universalsdk}"; then
1710 LDFLAGS="${UNIVERSAL_ARCH_FLAGS} -isysroot ${UNIVERSALSDK} ${LDFLAGS}"
1711 fi
1712 LDSHARED='$(CC) $(LDFLAGS) -bundle -undefined dynamic_lookup'
1713 BLDSHARED="$LDSHARED"
1714 else
1715 LDSHARED='$(CC) $(LDFLAGS) -bundle'
1716 if test "$enable_framework" ; then
1717 # Link against the framework. All externals should be defined.
1718 BLDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1719 LDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKPREFIX)/$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1720 else
1721 # No framework, use the Python app as bundle-loader
1722 BLDSHARED="$LDSHARED "'-bundle_loader $(BUILDPYTHON)'
1723 LDSHARED="$LDSHARED "'-bundle_loader $(BINDIR)/python$(VERSION)$(EXE)'
1724 fi
1725 fi
1726 ;;
1727 Linux*|GNU*|QNX*) LDSHARED='$(CC) -shared';;
1728 BSD/OS*/4*) LDSHARED="gcc -shared";;
1729 FreeBSD*)
1730 if [[ "`$CC -dM -E - </dev/null | grep __ELF__`" != "" ]]
1731 then
1732 LDSHARED="$CC -shared ${LDFLAGS}"
1733 else
1734 LDSHARED="ld -Bshareable ${LDFLAGS}"
1735 fi;;
1736 OpenBSD*)
1737 if [[ "`$CC -dM -E - </dev/null | grep __ELF__`" != "" ]]
1738 then
1739 LDSHARED='$(CC) -shared $(CCSHARED) ${LDFLAGS}'
1740 else
1741 case `uname -r` in
1742 [[01]].* | 2.[[0-7]] | 2.[[0-7]].*)
1743 LDSHARED="ld -Bshareable ${LDFLAGS}"
1744 ;;
1745 *)
1746 LDSHARED='$(CC) -shared $(CCSHARED) ${LDFLAGS}'
1747 ;;
1748 esac
1749 fi;;
1750 NetBSD*|DragonFly*) LDSHARED="cc -shared ${LDFLAGS}";;
1751 OpenUNIX*|UnixWare*)
1752 if test "$GCC" = "yes"
1753 then LDSHARED='$(CC) -shared'
1754 else LDSHARED='$(CC) -G'
1755 fi;;
1756 SCO_SV*) LDSHARED='$(CC) -Wl,-G,-Bexport';;
1757 Monterey*) LDSHARED="cc -G -dy -Bdynamic -Bexport -L/usr/lib/ia64l64";;
1758 CYGWIN*) LDSHARED="gcc -shared -Wl,--enable-auto-image-base";;
1759 atheos*) LDSHARED="gcc -shared";;
1760 *) LDSHARED="ld";;
1761 esac
1762 fi
1763 AC_MSG_RESULT($LDSHARED)
1764 BLDSHARED=${BLDSHARED-$LDSHARED}
1765 # CCSHARED are the C *flags* used to create objects to go into a shared
1766 # library (module) -- this is only needed for a few systems
1767 AC_MSG_CHECKING(CCSHARED)
1768 if test -z "$CCSHARED"
1769 then
1770 case $ac_sys_system/$ac_sys_release in
1771 SunOS*) if test "$GCC" = yes;
1772 then CCSHARED="-fPIC";
1773 elif test `uname -p` = sparc;
1774 then CCSHARED="-xcode=pic32";
1775 else CCSHARED="-Kpic";
1776 fi;;
1777 hp*|HP*) if test "$GCC" = yes;
1778 then CCSHARED="-fPIC";
1779 else CCSHARED="+z";
1780 fi;;
1781 Linux*|GNU*) CCSHARED="-fPIC";;
1782 BSD/OS*/4*) CCSHARED="-fpic";;
1783 FreeBSD*|NetBSD*|OpenBSD*|DragonFly*) CCSHARED="-fPIC";;
1784 OpenUNIX*|UnixWare*)
1785 if test "$GCC" = "yes"
1786 then CCSHARED="-fPIC"
1787 else CCSHARED="-KPIC"
1788 fi;;
1789 SCO_SV*)
1790 if test "$GCC" = "yes"
1791 then CCSHARED="-fPIC"
1792 else CCSHARED="-Kpic -belf"
1793 fi;;
1794 Monterey*) CCSHARED="-G";;
1795 IRIX*/6*) case $CC in
1796 *gcc*) CCSHARED="-shared";;
1797 *) CCSHARED="";;
1798 esac;;
1799 atheos*) CCSHARED="-fPIC";;
1800 esac
1801 fi
1802 AC_MSG_RESULT($CCSHARED)
1803 # LINKFORSHARED are the flags passed to the $(CC) command that links
1804 # the python executable -- this is only needed for a few systems
1805 AC_MSG_CHECKING(LINKFORSHARED)
1806 if test -z "$LINKFORSHARED"
1807 then
1808 case $ac_sys_system/$ac_sys_release in
1809 AIX*) LINKFORSHARED='-Wl,-bE:Modules/python.exp -lld';;
1810 hp*|HP*)
1811 LINKFORSHARED="-Wl,-E -Wl,+s";;
1812 # LINKFORSHARED="-Wl,-E -Wl,+s -Wl,+b\$(BINLIBDEST)/lib-dynload";;
1813 BSD/OS/4*) LINKFORSHARED="-Xlinker -export-dynamic";;
1814 Linux*|GNU*) LINKFORSHARED="-Xlinker -export-dynamic";;
1815 # -u libsys_s pulls in all symbols in libsys
1816 Darwin/*)
1817 # -u _PyMac_Error is needed to pull in the mac toolbox glue,
1818 # which is
1819 # not used by the core itself but which needs to be in the core so
1820 # that dynamically loaded extension modules have access to it.
1821 # -prebind is no longer used, because it actually seems to give a
1822 # slowdown in stead of a speedup, maybe due to the large number of
1823 # dynamic loads Python does.
1825 LINKFORSHARED="$extra_undefs"
1826 if test "$enable_framework"
1827 then
1828 LINKFORSHARED="$LINKFORSHARED "'$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1829 fi
1830 LINKFORSHARED="$LINKFORSHARED";;
1831 OpenUNIX*|UnixWare*) LINKFORSHARED="-Wl,-Bexport";;
1832 SCO_SV*) LINKFORSHARED="-Wl,-Bexport";;
1833 ReliantUNIX*) LINKFORSHARED="-W1 -Blargedynsym";;
1834 FreeBSD*|NetBSD*|OpenBSD*|DragonFly*)
1835 if [[ "`$CC -dM -E - </dev/null | grep __ELF__`" != "" ]]
1836 then
1837 LINKFORSHARED="-Wl,--export-dynamic"
1838 fi;;
1839 SunOS/5*) case $CC in
1840 *gcc*)
1841 if $CC -Xlinker --help 2>&1 | grep export-dynamic >/dev/null
1842 then
1843 LINKFORSHARED="-Xlinker --export-dynamic"
1844 fi;;
1845 esac;;
1846 CYGWIN*)
1847 if test $enable_shared = "no"
1848 then
1849 LINKFORSHARED='-Wl,--out-implib=$(LDLIBRARY)'
1850 fi;;
1851 QNX*)
1852 # -Wl,-E causes the symbols to be added to the dynamic
1853 # symbol table so that they can be found when a module
1854 # is loaded. -N 2048K causes the stack size to be set
1855 # to 2048 kilobytes so that the stack doesn't overflow
1856 # when running test_compile.py.
1857 LINKFORSHARED='-Wl,-E -N 2048K';;
1858 esac
1859 fi
1860 AC_MSG_RESULT($LINKFORSHARED)
1863 AC_SUBST(CFLAGSFORSHARED)
1864 AC_MSG_CHECKING(CFLAGSFORSHARED)
1865 if test ! "$LIBRARY" = "$LDLIBRARY"
1866 then
1867 case $ac_sys_system in
1868 CYGWIN*)
1869 # Cygwin needs CCSHARED when building extension DLLs
1870 # but not when building the interpreter DLL.
1871 CFLAGSFORSHARED='';;
1872 *)
1873 CFLAGSFORSHARED='$(CCSHARED)'
1874 esac
1875 fi
1876 AC_MSG_RESULT($CFLAGSFORSHARED)
1878 # SHLIBS are libraries (except -lc and -lm) to link to the python shared
1879 # library (with --enable-shared).
1880 # For platforms on which shared libraries are not allowed to have unresolved
1881 # symbols, this must be set to $(LIBS) (expanded by make). We do this even
1882 # if it is not required, since it creates a dependency of the shared library
1883 # to LIBS. This, in turn, means that applications linking the shared libpython
1884 # don't need to link LIBS explicitly. The default should be only changed
1885 # on systems where this approach causes problems.
1886 AC_SUBST(SHLIBS)
1887 AC_MSG_CHECKING(SHLIBS)
1888 case "$ac_sys_system" in
1889 *)
1890 SHLIBS='$(LIBS)';;
1891 esac
1892 AC_MSG_RESULT($SHLIBS)
1895 # checks for libraries
1896 AC_CHECK_LIB(dl, dlopen) # Dynamic linking for SunOS/Solaris and SYSV
1897 AC_CHECK_LIB(dld, shl_load) # Dynamic linking for HP-UX
1899 # only check for sem_init if thread support is requested
1900 if test "$with_threads" = "yes" -o -z "$with_threads"; then
1901 AC_SEARCH_LIBS(sem_init, pthread rt posix4) # 'Real Time' functions on Solaris
1902 # posix4 on Solaris 2.6
1903 # pthread (first!) on Linux
1904 fi
1906 # check if we need libintl for locale functions
1907 AC_CHECK_LIB(intl, textdomain,
1908 AC_DEFINE(WITH_LIBINTL, 1,
1909 [Define to 1 if libintl is needed for locale functions.]))
1911 # checks for system dependent C++ extensions support
1912 case "$ac_sys_system" in
1913 AIX*) AC_MSG_CHECKING(for genuine AIX C++ extensions support)
1914 AC_TRY_LINK([#include "/usr/lpp/xlC/include/load.h"],
1915 [loadAndInit("", 0, "")],
1916 [AC_DEFINE(AIX_GENUINE_CPLUSPLUS, 1,
1917 [Define for AIX if your compiler is a genuine IBM xlC/xlC_r
1918 and you want support for AIX C++ shared extension modules.])
1919 AC_MSG_RESULT(yes)],
1920 [AC_MSG_RESULT(no)]);;
1921 *) ;;
1922 esac
1924 # Most SVR4 platforms (e.g. Solaris) need -lsocket and -lnsl.
1925 # BeOS' sockets are stashed in libnet.
1926 AC_CHECK_LIB(nsl, t_open, [LIBS="-lnsl $LIBS"]) # SVR4
1927 AC_CHECK_LIB(socket, socket, [LIBS="-lsocket $LIBS"], [], $LIBS) # SVR4 sockets
1929 case "$ac_sys_system" in
1930 BeOS*)
1931 AC_CHECK_LIB(net, socket, [LIBS="-lnet $LIBS"], [], $LIBS) # BeOS
1932 ;;
1933 esac
1935 AC_MSG_CHECKING(for --with-libs)
1936 AC_ARG_WITH(libs,
1937 AC_HELP_STRING(--with-libs='lib1 ...', link against additional libs),
1938 [
1939 AC_MSG_RESULT($withval)
1940 LIBS="$withval $LIBS"
1941 ],
1942 [AC_MSG_RESULT(no)])
1944 # Check for use of the system libffi library
1945 AC_MSG_CHECKING(for --with-system-ffi)
1946 AC_ARG_WITH(system_ffi,
1947 AC_HELP_STRING(--with-system-ffi, build _ctypes module using an installed ffi library))
1949 AC_MSG_RESULT($with_system_ffi)
1951 # Check for --with-dbmliborder
1952 AC_MSG_CHECKING(for --with-dbmliborder)
1953 AC_ARG_WITH(dbmliborder,
1954 AC_HELP_STRING([--with-dbmliborder=db1:db2:...], [order to check db backends for dbm. Valid value is a colon separated string with the backend names `ndbm', `gdbm' and `bdb'.]),
1955 [
1956 if test x$with_dbmliborder = xyes
1957 then
1958 AC_MSG_ERROR([proper usage is --with-dbmliborder=db1:db2:...])
1959 else
1960 for db in `echo $with_dbmliborder | sed 's/:/ /g'`; do
1961 if test x$db != xndbm && test x$db != xgdbm && test x$db != xbdb
1962 then
1963 AC_MSG_ERROR([proper usage is --with-dbmliborder=db1:db2:...])
1964 fi
1965 done
1966 fi])
1967 AC_MSG_RESULT($with_dbmliborder)
1969 # Determine if signalmodule should be used.
1970 AC_SUBST(USE_SIGNAL_MODULE)
1971 AC_SUBST(SIGNAL_OBJS)
1972 AC_MSG_CHECKING(for --with-signal-module)
1973 AC_ARG_WITH(signal-module,
1974 AC_HELP_STRING(--with-signal-module, disable/enable signal module))
1976 if test -z "$with_signal_module"
1977 then with_signal_module="yes"
1978 fi
1979 AC_MSG_RESULT($with_signal_module)
1981 if test "${with_signal_module}" = "yes"; then
1982 USE_SIGNAL_MODULE=""
1983 SIGNAL_OBJS=""
1984 else
1985 USE_SIGNAL_MODULE="#"
1986 SIGNAL_OBJS="Parser/intrcheck.o Python/sigcheck.o"
1987 fi
1989 # This is used to generate Setup.config
1990 AC_SUBST(USE_THREAD_MODULE)
1991 USE_THREAD_MODULE=""
1993 AC_MSG_CHECKING(for --with-dec-threads)
1994 AC_SUBST(LDLAST)
1995 AC_ARG_WITH(dec-threads,
1996 AC_HELP_STRING(--with-dec-threads, use DEC Alpha/OSF1 thread-safe libraries),
1997 [
1998 AC_MSG_RESULT($withval)
1999 LDLAST=-threads
2000 if test "${with_thread+set}" != set; then
2001 with_thread="$withval";
2002 fi],
2003 [AC_MSG_RESULT(no)])
2005 # Templates for things AC_DEFINEd more than once.
2006 # For a single AC_DEFINE, no template is needed.
2007 AH_TEMPLATE(C_THREADS,[Define if you have the Mach cthreads package])
2008 AH_TEMPLATE(_REENTRANT,
2009 [Define to force use of thread-safe errno, h_errno, and other functions])
2010 AH_TEMPLATE(WITH_THREAD,
2011 [Define if you want to compile in rudimentary thread support])
2013 AC_MSG_CHECKING(for --with-threads)
2014 dnl quadrigraphs "@<:@" and "@:>@" produce "[" and "]" in the output
2015 AC_ARG_WITH(threads,
2016 AC_HELP_STRING(--with(out)-threads@<:@=DIRECTORY@:>@, disable/enable thread support))
2018 # --with-thread is deprecated, but check for it anyway
2019 dnl quadrigraphs "@<:@" and "@:>@" produce "[" and "]" in the output
2020 AC_ARG_WITH(thread,
2021 AC_HELP_STRING(--with(out)-thread@<:@=DIRECTORY@:>@, deprecated; use --with(out)-threads),
2022 [with_threads=$with_thread])
2024 if test -z "$with_threads"
2025 then with_threads="yes"
2026 fi
2027 AC_MSG_RESULT($with_threads)
2029 AC_SUBST(THREADOBJ)
2030 if test "$with_threads" = "no"
2031 then
2032 USE_THREAD_MODULE="#"
2033 elif test "$ac_cv_pthread_is_default" = yes
2034 then
2035 AC_DEFINE(WITH_THREAD)
2036 # Defining _REENTRANT on system with POSIX threads should not hurt.
2037 AC_DEFINE(_REENTRANT)
2038 posix_threads=yes
2039 THREADOBJ="Python/thread.o"
2040 elif test "$ac_cv_kpthread" = "yes"
2041 then
2042 CC="$CC -Kpthread"
2043 if test "$ac_cv_cxx_thread" = "yes"; then
2044 CXX="$CXX -Kpthread"
2045 fi
2046 AC_DEFINE(WITH_THREAD)
2047 posix_threads=yes
2048 THREADOBJ="Python/thread.o"
2049 elif test "$ac_cv_kthread" = "yes"
2050 then
2051 CC="$CC -Kthread"
2052 if test "$ac_cv_cxx_thread" = "yes"; then
2053 CXX="$CXX -Kthread"
2054 fi
2055 AC_DEFINE(WITH_THREAD)
2056 posix_threads=yes
2057 THREADOBJ="Python/thread.o"
2058 elif test "$ac_cv_pthread" = "yes"
2059 then
2060 CC="$CC -pthread"
2061 if test "$ac_cv_cxx_thread" = "yes"; then
2062 CXX="$CXX -pthread"
2063 fi
2064 AC_DEFINE(WITH_THREAD)
2065 posix_threads=yes
2066 THREADOBJ="Python/thread.o"
2067 else
2068 if test ! -z "$with_threads" -a -d "$with_threads"
2069 then LDFLAGS="$LDFLAGS -L$with_threads"
2070 fi
2071 if test ! -z "$withval" -a -d "$withval"
2072 then LDFLAGS="$LDFLAGS -L$withval"
2073 fi
2075 # According to the POSIX spec, a pthreads implementation must
2076 # define _POSIX_THREADS in unistd.h. Some apparently don't
2077 # (e.g. gnu pth with pthread emulation)
2078 AC_MSG_CHECKING(for _POSIX_THREADS in unistd.h)
2079 AC_EGREP_CPP(yes,
2080 [
2081 #include <unistd.h>
2082 #ifdef _POSIX_THREADS
2083 yes
2084 #endif
2085 ], unistd_defines_pthreads=yes, unistd_defines_pthreads=no)
2086 AC_MSG_RESULT($unistd_defines_pthreads)
2088 AC_DEFINE(_REENTRANT)
2089 AC_CHECK_HEADER(cthreads.h, [AC_DEFINE(WITH_THREAD)
2090 AC_DEFINE(C_THREADS)
2091 AC_DEFINE(HURD_C_THREADS, 1,
2092 [Define if you are using Mach cthreads directly under /include])
2093 LIBS="$LIBS -lthreads"
2094 THREADOBJ="Python/thread.o"],[
2095 AC_CHECK_HEADER(mach/cthreads.h, [AC_DEFINE(WITH_THREAD)
2096 AC_DEFINE(C_THREADS)
2097 AC_DEFINE(MACH_C_THREADS, 1,
2098 [Define if you are using Mach cthreads under mach /])
2099 THREADOBJ="Python/thread.o"],[
2100 AC_MSG_CHECKING(for --with-pth)
2101 AC_ARG_WITH([pth],
2102 AC_HELP_STRING(--with-pth, use GNU pth threading libraries),
2103 [AC_MSG_RESULT($withval)
2104 AC_DEFINE([WITH_THREAD])
2105 AC_DEFINE([HAVE_PTH], 1,
2106 [Define if you have GNU PTH threads.])
2107 LIBS="-lpth $LIBS"
2108 THREADOBJ="Python/thread.o"],
2109 [AC_MSG_RESULT(no)
2111 # Just looking for pthread_create in libpthread is not enough:
2112 # on HP/UX, pthread.h renames pthread_create to a different symbol name.
2113 # So we really have to include pthread.h, and then link.
2114 _libs=$LIBS
2115 LIBS="$LIBS -lpthread"
2116 AC_MSG_CHECKING([for pthread_create in -lpthread])
2117 AC_TRY_LINK([#include <pthread.h>
2119 void * start_routine (void *arg) { exit (0); }], [
2120 pthread_create (NULL, NULL, start_routine, NULL)], [
2121 AC_MSG_RESULT(yes)
2122 AC_DEFINE(WITH_THREAD)
2123 posix_threads=yes
2124 THREADOBJ="Python/thread.o"],[
2125 LIBS=$_libs
2126 AC_CHECK_FUNC(pthread_detach, [AC_DEFINE(WITH_THREAD)
2127 posix_threads=yes
2128 THREADOBJ="Python/thread.o"],[
2129 AC_CHECK_HEADER(atheos/threads.h, [AC_DEFINE(WITH_THREAD)
2130 AC_DEFINE(ATHEOS_THREADS, 1,
2131 [Define this if you have AtheOS threads.])
2132 THREADOBJ="Python/thread.o"],[
2133 AC_CHECK_HEADER(kernel/OS.h, [AC_DEFINE(WITH_THREAD)
2134 AC_DEFINE(BEOS_THREADS, 1,
2135 [Define this if you have BeOS threads.])
2136 THREADOBJ="Python/thread.o"],[
2137 AC_CHECK_LIB(pthreads, pthread_create, [AC_DEFINE(WITH_THREAD)
2138 posix_threads=yes
2139 LIBS="$LIBS -lpthreads"
2140 THREADOBJ="Python/thread.o"], [
2141 AC_CHECK_LIB(c_r, pthread_create, [AC_DEFINE(WITH_THREAD)
2142 posix_threads=yes
2143 LIBS="$LIBS -lc_r"
2144 THREADOBJ="Python/thread.o"], [
2145 AC_CHECK_LIB(pthread, __pthread_create_system, [AC_DEFINE(WITH_THREAD)
2146 posix_threads=yes
2147 LIBS="$LIBS -lpthread"
2148 THREADOBJ="Python/thread.o"], [
2149 AC_CHECK_LIB(cma, pthread_create, [AC_DEFINE(WITH_THREAD)
2150 posix_threads=yes
2151 LIBS="$LIBS -lcma"
2152 THREADOBJ="Python/thread.o"],[
2153 USE_THREAD_MODULE="#"])
2154 ])])])])])])])])])])
2156 AC_CHECK_LIB(mpc, usconfig, [AC_DEFINE(WITH_THREAD)
2157 LIBS="$LIBS -lmpc"
2158 THREADOBJ="Python/thread.o"
2159 USE_THREAD_MODULE=""])
2161 if test "$posix_threads" != "yes"; then
2162 AC_CHECK_LIB(thread, thr_create, [AC_DEFINE(WITH_THREAD)
2163 LIBS="$LIBS -lthread"
2164 THREADOBJ="Python/thread.o"
2165 USE_THREAD_MODULE=""])
2166 fi
2168 if test "$USE_THREAD_MODULE" != "#"
2169 then
2170 # If the above checks didn't disable threads, (at least) OSF1
2171 # needs this '-threads' argument during linking.
2172 case $ac_sys_system in
2173 OSF1) LDLAST=-threads;;
2174 esac
2175 fi
2176 fi
2178 if test "$posix_threads" = "yes"; then
2179 if test "$unistd_defines_pthreads" = "no"; then
2180 AC_DEFINE(_POSIX_THREADS, 1,
2181 [Define if you have POSIX threads,
2182 and your system does not define that.])
2183 fi
2185 # Bug 662787: Using semaphores causes unexplicable hangs on Solaris 8.
2186 case $ac_sys_system/$ac_sys_release in
2187 SunOS/5.6) AC_DEFINE(HAVE_PTHREAD_DESTRUCTOR, 1,
2188 Defined for Solaris 2.6 bug in pthread header.)
2189 ;;
2190 SunOS/5.8) AC_DEFINE(HAVE_BROKEN_POSIX_SEMAPHORES, 1,
2191 Define if the Posix semaphores do not work on your system)
2192 ;;
2193 AIX/5) AC_DEFINE(HAVE_BROKEN_POSIX_SEMAPHORES, 1,
2194 Define if the Posix semaphores do not work on your system)
2195 ;;
2196 esac
2198 AC_MSG_CHECKING(if PTHREAD_SCOPE_SYSTEM is supported)
2199 AC_CACHE_VAL(ac_cv_pthread_system_supported,
2200 [AC_TRY_RUN([#include <pthread.h>
2201 void *foo(void *parm) {
2202 return NULL;
2203 }
2204 main() {
2205 pthread_attr_t attr;
2206 pthread_t id;
2207 if (pthread_attr_init(&attr)) exit(-1);
2208 if (pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM)) exit(-1);
2209 if (pthread_create(&id, &attr, foo, NULL)) exit(-1);
2210 exit(0);
2211 }],
2212 ac_cv_pthread_system_supported=yes,
2213 ac_cv_pthread_system_supported=no,
2214 ac_cv_pthread_system_supported=no)
2215 ])
2216 AC_MSG_RESULT($ac_cv_pthread_system_supported)
2217 if test "$ac_cv_pthread_system_supported" = "yes"; then
2218 AC_DEFINE(PTHREAD_SYSTEM_SCHED_SUPPORTED, 1, [Defined if PTHREAD_SCOPE_SYSTEM supported.])
2219 fi
2220 AC_CHECK_FUNCS(pthread_sigmask,
2221 [case $ac_sys_system in
2222 CYGWIN*)
2223 AC_DEFINE(HAVE_BROKEN_PTHREAD_SIGMASK, 1,
2224 [Define if pthread_sigmask() does not work on your system.])
2225 ;;
2226 esac])
2227 fi
2230 # Check for enable-ipv6
2231 AH_TEMPLATE(ENABLE_IPV6, [Define if --enable-ipv6 is specified])
2232 AC_MSG_CHECKING([if --enable-ipv6 is specified])
2233 AC_ARG_ENABLE(ipv6,
2234 [ --enable-ipv6 Enable ipv6 (with ipv4) support
2235 --disable-ipv6 Disable ipv6 support],
2236 [ case "$enableval" in
2237 no)
2238 AC_MSG_RESULT(no)
2239 ipv6=no
2240 ;;
2241 *) AC_MSG_RESULT(yes)
2242 AC_DEFINE(ENABLE_IPV6)
2243 ipv6=yes
2244 ;;
2245 esac ],
2247 [
2248 dnl the check does not work on cross compilation case...
2249 AC_TRY_RUN([ /* AF_INET6 available check */
2250 #include <sys/types.h>
2251 #include <sys/socket.h>
2252 main()
2253 {
2254 if (socket(AF_INET6, SOCK_STREAM, 0) < 0)
2255 exit(1);
2256 else
2257 exit(0);
2258 }
2259 ],
2260 AC_MSG_RESULT(yes)
2261 ipv6=yes,
2262 AC_MSG_RESULT(no)
2263 ipv6=no,
2264 AC_MSG_RESULT(no)
2265 ipv6=no
2266 )
2268 if test "$ipv6" = "yes"; then
2269 AC_MSG_CHECKING(if RFC2553 API is available)
2270 AC_TRY_COMPILE([#include <sys/types.h>
2271 #include <netinet/in.h>],
2272 [struct sockaddr_in6 x;
2273 x.sin6_scope_id;],
2274 AC_MSG_RESULT(yes)
2275 ipv6=yes,
2276 AC_MSG_RESULT(no, IPv6 disabled)
2277 ipv6=no)
2278 fi
2280 if test "$ipv6" = "yes"; then
2281 AC_DEFINE(ENABLE_IPV6)
2282 fi
2283 ])
2285 ipv6type=unknown
2286 ipv6lib=none
2287 ipv6trylibc=no
2289 if test "$ipv6" = "yes"; then
2290 AC_MSG_CHECKING([ipv6 stack type])
2291 for i in inria kame linux-glibc linux-inet6 solaris toshiba v6d zeta;
2292 do
2293 case $i in
2294 inria)
2295 dnl http://www.kame.net/
2296 AC_EGREP_CPP(yes, [
2297 #include <netinet/in.h>
2298 #ifdef IPV6_INRIA_VERSION
2299 yes
2300 #endif],
2301 [ipv6type=$i])
2302 ;;
2303 kame)
2304 dnl http://www.kame.net/
2305 AC_EGREP_CPP(yes, [
2306 #include <netinet/in.h>
2307 #ifdef __KAME__
2308 yes
2309 #endif],
2310 [ipv6type=$i;
2311 ipv6lib=inet6
2312 ipv6libdir=/usr/local/v6/lib
2313 ipv6trylibc=yes])
2314 ;;
2315 linux-glibc)
2316 dnl http://www.v6.linux.or.jp/
2317 AC_EGREP_CPP(yes, [
2318 #include <features.h>
2319 #if defined(__GLIBC__) && ((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 1) || (__GLIBC__ > 2))
2320 yes
2321 #endif],
2322 [ipv6type=$i;
2323 ipv6trylibc=yes])
2324 ;;
2325 linux-inet6)
2326 dnl http://www.v6.linux.or.jp/
2327 if test -d /usr/inet6; then
2328 ipv6type=$i
2329 ipv6lib=inet6
2330 ipv6libdir=/usr/inet6/lib
2331 BASECFLAGS="-I/usr/inet6/include $BASECFLAGS"
2332 fi
2333 ;;
2334 solaris)
2335 if test -f /etc/netconfig; then
2336 if /usr/xpg4/bin/grep -q tcp6 /etc/netconfig; then
2337 ipv6type=$i
2338 ipv6trylibc=yes
2339 fi
2340 fi
2341 ;;
2342 toshiba)
2343 AC_EGREP_CPP(yes, [
2344 #include <sys/param.h>
2345 #ifdef _TOSHIBA_INET6
2346 yes
2347 #endif],
2348 [ipv6type=$i;
2349 ipv6lib=inet6;
2350 ipv6libdir=/usr/local/v6/lib])
2351 ;;
2352 v6d)
2353 AC_EGREP_CPP(yes, [
2354 #include </usr/local/v6/include/sys/v6config.h>
2355 #ifdef __V6D__
2356 yes
2357 #endif],
2358 [ipv6type=$i;
2359 ipv6lib=v6;
2360 ipv6libdir=/usr/local/v6/lib;
2361 BASECFLAGS="-I/usr/local/v6/include $BASECFLAGS"])
2362 ;;
2363 zeta)
2364 AC_EGREP_CPP(yes, [
2365 #include <sys/param.h>
2366 #ifdef _ZETA_MINAMI_INET6
2367 yes
2368 #endif],
2369 [ipv6type=$i;
2370 ipv6lib=inet6;
2371 ipv6libdir=/usr/local/v6/lib])
2372 ;;
2373 esac
2374 if test "$ipv6type" != "unknown"; then
2375 break
2376 fi
2377 done
2378 AC_MSG_RESULT($ipv6type)
2379 fi
2381 if test "$ipv6" = "yes" -a "$ipv6lib" != "none"; then
2382 if test -d $ipv6libdir -a -f $ipv6libdir/lib$ipv6lib.a; then
2383 LIBS="-L$ipv6libdir -l$ipv6lib $LIBS"
2384 echo "using lib$ipv6lib"
2385 else
2386 if test $ipv6trylibc = "yes"; then
2387 echo "using libc"
2388 else
2389 echo 'Fatal: no $ipv6lib library found. cannot continue.'
2390 echo "You need to fetch lib$ipv6lib.a from appropriate"
2391 echo 'ipv6 kit and compile beforehand.'
2392 exit 1
2393 fi
2394 fi
2395 fi
2397 AC_MSG_CHECKING(for OSX 10.5 SDK or later)
2398 AC_TRY_COMPILE([#include <Carbon/Carbon.h>], FSIORefNum fRef = 0,
2399 AC_DEFINE(HAVE_OSX105_SDK, 1, Define if compiling using MacOS X 10.5 SDK or later.)
2400 AC_MSG_RESULT(yes),
2401 AC_MSG_RESULT(no)
2402 )
2404 # Check for --with-doc-strings
2405 AC_MSG_CHECKING(for --with-doc-strings)
2406 AC_ARG_WITH(doc-strings,
2407 AC_HELP_STRING(--with(out)-doc-strings, disable/enable documentation strings))
2409 if test -z "$with_doc_strings"
2410 then with_doc_strings="yes"
2411 fi
2412 if test "$with_doc_strings" != "no"
2413 then
2414 AC_DEFINE(WITH_DOC_STRINGS, 1,
2415 [Define if you want documentation strings in extension modules])
2416 fi
2417 AC_MSG_RESULT($with_doc_strings)
2419 # Check for Python-specific malloc support
2420 AC_MSG_CHECKING(for --with-tsc)
2421 AC_ARG_WITH(tsc,
2422 [ --with(out)-tsc enable/disable timestamp counter profile], [
2423 if test "$withval" != no
2424 then
2425 AC_DEFINE(WITH_TSC, 1,
2426 [Define to profile with the Pentium timestamp counter])
2427 AC_MSG_RESULT(yes)
2428 else AC_MSG_RESULT(no)
2429 fi],
2430 [AC_MSG_RESULT(no)])
2432 # Check for Python-specific malloc support
2433 AC_MSG_CHECKING(for --with-pymalloc)
2434 AC_ARG_WITH(pymalloc,
2435 AC_HELP_STRING(--with(out)-pymalloc, disable/enable specialized mallocs))
2437 if test -z "$with_pymalloc"
2438 then with_pymalloc="yes"
2439 fi
2440 if test "$with_pymalloc" != "no"
2441 then
2442 AC_DEFINE(WITH_PYMALLOC, 1,
2443 [Define if you want to compile in Python-specific mallocs])
2444 fi
2445 AC_MSG_RESULT($with_pymalloc)
2447 # Check for --with-wctype-functions
2448 AC_MSG_CHECKING(for --with-wctype-functions)
2449 AC_ARG_WITH(wctype-functions,
2450 AC_HELP_STRING(--with-wctype-functions, use wctype.h functions),
2451 [
2452 if test "$withval" != no
2453 then
2454 AC_DEFINE(WANT_WCTYPE_FUNCTIONS, 1,
2455 [Define if you want wctype.h functions to be used instead of the
2456 one supplied by Python itself. (see Include/unicodectype.h).])
2457 AC_MSG_RESULT(yes)
2458 else AC_MSG_RESULT(no)
2459 fi],
2460 [AC_MSG_RESULT(no)])
2462 # -I${DLINCLDIR} is added to the compile rule for importdl.o
2463 AC_SUBST(DLINCLDIR)
2464 DLINCLDIR=.
2466 # the dlopen() function means we might want to use dynload_shlib.o. some
2467 # platforms, such as AIX, have dlopen(), but don't want to use it.
2468 AC_CHECK_FUNCS(dlopen)
2470 # DYNLOADFILE specifies which dynload_*.o file we will use for dynamic
2471 # loading of modules.
2472 AC_SUBST(DYNLOADFILE)
2473 AC_MSG_CHECKING(DYNLOADFILE)
2474 if test -z "$DYNLOADFILE"
2475 then
2476 case $ac_sys_system/$ac_sys_release in
2477 AIX*) # Use dynload_shlib.c and dlopen() if we have it; otherwise dynload_aix.c
2478 if test "$ac_cv_func_dlopen" = yes
2479 then DYNLOADFILE="dynload_shlib.o"
2480 else DYNLOADFILE="dynload_aix.o"
2481 fi
2482 ;;
2483 BeOS*) DYNLOADFILE="dynload_beos.o";;
2484 hp*|HP*) DYNLOADFILE="dynload_hpux.o";;
2485 # Use dynload_next.c only on 10.2 and below, which don't have native dlopen()
2486 Darwin/@<:@0156@:>@\..*) DYNLOADFILE="dynload_next.o";;
2487 atheos*) DYNLOADFILE="dynload_atheos.o";;
2488 *)
2489 # use dynload_shlib.c and dlopen() if we have it; otherwise stub
2490 # out any dynamic loading
2491 if test "$ac_cv_func_dlopen" = yes
2492 then DYNLOADFILE="dynload_shlib.o"
2493 else DYNLOADFILE="dynload_stub.o"
2494 fi
2495 ;;
2496 esac
2497 fi
2498 AC_MSG_RESULT($DYNLOADFILE)
2499 if test "$DYNLOADFILE" != "dynload_stub.o"
2500 then
2501 AC_DEFINE(HAVE_DYNAMIC_LOADING, 1,
2502 [Defined when any dynamic module loading is enabled.])
2503 fi
2505 # MACHDEP_OBJS can be set to platform-specific object files needed by Python
2507 AC_SUBST(MACHDEP_OBJS)
2508 AC_MSG_CHECKING(MACHDEP_OBJS)
2509 if test -z "$MACHDEP_OBJS"
2510 then
2511 MACHDEP_OBJS=$extra_machdep_objs
2512 else
2513 MACHDEP_OBJS="$MACHDEP_OBJS $extra_machdep_objs"
2514 fi
2515 AC_MSG_RESULT(MACHDEP_OBJS)
2517 # checks for library functions
2518 AC_CHECK_FUNCS(alarm setitimer getitimer bind_textdomain_codeset chown \
2519 clock confstr ctermid execv fchmod fchown fork fpathconf ftime ftruncate \
2520 gai_strerror getgroups getlogin getloadavg getpeername getpgid getpid \
2521 getpriority getpwent getspnam getspent getsid getwd \
2522 kill killpg lchmod lchown lstat mkfifo mknod mktime \
2523 mremap nice pathconf pause plock poll pthread_init \
2524 putenv readlink realpath \
2525 select sem_open sem_timedwait sem_getvalue sem_unlink setegid seteuid \
2526 setgid \
2527 setlocale setregid setreuid setsid setpgid setpgrp setuid setvbuf snprintf \
2528 sigaction siginterrupt sigrelse strftime \
2529 sysconf tcgetpgrp tcsetpgrp tempnam timegm times tmpfile tmpnam tmpnam_r \
2530 truncate uname unsetenv utimes waitpid wait3 wait4 wcscoll _getpty)
2532 # For some functions, having a definition is not sufficient, since
2533 # we want to take their address.
2534 AC_MSG_CHECKING(for chroot)
2535 AC_TRY_COMPILE([#include <unistd.h>], void *x=chroot,
2536 AC_DEFINE(HAVE_CHROOT, 1, Define if you have the 'chroot' function.)
2537 AC_MSG_RESULT(yes),
2538 AC_MSG_RESULT(no)
2539 )
2540 AC_MSG_CHECKING(for link)
2541 AC_TRY_COMPILE([#include <unistd.h>], void *x=link,
2542 AC_DEFINE(HAVE_LINK, 1, Define if you have the 'link' function.)
2543 AC_MSG_RESULT(yes),
2544 AC_MSG_RESULT(no)
2545 )
2546 AC_MSG_CHECKING(for symlink)
2547 AC_TRY_COMPILE([#include <unistd.h>], void *x=symlink,
2548 AC_DEFINE(HAVE_SYMLINK, 1, Define if you have the 'symlink' function.)
2549 AC_MSG_RESULT(yes),
2550 AC_MSG_RESULT(no)
2551 )
2552 AC_MSG_CHECKING(for fchdir)
2553 AC_TRY_COMPILE([#include <unistd.h>], void *x=fchdir,
2554 AC_DEFINE(HAVE_FCHDIR, 1, Define if you have the 'fchdir' function.)
2555 AC_MSG_RESULT(yes),
2556 AC_MSG_RESULT(no)
2557 )
2558 AC_MSG_CHECKING(for fsync)
2559 AC_TRY_COMPILE([#include <unistd.h>], void *x=fsync,
2560 AC_DEFINE(HAVE_FSYNC, 1, Define if you have the 'fsync' function.)
2561 AC_MSG_RESULT(yes),
2562 AC_MSG_RESULT(no)
2563 )
2564 AC_MSG_CHECKING(for fdatasync)
2565 AC_TRY_COMPILE([#include <unistd.h>], void *x=fdatasync,
2566 AC_DEFINE(HAVE_FDATASYNC, 1, Define if you have the 'fdatasync' function.)
2567 AC_MSG_RESULT(yes),
2568 AC_MSG_RESULT(no)
2569 )
2570 AC_MSG_CHECKING(for epoll)
2571 AC_TRY_COMPILE([#include <sys/epoll.h>], void *x=epoll_create,
2572 AC_DEFINE(HAVE_EPOLL, 1, Define if you have the 'epoll' functions.)
2573 AC_MSG_RESULT(yes),
2574 AC_MSG_RESULT(no)
2575 )
2576 AC_MSG_CHECKING(for kqueue)
2577 AC_TRY_COMPILE([
2578 #include <sys/types.h>
2579 #include <sys/event.h>
2580 ], int x=kqueue(),
2581 AC_DEFINE(HAVE_KQUEUE, 1, Define if you have the 'kqueue' functions.)
2582 AC_MSG_RESULT(yes),
2583 AC_MSG_RESULT(no)
2584 )
2585 # On some systems (eg. FreeBSD 5), we would find a definition of the
2586 # functions ctermid_r, setgroups in the library, but no prototype
2587 # (e.g. because we use _XOPEN_SOURCE). See whether we can take their
2588 # address to avoid compiler warnings and potential miscompilations
2589 # because of the missing prototypes.
2591 AC_MSG_CHECKING(for ctermid_r)
2592 AC_TRY_COMPILE([
2593 #include "confdefs.h"
2594 #include <stdio.h>
2595 ], void* p = ctermid_r,
2596 AC_DEFINE(HAVE_CTERMID_R, 1, Define if you have the 'ctermid_r' function.)
2597 AC_MSG_RESULT(yes),
2598 AC_MSG_RESULT(no)
2599 )
2601 AC_MSG_CHECKING(for flock)
2602 AC_TRY_COMPILE([
2603 #include "confdefs.h"
2604 #include <sys/file.h>
2605 ], void* p = flock,
2606 AC_DEFINE(HAVE_FLOCK, 1, Define if you have the 'flock' function.)
2607 AC_MSG_RESULT(yes),
2608 AC_MSG_RESULT(no)
2609 )
2611 AC_MSG_CHECKING(for getpagesize)
2612 AC_TRY_COMPILE([
2613 #include "confdefs.h"
2614 #include <unistd.h>
2615 ], void* p = getpagesize,
2616 AC_DEFINE(HAVE_GETPAGESIZE, 1, Define if you have the 'getpagesize' function.)
2617 AC_MSG_RESULT(yes),
2618 AC_MSG_RESULT(no)
2619 )
2621 dnl check for true
2622 AC_CHECK_PROGS(TRUE, true, /bin/true)
2624 dnl On some systems (e.g. Solaris 9), hstrerror and inet_aton are in -lresolv
2625 dnl On others, they are in the C library, so we to take no action
2626 AC_CHECK_LIB(c, inet_aton, [$ac_cv_prog_TRUE],
2627 AC_CHECK_LIB(resolv, inet_aton)
2628 )
2630 # On Tru64, chflags seems to be present, but calling it will
2631 # exit Python
2632 AC_MSG_CHECKING(for chflags)
2633 AC_TRY_RUN([
2634 #include <sys/stat.h>
2635 #include <unistd.h>
2636 int main(int argc, char*argv[])
2637 {
2638 if(chflags(argv[0], 0) != 0)
2639 return 1;
2640 return 0;
2641 }
2642 ],AC_DEFINE(HAVE_CHFLAGS, 1, Define to 1 if you have the `chflags' function.)
2643 AC_MSG_RESULT(yes),
2644 AC_MSG_RESULT(no)
2645 )
2647 AC_MSG_CHECKING(for lchflags)
2648 AC_TRY_RUN([
2649 #include <sys/stat.h>
2650 #include <unistd.h>
2651 int main(int argc, char*argv[])
2652 {
2653 if(lchflags(argv[0], 0) != 0)
2654 return 1;
2655 return 0;
2656 }
2657 ],AC_DEFINE(HAVE_LCHFLAGS, 1, Define to 1 if you have the `lchflags' function.)
2658 AC_MSG_RESULT(yes),
2659 AC_MSG_RESULT(no)
2660 )
2662 dnl Check if system zlib has *Copy() functions
2663 dnl
2664 dnl On MacOSX the linker will search for dylibs on the entire linker path
2665 dnl before searching for static libraries. setup.py adds -Wl,-search_paths_first
2666 dnl to revert to a more traditional unix behaviour and make it possible to
2667 dnl override the system libz with a local static library of libz. Temporarily
2668 dnl add that flag to our CFLAGS as well to ensure that we check the version
2669 dnl of libz that will be used by setup.py.
2670 dnl The -L/usr/local/lib is needed as wel to get the same compilation
2671 dnl environment as setup.py (and leaving it out can cause configure to use the
2672 dnl wrong version of the library)
2673 case $ac_sys_system/$ac_sys_release in
2674 Darwin/*)
2675 _CUR_CFLAGS="${CFLAGS}"
2676 _CUR_LDFLAGS="${LDFLAGS}"
2677 CFLAGS="${CFLAGS} -Wl,-search_paths_first"
2678 LDFLAGS="${LDFLAGS} -Wl,-search_paths_first -L/usr/local/lib"
2679 ;;
2680 esac
2682 AC_CHECK_LIB(z, inflateCopy, AC_DEFINE(HAVE_ZLIB_COPY, 1, Define if the zlib library has inflateCopy))
2684 case $ac_sys_system/$ac_sys_release in
2685 Darwin/*)
2686 CFLAGS="${_CUR_CFLAGS}"
2687 LDFLAGS="${_CUR_LDFLAGS}"
2688 ;;
2689 esac
2691 AC_MSG_CHECKING(for hstrerror)
2692 AC_TRY_LINK([
2693 #include "confdefs.h"
2694 #include <netdb.h>
2695 ], void* p = hstrerror; hstrerror(0),
2696 AC_DEFINE(HAVE_HSTRERROR, 1, Define if you have the 'hstrerror' function.)
2697 AC_MSG_RESULT(yes),
2698 AC_MSG_RESULT(no)
2699 )
2701 AC_MSG_CHECKING(for inet_aton)
2702 AC_TRY_LINK([
2703 #include "confdefs.h"
2704 #include <sys/types.h>
2705 #include <sys/socket.h>
2706 #include <netinet/in.h>
2707 #include <arpa/inet.h>
2708 ], void* p = inet_aton;inet_aton(0,0),
2709 AC_DEFINE(HAVE_INET_ATON, 1, Define if you have the 'inet_aton' function.)
2710 AC_MSG_RESULT(yes),
2711 AC_MSG_RESULT(no)
2712 )
2714 AC_MSG_CHECKING(for inet_pton)
2715 AC_TRY_COMPILE([
2716 #include "confdefs.h"
2717 #include <sys/types.h>
2718 #include <sys/socket.h>
2719 #include <netinet/in.h>
2720 #include <arpa/inet.h>
2721 ], void* p = inet_pton,
2722 AC_DEFINE(HAVE_INET_PTON, 1, Define if you have the 'inet_pton' function.)
2723 AC_MSG_RESULT(yes),
2724 AC_MSG_RESULT(no)
2725 )
2727 # On some systems, setgroups is in unistd.h, on others, in grp.h
2728 AC_MSG_CHECKING(for setgroups)
2729 AC_TRY_COMPILE([
2730 #include "confdefs.h"
2731 #include <unistd.h>
2732 #ifdef HAVE_GRP_H
2733 #include <grp.h>
2734 #endif
2735 ],
2736 void* p = setgroups,
2737 AC_DEFINE(HAVE_SETGROUPS, 1, Define if you have the 'setgroups' function.)
2738 AC_MSG_RESULT(yes),
2739 AC_MSG_RESULT(no)
2740 )
2742 # check for openpty and forkpty
2744 AC_CHECK_FUNCS(openpty,,
2745 AC_CHECK_LIB(util,openpty,
2746 [AC_DEFINE(HAVE_OPENPTY) LIBS="$LIBS -lutil"],
2747 AC_CHECK_LIB(bsd,openpty, [AC_DEFINE(HAVE_OPENPTY) LIBS="$LIBS -lbsd"])
2748 )
2749 )
2750 AC_CHECK_FUNCS(forkpty,,
2751 AC_CHECK_LIB(util,forkpty,
2752 [AC_DEFINE(HAVE_FORKPTY) LIBS="$LIBS -lutil"],
2753 AC_CHECK_LIB(bsd,forkpty, [AC_DEFINE(HAVE_FORKPTY) LIBS="$LIBS -lbsd"])
2754 )
2755 )
2757 # Stuff for expat.
2758 AC_CHECK_FUNCS(memmove)
2760 # check for long file support functions
2761 AC_CHECK_FUNCS(fseek64 fseeko fstatvfs ftell64 ftello statvfs)
2763 AC_REPLACE_FUNCS(dup2 getcwd strdup)
2764 AC_CHECK_FUNCS(getpgrp,
2765 AC_TRY_COMPILE([#include <unistd.h>],
2766 [getpgrp(0);],
2767 AC_DEFINE(GETPGRP_HAVE_ARG, 1,
2768 [Define if getpgrp() must be called as getpgrp(0).])
2769 )
2770 )
2771 AC_CHECK_FUNCS(setpgrp,
2772 AC_TRY_COMPILE([#include <unistd.h>],
2773 [setpgrp(0,0);],
2774 AC_DEFINE(SETPGRP_HAVE_ARG, 1,
2775 [Define if setpgrp() must be called as setpgrp(0, 0).])
2776 )
2777 )
2778 AC_CHECK_FUNCS(gettimeofday,
2779 AC_TRY_COMPILE([#include <sys/time.h>],
2780 [gettimeofday((struct timeval*)0,(struct timezone*)0);], ,
2781 AC_DEFINE(GETTIMEOFDAY_NO_TZ, 1,
2782 [Define if gettimeofday() does not have second (timezone) argument
2783 This is the case on Motorola V4 (R40V4.2)])
2784 )
2785 )
2787 AC_MSG_CHECKING(for major, minor, and makedev)
2788 AC_TRY_LINK([
2789 #if defined(MAJOR_IN_MKDEV)
2790 #include <sys/mkdev.h>
2791 #elif defined(MAJOR_IN_SYSMACROS)
2792 #include <sys/sysmacros.h>
2793 #else
2794 #include <sys/types.h>
2795 #endif
2796 ],[
2797 makedev(major(0),minor(0));
2798 ],[
2799 AC_DEFINE(HAVE_DEVICE_MACROS, 1,
2800 [Define to 1 if you have the device macros.])
2801 AC_MSG_RESULT(yes)
2802 ],[
2803 AC_MSG_RESULT(no)
2804 ])
2806 # On OSF/1 V5.1, getaddrinfo is available, but a define
2807 # for [no]getaddrinfo in netdb.h.
2808 AC_MSG_CHECKING(for getaddrinfo)
2809 AC_TRY_LINK([
2810 #include <sys/types.h>
2811 #include <sys/socket.h>
2812 #include <netdb.h>
2813 #include <stdio.h>
2814 ],[
2815 getaddrinfo(NULL, NULL, NULL, NULL);
2816 ], [
2817 AC_MSG_RESULT(yes)
2818 AC_MSG_CHECKING(getaddrinfo bug)
2819 AC_TRY_RUN([
2820 #include <sys/types.h>
2821 #include <netdb.h>
2822 #include <string.h>
2823 #include <sys/socket.h>
2824 #include <netinet/in.h>
2826 main()
2827 {
2828 int passive, gaierr, inet4 = 0, inet6 = 0;
2829 struct addrinfo hints, *ai, *aitop;
2830 char straddr[INET6_ADDRSTRLEN], strport[16];
2832 for (passive = 0; passive <= 1; passive++) {
2833 memset(&hints, 0, sizeof(hints));
2834 hints.ai_family = AF_UNSPEC;
2835 hints.ai_flags = passive ? AI_PASSIVE : 0;
2836 hints.ai_socktype = SOCK_STREAM;
2837 hints.ai_protocol = IPPROTO_TCP;
2838 if ((gaierr = getaddrinfo(NULL, "54321", &hints, &aitop)) != 0) {
2839 (void)gai_strerror(gaierr);
2840 goto bad;
2841 }
2842 for (ai = aitop; ai; ai = ai->ai_next) {
2843 if (ai->ai_addr == NULL ||
2844 ai->ai_addrlen == 0 ||
2845 getnameinfo(ai->ai_addr, ai->ai_addrlen,
2846 straddr, sizeof(straddr), strport, sizeof(strport),
2847 NI_NUMERICHOST|NI_NUMERICSERV) != 0) {
2848 goto bad;
2849 }
2850 switch (ai->ai_family) {
2851 case AF_INET:
2852 if (strcmp(strport, "54321") != 0) {
2853 goto bad;
2854 }
2855 if (passive) {
2856 if (strcmp(straddr, "0.0.0.0") != 0) {
2857 goto bad;
2858 }
2859 } else {
2860 if (strcmp(straddr, "127.0.0.1") != 0) {
2861 goto bad;
2862 }
2863 }
2864 inet4++;
2865 break;
2866 case AF_INET6:
2867 if (strcmp(strport, "54321") != 0) {
2868 goto bad;
2869 }
2870 if (passive) {
2871 if (strcmp(straddr, "::") != 0) {
2872 goto bad;
2873 }
2874 } else {
2875 if (strcmp(straddr, "::1") != 0) {
2876 goto bad;
2877 }
2878 }
2879 inet6++;
2880 break;
2881 case AF_UNSPEC:
2882 goto bad;
2883 break;
2884 default:
2885 /* another family support? */
2886 break;
2887 }
2888 }
2889 }
2891 if (!(inet4 == 0 || inet4 == 2))
2892 goto bad;
2893 if (!(inet6 == 0 || inet6 == 2))
2894 goto bad;
2896 if (aitop)
2897 freeaddrinfo(aitop);
2898 exit(0);
2900 bad:
2901 if (aitop)
2902 freeaddrinfo(aitop);
2903 exit(1);
2904 }
2905 ],
2906 AC_MSG_RESULT(good)
2907 buggygetaddrinfo=no,
2908 AC_MSG_RESULT(buggy)
2909 buggygetaddrinfo=yes,
2910 AC_MSG_RESULT(buggy)
2911 buggygetaddrinfo=yes)], [
2912 AC_MSG_RESULT(no)
2913 buggygetaddrinfo=yes
2914 ])
2916 if test "$buggygetaddrinfo" = "yes"; then
2917 if test "$ipv6" = "yes"; then
2918 echo 'Fatal: You must get working getaddrinfo() function.'
2919 echo ' or you can specify "--disable-ipv6"'.
2920 exit 1
2921 fi
2922 else
2923 AC_DEFINE(HAVE_GETADDRINFO, 1, [Define if you have the getaddrinfo function.])
2924 fi
2925 AC_CHECK_FUNCS(getnameinfo)
2927 # checks for structures
2928 AC_HEADER_TIME
2929 AC_STRUCT_TM
2930 AC_STRUCT_TIMEZONE
2931 AC_CHECK_MEMBERS([struct stat.st_rdev])
2932 AC_CHECK_MEMBERS([struct stat.st_blksize])
2933 AC_CHECK_MEMBERS([struct stat.st_flags])
2934 AC_CHECK_MEMBERS([struct stat.st_gen])
2935 AC_CHECK_MEMBERS([struct stat.st_birthtime])
2936 AC_STRUCT_ST_BLOCKS
2938 AC_MSG_CHECKING(for time.h that defines altzone)
2939 AC_CACHE_VAL(ac_cv_header_time_altzone,
2940 [AC_TRY_COMPILE([#include <time.h>], [return altzone;],
2941 ac_cv_header_time_altzone=yes,
2942 ac_cv_header_time_altzone=no)])
2943 AC_MSG_RESULT($ac_cv_header_time_altzone)
2944 if test $ac_cv_header_time_altzone = yes; then
2945 AC_DEFINE(HAVE_ALTZONE, 1, [Define this if your time.h defines altzone.])
2946 fi
2948 was_it_defined=no
2949 AC_MSG_CHECKING(whether sys/select.h and sys/time.h may both be included)
2950 AC_TRY_COMPILE([
2951 #include <sys/types.h>
2952 #include <sys/select.h>
2953 #include <sys/time.h>
2954 ], [;], [
2955 AC_DEFINE(SYS_SELECT_WITH_SYS_TIME, 1,
2956 [Define if you can safely include both <sys/select.h> and <sys/time.h>
2957 (which you can't on SCO ODT 3.0).])
2958 was_it_defined=yes
2959 ])
2960 AC_MSG_RESULT($was_it_defined)
2962 AC_MSG_CHECKING(for addrinfo)
2963 AC_CACHE_VAL(ac_cv_struct_addrinfo,
2964 AC_TRY_COMPILE([
2965 # include <netdb.h>],
2966 [struct addrinfo a],
2967 ac_cv_struct_addrinfo=yes,
2968 ac_cv_struct_addrinfo=no))
2969 AC_MSG_RESULT($ac_cv_struct_addrinfo)
2970 if test $ac_cv_struct_addrinfo = yes; then
2971 AC_DEFINE(HAVE_ADDRINFO, 1, [struct addrinfo (netdb.h)])
2972 fi
2974 AC_MSG_CHECKING(for sockaddr_storage)
2975 AC_CACHE_VAL(ac_cv_struct_sockaddr_storage,
2976 AC_TRY_COMPILE([
2977 # include <sys/types.h>
2978 # include <sys/socket.h>],
2979 [struct sockaddr_storage s],
2980 ac_cv_struct_sockaddr_storage=yes,
2981 ac_cv_struct_sockaddr_storage=no))
2982 AC_MSG_RESULT($ac_cv_struct_sockaddr_storage)
2983 if test $ac_cv_struct_sockaddr_storage = yes; then
2984 AC_DEFINE(HAVE_SOCKADDR_STORAGE, 1, [struct sockaddr_storage (sys/socket.h)])
2985 fi
2987 # checks for compiler characteristics
2989 AC_C_CHAR_UNSIGNED
2990 AC_C_CONST
2992 works=no
2993 AC_MSG_CHECKING(for working volatile)
2994 AC_TRY_COMPILE([],[volatile int x; x = 0;], works=yes,
2995 AC_DEFINE(volatile, [], [Define to empty if the keyword does not work.])
2996 )
2997 AC_MSG_RESULT($works)
2999 works=no
3000 AC_MSG_CHECKING(for working signed char)
3001 AC_TRY_COMPILE([], [signed char c;], works=yes,
3002 AC_DEFINE(signed, [], [Define to empty if the keyword does not work.])
3003 )
3004 AC_MSG_RESULT($works)
3006 have_prototypes=no
3007 AC_MSG_CHECKING(for prototypes)
3008 AC_TRY_COMPILE([int foo(int x) { return 0; }], [return foo(10);],[
3009 AC_DEFINE(HAVE_PROTOTYPES, 1,
3010 [Define if your compiler supports function prototype])
3011 have_prototypes=yes
3012 ])
3013 AC_MSG_RESULT($have_prototypes)
3015 works=no
3016 AC_MSG_CHECKING(for variable length prototypes and stdarg.h)
3017 AC_TRY_COMPILE([
3018 #include <stdarg.h>
3019 int foo(int x, ...) {
3020 va_list va;
3021 va_start(va, x);
3022 va_arg(va, int);
3023 va_arg(va, char *);
3024 va_arg(va, double);
3025 return 0;
3026 }
3027 ], [return foo(10, "", 3.14);], [
3028 AC_DEFINE(HAVE_STDARG_PROTOTYPES, 1,
3029 [Define if your compiler supports variable length function prototypes
3030 (e.g. void fprintf(FILE *, char *, ...);) *and* <stdarg.h>])
3031 works=yes
3032 ])
3033 AC_MSG_RESULT($works)
3035 # check for socketpair
3036 AC_MSG_CHECKING(for socketpair)
3037 AC_TRY_COMPILE([
3038 #include <sys/types.h>
3039 #include <sys/socket.h>
3040 ], void *x=socketpair,
3041 AC_DEFINE(HAVE_SOCKETPAIR, 1, Define if you have the 'socketpair' function.)
3042 AC_MSG_RESULT(yes),
3043 AC_MSG_RESULT(no)
3044 )
3046 # check if sockaddr has sa_len member
3047 AC_MSG_CHECKING(if sockaddr has sa_len member)
3048 AC_TRY_COMPILE([#include <sys/types.h>
3049 #include <sys/socket.h>],
3050 [struct sockaddr x;
3051 x.sa_len = 0;],
3052 AC_MSG_RESULT(yes)
3053 AC_DEFINE(HAVE_SOCKADDR_SA_LEN, 1, [Define if sockaddr has sa_len member]),
3054 AC_MSG_RESULT(no))
3056 va_list_is_array=no
3057 AC_MSG_CHECKING(whether va_list is an array)
3058 AC_TRY_COMPILE([
3059 #ifdef HAVE_STDARG_PROTOTYPES
3060 #include <stdarg.h>
3061 #else
3062 #include <varargs.h>
3063 #endif
3064 ], [va_list list1, list2; list1 = list2;], , [
3065 AC_DEFINE(VA_LIST_IS_ARRAY, 1, [Define if a va_list is an array of some kind])
3066 va_list_is_array=yes
3067 ])
3068 AC_MSG_RESULT($va_list_is_array)
3070 # sigh -- gethostbyname_r is a mess; it can have 3, 5 or 6 arguments :-(
3071 AH_TEMPLATE(HAVE_GETHOSTBYNAME_R,
3072 [Define this if you have some version of gethostbyname_r()])
3074 AC_CHECK_FUNC(gethostbyname_r, [
3075 AC_DEFINE(HAVE_GETHOSTBYNAME_R)
3076 AC_MSG_CHECKING([gethostbyname_r with 6 args])
3077 OLD_CFLAGS=$CFLAGS
3078 CFLAGS="$CFLAGS $MY_CPPFLAGS $MY_THREAD_CPPFLAGS $MY_CFLAGS"
3079 AC_TRY_COMPILE([
3080 # include <netdb.h>
3081 ], [
3082 char *name;
3083 struct hostent *he, *res;
3084 char buffer[2048];
3085 int buflen = 2048;
3086 int h_errnop;
3088 (void) gethostbyname_r(name, he, buffer, buflen, &res, &h_errnop)
3089 ], [
3090 AC_DEFINE(HAVE_GETHOSTBYNAME_R)
3091 AC_DEFINE(HAVE_GETHOSTBYNAME_R_6_ARG, 1,
3092 [Define this if you have the 6-arg version of gethostbyname_r().])
3093 AC_MSG_RESULT(yes)
3094 ], [
3095 AC_MSG_RESULT(no)
3096 AC_MSG_CHECKING([gethostbyname_r with 5 args])
3097 AC_TRY_COMPILE([
3098 # include <netdb.h>
3099 ], [
3100 char *name;
3101 struct hostent *he;
3102 char buffer[2048];
3103 int buflen = 2048;
3104 int h_errnop;
3106 (void) gethostbyname_r(name, he, buffer, buflen, &h_errnop)
3107 ], [
3108 AC_DEFINE(HAVE_GETHOSTBYNAME_R)
3109 AC_DEFINE(HAVE_GETHOSTBYNAME_R_5_ARG, 1,
3110 [Define this if you have the 5-arg version of gethostbyname_r().])
3111 AC_MSG_RESULT(yes)
3112 ], [
3113 AC_MSG_RESULT(no)
3114 AC_MSG_CHECKING([gethostbyname_r with 3 args])
3115 AC_TRY_COMPILE([
3116 # include <netdb.h>
3117 ], [
3118 char *name;
3119 struct hostent *he;
3120 struct hostent_data data;
3122 (void) gethostbyname_r(name, he, &data);
3123 ], [
3124 AC_DEFINE(HAVE_GETHOSTBYNAME_R)
3125 AC_DEFINE(HAVE_GETHOSTBYNAME_R_3_ARG, 1,
3126 [Define this if you have the 3-arg version of gethostbyname_r().])
3127 AC_MSG_RESULT(yes)
3128 ], [
3129 AC_MSG_RESULT(no)
3130 ])
3131 ])
3132 ])
3133 CFLAGS=$OLD_CFLAGS
3134 ], [
3135 AC_CHECK_FUNCS(gethostbyname)
3136 ])
3137 AC_SUBST(HAVE_GETHOSTBYNAME_R_6_ARG)
3138 AC_SUBST(HAVE_GETHOSTBYNAME_R_5_ARG)
3139 AC_SUBST(HAVE_GETHOSTBYNAME_R_3_ARG)
3140 AC_SUBST(HAVE_GETHOSTBYNAME_R)
3141 AC_SUBST(HAVE_GETHOSTBYNAME)
3143 # checks for system services
3144 # (none yet)
3146 # Linux requires this for correct f.p. operations
3147 AC_CHECK_FUNC(__fpu_control,
3148 [],
3149 [AC_CHECK_LIB(ieee, __fpu_control)
3150 ])
3152 # Check for --with-fpectl
3153 AC_MSG_CHECKING(for --with-fpectl)
3154 AC_ARG_WITH(fpectl,
3155 AC_HELP_STRING(--with-fpectl, enable SIGFPE catching),
3156 [
3157 if test "$withval" != no
3158 then
3159 AC_DEFINE(WANT_SIGFPE_HANDLER, 1,
3160 [Define if you want SIGFPE handled (see Include/pyfpe.h).])
3161 AC_MSG_RESULT(yes)
3162 else AC_MSG_RESULT(no)
3163 fi],
3164 [AC_MSG_RESULT(no)])
3166 # check for --with-libm=...
3167 AC_SUBST(LIBM)
3168 case $ac_sys_system in
3169 Darwin) ;;
3170 BeOS) ;;
3171 *) LIBM=-lm
3172 esac
3173 AC_MSG_CHECKING(for --with-libm=STRING)
3174 AC_ARG_WITH(libm,
3175 AC_HELP_STRING(--with-libm=STRING, math library),
3176 [
3177 if test "$withval" = no
3178 then LIBM=
3179 AC_MSG_RESULT(force LIBM empty)
3180 elif test "$withval" != yes
3181 then LIBM=$withval
3182 AC_MSG_RESULT(set LIBM="$withval")
3183 else AC_MSG_ERROR([proper usage is --with-libm=STRING])
3184 fi],
3185 [AC_MSG_RESULT(default LIBM="$LIBM")])
3187 # check for --with-libc=...
3188 AC_SUBST(LIBC)
3189 AC_MSG_CHECKING(for --with-libc=STRING)
3190 AC_ARG_WITH(libc,
3191 AC_HELP_STRING(--with-libc=STRING, C library),
3192 [
3193 if test "$withval" = no
3194 then LIBC=
3195 AC_MSG_RESULT(force LIBC empty)
3196 elif test "$withval" != yes
3197 then LIBC=$withval
3198 AC_MSG_RESULT(set LIBC="$withval")
3199 else AC_MSG_ERROR([proper usage is --with-libc=STRING])
3200 fi],
3201 [AC_MSG_RESULT(default LIBC="$LIBC")])
3203 # ************************************
3204 # * Check for mathematical functions *
3205 # ************************************
3207 LIBS_SAVE=$LIBS
3208 LIBS="$LIBS $LIBM"
3210 # Detect whether system arithmetic is subject to x87-style double
3211 # rounding issues. The result of this test has little meaning on non
3212 # IEEE 754 platforms. On IEEE 754, test should return 1 if rounding
3213 # mode is round-to-nearest and double rounding issues are present, and
3214 # 0 otherwise. See http://bugs.python.org/issue2937 for more info.
3215 AC_MSG_CHECKING(for x87-style double rounding)
3216 AC_CACHE_VAL(ac_cv_x87_double_rounding, [
3217 AC_TRY_RUN([
3218 #include <stdlib.h>
3219 #include <math.h>
3220 int main() {
3221 volatile double x, y, z;
3222 /* 1./(1-2**-53) -> 1+2**-52 (correct), 1.0 (double rounding) */
3223 x = 0.99999999999999989; /* 1-2**-53 */
3224 y = 1./x;
3225 if (y != 1.)
3226 exit(0);
3227 /* 1e16+2.99999 -> 1e16+2. (correct), 1e16+4. (double rounding) */
3228 x = 1e16;
3229 y = 2.99999;
3230 z = x + y;
3231 if (z != 1e16+4.)
3232 exit(0);
3233 /* both tests show evidence of double rounding */
3234 exit(1);
3235 }
3236 ],
3237 ac_cv_x87_double_rounding=no,
3238 ac_cv_x87_double_rounding=yes,
3239 ac_cv_x87_double_rounding=no)])
3240 AC_MSG_RESULT($ac_cv_x87_double_rounding)
3241 if test "$ac_cv_x87_double_rounding" = yes
3242 then
3243 AC_DEFINE(X87_DOUBLE_ROUNDING, 1,
3244 [Define if arithmetic is subject to x87-style double rounding issue])
3245 fi
3247 # Multiprocessing check for broken sem_getvalue
3248 AC_MSG_CHECKING(for broken sem_getvalue)
3249 AC_TRY_RUN([
3250 #include <unistd.h>
3251 #include <fcntl.h>
3252 #include <stdio.h>
3253 #include <semaphore.h>
3254 #include <sys/stat.h>
3256 int main(void){
3257 sem_t *a = sem_open("/autoconf", O_CREAT, S_IRUSR|S_IWUSR, 0);
3258 int count;
3259 int res;
3260 if(a==SEM_FAILED){
3261 perror("sem_open");
3262 return 1;
3264 }
3265 res = sem_getvalue(a, &count);
3266 sem_close(a);
3267 return res==-1 ? 1 : 0;
3268 }
3269 ]
3270 ,AC_MSG_RESULT(no),
3271 AC_MSG_RESULT(yes)
3272 AC_DEFINE(HAVE_BROKEN_SEM_GETVALUE, 1, define to 1 if your sem_getvalue is broken.)
3273 )
3275 # On FreeBSD 6.2, it appears that tanh(-0.) returns 0. instead of
3276 # -0. on some architectures.
3277 AC_MSG_CHECKING(whether tanh preserves the sign of zero)
3278 AC_CACHE_VAL(ac_cv_tanh_preserves_zero_sign, [
3279 AC_TRY_RUN([
3280 #include <math.h>
3281 #include <stdlib.h>
3282 int main() {
3283 /* return 0 if either negative zeros don't exist
3284 on this platform or if negative zeros exist
3285 and tanh(-0.) == -0. */
3286 if (atan2(0., -1.) == atan2(-0., -1.) ||
3287 atan2(tanh(-0.), -1.) == atan2(-0., -1.)) exit(0);
3288 else exit(1);
3289 }
3290 ],
3291 ac_cv_tanh_preserves_zero_sign=yes,
3292 ac_cv_tanh_preserves_zero_sign=no,
3293 ac_cv_tanh_preserves_zero_sign=no)])
3294 AC_MSG_RESULT($ac_cv_tanh_preserves_zero_sign)
3295 if test "$ac_cv_tanh_preserves_zero_sign" = yes
3296 then
3297 AC_DEFINE(TANH_PRESERVES_ZERO_SIGN, 1,
3298 [Define if tanh(-0.) is -0., or if platform doesn't have signed zeros])
3299 fi
3301 AC_CHECK_FUNCS([acosh asinh atanh copysign expm1 finite hypot log1p round])
3302 AC_CHECK_DECLS([isinf, isnan, isfinite], [], [], [[#include <math.h>]])
3304 LIBS=$LIBS_SAVE
3306 # determine what size digit to use for Python's longs
3307 AC_MSG_CHECKING([digit size for Python's longs])
3308 AC_ARG_ENABLE(big-digits,
3309 AC_HELP_STRING([--enable-big-digits@<:@=BITS@:>@],[use big digits for Python longs [[BITS=30]]]),
3310 [case $enable_big_digits in
3311 yes)
3312 enable_big_digits=30 ;;
3313 no)
3314 enable_big_digits=15 ;;
3315 [15|30])
3316 ;;
3317 *)
3318 AC_MSG_ERROR([bad value $enable_big_digits for --enable-big-digits; value should be 15 or 30]) ;;
3319 esac
3320 AC_MSG_RESULT($enable_big_digits)
3321 AC_DEFINE_UNQUOTED(PYLONG_BITS_IN_DIGIT, $enable_big_digits, [Define as the preferred size in bits of long digits])
3322 ],
3323 [AC_MSG_RESULT(no value specified)])
3325 # check for wchar.h
3326 AC_CHECK_HEADER(wchar.h, [
3327 AC_DEFINE(HAVE_WCHAR_H, 1,
3328 [Define if the compiler provides a wchar.h header file.])
3329 wchar_h="yes"
3330 ],
3331 wchar_h="no"
3332 )
3334 # determine wchar_t size
3335 if test "$wchar_h" = yes
3336 then
3337 AC_CHECK_SIZEOF(wchar_t, 4, [#include <wchar.h>])
3338 fi
3340 AC_MSG_CHECKING(for UCS-4 tcl)
3341 have_ucs4_tcl=no
3342 AC_TRY_COMPILE([
3343 #include <tcl.h>
3344 #if TCL_UTF_MAX != 6
3345 # error "NOT UCS4_TCL"
3346 #endif], [], [
3347 AC_DEFINE(HAVE_UCS4_TCL, 1, [Define this if you have tcl and TCL_UTF_MAX==6])
3348 have_ucs4_tcl=yes
3349 ])
3350 AC_MSG_RESULT($have_ucs4_tcl)
3352 # check whether wchar_t is signed or not
3353 if test "$wchar_h" = yes
3354 then
3355 # check whether wchar_t is signed or not
3356 AC_MSG_CHECKING(whether wchar_t is signed)
3357 AC_CACHE_VAL(ac_cv_wchar_t_signed, [
3358 AC_TRY_RUN([
3359 #include <wchar.h>
3360 int main()
3361 {
3362 /* Success: exit code 0 */
3363 exit((((wchar_t) -1) < ((wchar_t) 0)) ? 0 : 1);
3364 }
3365 ],
3366 ac_cv_wchar_t_signed=yes,
3367 ac_cv_wchar_t_signed=no,
3368 ac_cv_wchar_t_signed=yes)])
3369 AC_MSG_RESULT($ac_cv_wchar_t_signed)
3370 fi
3372 AC_MSG_CHECKING(what type to use for unicode)
3373 dnl quadrigraphs "@<:@" and "@:>@" produce "[" and "]" in the output
3374 AC_ARG_ENABLE(unicode,
3375 AC_HELP_STRING(--enable-unicode@<:@=ucs@<:@24@:>@@:>@, Enable Unicode strings (default is yes)),
3376 [],
3377 [enable_unicode=yes])
3379 if test $enable_unicode = yes
3380 then
3381 # Without any arguments, Py_UNICODE defaults to two-byte mode
3382 case "$have_ucs4_tcl" in
3383 yes) enable_unicode="ucs4"
3384 ;;
3385 *) enable_unicode="ucs2"
3386 ;;
3387 esac
3388 fi
3390 AH_TEMPLATE(Py_UNICODE_SIZE,
3391 [Define as the size of the unicode type.])
3392 case "$enable_unicode" in
3393 ucs2) unicode_size="2"
3394 AC_DEFINE(Py_UNICODE_SIZE,2)
3395 ;;
3396 ucs4) unicode_size="4"
3397 AC_DEFINE(Py_UNICODE_SIZE,4)
3398 ;;
3399 esac
3401 AH_TEMPLATE(PY_UNICODE_TYPE,
3402 [Define as the integral type used for Unicode representation.])
3404 AC_SUBST(UNICODE_OBJS)
3405 if test "$enable_unicode" = "no"
3406 then
3407 UNICODE_OBJS=""
3408 AC_MSG_RESULT(not used)
3409 else
3410 UNICODE_OBJS="Objects/unicodeobject.o Objects/unicodectype.o"
3411 AC_DEFINE(Py_USING_UNICODE, 1,
3412 [Define if you want to have a Unicode type.])
3414 # wchar_t is only usable if it maps to an unsigned type
3415 if test "$unicode_size" = "$ac_cv_sizeof_wchar_t" \
3416 -a "$ac_cv_wchar_t_signed" = "no"
3417 then
3418 PY_UNICODE_TYPE="wchar_t"
3419 AC_DEFINE(HAVE_USABLE_WCHAR_T, 1,
3420 [Define if you have a useable wchar_t type defined in wchar.h; useable
3421 means wchar_t must be an unsigned type with at least 16 bits. (see
3422 Include/unicodeobject.h).])
3423 AC_DEFINE(PY_UNICODE_TYPE,wchar_t)
3424 elif test "$ac_cv_sizeof_short" = "$unicode_size"
3425 then
3426 PY_UNICODE_TYPE="unsigned short"
3427 AC_DEFINE(PY_UNICODE_TYPE,unsigned short)
3428 elif test "$ac_cv_sizeof_long" = "$unicode_size"
3429 then
3430 PY_UNICODE_TYPE="unsigned long"
3431 AC_DEFINE(PY_UNICODE_TYPE,unsigned long)
3432 else
3433 PY_UNICODE_TYPE="no type found"
3434 fi
3435 AC_MSG_RESULT($PY_UNICODE_TYPE)
3436 fi
3438 # check for endianness
3439 AC_C_BIGENDIAN
3441 # Check whether right shifting a negative integer extends the sign bit
3442 # or fills with zeros (like the Cray J90, according to Tim Peters).
3443 AC_MSG_CHECKING(whether right shift extends the sign bit)
3444 AC_CACHE_VAL(ac_cv_rshift_extends_sign, [
3445 AC_TRY_RUN([
3446 int main()
3447 {
3448 exit(((-1)>>3 == -1) ? 0 : 1);
3449 }
3450 ],
3451 ac_cv_rshift_extends_sign=yes,
3452 ac_cv_rshift_extends_sign=no,
3453 ac_cv_rshift_extends_sign=yes)])
3454 AC_MSG_RESULT($ac_cv_rshift_extends_sign)
3455 if test "$ac_cv_rshift_extends_sign" = no
3456 then
3457 AC_DEFINE(SIGNED_RIGHT_SHIFT_ZERO_FILLS, 1,
3458 [Define if i>>j for signed int i does not extend the sign bit
3459 when i < 0])
3460 fi
3462 # check for getc_unlocked and related locking functions
3463 AC_MSG_CHECKING(for getc_unlocked() and friends)
3464 AC_CACHE_VAL(ac_cv_have_getc_unlocked, [
3465 AC_TRY_LINK([#include <stdio.h>],[
3466 FILE *f = fopen("/dev/null", "r");
3467 flockfile(f);
3468 getc_unlocked(f);
3469 funlockfile(f);
3470 ], ac_cv_have_getc_unlocked=yes, ac_cv_have_getc_unlocked=no)])
3471 AC_MSG_RESULT($ac_cv_have_getc_unlocked)
3472 if test "$ac_cv_have_getc_unlocked" = yes
3473 then
3474 AC_DEFINE(HAVE_GETC_UNLOCKED, 1,
3475 [Define this if you have flockfile(), getc_unlocked(), and funlockfile()])
3476 fi
3478 # check where readline lives
3479 # save the value of LIBS so we don't actually link Python with readline
3480 LIBS_no_readline=$LIBS
3482 # On some systems we need to link readline to a termcap compatible
3483 # library. NOTE: Keep the precedence of listed libraries synchronised
3484 # with setup.py.
3485 py_cv_lib_readline=no
3486 AC_MSG_CHECKING([how to link readline libs])
3487 for py_libtermcap in "" ncursesw ncurses curses termcap; do
3488 if test -z "$py_libtermcap"; then
3489 READLINE_LIBS="-lreadline"
3490 else
3491 READLINE_LIBS="-lreadline -l$py_libtermcap"
3492 fi
3493 LIBS="$READLINE_LIBS $LIBS_no_readline"
3494 AC_LINK_IFELSE(
3495 [AC_LANG_CALL([],[readline])],
3496 [py_cv_lib_readline=yes])
3497 if test $py_cv_lib_readline = yes; then
3498 break
3499 fi
3500 done
3501 # Uncomment this line if you want to use READINE_LIBS in Makefile or scripts
3502 #AC_SUBST([READLINE_LIBS])
3503 if test $py_cv_lib_readline = no; then
3504 AC_MSG_RESULT([none])
3505 else
3506 AC_MSG_RESULT([$READLINE_LIBS])
3507 AC_DEFINE(HAVE_LIBREADLINE, 1,
3508 [Define if you have the readline library (-lreadline).])
3509 fi
3511 # check for readline 2.1
3512 AC_CHECK_LIB(readline, rl_callback_handler_install,
3513 AC_DEFINE(HAVE_RL_CALLBACK, 1,
3514 [Define if you have readline 2.1]), ,$READLINE_LIBS)
3516 # check for readline 2.2
3517 AC_TRY_CPP([#include <readline/readline.h>],
3518 have_readline=yes, have_readline=no)
3519 if test $have_readline = yes
3520 then
3521 AC_EGREP_HEADER([extern int rl_completion_append_character;],
3522 [readline/readline.h],
3523 AC_DEFINE(HAVE_RL_COMPLETION_APPEND_CHARACTER, 1,
3524 [Define if you have readline 2.2]), )
3525 fi
3527 # check for readline 4.0
3528 AC_CHECK_LIB(readline, rl_pre_input_hook,
3529 AC_DEFINE(HAVE_RL_PRE_INPUT_HOOK, 1,
3530 [Define if you have readline 4.0]), ,$READLINE_LIBS)
3532 # also in 4.0
3533 AC_CHECK_LIB(readline, rl_completion_display_matches_hook,
3534 AC_DEFINE(HAVE_RL_COMPLETION_DISPLAY_MATCHES_HOOK, 1,
3535 [Define if you have readline 4.0]), ,$READLINE_LIBS)
3537 # check for readline 4.2
3538 AC_CHECK_LIB(readline, rl_completion_matches,
3539 AC_DEFINE(HAVE_RL_COMPLETION_MATCHES, 1,
3540 [Define if you have readline 4.2]), ,$READLINE_LIBS)
3542 # also in readline 4.2
3543 AC_TRY_CPP([#include <readline/readline.h>],
3544 have_readline=yes, have_readline=no)
3545 if test $have_readline = yes
3546 then
3547 AC_EGREP_HEADER([extern int rl_catch_signals;],
3548 [readline/readline.h],
3549 AC_DEFINE(HAVE_RL_CATCH_SIGNAL, 1,
3550 [Define if you can turn off readline's signal handling.]), )
3551 fi
3553 # End of readline checks: restore LIBS
3554 LIBS=$LIBS_no_readline
3556 AC_MSG_CHECKING(for broken nice())
3557 AC_CACHE_VAL(ac_cv_broken_nice, [
3558 AC_TRY_RUN([
3559 int main()
3560 {
3561 int val1 = nice(1);
3562 if (val1 != -1 && val1 == nice(2))
3563 exit(0);
3564 exit(1);
3565 }
3566 ],
3567 ac_cv_broken_nice=yes,
3568 ac_cv_broken_nice=no,
3569 ac_cv_broken_nice=no)])
3570 AC_MSG_RESULT($ac_cv_broken_nice)
3571 if test "$ac_cv_broken_nice" = yes
3572 then
3573 AC_DEFINE(HAVE_BROKEN_NICE, 1,
3574 [Define if nice() returns success/failure instead of the new priority.])
3575 fi
3577 AC_MSG_CHECKING(for broken poll())
3578 AC_TRY_RUN([
3579 #include <poll.h>
3581 int main (void)
3582 {
3583 struct pollfd poll_struct = { 42, POLLIN|POLLPRI|POLLOUT, 0 };
3585 close (42);
3587 int poll_test = poll (&poll_struct, 1, 0);
3589 if (poll_test < 0)
3590 {
3591 exit(0);
3592 }
3593 else if (poll_test == 0 && poll_struct.revents != POLLNVAL)
3594 {
3595 exit(0);
3596 }
3597 else
3598 {
3599 exit(1);
3600 }
3601 }
3602 ],
3603 ac_cv_broken_poll=yes,
3604 ac_cv_broken_poll=no,
3605 ac_cv_broken_poll=no)
3606 AC_MSG_RESULT($ac_cv_broken_poll)
3607 if test "$ac_cv_broken_poll" = yes
3608 then
3609 AC_DEFINE(HAVE_BROKEN_POLL, 1,
3610 [Define if poll() sets errno on invalid file descriptors.])
3611 fi
3613 # Before we can test tzset, we need to check if struct tm has a tm_zone
3614 # (which is not required by ISO C or UNIX spec) and/or if we support
3615 # tzname[]
3616 AC_STRUCT_TIMEZONE
3618 # check tzset(3) exists and works like we expect it to
3619 AC_MSG_CHECKING(for working tzset())
3620 AC_CACHE_VAL(ac_cv_working_tzset, [
3621 AC_TRY_RUN([
3622 #include <stdlib.h>
3623 #include <time.h>
3624 #include <string.h>
3626 #if HAVE_TZNAME
3627 extern char *tzname[];
3628 #endif
3630 int main()
3631 {
3632 /* Note that we need to ensure that not only does tzset(3)
3633 do 'something' with localtime, but it works as documented
3634 in the library reference and as expected by the test suite.
3635 This includes making sure that tzname is set properly if
3636 tm->tm_zone does not exist since it is the alternative way
3637 of getting timezone info.
3639 Red Hat 6.2 doesn't understand the southern hemisphere
3640 after New Year's Day.
3641 */
3643 time_t groundhogday = 1044144000; /* GMT-based */
3644 time_t midyear = groundhogday + (365 * 24 * 3600 / 2);
3646 putenv("TZ=UTC+0");
3647 tzset();
3648 if (localtime(&groundhogday)->tm_hour != 0)
3649 exit(1);
3650 #if HAVE_TZNAME
3651 /* For UTC, tzname[1] is sometimes "", sometimes " " */
3652 if (strcmp(tzname[0], "UTC") ||
3653 (tzname[1][0] != 0 && tzname[1][0] != ' '))
3654 exit(1);
3655 #endif
3657 putenv("TZ=EST+5EDT,M4.1.0,M10.5.0");
3658 tzset();
3659 if (localtime(&groundhogday)->tm_hour != 19)
3660 exit(1);
3661 #if HAVE_TZNAME
3662 if (strcmp(tzname[0], "EST") || strcmp(tzname[1], "EDT"))
3663 exit(1);
3664 #endif
3666 putenv("TZ=AEST-10AEDT-11,M10.5.0,M3.5.0");
3667 tzset();
3668 if (localtime(&groundhogday)->tm_hour != 11)
3669 exit(1);
3670 #if HAVE_TZNAME
3671 if (strcmp(tzname[0], "AEST") || strcmp(tzname[1], "AEDT"))
3672 exit(1);
3673 #endif
3675 #if HAVE_STRUCT_TM_TM_ZONE
3676 if (strcmp(localtime(&groundhogday)->tm_zone, "AEDT"))
3677 exit(1);
3678 if (strcmp(localtime(&midyear)->tm_zone, "AEST"))
3679 exit(1);
3680 #endif
3682 exit(0);
3683 }
3684 ],
3685 ac_cv_working_tzset=yes,
3686 ac_cv_working_tzset=no,
3687 ac_cv_working_tzset=no)])
3688 AC_MSG_RESULT($ac_cv_working_tzset)
3689 if test "$ac_cv_working_tzset" = yes
3690 then
3691 AC_DEFINE(HAVE_WORKING_TZSET, 1,
3692 [Define if tzset() actually switches the local timezone in a meaningful way.])
3693 fi
3695 # Look for subsecond timestamps in struct stat
3696 AC_MSG_CHECKING(for tv_nsec in struct stat)
3697 AC_CACHE_VAL(ac_cv_stat_tv_nsec,
3698 AC_TRY_COMPILE([#include <sys/stat.h>], [
3699 struct stat st;
3700 st.st_mtim.tv_nsec = 1;
3701 ],
3702 ac_cv_stat_tv_nsec=yes,
3703 ac_cv_stat_tv_nsec=no,
3704 ac_cv_stat_tv_nsec=no))
3705 AC_MSG_RESULT($ac_cv_stat_tv_nsec)
3706 if test "$ac_cv_stat_tv_nsec" = yes
3707 then
3708 AC_DEFINE(HAVE_STAT_TV_NSEC, 1,
3709 [Define if you have struct stat.st_mtim.tv_nsec])
3710 fi
3712 # Look for BSD style subsecond timestamps in struct stat
3713 AC_MSG_CHECKING(for tv_nsec2 in struct stat)
3714 AC_CACHE_VAL(ac_cv_stat_tv_nsec2,
3715 AC_TRY_COMPILE([#include <sys/stat.h>], [
3716 struct stat st;
3717 st.st_mtimespec.tv_nsec = 1;
3718 ],
3719 ac_cv_stat_tv_nsec2=yes,
3720 ac_cv_stat_tv_nsec2=no,
3721 ac_cv_stat_tv_nsec2=no))
3722 AC_MSG_RESULT($ac_cv_stat_tv_nsec2)
3723 if test "$ac_cv_stat_tv_nsec2" = yes
3724 then
3725 AC_DEFINE(HAVE_STAT_TV_NSEC2, 1,
3726 [Define if you have struct stat.st_mtimensec])
3727 fi
3729 # On HP/UX 11.0, mvwdelch is a block with a return statement
3730 AC_MSG_CHECKING(whether mvwdelch is an expression)
3731 AC_CACHE_VAL(ac_cv_mvwdelch_is_expression,
3732 AC_TRY_COMPILE([#include <curses.h>], [
3733 int rtn;
3734 rtn = mvwdelch(0,0,0);
3735 ], ac_cv_mvwdelch_is_expression=yes,
3736 ac_cv_mvwdelch_is_expression=no,
3737 ac_cv_mvwdelch_is_expression=yes))
3738 AC_MSG_RESULT($ac_cv_mvwdelch_is_expression)
3740 if test "$ac_cv_mvwdelch_is_expression" = yes
3741 then
3742 AC_DEFINE(MVWDELCH_IS_EXPRESSION, 1,
3743 [Define if mvwdelch in curses.h is an expression.])
3744 fi
3746 AC_MSG_CHECKING(whether WINDOW has _flags)
3747 AC_CACHE_VAL(ac_cv_window_has_flags,
3748 AC_TRY_COMPILE([#include <curses.h>], [
3749 WINDOW *w;
3750 w->_flags = 0;
3751 ], ac_cv_window_has_flags=yes,
3752 ac_cv_window_has_flags=no,
3753 ac_cv_window_has_flags=no))
3754 AC_MSG_RESULT($ac_cv_window_has_flags)
3757 if test "$ac_cv_window_has_flags" = yes
3758 then
3759 AC_DEFINE(WINDOW_HAS_FLAGS, 1,
3760 [Define if WINDOW in curses.h offers a field _flags.])
3761 fi
3763 AC_MSG_CHECKING(for is_term_resized)
3764 AC_TRY_COMPILE([#include <curses.h>], void *x=is_term_resized,
3765 AC_DEFINE(HAVE_CURSES_IS_TERM_RESIZED, 1, Define if you have the 'is_term_resized' function.)
3766 AC_MSG_RESULT(yes),
3767 AC_MSG_RESULT(no)
3768 )
3770 AC_MSG_CHECKING(for resize_term)
3771 AC_TRY_COMPILE([#include <curses.h>], void *x=resize_term,
3772 AC_DEFINE(HAVE_CURSES_RESIZE_TERM, 1, Define if you have the 'resize_term' function.)
3773 AC_MSG_RESULT(yes),
3774 AC_MSG_RESULT(no)
3775 )
3777 AC_MSG_CHECKING(for resizeterm)
3778 AC_TRY_COMPILE([#include <curses.h>], void *x=resizeterm,
3779 AC_DEFINE(HAVE_CURSES_RESIZETERM, 1, Define if you have the 'resizeterm' function.)
3780 AC_MSG_RESULT(yes),
3781 AC_MSG_RESULT(no)
3782 )
3784 AC_MSG_CHECKING(for /dev/ptmx)
3786 if test -r /dev/ptmx
3787 then
3788 AC_MSG_RESULT(yes)
3789 AC_DEFINE(HAVE_DEV_PTMX, 1,
3790 [Define if we have /dev/ptmx.])
3791 else
3792 AC_MSG_RESULT(no)
3793 fi
3795 AC_MSG_CHECKING(for /dev/ptc)
3797 if test -r /dev/ptc
3798 then
3799 AC_MSG_RESULT(yes)
3800 AC_DEFINE(HAVE_DEV_PTC, 1,
3801 [Define if we have /dev/ptc.])
3802 else
3803 AC_MSG_RESULT(no)
3804 fi
3806 AC_MSG_CHECKING(for %zd printf() format support)
3807 AC_TRY_RUN([#include <stdio.h>
3808 #include <stddef.h>
3809 #include <string.h>
3811 #ifdef HAVE_SYS_TYPES_H
3812 #include <sys/types.h>
3813 #endif
3815 #ifdef HAVE_SSIZE_T
3816 typedef ssize_t Py_ssize_t;
3817 #elif SIZEOF_VOID_P == SIZEOF_LONG
3818 typedef long Py_ssize_t;
3819 #else
3820 typedef int Py_ssize_t;
3821 #endif
3823 int main()
3824 {
3825 char buffer[256];
3827 if(sprintf(buffer, "%zd", (size_t)123) < 0)
3828 return 1;
3830 if (strcmp(buffer, "123"))
3831 return 1;
3833 if (sprintf(buffer, "%zd", (Py_ssize_t)-123) < 0)
3834 return 1;
3836 if (strcmp(buffer, "-123"))
3837 return 1;
3839 return 0;
3840 }],
3841 [AC_MSG_RESULT(yes)
3842 AC_DEFINE(PY_FORMAT_SIZE_T, "z", [Define to printf format modifier for Py_ssize_t])],
3843 AC_MSG_RESULT(no))
3845 AC_CHECK_TYPE(socklen_t,,
3846 AC_DEFINE(socklen_t,int,
3847 Define to `int' if <sys/socket.h> does not define.),[
3848 #ifdef HAVE_SYS_TYPES_H
3849 #include <sys/types.h>
3850 #endif
3851 #ifdef HAVE_SYS_SOCKET_H
3852 #include <sys/socket.h>
3853 #endif
3854 ])
3856 AC_SUBST(THREADHEADERS)
3858 for h in `(cd $srcdir;echo Python/thread_*.h)`
3859 do
3860 THREADHEADERS="$THREADHEADERS \$(srcdir)/$h"
3861 done
3863 AC_SUBST(SRCDIRS)
3864 SRCDIRS="Parser Grammar Objects Python Modules Mac"
3865 AC_MSG_CHECKING(for build directories)
3866 for dir in $SRCDIRS; do
3867 if test ! -d $dir; then
3868 mkdir $dir
3869 fi
3870 done
3871 AC_MSG_RESULT(done)
3873 # generate output files
3874 AC_CONFIG_FILES(Makefile.pre Modules/Setup.config Misc/python.pc)
3875 AC_OUTPUT
3877 echo "creating Modules/Setup"
3878 if test ! -f Modules/Setup
3879 then
3880 cp $srcdir/Modules/Setup.dist Modules/Setup
3881 fi
3883 echo "creating Modules/Setup.local"
3884 if test ! -f Modules/Setup.local
3885 then
3886 echo "# Edit this file for local setup changes" >Modules/Setup.local
3887 fi
3889 echo "creating Makefile"
3890 $SHELL $srcdir/Modules/makesetup -c $srcdir/Modules/config.c.in \
3891 -s Modules Modules/Setup.config \
3892 Modules/Setup.local Modules/Setup
3894 case $ac_sys_system in
3895 BeOS)
3896 AC_MSG_WARN([
3898 Support for BeOS is deprecated as of Python 2.6.
3899 See PEP 11 for the gory details.
3900 ])
3901 ;;
3902 *) ;;
3903 esac
3905 mv config.c Modules