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