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