configure.in

   1 dnl Process this file with autoconf 2.0 or later to make a configure script.
   2 AC_REVISION($Revision$)
   3 AC_PREREQ(2.0)
   4 AC_INIT(Include/object.h)
   5 AC_CONFIG_HEADER(pyconfig.h)
   6
   7 # Set VERSION so we only need to edit in one place (i.e., here)
   8 AC_SUBST(VERSION)
   9 VERSION=2.2
  10
  11 # Arguments passed to configure.
  12 AC_SUBST(CONFIG_ARGS)
  13 CONFIG_ARGS="$ac_configure_args"
  14
  15
  16 AC_ARG_ENABLE(framework,
  17 [  --enable-framework[=INSTALLDIR] Build (MacOSX|Darwin) framework],[
  18         PYTHONFRAMEWORK=Python
  19         PYTHONFRAMEWORKDIR=Python.framework
  20         case $enableval in
  21         yes)
  22                 enableval=/Library/Frameworks
  23                 PYTHONFRAMEWORKPREFIX=$enableval
  24                 ;;
  25         *)
  26                 PYTHONFRAMEWORKPREFIX=$enableval
  27         esac
  28         PYTHONFRAMEWORKINSTALLDIR=$PYTHONFRAMEWORKPREFIX/$PYTHONFRAMEWORKDIR
  29         prefix=$PYTHONFRAMEWORKINSTALLDIR/Versions/$VERSION
  30         ],[
  31         PYTHONFRAMEWORK=
  32         PYTHONFRAMEWORKDIR=
  33         PYTHONFRAMEWORKPREFIX=
  34         PYTHONFRAMEWORKINSTALLDIR=
  35         enable_framework=
  36 ])
  37 AC_SUBST(PYTHONFRAMEWORK)
  38 AC_SUBST(PYTHONFRAMEWORKDIR)
  39 AC_SUBST(PYTHONFRAMEWORKPREFIX)
  40 AC_SUBST(PYTHONFRAMEWORKINSTALLDIR)
  41
  42 ##AC_ARG_WITH(dyld,
  43 ##[  --with-dyld                     Use (OpenStep|Rhapsody) dynamic linker],,)
  44 ##
  45 # Set name for machine-dependent library files
  46 AC_SUBST(MACHDEP)
  47 AC_MSG_CHECKING(MACHDEP)
  48 if test -z "$MACHDEP"
  49 then
  50         ac_sys_system=`uname -s`
  51         if test "$ac_sys_system" = "AIX" -o "$ac_sys_system" = "Monterey64"; then
  52                 ac_sys_release=`uname -v`
  53         else
  54                 ac_sys_release=`uname -r`
  55         fi
  56         ac_md_system=`echo $ac_sys_system |
  57                            tr -d '[/ ]' | tr '[[A-Z]]' '[[a-z]]'`
  58         ac_md_release=`echo $ac_sys_release |
  59                            tr -d '[/ ]' | sed 's/\..*//'`
  60         MACHDEP="$ac_md_system$ac_md_release"
  61
  62         case $MACHDEP in
  63         cygwin*) MACHDEP="cygwin";;
  64         '')     MACHDEP="unknown";;
  65         esac
  66 fi
  67
  68 #
  69 # SGI compilers allow the specification of the both the ABI and the
  70 # ISA on the command line.  Depending on the values of these switches,
  71 # different and often incompatable code will be generated.
  72 #
  73 # The SGI_ABI variable can be used to modify the CC and LDFLAGS and
  74 # thus supply support for various ABI/ISA combinations.  The MACHDEP
  75 # variable is also adjusted.
  76 #
  77 AC_SUBST(SGI_ABI)
  78 if test ! -z "$SGI_ABI"
  79 then
  80         CC="cc $SGI_ABI"
  81         LDFLAGS="$SGI_ABI $LDFLAGS"
  82         MACHDEP=`echo "${MACHDEP}${SGI_ABI}" | sed 's/ *//g'`
  83 fi
  84 AC_MSG_RESULT($MACHDEP)
  85
  86 # checks for alternative programs
  87 AC_MSG_CHECKING(for --without-gcc)
  88 AC_ARG_WITH(gcc, [  --without-gcc                   never use gcc], [
  89         case $withval in
  90         no)     CC=cc
  91                 without_gcc=yes;;
  92         yes)    CC=gcc
  93                 without_gcc=no;;
  94         *)      CC=$withval
  95                 without_gcc=$withval;;
  96         esac], [
  97         case $ac_sys_system in
  98         AIX*)   CC=cc_r
  99                 without_gcc=;;
 100         BeOS*)
 101                 case $BE_HOST_CPU in
 102                 ppc)
 103                         CC=mwcc
 104                         without_gcc=yes
 105                         OPT="-O -D'DL_EXPORT(RTYPE)=__declspec(dllexport) RTYPE' -D'DL_IMPORT(RTYPE)=__declspec(dllexport) RTYPE' -export pragma"
 106                         CCSHARED="-UDL_IMPORT -D'DL_IMPORT(RTYPE)=__declspec(dllimport) RTYPE'"
 107                         LDFLAGS="$LDFLAGS -nodup"
 108                         ;;
 109                 x86)
 110                         CC=gcc
 111                         without_gcc=no
 112                         OPT=-O
 113                         ;;
 114                 *)
 115                         AC_ERROR(Unknown BeOS platform \"$BE_HOST_CPU\")
 116                         ;;
 117                 esac
 118                 AR="\$(srcdir)/Modules/ar_beos"
 119                 RANLIB=:
 120                 ;;
 121     Monterey*)
 122         RANLIB=:
 123         without_gcc=;;
 124         *)      without_gcc=no;;
 125         esac])
 126 AC_MSG_RESULT($without_gcc)
 127
 128 AC_SUBST(CXX)
 129 AC_SUBST(MAINOBJ)
 130 MAINOBJ=python.o
 131 AC_MSG_CHECKING(for --with-cxx=<compiler>)
 132 AC_ARG_WITH(cxx, [  --with-cxx=<compiler>           enable C++ support],[
 133         check_cxx=no
 134         case $withval in
 135         no)     CXX=
 136                 with_cxx=no;;
 137         *)      CXX=$withval
 138                 MAINOBJ=ccpython.o
 139                 with_cxx=$withval;;
 140         esac], [
 141         with_cxx=no
 142         check_cxx=yes
 143 ])
 144 AC_MSG_RESULT($with_cxx)
 145
 146 dnl The following fragment works similar to AC_PROG_CXX.
 147 dnl It does not fail if CXX is not found, and it is not executed if
 148 dnl --with-cxx was given.
 149 dnl Finally, it does not test whether CXX is g++.
 150
 151 if test "$check_cxx" = "yes"
 152 then
 153         AC_CHECK_PROGS(CXX, $CCC c++ g++ gcc CC cxx cc++ cl, notfound)
 154         if test "$CXX" = "notfound"
 155         then
 156                 CXX=
 157         else
 158                 AC_PROG_CXX_WORKS
 159         fi
 160 fi
 161
 162 # If the user switches compilers, we can't believe the cache
 163 if test ! -z "$ac_cv_prog_CC" -a ! -z "$CC" -a "$CC" != "$ac_cv_prog_CC"
 164 then
 165   AC_ERROR(cached CC is different -- throw away $cache_file
 166 (it is also a good idea to do 'make clean' before compiling))
 167 fi
 168
 169 AC_PROG_CC
 170
 171 # checks for UNIX variants that set C preprocessor variables
 172 AC_AIX
 173 AC_MINIX
 174
 175 AC_EXEEXT
 176 AC_MSG_CHECKING(for --with-suffix)
 177 AC_ARG_WITH(suffix, [  --with-suffix=.exe              set executable suffix],[
 178         case $withval in
 179         no)     EXEEXT=;;
 180         yes)    EXEEXT=.exe;;
 181         *)      EXEEXT=$withval;;
 182         esac])
 183 AC_MSG_RESULT($EXEEXT)
 184 # Test whether we're running on a non-case-sensitive system, in which
 185 # case we give a warning if no ext is given
 186 if test -d "python" -a -z "$EXEEXT"
 187 then
 188     AC_MSG_WARN(This filesystem is not case-sensitive so you should probably use --with-suffix)
 189 fi
 190
 191 case $MACHDEP in
 192 bsdos*)
 193     case $CC in
 194     gcc) CC="$CC -D_HAVE_BSDI";;
 195     esac;;
 196 esac
 197
 198 case $ac_sys_system in
 199 hp*|HP*)
 200     case $CC in
 201     cc|*/cc) CC="$CC -Ae";;
 202     esac;;
 203 Monterey*)
 204     case $CC in
 205     cc) CC="$CC -Wl,-Bexport";;
 206     esac;;
 207 SunOS*)
 208     # Some functions have a prototype only with that define, e.g. confstr
 209     AC_DEFINE(__EXTENSIONS__)
 210     ;;
 211 esac
 212
 213
 214 AC_SUBST(LIBRARY)
 215 AC_MSG_CHECKING(LIBRARY)
 216 if test -z "$LIBRARY"
 217 then
 218         LIBRARY='libpython$(VERSION).a'
 219 fi
 220 AC_MSG_RESULT($LIBRARY)
 221
 222 # LDLIBRARY is the name of the library to link against (as opposed to the
 223 # name of the library into which to insert object files). BLDLIBRARY is also
 224 # the library to link against, usually. On Mac OS X frameworks, BLDLIBRARY
 225 # is blank as the main program is not linked directly against LDLIBRARY.
 226 # LDLIBRARYDIR is the path to LDLIBRARY, which is made in a subdirectory. On
 227 # systems without shared libraries, LDLIBRARY is the same as LIBRARY
 228 # (defined in the Makefiles). On Cygwin LDLIBRARY is the import library,
 229 # DLLLIBRARY is the shared (i.e., DLL) library.
 230 #
 231 AC_SUBST(LDLIBRARY)
 232 AC_SUBST(DLLLIBRARY)
 233 AC_SUBST(BLDLIBRARY)
 234 AC_SUBST(LDLIBRARYDIR)
 235 LDLIBRARY="$LIBRARY"
 236 BLDLIBRARY='$(LDLIBRARY)'
 237 DLLLIBRARY=''
 238 LDLIBRARYDIR=''
 239
 240 # LINKCC is the command that links the python executable -- default is $(CC).
 241 # This is altered for AIX in order to build the export list before
 242 # linking.
 243 AC_SUBST(LINKCC)
 244 AC_MSG_CHECKING(LINKCC)
 245 if test -z "$LINKCC"
 246 then
 247         case $ac_sys_system in
 248         AIX*)
 249            LINKCC="\$(srcdir)/Modules/makexp_aix Modules/python.exp \"\" \$(LIBRARY); \$(PURIFY) \$(CC)";;
 250         dgux*)
 251            LINKCC="LD_RUN_PATH=$libdir \$(PURIFY) \$(CC)";;
 252         Monterey64*)
 253            LINKCC="\$(PURIFY) \$(CC) -L/usr/lib/ia64l64";;
 254         *) LINKCC="\$(PURIFY) \$(CC)";;
 255         esac
 256 fi
 257 AC_MSG_RESULT($LINKCC)
 258
 259 AC_MSG_CHECKING(LDLIBRARY)
 260
 261 # DG/UX requires some fancy ld contortions to produce a .so from an .a
 262 case $MACHDEP in
 263 dguxR4)
 264       LDLIBRARY='libpython$(VERSION).so'
 265       OPT="$OPT -pic"
 266       ;;
 267 beos*)
 268       LDLIBRARY='libpython$(VERSION).so'
 269       ;;
 270 cygwin*)
 271       LDLIBRARY='libpython$(VERSION).dll.a'
 272       DLLLIBRARY='libpython$(VERSION).dll'
 273       ;;
 274 esac
 275
 276 # MacOSX framework builds need more magic. LDLIBRARY is the dynamic
 277 # library that we build, but we do not want to link against it (we
 278 # will find it with a -framework option). For this reason there is an
 279 # extra variable BLDLIBRARY against which Python and the extension
 280 # modules are linked, BLDLIBRARY. This is normally the same as
 281 # LDLIBRARY, but empty for MacOSX framework builds.
 282 if test "$enable_framework"
 283 then
 284   LDLIBRARY='$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
 285   LDLIBRARYDIR='$(PYTHONFRAMEWORKDIR)'
 286   BLDLIBRARY=''
 287 else
 288   BLDLIBRARY='$(LDLIBRARY)'
 289 fi
 290
 291 AC_MSG_RESULT($LDLIBRARY)
 292
 293 AC_PROG_RANLIB
 294 AC_SUBST(AR)
 295 AC_CHECK_PROGS(AR, ar aal, ar)
 296
 297 case $MACHDEP in
 298 bsdos*)
 299         # install -d does not work on BSDI
 300         if test -z "$INSTALL"
 301         then
 302                 INSTALL="${srcdir}/install-sh -c"
 303         fi
 304 esac
 305 AC_PROG_INSTALL
 306
 307 # Not every filesystem supports hard links
 308 AC_SUBST(LN)
 309 if test -z "$LN" ; then
 310         case $ac_sys_system in
 311                 BeOS*) LN="ln -s";;
 312                 CYGWIN*) LN="ln -s";;
 313                 *) LN=ln;;
 314         esac
 315 fi
 316
 317 # Check for --with-pydebug
 318 AC_MSG_CHECKING(for --with-pydebug)
 319 AC_ARG_WITH(pydebug,
 320 [  --with-pydebug                  build with Py_DEBUG defined], [
 321 if test "$withval" != no
 322 then AC_DEFINE(Py_DEBUG) AC_MSG_RESULT(yes); Py_DEBUG='true'
 323 else AC_MSG_RESULT(no); Py_DEBUG='false'
 324 fi],
 325 [AC_MSG_RESULT(no)])
 326
 327 # Optimizer/debugger flags
 328 AC_SUBST(OPT)
 329 if test -z "$OPT"
 330 then
 331         case $GCC in
 332         yes)
 333                 case $ac_cv_prog_cc_g in
 334         yes)
 335             if test "$Py_DEBUG" = 'true' ; then
 336                 # Optimization messes up debuggers, so turn it off for
 337                 # debug builds.
 338                 OPT="-g -Wall -Wstrict-prototypes"
 339             else
 340                 OPT="-g -O3 -Wall -Wstrict-prototypes"
 341             fi;;
 342         *)
 343             OPT="-O3 -Wall -Wstrict-prototypes";;
 344         esac
 345         ;;
 346     *)
 347         case $ac_sys_system in
 348         UnixWare*)
 349             OPT="-O -K pentium,host,inline,loop_unroll,alloca ";;
 350         *)
 351             OPT="-O";;
 352         esac
 353     esac
 354     case $ac_sys_system in
 355     Darwin*)
 356         OPT="$OPT -no-cpp-precomp";;
 357     esac
 358 fi
 359
 360 # The current (beta) Monterey compiler dies with optimizations
 361 case $ac_sys_system in
 362 Monterey*) OPT="";;
 363 esac
 364
 365 if test "$ac_arch_flags"
 366 then
 367         OPT="$OPT $ac_arch_flags"
 368 fi
 369
 370 AC_MSG_CHECKING(whether $CC accepts -OPT:Olimit=0)
 371 AC_CACHE_VAL(ac_cv_opt_olimit_ok,
 372 [ac_save_cc="$CC"
 373 CC="$CC -OPT:Olimit=0"
 374 AC_TRY_RUN([int main() { return 0; }],
 375   ac_cv_opt_olimit_ok=yes,
 376   ac_cv_opt_olimit_ok=no)
 377 CC="$ac_save_cc"])
 378 AC_MSG_RESULT($ac_cv_opt_olimit_ok)
 379 if test $ac_cv_opt_olimit_ok = yes; then
 380     case $ac_sys_system in
 381       Darwin*) OPT="$OPT" ;;
 382       *) OPT="$OPT -OPT:Olimit=0";;
 383     esac
 384 else
 385   AC_MSG_CHECKING(whether $CC accepts -Olimit 1500)
 386   AC_CACHE_VAL(ac_cv_olimit_ok,
 387   [ac_save_cc="$CC"
 388   CC="$CC -Olimit 1500"
 389   AC_TRY_RUN([int main() { return 0; }],
 390     ac_cv_olimit_ok=yes,
 391     ac_cv_olimit_ok=no)
 392   CC="$ac_save_cc"])
 393   AC_MSG_RESULT($ac_cv_olimit_ok)
 394   if test $ac_cv_olimit_ok = yes; then
 395     OPT="$OPT -Olimit 1500"
 396   fi
 397 fi
 398
 399 # -Kpthread, if available, provides the right #defines
 400 # and linker options to make pthread_create available
 401 AC_MSG_CHECKING(whether $CC accepts -Kpthread)
 402 AC_CACHE_VAL(ac_cv_kpthread,
 403 [ac_save_cc="$CC"
 404 CC="$CC -Kpthread"
 405 AC_TRY_LINK([#include <pthread.h>],[pthread_create(0,0,0,0)],
 406   ac_cv_kpthread=yes,
 407   ac_cv_kpthread=no)
 408 CC="$ac_save_cc"])
 409
 410 # GCC does not reject -Kpthread as an illegal option, it merely complains that
 411 # it is unrecognized
 412 if test "$GCC" = "yes"
 413 then ac_cv_kpthread="no, we have gcc"
 414 fi
 415 AC_MSG_RESULT($ac_cv_kpthread)
 416
 417 dnl # check for ANSI or K&R ("traditional") preprocessor
 418 dnl AC_MSG_CHECKING(for C preprocessor type)
 419 dnl AC_TRY_COMPILE([
 420 dnl #define spam(name, doc) {#name, &name, #name "() -- " doc}
 421 dnl int foo;
 422 dnl struct {char *name; int *addr; char *doc;} desc = spam(foo, "something");
 423 dnl ], [;], cpp_type=ansi, AC_DEFINE(HAVE_OLD_CPP) cpp_type=traditional)
 424 dnl AC_MSG_RESULT($cpp_type)
 425
 426 # checks for header files
 427 AC_HEADER_STDC
 428 AC_CHECK_HEADERS(dlfcn.h fcntl.h limits.h langinfo.h locale.h \
 429 ncurses.h poll.h pthread.h \
 430 signal.h stdarg.h stddef.h stdlib.h thread.h unistd.h utime.h termios.h \
 431 sys/audioio.h sys/file.h sys/lock.h sys/modem.h db_185.h db.h \
 432 sys/param.h sys/poll.h sys/select.h sys/socket.h sys/time.h sys/times.h \
 433 sys/un.h sys/utsname.h sys/wait.h pty.h libutil.h \
 434 ndbm.h db1/ndbm.h gdbm/ndbm.h sys/resource.h netpacket/packet.h)
 435 AC_HEADER_DIRENT
 436
 437 # checks for typedefs
 438 was_it_defined=no
 439 AC_MSG_CHECKING(for clock_t in time.h)
 440 AC_EGREP_HEADER(clock_t, time.h, was_it_defined=yes, AC_DEFINE(clock_t, long))
 441 AC_MSG_RESULT($was_it_defined)
 442
 443 # Add some code to confdefs.h so that the test for off_t works on SCO
 444 cat >> confdefs.h <<\EOF
 445 #if defined(SCO_DS)
 446 #undef _OFF_T
 447 #endif
 448 EOF
 449
 450 # Type availability checks
 451 AC_TYPE_MODE_T
 452 AC_TYPE_OFF_T
 453 AC_TYPE_PID_T
 454 AC_TYPE_SIGNAL
 455 AC_TYPE_SIZE_T
 456 AC_TYPE_UID_T
 457
 458 # Sizes of various common basic types
 459 AC_CHECK_SIZEOF(int)
 460 AC_CHECK_SIZEOF(long)
 461 AC_CHECK_SIZEOF(void *)
 462 AC_CHECK_SIZEOF(char)
 463 AC_CHECK_SIZEOF(short)
 464 AC_CHECK_SIZEOF(float)
 465 AC_CHECK_SIZEOF(double)
 466 AC_CHECK_SIZEOF(fpos_t)
 467
 468 AC_MSG_CHECKING(for long long support)
 469 have_long_long=no
 470 AC_TRY_COMPILE([], [long long x; x = (long long)0;], AC_DEFINE(HAVE_LONG_LONG) have_long_long=yes)
 471 AC_MSG_RESULT($have_long_long)
 472 if test "$have_long_long" = yes ; then
 473 AC_CHECK_SIZEOF(long long)
 474 fi
 475
 476 AC_MSG_CHECKING(for uintptr_t support)
 477 have_uintptr_t=no
 478 AC_TRY_COMPILE([], [uintptr_t x; x = (uintptr_t)0;], AC_DEFINE(HAVE_UINTPTR_T) have_uintptr_t=yes)
 479 AC_MSG_RESULT($have_uintptr_t)
 480 if test "$have_uintptr_t" = yes ; then
 481 AC_CHECK_SIZEOF(uintptr_t)
 482 fi
 483
 484 # Hmph. AC_CHECK_SIZEOF() doesn't include <sys/types.h>.
 485 AC_MSG_CHECKING(size of off_t)
 486 AC_CACHE_VAL(ac_cv_sizeof_off_t,
 487 [AC_TRY_RUN([#include <stdio.h>
 488 #include <sys/types.h>
 489 main()
 490 {
 491   FILE *f=fopen("conftestval", "w");
 492   if (!f) exit(1);
 493   fprintf(f, "%d\n", sizeof(off_t));
 494   exit(0);
 495 }], ac_cv_sizeof_off_t=`cat conftestval`, ac_cv_sizeof_off_t=0)
 496 ])
 497 AC_MSG_RESULT($ac_cv_sizeof_off_t)
 498 AC_DEFINE_UNQUOTED(SIZEOF_OFF_T, $ac_cv_sizeof_off_t)
 499
 500 AC_MSG_CHECKING(whether to enable large file support)
 501 if test "$have_long_long" = yes -a \
 502         "$ac_cv_sizeof_off_t" -gt "$ac_cv_sizeof_long" -a \
 503         "$ac_cv_sizeof_long_long" -ge "$ac_cv_sizeof_off_t"; then
 504   AC_DEFINE(HAVE_LARGEFILE_SUPPORT)
 505   AC_MSG_RESULT(yes)
 506 else
 507   AC_MSG_RESULT(no)
 508 fi
 509
 510 # AC_CHECK_SIZEOF() doesn't include <time.h>.
 511 AC_MSG_CHECKING(size of time_t)
 512 AC_CACHE_VAL(ac_cv_sizeof_time_t,
 513 [AC_TRY_RUN([#include <stdio.h>
 514 #include <time.h>
 515 main()
 516 {
 517   FILE *f=fopen("conftestval", "w");
 518   if (!f) exit(1);
 519   fprintf(f, "%d\n", sizeof(time_t));
 520   exit(0);
 521 }], ac_cv_sizeof_time_t=`cat conftestval`, ac_cv_sizeof_time_t=0)
 522 ])
 523 AC_MSG_RESULT($ac_cv_sizeof_time_t)
 524 AC_DEFINE_UNQUOTED(SIZEOF_TIME_T, $ac_cv_sizeof_time_t)
 525
 526
 527 # if have pthread_t then define SIZEOF_PTHREAD_T
 528 ac_save_cc="$CC"
 529 if test "$ac_cv_kpthread" = "yes"
 530 then CC="$CC -Kpthread"
 531 fi
 532 AC_MSG_CHECKING(for pthread_t)
 533 have_pthread_t=no
 534 AC_TRY_COMPILE([#include <pthread.h>], [pthread_t x; x = *(pthread_t*)0;], have_pthread_t=yes)
 535 AC_MSG_RESULT($have_pthread_t)
 536 if test "$have_pthread_t" = yes ; then
 537   # AC_CHECK_SIZEOF() doesn't include <pthread.h>.
 538   AC_MSG_CHECKING(size of pthread_t)
 539   AC_CACHE_VAL(ac_cv_sizeof_pthread_t,
 540   [AC_TRY_RUN([#include <stdio.h>
 541   #include <pthread.h>
 542   main()
 543   {
 544     FILE *f=fopen("conftestval", "w");
 545     if (!f) exit(1);
 546     fprintf(f, "%d\n", sizeof(pthread_t));
 547     exit(0);
 548   }], ac_cv_sizeof_pthread_t=`cat conftestval`, ac_cv_sizeof_pthread_t=0)
 549   ])
 550   AC_MSG_RESULT($ac_cv_sizeof_pthread_t)
 551   AC_DEFINE_UNQUOTED(SIZEOF_PTHREAD_T, $ac_cv_sizeof_pthread_t)
 552 fi
 553 CC="$ac_save_cc"
 554
 555 AC_MSG_CHECKING(for --enable-toolbox-glue)
 556 AC_ARG_ENABLE(toolbox-glue,
 557 [  --enable-toolbox-glue            disable/enable MacOSX glue code for extensions])
 558
 559 if test -z "$enable_toolbox_glue"
 560 then
 561         case $ac_sys_system/$ac_sys_release in
 562         Darwin/*)
 563                 enable_toolbox_glue="yes";;
 564         *)
 565                 enable_toolbox_glue="no";;
 566         esac
 567 fi
 568 case "$enable_toolbox_glue" in
 569 yes)
 570         extra_frameworks="-framework Carbon -framework Foundation"
 571         extra_machdep_objs="Python/mactoolboxglue.o"
 572         extra_undefs="-u __dummy -u _PyMac_Error"
 573         AC_DEFINE(USE_TOOLBOX_OBJECT_GLUE)
 574         ;;
 575 *)
 576         extra_frameworks=""
 577         extra_machdep_objs=""
 578         extra_undefs=""
 579         ;;
 580 esac
 581 AC_MSG_RESULT($enable_toolbox_glue)
 582
 583 AC_SUBST(LIBTOOL_CRUFT)
 584 case $ac_sys_system/$ac_sys_release in
 585   Darwin/*)
 586     ns_undef_sym='_environ'
 587     LIBTOOL_CRUFT="-lcc_dynamic -arch_only ppc -U $ns_undef_sym"
 588         LIBTOOL_CRUFT="$LIBTOOL_CRUFT $extra_frameworks"
 589     LIBTOOL_CRUFT=$LIBTOOL_CRUFT' -install_name $(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/Python'
 590     LIBTOOL_CRUFT=$LIBTOOL_CRUFT' -compatibility_version $(VERSION) -current_version $(VERSION)';;
 591 esac
 592
 593 AC_MSG_CHECKING(for --enable-framework)
 594 if test "$enable_framework"
 595 then
 596         OPT="$OPT -fno-common -dynamic"
 597         # -U __environ is needed since bundles don't have access
 598         # to crt0 when built but will always be linked against it
 599         # -F. is needed to allow linking to the framework while
 600         # in the build location.
 601
 602         LDFLAGS="$LDFLAGS -Wl,-F. -Wl,-U,$ns_undef_sym"
 603         AC_DEFINE(WITH_NEXT_FRAMEWORK)
 604         AC_MSG_RESULT(yes)
 605 else
 606         AC_MSG_RESULT(no)
 607 fi
 608
 609 AC_MSG_CHECKING(for dyld)
 610 case $ac_sys_system/$ac_sys_release in
 611   Darwin/*)
 612         AC_DEFINE(WITH_DYLD)
 613         AC_MSG_RESULT(always on for Darwin)
 614         ;;
 615   *)
 616         AC_MSG_RESULT(no)
 617         ;;
 618 esac
 619
 620 # Set info about shared libraries.
 621 AC_SUBST(SO)
 622 AC_SUBST(LDSHARED)
 623 AC_SUBST(BLDSHARED)
 624 AC_SUBST(CCSHARED)
 625 AC_SUBST(LINKFORSHARED)
 626 # SO is the extension of shared libraries `(including the dot!)
 627 # -- usually .so, .sl on HP-UX, .dll on Cygwin
 628 AC_MSG_CHECKING(SO)
 629 if test -z "$SO"
 630 then
 631         case $ac_sys_system in
 632         hp*|HP*)   SO=.sl;;
 633         CYGWIN*)   SO=.dll;;
 634         *)         SO=.so;;
 635         esac
 636 fi
 637 AC_MSG_RESULT($SO)
 638 # LDSHARED is the ld *command* used to create shared library
 639 # -- "ld" on SunOS 4.x.x, "ld -G" on SunOS 5.x, "ld -shared" on IRIX 5
 640 # (Shared libraries in this instance are shared modules to be loaded into
 641 # Python, as opposed to building Python itself as a shared library.)
 642 AC_MSG_CHECKING(LDSHARED)
 643 if test -z "$LDSHARED"
 644 then
 645         case $ac_sys_system/$ac_sys_release in
 646         AIX*)
 647                 BLDSHARED="\$(srcdir)/Modules/ld_so_aix \$(CC) -bI:Modules/python.exp"
 648                 LDSHARED="\$(BINLIBDEST)/ld_so_aix \$(CC) -bI:\$(BINLIBDEST)/python.exp"
 649                 ;;
 650         BeOS*)
 651                 BLDSHARED="\$(srcdir)/Modules/ld_so_beos $LDLIBRARY"
 652                 LDSHARED="\$(BINLIBDEST)/ld_so_beos \$(LIBDIR)/$LDLIBRARY"
 653                 ;;
 654         IRIX/5*) LDSHARED="ld -shared";;
 655         IRIX*/6*) LDSHARED="ld ${SGI_ABI} -shared -all";;
 656         SunOS/4*) LDSHARED="ld";;
 657         SunOS/5*)
 658                 if test "$GCC" = "yes"
 659                 then LDSHARED='$(CC) -shared'
 660                 else LDSHARED="ld -G";
 661                 fi ;;
 662         hp*|HP*) LDSHARED="ld -b";;
 663         OSF*) LDSHARED="ld -shared -expect_unresolved \"*\"";;
 664         DYNIX/ptx*) LDSHARED="ld -G";;
 665         Darwin/*)
 666                 LDSHARED='$(CC) $(LDFLAGS) -bundle'
 667                 if test "$enable_framework" ; then
 668                         # Link against the framework. All externals should be defined.
 669                         LDSHARED="$LDSHARED "'-framework $(PYTHONFRAMEWORK)'
 670                 else
 671                         # No framework. Ignore undefined symbols, assuming they come from Python
 672                         LDSHARED="$LDSHARED -undefined suppress"
 673                 fi ;;
 674         Linux*) LDSHARED="gcc -shared";;
 675         dgux*) LDSHARED="ld -G";;
 676         BSD/OS*/4*) LDSHARED="gcc -shared";;
 677         OpenBSD*|NetBSD*|FreeBSD*)
 678                 if [[ "`$CC -dM -E - </dev/null | grep __ELF__`" != "" ]]
 679                 then
 680                         LDSHARED="cc -shared ${LDFLAGS}"
 681                 else
 682                         LDSHARED="ld -Bshareable ${LDFLAGS}"
 683                 fi;;
 684         UnixWare*)
 685                 if test "$GCC" = "yes"
 686                 then LDSHARED="$(CC) -shared"
 687                 else LDSHARED="$(CC) -G"
 688                 fi;;
 689         SCO_SV*) LDSHARED="cc -G -KPIC -Ki486 -belf -Wl,-Bexport";;
 690         Monterey*) LDSHARED="cc -G -dy -Bdynamic -Bexport -L/usr/lib/ia64l64";;
 691         CYGWIN*) LDSHARED="gcc -shared -Wl,--enable-auto-image-base";;
 692         *)      LDSHARED="ld";;
 693         esac
 694 fi
 695 AC_MSG_RESULT($LDSHARED)
 696 BLDSHARED=${BLDSHARED-$LDSHARED}
 697 # CCSHARED are the C *flags* used to create objects to go into a shared
 698 # library (module) -- this is only needed for a few systems
 699 AC_MSG_CHECKING(CCSHARED)
 700 if test -z "$CCSHARED"
 701 then
 702         case $ac_sys_system/$ac_sys_release in
 703         SunOS*) if test "$GCC" = yes;
 704                 then CCSHARED="-fPIC";
 705                 fi;;
 706         hp*|HP*) if test "$GCC" = yes;
 707                  then CCSHARED="-fPIC";
 708                  else CCSHARED="+z";
 709                  fi;;
 710         Linux*) CCSHARED="-fPIC";;
 711         BSD/OS*/4*) CCSHARED="-fpic";;
 712         FreeBSD*|NetBSD*|OpenBSD*) CCSHARED="-fPIC";;
 713         UnixWare*)
 714                 if test "$GCC" = "yes"
 715                 then CCSHARED="-fPIC"
 716                 else CCSHARED="-KPIC"
 717                 fi;;
 718         SCO_SV*) CCSHARED="-KPIC -dy -Bdynamic";;
 719         Monterey*) CCSHARED="-G";;
 720         IRIX*/6*)  case $CC in
 721                    *gcc*) CCSHARED="-shared";;
 722                    *) CCSHARED="";;
 723                    esac;;
 724         CYGWIN*) CCSHARED="-DUSE_DL_IMPORT";;
 725         esac
 726 fi
 727 AC_MSG_RESULT($CCSHARED)
 728 # LINKFORSHARED are the flags passed to the $(CC) command that links
 729 # the python executable -- this is only needed for a few systems
 730 AC_MSG_CHECKING(LINKFORSHARED)
 731 if test -z "$LINKFORSHARED"
 732 then
 733         case $ac_sys_system/$ac_sys_release in
 734         AIX*)   LINKFORSHARED='-Wl,-bE:Modules/python.exp -lld';;
 735         hp*|HP*)
 736             LINKFORSHARED="-Wl,-E -Wl,+s -Wl,+b\$(BINLIBDEST)/lib-dynload";;
 737         BSD/OS/4*) LINKFORSHARED="-Xlinker -export-dynamic";;
 738         Linux*) LINKFORSHARED="-Xlinker -export-dynamic";;
 739         # -u libsys_s pulls in all symbols in libsys
 740         Darwin/*)
 741                 # -u __dummy makes the linker aware of the objc runtime
 742                 # in System.framework; otherwise, __objcInit (referenced in
 743                 # crt1.o) gets erroneously defined as common, which breaks dynamic
 744                 # loading of any modules which reference it in System.framework.
 745                 # -u _PyMac_Error is needed to pull in the mac toolbox glue, which is
 746                 # not used by the core itself but which needs to be in the core so
 747                 # that dynamically loaded extension modules have access to it.
 748                 LINKFORSHARED="$extra_undefs -framework System"
 749                 if test "$enable_framework"
 750                 then
 751                         LINKFORSHARED="$LINKFORSHARED -framework Python"
 752                 fi
 753                 LINKFORSHARED="$LINKFORSHARED $extra_frameworks";;
 754         UnixWare*) LINKFORSHARED="-Wl,-Bexport";;
 755         SCO_SV*) LINKFORSHARED="-Bdynamic -dy -Wl,-Bexport";;
 756         ReliantUNIX*) LINKFORSHARED="-W1 -Blargedynsym";;
 757         FreeBSD*|NetBSD*|OpenBSD*)
 758                 if [[ "`$CC -dM -E - </dev/null | grep __ELF__`" != "" ]]
 759                 then
 760                         LINKFORSHARED="-Wl,--export-dynamic"
 761                 fi;;
 762         SunOS/5*) case $CC in
 763                   *gcc*)
 764                     if $CC -Xlinker -V 2>&1 | grep BFD >/dev/null
 765                     then
 766                         LINKFORSHARED="-Xlinker --export-dynamic"
 767                     fi;;
 768                   esac;;
 769         esac
 770 fi
 771 AC_MSG_RESULT($LINKFORSHARED)
 772
 773 AC_SUBST(CFLAGSFORSHARED)
 774 AC_MSG_CHECKING(CFLAGSFORSHARED)
 775 if test ! "$LIBRARY" = "$LDLIBRARY"
 776 then
 777         case $ac_sys_system in
 778         CYGWIN*)
 779                 # Cygwin needs CCSHARED when building extension DLLs
 780                 # but not when building the interpreter DLL.
 781                 CFLAGSFORSHARED='';;
 782         *)
 783                 CFLAGSFORSHARED='$(CCSHARED)'
 784         esac
 785 fi
 786 AC_MSG_RESULT($CFLAGSFORSHARED)
 787
 788 # checks for libraries
 789 AC_CHECK_LIB(dl, dlopen)        # Dynamic linking for SunOS/Solaris and SYSV
 790 AC_CHECK_LIB(dld, shl_load)     # Dynamic linking for HP-UX
 791
 792 # checks for system dependent C++ extensions support
 793 case "$ac_sys_system" in
 794         AIX*)   AC_MSG_CHECKING(for genuine AIX C++ extensions support)
 795                 AC_TRY_LINK([#include "/usr/lpp/xlC/include/load.h"],
 796                             [loadAndInit("", 0, "")],
 797                             [AC_DEFINE(AIX_GENUINE_CPLUSPLUS)
 798                              AC_MSG_RESULT(yes)],
 799                             [AC_MSG_RESULT(no)]);;
 800         *) ;;
 801 esac
 802
 803 # Most SVR4 platforms (e.g. Solaris) need -lsocket and -lnsl.
 804 # However on SGI IRIX, these exist but are broken.
 805 # BeOS' sockets are stashed in libnet.
 806 case "$ac_sys_system" in
 807 IRIX*) ;;
 808 *)
 809 AC_CHECK_LIB(nsl, t_open, [LIBS="-lnsl $LIBS"]) # SVR4
 810 AC_CHECK_LIB(socket, socket, [LIBS="-lsocket $LIBS"], [], $LIBS) # SVR4 sockets
 811 ;;
 812 esac
 813 case "$ac_sys_system" in
 814 BeOS*)
 815 AC_CHECK_LIB(net, socket, [LIBS="-lnet $LIBS"], [], $LIBS) # BeOS
 816 ;;
 817 esac
 818
 819 AC_MSG_CHECKING(for --with-libs)
 820 AC_ARG_WITH(libs,
 821 [  --with-libs='lib1 ...'          link against additional libs], [
 822 AC_MSG_RESULT($withval)
 823 LIBS="$withval $LIBS"
 824 ], AC_MSG_RESULT(no))
 825
 826 # Determine if signalmodule should be used.
 827 AC_SUBST(USE_SIGNAL_MODULE)
 828 AC_SUBST(SIGNAL_OBJS)
 829 AC_MSG_CHECKING(for --with-signal-module)
 830 AC_ARG_WITH(signal-module,
 831 [  --with-signal-module            disable/enable signal module])
 832
 833 if test -z "$with_signal_module"
 834 then with_signal_module="yes"
 835 fi
 836 AC_MSG_RESULT($with_signal_module)
 837
 838 if test "${with_signal_module}" = "yes"; then
 839         USE_SIGNAL_MODULE=""
 840         SIGNAL_OBJS=""
 841 else
 842         USE_SIGNAL_MODULE="#"
 843         SIGNAL_OBJS="Parser/intrcheck.o Python/sigcheck.o"
 844 fi
 845
 846 # This is used to generate Setup.config
 847 AC_SUBST(USE_THREAD_MODULE)
 848 USE_THREAD_MODULE=""
 849
 850 AC_MSG_CHECKING(for --with-dec-threads)
 851 AC_SUBST(LDLAST)
 852 AC_ARG_WITH(dec-threads,
 853 [  --with-dec-threads              use DEC Alpha/OSF1 thread-safe libraries], [
 854 AC_MSG_RESULT($withval)
 855 LDLAST=-threads
 856 if test "${with_thread+set}" != set; then
 857    with_thread="$withval";
 858 fi],
 859 AC_MSG_RESULT(no))
 860
 861 AC_MSG_CHECKING(for --with-threads)
 862 AC_ARG_WITH(threads,
 863 [  --with(out)-threads[=DIRECTORY] disable/enable thread support])
 864
 865 # --with-thread is deprecated, but check for it anyway
 866 AC_ARG_WITH(thread,
 867 [  --with(out)-thread[=DIRECTORY]  deprecated; use --with(out)-threads],[
 868 with_threads=$with_thread])
 869
 870 if test -z "$with_threads"
 871 then with_threads="yes"
 872 fi
 873 AC_MSG_RESULT($with_threads)
 874
 875 if test "$with_threads" = "no"
 876 then
 877     USE_THREAD_MODULE="#"
 878 elif test "$ac_cv_kpthread" = "yes"
 879 then
 880     CC="$CC -Kpthread"
 881     AC_DEFINE(WITH_THREAD)
 882     AC_DEFINE(_POSIX_THREADS)
 883     LIBOBJS="$LIBOBJS thread.o"
 884 else
 885     if test ! -z "$with_threads" -a -d "$with_threads"
 886     then LDFLAGS="$LDFLAGS -L$with_threads"
 887     fi
 888     if test ! -z "$withval" -a -d "$withval"
 889     then LDFLAGS="$LDFLAGS -L$withval"
 890     fi
 891     AC_DEFINE(_REENTRANT)
 892     AC_CHECK_HEADER(mach/cthreads.h, [AC_DEFINE(WITH_THREAD)
 893     AC_DEFINE(C_THREADS)
 894     LIBOBJS="$LIBOBJS thread.o"],[
 895     AC_MSG_CHECKING(for --with-pth)
 896     AC_ARG_WITH(pth,
 897     [  --with-pth                      use GNU pth threading libraries], [
 898     AC_MSG_RESULT($withval)
 899     AC_DEFINE(WITH_THREAD)
 900     AC_DEFINE(HAVE_PTH)
 901     LIBS="-lpth $LIBS"
 902     LIBOBJS="$LIBOBJS thread.o"],[
 903     AC_MSG_RESULT(no)
 904     AC_CHECK_LIB(pthread, pthread_create, [AC_DEFINE(WITH_THREAD)
 905     case $ac_sys_system in
 906       Darwin*) ;;
 907       *) AC_DEFINE(_POSIX_THREADS);;
 908     esac
 909     LIBS="-lpthread $LIBS"
 910     LIBOBJS="$LIBOBJS thread.o"],[
 911     AC_CHECK_FUNC(pthread_detach, [AC_DEFINE(WITH_THREAD)
 912     case $ac_sys_system in
 913       Darwin*) ;;
 914       *) AC_DEFINE(_POSIX_THREADS);;
 915     esac
 916     LIBOBJS="$LIBOBJS thread.o"],[
 917     AC_CHECK_HEADER(kernel/OS.h, [AC_DEFINE(WITH_THREAD)
 918     AC_DEFINE(BEOS_THREADS)
 919     LIBOBJS="$LIBOBJS thread.o"],[
 920     AC_CHECK_LIB(pthreads, pthread_create, [AC_DEFINE(WITH_THREAD)
 921     AC_DEFINE(_POSIX_THREADS)
 922     LIBS="$LIBS -lpthreads"
 923     LIBOBJS="$LIBOBJS thread.o"], [
 924     AC_CHECK_LIB(c_r, pthread_create, [AC_DEFINE(WITH_THREAD)
 925     AC_DEFINE(_POSIX_THREADS)
 926     LIBS="$LIBS -lc_r"
 927     LIBOBJS="$LIBOBJS thread.o"], [
 928     AC_CHECK_LIB(thread, __d6_pthread_create, [AC_DEFINE(WITH_THREAD)
 929     AC_DEFINE(_POSIX_THREADS)
 930     LIBS="$LIBS -lthread"
 931     LIBOBJS="$LIBOBJS thread.o"], [
 932     AC_CHECK_LIB(pthread, __pthread_create_system, [AC_DEFINE(WITH_THREAD)
 933     AC_DEFINE(_POSIX_THREADS)
 934     LIBS="$LIBS -lpthread"
 935     LIBOBJS="$LIBOBJS thread.o"], [
 936     AC_CHECK_LIB(cma, pthread_create, [AC_DEFINE(WITH_THREAD)
 937     AC_DEFINE(_POSIX_THREADS)
 938     LIBS="$LIBS -lcma"
 939     LIBOBJS="$LIBOBJS thread.o"],[
 940     USE_THREAD_MODULE="#"])
 941     ])])])])])])])])])
 942
 943     AC_CHECK_LIB(mpc, usconfig, [AC_DEFINE(WITH_THREAD)
 944     LIBS="$LIBS -lmpc"
 945     LIBOBJS="$LIBOBJS thread.o"
 946     USE_THREAD_MODULE=""])
 947     AC_CHECK_LIB(thread, thr_create, [AC_DEFINE(WITH_THREAD)
 948     LIBS="$LIBS -lthread"
 949     LIBOBJS="$LIBOBJS thread.o"
 950     USE_THREAD_MODULE=""])
 951
 952     if test "$USE_THREAD_MODULE" != "#"
 953     then
 954         # If the above checks didn't disable threads, (at least) OSF1
 955         # needs this '-threads' argument during linking.
 956         case $ac_sys_system in
 957         OSF1) LDLAST=-threads;;
 958         esac
 959     fi
 960 fi
 961
 962 # Check for enable-ipv6
 963 AC_MSG_CHECKING([if --enable-ipv6 is specified])
 964 AC_ARG_ENABLE(ipv6,
 965 [  --enable-ipv6                   Enable ipv6 (with ipv4) support
 966   --disable-ipv6                  Disable ipv6 support],
 967 [ case "$enableval" in
 968   no)
 969        AC_MSG_RESULT(no)
 970        ipv6=no
 971        ;;
 972   *)   AC_MSG_RESULT(yes)
 973        AC_DEFINE(ENABLE_IPV6)
 974        ipv6=yes
 975        ;;
 976   esac ],
 977
 978 [
 979 dnl the check does not work on cross compilation case...
 980   AC_TRY_RUN([ /* AF_INET6 available check */
 981 #include <sys/types.h>
 982 #include <sys/socket.h>
 983 main()
 984 {
 985  if (socket(AF_INET6, SOCK_STREAM, 0) < 0)
 986    exit(1);
 987  else
 988    exit(0);
 989 }
 990 ],
 991   AC_MSG_RESULT(yes)
 992   ipv6=yes,
 993   AC_MSG_RESULT(no)
 994   ipv6=no,
 995   AC_MSG_RESULT(no)
 996   ipv6=no
 997 )
 998
 999 if test "$ipv6" = "yes"; then
1000         AC_MSG_CHECKING(if RFC2553 API is available)
1001         AC_TRY_COMPILE([#include <sys/types.h>
1002 #include <netinet/in.h>],
1003         [struct sockaddr_in6 x;
1004 x.sin6_scope_id;],
1005                 AC_MSG_RESULT(yes)
1006                 ipv6=yes,
1007                 AC_MSG_RESULT(no, IPv6 disabled)
1008                 ipv6=no)
1009 fi
1010
1011 if test "$ipv6" = "yes"; then
1012         AC_DEFINE(ENABLE_IPV6)
1013 fi
1014 ])
1015
1016 ipv6type=unknown
1017 ipv6lib=none
1018 ipv6trylibc=no
1019
1020 if test "$ipv6" = "yes"; then
1021         AC_MSG_CHECKING([ipv6 stack type])
1022         for i in inria kame linux-glibc linux-inet6 solaris toshiba v6d zeta;
1023         do
1024                 case $i in
1025                 inria)
1026                         dnl http://www.kame.net/
1027                         AC_EGREP_CPP(yes, [dnl
1028 #include <netinet/in.h>
1029 #ifdef IPV6_INRIA_VERSION
1030 yes
1031 #endif],
1032                                 [ipv6type=$i;
1033                                 OPT="-DINET6 $OPT"])
1034                         ;;
1035                 kame)
1036                         dnl http://www.kame.net/
1037                         AC_EGREP_CPP(yes, [dnl
1038 #include <netinet/in.h>
1039 #ifdef __KAME__
1040 yes
1041 #endif],
1042                                 [ipv6type=$i;
1043                                 ipv6lib=inet6
1044                                 ipv6libdir=/usr/local/v6/lib
1045                                 ipv6trylibc=yes
1046                                 OPT="-DINET6 $OPT"])
1047                         ;;
1048                 linux-glibc)
1049                         dnl http://www.v6.linux.or.jp/
1050                         AC_EGREP_CPP(yes, [dnl
1051 #include <features.h>
1052 #if defined(__GLIBC__) && ((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 1) || (__GLIBC__ > 2))
1053 yes
1054 #endif],
1055                                 [ipv6type=$i;
1056                                 ipv6trylibc=yes
1057                                 OPT="-DINET6 $OPT"])
1058                         ;;
1059                 linux-inet6)
1060                         dnl http://www.v6.linux.or.jp/
1061                         if test -d /usr/inet6; then
1062                                 ipv6type=$i
1063                                 ipv6lib=inet6
1064                                 ipv6libdir=/usr/inet6/lib
1065                                 OPT="-DINET6 -I/usr/inet6/include $OPT"
1066                         fi
1067                         ;;
1068                 solaris)
1069                         if test -f /etc/netconfig; then
1070                           if /usr/xpg4/bin/grep -q tcp6 /etc/netconfig; then
1071                                 ipv6type=$i
1072                                 ipv6trylibc=yes
1073                                 OPT="-DINET6 $OPT"
1074                           fi
1075                         fi
1076                         ;;
1077                 toshiba)
1078                         AC_EGREP_CPP(yes, [dnl
1079 #include <sys/param.h>
1080 #ifdef _TOSHIBA_INET6
1081 yes
1082 #endif],
1083                                 [ipv6type=$i;
1084                                 ipv6lib=inet6;
1085                                 ipv6libdir=/usr/local/v6/lib;
1086                                 OPT="-DINET6 $OPT"])
1087                         ;;
1088                 v6d)
1089                         AC_EGREP_CPP(yes, [dnl
1090 #include </usr/local/v6/include/sys/v6config.h>
1091 #ifdef __V6D__
1092 yes
1093 #endif],
1094                                 [ipv6type=$i;
1095                                 ipv6lib=v6;
1096                                 ipv6libdir=/usr/local/v6/lib;
1097                                 OPT="-I/usr/local/v6/include $OPT"])
1098                         ;;
1099                 zeta)
1100                         AC_EGREP_CPP(yes, [dnl
1101 #include <sys/param.h>
1102 #ifdef _ZETA_MINAMI_INET6
1103 yes
1104 #endif],
1105                                 [ipv6type=$i;
1106                                 ipv6lib=inet6;
1107                                 ipv6libdir=/usr/local/v6/lib;
1108                                 OPT="-DINET6 $OPT"])
1109                         ;;
1110                 esac
1111                 if test "$ipv6type" != "unknown"; then
1112                         break
1113                 fi
1114         done
1115         AC_MSG_RESULT($ipv6type)
1116 fi
1117
1118 if test "$ipv6" = "yes" -a "$ipv6lib" != "none"; then
1119         if test -d $ipv6libdir -a -f $ipv6libdir/lib$ipv6lib.a; then
1120                 LIBS="-L$ipv6libdir -l$ipv6lib $LIBS"
1121                 echo "using lib$ipv6lib"
1122         else
1123                 if test $ipv6trylibc = "yes"; then
1124                         echo "using libc"
1125                 else
1126                         echo 'Fatal: no $ipv6lib library found.  cannot continue.'
1127                         echo "You need to fetch lib$ipv6lib.a from appropriate"
1128                         echo 'ipv6 kit and compile beforehand.'
1129                         exit 1
1130                 fi
1131         fi
1132 fi
1133
1134 # Check for GC support
1135 AC_MSG_CHECKING(for --with-cycle-gc)
1136 AC_ARG_WITH(cycle-gc,
1137 [  --with(out)-cycle-gc            disable/enable garbage collection])
1138
1139 if test -z "$with_cycle_gc"
1140 then with_cycle_gc="yes"
1141 fi
1142 if test "$with_cycle_gc" != "no"
1143 then
1144     AC_DEFINE(WITH_CYCLE_GC)
1145 fi
1146 AC_MSG_RESULT($with_cycle_gc)
1147
1148 # Check for Python-specific malloc support
1149 AC_MSG_CHECKING(for --with-pymalloc)
1150 AC_ARG_WITH(pymalloc,
1151 [  --with(out)-pymalloc            disable/enable specialized mallocs], [
1152 if test "$withval" != no
1153 then AC_DEFINE(WITH_PYMALLOC) AC_MSG_RESULT(yes)
1154 else AC_MSG_RESULT(no)
1155 fi],
1156 [AC_MSG_RESULT(no)])
1157
1158 # Check for --with-wctype-functions
1159 AC_MSG_CHECKING(for --with-wctype-functions)
1160 AC_ARG_WITH(wctype-functions,
1161 [  --with-wctype-functions         use wctype.h functions], [
1162 if test "$withval" != no
1163 then AC_DEFINE(WANT_WCTYPE_FUNCTIONS) AC_MSG_RESULT(yes)
1164 else AC_MSG_RESULT(no)
1165 fi],
1166 [AC_MSG_RESULT(no)])
1167
1168 # -I${DLINCLDIR} is added to the compile rule for importdl.o
1169 AC_SUBST(DLINCLDIR)
1170 DLINCLDIR=.
1171
1172 AC_MSG_CHECKING(for --with-sgi-dl)
1173 AC_ARG_WITH(sgi-dl,
1174 [  --with-sgi-dl=DIRECTORY         IRIX 4 dynamic linking], [
1175 AC_MSG_RESULT($withval)
1176 AC_DEFINE(WITH_SGI_DL)
1177 DYNLOADFILE="dynload_dl.o"
1178 dldir=$withval
1179 if test ! -z "$dldir" -a -d "$dldir"
1180 then LDFLAGS="$LDFLAGS -L$dldir"
1181 else AC_ERROR(proper usage is --with-sgi-dl=DIRECTORY)
1182 fi
1183 DLINCLDIR=${dldir}
1184 LIBS="$LIBS -ldl -lmld"], AC_MSG_RESULT(no))
1185
1186 AC_MSG_CHECKING(for --with-dl-dld)
1187 AC_ARG_WITH(dl-dld, [  --with-dl-dld=DL_DIR,DLD_DIR    GNU dynamic linking], [
1188 AC_MSG_RESULT($withval)
1189 AC_DEFINE(WITH_DL_DLD)
1190 DYNLOADFILE="dynload_dl.o"
1191 dldir=`echo "$withval" | sed 's/,.*//'`
1192 dlddir=`echo "$withval" | sed 's/.*,//'`
1193 if test ! -z "$dldir" -a -d "$dldir" -a ! -z "$dlddir" -a -d "$dlddir"
1194 then LDFLAGS="$LDFLAGS -L$dldir -L$dlddir"
1195 else AC_ERROR(proper usage is --with-dl-dld=DL_DIRECTORY,DLD_DIRECTORY)
1196 fi
1197 DLINCLDIR=${dldir}
1198 LIBS="$LIBS -ldl -ldld"], AC_MSG_RESULT(no))
1199
1200 # the dlopen() function means we might want to use dynload_shlib.o. some
1201 # platforms, such as AIX, have dlopen(), but don't want to use it.
1202 AC_CHECK_FUNCS(dlopen)
1203
1204 # DYNLOADFILE specifies which dynload_*.o file we will use for dynamic
1205 # loading of modules.
1206 AC_SUBST(DYNLOADFILE)
1207 AC_MSG_CHECKING(DYNLOADFILE)
1208 if test -z "$DYNLOADFILE"
1209 then
1210         case $ac_sys_system/$ac_sys_release in
1211         AIX*) DYNLOADFILE="dynload_aix.o";;
1212         BeOS*) DYNLOADFILE="dynload_beos.o";;
1213         hp*|HP*) DYNLOADFILE="dynload_hpux.o";;
1214         Darwin/*) DYNLOADFILE="dynload_next.o";;
1215         *)
1216         # use dynload_shlib.c and dlopen() if we have it; otherwise stub
1217         # out any dynamic loading
1218         if test "$ac_cv_func_dlopen" = yes
1219         then DYNLOADFILE="dynload_shlib.o"
1220         else DYNLOADFILE="dynload_stub.o"
1221         fi
1222         ;;
1223         esac
1224 fi
1225 AC_MSG_RESULT($DYNLOADFILE)
1226 if test "$DYNLOADFILE" != "dynload_stub.o"
1227 then
1228         AC_DEFINE(HAVE_DYNAMIC_LOADING)
1229 fi
1230
1231 # MACHDEP_OBJS can be set to platform-specific object files needed by Python
1232
1233 AC_SUBST(MACHDEP_OBJS)
1234 AC_MSG_CHECKING(MACHDEP_OBJS)
1235 if test -z "$MACHDEP_OBJS"
1236 then
1237         MACHDEP_OBJS=$extra_machdep_objs
1238 else
1239         MACHDEP_OBJS="$MACHDEP_OBJS $extra_machdep_objs"
1240 fi
1241 AC_MSG_RESULT(MACHDEP_OBJS)
1242
1243 # checks for library functions
1244 AC_CHECK_FUNCS(alarm chown clock confstr ctermid ctermid_r execv \
1245  flock fork fsync fdatasync fpathconf ftime ftruncate \
1246  gai_strerror getgroups getlogin getpeername getpid getpwent getwd \
1247  hstrerror inet_pton kill link lstat mkfifo mktime mremap \
1248  nice pathconf pause plock poll pthread_init \
1249  putenv readlink \
1250  select setegid seteuid setgid \
1251  setlocale setregid setreuid setsid setpgid setuid setvbuf snprintf \
1252  sigaction siginterrupt sigrelse strftime strptime symlink sysconf \
1253  tcgetpgrp tcsetpgrp tempnam timegm times tmpfile tmpnam tmpnam_r \
1254  truncate uname waitpid _getpty getpriority)
1255
1256 # check for openpty and forkpty
1257
1258 AC_CHECK_FUNCS(openpty,, AC_CHECK_LIB(util,openpty, [AC_DEFINE(HAVE_OPENPTY)] [LIBS="$LIBS -lutil"]))
1259 AC_CHECK_FUNCS(forkpty,, AC_CHECK_LIB(util,forkpty, [AC_DEFINE(HAVE_FORKPTY)] [LIBS="$LIBS -lutil"]))
1260
1261 # Try defining symbols to enable large file support.
1262 # The particular combination of symbols used here is known to work
1263 # on Linux and Solaris [2.]7.
1264 AC_MSG_CHECKING(for CFLAGS to enable large files)
1265 OLD_CFLAGS="$CFLAGS"
1266 CFLAGS="$CFLAGS -D_LARGEFILE_SOURCE -D_FILE_OFFSET_BITS=64"
1267 AC_TRY_RUN([
1268 #include <sys/types.h>
1269 #include <stdio.h>
1270 main() {
1271         FILE *fp;
1272         off_t seek = 0x80000000ul;
1273         off_t tell = 0;
1274         fp = fopen("conftestval", "wb");
1275         if (fp == NULL) {
1276                 perror("conftestval");
1277                 exit(1);
1278         }
1279         if (fseeko(fp, seek, 0) < 0)
1280                 perror("fseeko");
1281         else
1282                 tell = ftello(fp);
1283         fclose(fp);
1284         unlink("conftestval");
1285         if (tell == seek) {
1286                 fprintf(stderr, "seek to 2**31 worked\n");
1287                 exit(0);
1288         }
1289         else {
1290                 exit(1);
1291                 fprintf(stderr, "seek to 2**31 didn't work\n");
1292         }
1293 }
1294 ],
1295 AC_MSG_RESULT(yes)
1296 AC_DEFINE(_LARGEFILE_SOURCE)
1297 AC_DEFINE(_FILE_OFFSET_BITS,64),
1298 AC_MSG_RESULT(no),
1299 AC_MSG_RESULT(no (cross-compiling)))
1300 CFLAGS="$OLD_CFLAGS"
1301
1302 # check for long file support functions
1303 AC_CHECK_FUNCS(fseek64 fseeko fstatvfs ftell64 ftello statvfs)
1304
1305 AC_REPLACE_FUNCS(dup2 getcwd strdup strerror memmove)
1306 AC_CHECK_FUNCS(getpgrp, AC_TRY_COMPILE([#include <unistd.h>], [getpgrp(0);], AC_DEFINE(GETPGRP_HAVE_ARG)))
1307 AC_CHECK_FUNCS(setpgrp, AC_TRY_COMPILE([#include <unistd.h>], [setpgrp(0,0);], AC_DEFINE(SETPGRP_HAVE_ARG)))
1308 AC_CHECK_FUNCS(gettimeofday, AC_TRY_COMPILE([#include <sys/time.h>], [gettimeofday((struct timeval*)0,(struct timezone*)0);], ,AC_DEFINE(GETTIMEOFDAY_NO_TZ)))
1309
1310 AC_CHECK_FUNCS(getaddrinfo, [dnl
1311 AC_MSG_CHECKING(getaddrinfo bug)
1312 AC_TRY_RUN([
1313 #include <sys/types.h>
1314 #include <netdb.h>
1315 #include <string.h>
1316 #include <sys/socket.h>
1317 #include <netinet/in.h>
1318
1319 main()
1320 {
1321   int passive, gaierr, inet4 = 0, inet6 = 0;
1322   struct addrinfo hints, *ai, *aitop;
1323   char straddr[INET6_ADDRSTRLEN], strport[16];
1324
1325   for (passive = 0; passive <= 1; passive++) {
1326     memset(&hints, 0, sizeof(hints));
1327     hints.ai_family = AF_UNSPEC;
1328     hints.ai_flags = passive ? AI_PASSIVE : 0;
1329     hints.ai_socktype = SOCK_STREAM;
1330     if ((gaierr = getaddrinfo(NULL, "54321", &hints, &aitop)) != 0) {
1331       (void)gai_strerror(gaierr);
1332       goto bad;
1333     }
1334     for (ai = aitop; ai; ai = ai->ai_next) {
1335       if (ai->ai_addr == NULL ||
1336           ai->ai_addrlen == 0 ||
1337           getnameinfo(ai->ai_addr, ai->ai_addrlen,
1338                       straddr, sizeof(straddr), strport, sizeof(strport),
1339                       NI_NUMERICHOST|NI_NUMERICSERV) != 0) {
1340         goto bad;
1341       }
1342       switch (ai->ai_family) {
1343       case AF_INET:
1344         if (strcmp(strport, "54321") != 0) {
1345           goto bad;
1346         }
1347         if (passive) {
1348           if (strcmp(straddr, "0.0.0.0") != 0) {
1349             goto bad;
1350           }
1351         } else {
1352           if (strcmp(straddr, "127.0.0.1") != 0) {
1353             goto bad;
1354           }
1355         }
1356         inet4++;
1357         break;
1358       case AF_INET6:
1359         if (strcmp(strport, "54321") != 0) {
1360           goto bad;
1361         }
1362         if (passive) {
1363           if (strcmp(straddr, "::") != 0) {
1364             goto bad;
1365           }
1366         } else {
1367           if (strcmp(straddr, "::1") != 0) {
1368             goto bad;
1369           }
1370         }
1371         inet6++;
1372         break;
1373       case AF_UNSPEC:
1374         goto bad;
1375         break;
1376       default:
1377         /* another family support? */
1378         break;
1379       }
1380     }
1381   }
1382
1383   if (!(inet4 == 0 || inet4 == 2))
1384     goto bad;
1385   if (!(inet6 == 0 || inet6 == 2))
1386     goto bad;
1387
1388   if (aitop)
1389     freeaddrinfo(aitop);
1390   exit(0);
1391
1392  bad:
1393   if (aitop)
1394     freeaddrinfo(aitop);
1395   exit(1);
1396 }
1397 ],
1398 AC_MSG_RESULT(good)
1399 buggygetaddrinfo=no,
1400 AC_MSG_RESULT(buggy)
1401 buggygetaddrinfo=yes,
1402 AC_MSG_RESULT(buggy)
1403 buggygetaddrinfo=yes)], [buggygetaddrinfo=yes])
1404
1405 if test "$buggygetaddrinfo" = "yes"; then
1406         if test "$ipv6" = "yes"; then
1407                 echo 'Fatal: You must get working getaddrinfo() function.'
1408                 echo '       or you can specify "--disable-ipv6"'.
1409                 exit 1
1410         fi
1411 fi
1412 AC_CHECK_FUNCS(getnameinfo)
1413
1414 # checks for structures
1415 AC_HEADER_TIME
1416 AC_STRUCT_TM
1417 AC_STRUCT_TIMEZONE
1418
1419 AC_MSG_CHECKING(for time.h that defines altzone)
1420 AC_CACHE_VAL(ac_cv_header_time_altzone,
1421 [AC_TRY_COMPILE([#include <time.h>], [return altzone;],
1422   ac_cv_header_time_altzone=yes,
1423   ac_cv_header_time_altzone=no)])
1424 AC_MSG_RESULT($ac_cv_header_time_altzone)
1425 if test $ac_cv_header_time_altzone = yes; then
1426   AC_DEFINE(HAVE_ALTZONE)
1427 fi
1428
1429 was_it_defined=no
1430 AC_MSG_CHECKING(whether sys/select.h and sys/time.h may both be included)
1431 AC_TRY_COMPILE([
1432 #include <sys/types.h>
1433 #include <sys/select.h>
1434 #include <sys/time.h>
1435 ], [;], [AC_DEFINE(SYS_SELECT_WITH_SYS_TIME) was_it_defined=yes])
1436 AC_MSG_RESULT($was_it_defined)
1437
1438 AC_MSG_CHECKING(for addrinfo)
1439 AC_CACHE_VAL(ac_cv_struct_addrinfo,
1440 AC_TRY_COMPILE([
1441 #               include <netdb.h>],
1442         [struct addrinfo a],
1443         ac_cv_struct_addrinfo=yes,
1444         ac_cv_struct_addrinfo=no))
1445 AC_MSG_RESULT($ac_cv_struct_addrinfo)
1446 if test $ac_cv_struct_addrinfo = yes; then
1447         AC_DEFINE(HAVE_ADDRINFO)
1448 fi
1449
1450 AC_MSG_CHECKING(for sockaddr_storage)
1451 AC_CACHE_VAL(ac_cv_struct_sockaddr_storage,
1452 AC_TRY_COMPILE([
1453 #               include <sys/types.h>
1454 #               include <sys/socket.h>],
1455         [struct sockaddr_storage s],
1456         ac_cv_struct_sockaddr_storage=yes,
1457         ac_cv_struct_sockaddr_storage=no))
1458 AC_MSG_RESULT($ac_cv_struct_sockaddr_storage)
1459 if test $ac_cv_struct_sockaddr_storage = yes; then
1460         AC_DEFINE(HAVE_SOCKADDR_STORAGE)
1461 fi
1462
1463 # checks for compiler characteristics
1464
1465 AC_C_CHAR_UNSIGNED
1466 AC_C_CONST
1467
1468 works=no
1469 AC_MSG_CHECKING(for working volatile)
1470 AC_TRY_COMPILE([],[volatile int x; x = 0;], works=yes, AC_DEFINE(volatile, []))
1471 AC_MSG_RESULT($works)
1472
1473 works=no
1474 AC_MSG_CHECKING(for working signed char)
1475 AC_TRY_COMPILE([], [signed char c;], works=yes, AC_DEFINE(signed, []))
1476 AC_MSG_RESULT($works)
1477
1478 have_prototypes=no
1479 AC_MSG_CHECKING(for prototypes)
1480 AC_TRY_COMPILE([int foo(int x) { return 0; }], [return foo(10);],
1481 AC_DEFINE(HAVE_PROTOTYPES) have_prototypes=yes)
1482 AC_MSG_RESULT($have_prototypes)
1483
1484 works=no
1485 AC_MSG_CHECKING(for variable length prototypes and stdarg.h)
1486 AC_TRY_COMPILE([
1487 #include <stdarg.h>
1488 int foo(int x, ...) {
1489         va_list va;
1490         va_start(va, x);
1491         va_arg(va, int);
1492         va_arg(va, char *);
1493         va_arg(va, double);
1494         return 0;
1495 }
1496 ], [return foo(10, "", 3.14);],
1497 AC_DEFINE(HAVE_STDARG_PROTOTYPES) works=yes)
1498 AC_MSG_RESULT($works)
1499
1500 if test "$have_prototypes" = yes; then
1501 bad_prototypes=no
1502 AC_MSG_CHECKING(for bad exec* prototypes)
1503 AC_TRY_COMPILE([#include <unistd.h>], [char **t;execve("@",t,t);], ,
1504         AC_DEFINE(BAD_EXEC_PROTOTYPES) bad_prototypes=yes)
1505 AC_MSG_RESULT($bad_prototypes)
1506 fi
1507
1508 # check if sockaddr has sa_len member
1509 AC_MSG_CHECKING(if sockaddr has sa_len member)
1510 AC_TRY_COMPILE([#include <sys/types.h>
1511 #include <sys/socket.h>],
1512 [struct sockaddr x;
1513 x.sa_len = 0;],
1514         AC_MSG_RESULT(yes)
1515         AC_DEFINE(HAVE_SOCKADDR_SA_LEN),
1516         AC_MSG_RESULT(no))
1517
1518 AC_MSG_CHECKING(for bad static forward)
1519 AC_CACHE_VAL(ac_cv_bad_static_forward,
1520 [AC_TRY_RUN([
1521 struct s { int a; int b; };
1522 static struct s foo;
1523 int foobar() {
1524  static int random;
1525  random = (int) &foo;
1526  return random;
1527 }
1528 static struct s foo = { 1, 2 };
1529 main() {
1530  exit(!((int)&foo == foobar()));
1531 }], ac_cv_bad_static_forward=no, ac_cv_bad_static_forward=yes)])
1532 AC_MSG_RESULT($ac_cv_bad_static_forward)
1533 if test "$ac_cv_bad_static_forward" = yes
1534 then
1535     AC_DEFINE(BAD_STATIC_FORWARD)
1536 fi
1537
1538 va_list_is_array=no
1539 AC_MSG_CHECKING(whether va_list is an array)
1540 AC_TRY_COMPILE([
1541 #ifdef HAVE_STDARG_PROTOTYPES
1542 #include <stdarg.h>
1543 #else
1544 #include <varargs.h>
1545 #endif
1546 ], [va_list list1, list2; list1 = list2;], ,
1547 AC_DEFINE(VA_LIST_IS_ARRAY) va_list_is_array=yes)
1548 AC_MSG_RESULT($va_list_is_array)
1549
1550 # sigh -- gethostbyname_r is a mess; it can have 3, 5 or 6 arguments :-(
1551 AC_CHECK_FUNC(gethostbyname_r, [
1552   AC_DEFINE(HAVE_GETHOSTBYNAME_R)
1553   AC_MSG_CHECKING([gethostbyname_r with 6 args])
1554   OLD_CFLAGS=$CFLAGS
1555   CFLAGS="$CFLAGS $MY_CPPFLAGS $MY_THREAD_CPPFLAGS $MY_CFLAGS"
1556   AC_TRY_COMPILE([
1557 #   include <netdb.h>
1558   ], [
1559     char *name;
1560     struct hostent *he, *res;
1561     char buffer[2048];
1562     int buflen = 2048;
1563     int h_errnop;
1564
1565     (void) gethostbyname_r(name, he, buffer, buflen, &res, &h_errnop)
1566   ], [
1567     AC_DEFINE(HAVE_GETHOSTBYNAME_R)
1568     AC_DEFINE(HAVE_GETHOSTBYNAME_R_6_ARG)
1569     AC_MSG_RESULT(yes)
1570   ], [
1571     AC_MSG_RESULT(no)
1572     AC_MSG_CHECKING([gethostbyname_r with 5 args])
1573     AC_TRY_COMPILE([
1574 #     include <netdb.h>
1575     ], [
1576       char *name;
1577       struct hostent *he;
1578       char buffer[2048];
1579       int buflen = 2048;
1580       int h_errnop;
1581
1582       (void) gethostbyname_r(name, he, buffer, buflen, &h_errnop)
1583     ], [
1584       AC_DEFINE(HAVE_GETHOSTBYNAME_R)
1585       AC_DEFINE(HAVE_GETHOSTBYNAME_R_5_ARG)
1586       AC_MSG_RESULT(yes)
1587     ], [
1588       AC_MSG_RESULT(no)
1589       AC_MSG_CHECKING([gethostbyname_r with 3 args])
1590       AC_TRY_COMPILE([
1591 #       include <netdb.h>
1592       ], [
1593         char *name;
1594         struct hostent *he;
1595         struct hostent_data data;
1596
1597         (void) gethostbyname_r(name, he, &data);
1598       ], [
1599         AC_DEFINE(HAVE_GETHOSTBYNAME_R)
1600         AC_DEFINE(HAVE_GETHOSTBYNAME_R_3_ARG)
1601         AC_MSG_RESULT(yes)
1602       ], [
1603         AC_MSG_RESULT(no)
1604       ])
1605     ])
1606   ])
1607   CFLAGS=$OLD_CFLAGS
1608 ], [
1609   AC_CHECK_FUNCS(gethostbyname)
1610 ])
1611 AC_SUBST(HAVE_GETHOSTBYNAME_R_6_ARG)
1612 AC_SUBST(HAVE_GETHOSTBYNAME_R_5_ARG)
1613 AC_SUBST(HAVE_GETHOSTBYNAME_R_3_ARG)
1614 AC_SUBST(HAVE_GETHOSTBYNAME_R)
1615 AC_SUBST(HAVE_GETHOSTBYNAME)
1616
1617 # checks for system services
1618 # (none yet)
1619
1620 # Linux requires this for correct f.p. operations
1621 AC_CHECK_FUNC(__fpu_control,
1622   [],
1623   [AC_CHECK_LIB(ieee, __fpu_control)
1624 ])
1625
1626 # Check for --with-fpectl
1627 AC_MSG_CHECKING(for --with-fpectl)
1628 AC_ARG_WITH(fpectl,
1629 [  --with-fpectl                   enable SIGFPE catching], [
1630 if test "$withval" != no
1631 then AC_DEFINE(WANT_SIGFPE_HANDLER) AC_MSG_RESULT(yes)
1632 else AC_MSG_RESULT(no)
1633 fi],
1634 [AC_MSG_RESULT(no)])
1635
1636 # check for --with-libm=...
1637 AC_SUBST(LIBM)
1638 case $ac_sys_system in
1639 Darwin) ;;
1640 BeOS) ;;
1641 *) LIBM=-lm
1642 esac
1643 AC_MSG_CHECKING(for --with-libm=STRING)
1644 AC_ARG_WITH(libm, [  --with-libm=STRING              math library], [
1645 if test "$withval" = no
1646 then LIBM=
1647      AC_MSG_RESULT(force LIBM empty)
1648 elif test "$withval" != yes
1649 then LIBM=$withval
1650      AC_MSG_RESULT(set LIBM=\"$withval\")
1651 else AC_ERROR(proper usage is --with-libm=STRING)
1652 fi],
1653 [AC_MSG_RESULT(default LIBM=\"$LIBM\")])
1654
1655 # check for --with-libc=...
1656 AC_SUBST(LIBC)
1657 AC_MSG_CHECKING(for --with-libc=STRING)
1658 AC_ARG_WITH(libc, [  --with-libc=STRING              C library], [
1659 if test "$withval" = no
1660 then LIBC=
1661      AC_MSG_RESULT(force LIBC empty)
1662 elif test "$withval" != yes
1663 then LIBC=$withval
1664      AC_MSG_RESULT(set LIBC=\"$withval\")
1665 else AC_ERROR(proper usage is --with-libc=STRING)
1666 fi],
1667 [AC_MSG_RESULT(default LIBC=\"$LIBC\")])
1668
1669 # check for hypot() in math library
1670 LIBS_SAVE=$LIBS
1671 LIBS="$LIBS $LIBM"
1672 AC_REPLACE_FUNCS(hypot)
1673 LIBS=$LIBS_SAVE
1674
1675 # check whether malloc(0) returns NULL or not
1676 AC_MSG_CHECKING(what malloc(0) returns)
1677 AC_CACHE_VAL(ac_cv_malloc_zero,
1678 [AC_TRY_RUN([#include <stdio.h>
1679 #ifdef HAVE_STDLIB
1680 #include <stdlib.h>
1681 #else
1682 char *malloc(), *realloc();
1683 int *free();
1684 #endif
1685 main() {
1686         char *p;
1687         p = malloc(0);
1688         if (p == NULL) exit(1);
1689         p = realloc(p, 0);
1690         if (p == NULL) exit(1);
1691         free(p);
1692         exit(0);
1693 }], ac_cv_malloc_zero=nonnull, ac_cv_malloc_zero=null)])
1694 AC_MSG_RESULT($ac_cv_malloc_zero)
1695 if test "$ac_cv_malloc_zero" = null
1696 then
1697   AC_DEFINE(MALLOC_ZERO_RETURNS_NULL)
1698 fi
1699
1700 # check for wchar.h
1701 AC_CHECK_HEADER(wchar.h,
1702 AC_DEFINE(HAVE_WCHAR_H) wchar_h="yes",
1703 wchar_h="no"
1704 )
1705
1706 # determine wchar_t size
1707 if test "$wchar_h" = yes
1708 then
1709   AC_CHECK_SIZEOF(wchar_t)
1710 fi
1711
1712 AC_MSG_CHECKING(what type to use for unicode)
1713 AC_ARG_ENABLE(unicode,
1714 [  --enable-unicode[=ucs2,ucs4]    Enable Unicode strings (default is yes)],,enable_unicode=yes)
1715
1716 if test $enable_unicode = yes
1717 then
1718   # Without any arguments, Py_UNICODE defaults to two-byte mode
1719   enable_unicode="ucs2"
1720 fi
1721
1722 case "$enable_unicode" in
1723 ucs2) unicode_size="2"
1724       AC_DEFINE(Py_UNICODE_SIZE,2)
1725       ;;
1726 ucs4) unicode_size="4"
1727       AC_DEFINE(Py_UNICODE_SIZE,4)
1728       ;;
1729 esac
1730
1731 AC_SUBST(UNICODE_OBJS)
1732 if test "$enable_unicode" = "no"
1733 then
1734   UNICODE_OBJS=""
1735   AC_MSG_RESULT(not used)
1736 else
1737   UNICODE_OBJS="Objects/unicodeobject.o Objects/unicodectype.o"
1738   AC_DEFINE(Py_USING_UNICODE)
1739   if test "$unicode_size" = "$ac_cv_sizeof_wchar_t"
1740   then
1741     PY_UNICODE_TYPE="wchar_t"
1742     AC_DEFINE(HAVE_USABLE_WCHAR_T)
1743     AC_DEFINE(PY_UNICODE_TYPE,wchar_t)
1744   elif test "$ac_cv_sizeof_short" = "$unicode_size"
1745   then
1746        PY_UNICODE_TYPE="unsigned short"
1747        AC_DEFINE(PY_UNICODE_TYPE,unsigned short)
1748   elif test "$ac_cv_sizeof_long" = "$unicode_size"
1749   then
1750        PY_UNICODE_TYPE="unsigned long"
1751        AC_DEFINE(PY_UNICODE_TYPE,unsigned long)
1752   else
1753        PY_UNICODE_TYPE="no type found"
1754   fi
1755   AC_MSG_RESULT($PY_UNICODE_TYPE)
1756 fi
1757
1758 # check for endianness
1759 AC_C_BIGENDIAN
1760
1761 # Check whether right shifting a negative integer extends the sign bit
1762 # or fills with zeros (like the Cray J90, according to Tim Peters).
1763 AC_MSG_CHECKING(whether right shift extends the sign bit)
1764 AC_CACHE_VAL(ac_cv_rshift_extends_sign, [
1765 AC_TRY_RUN([
1766 int main()
1767 {
1768         exit(((-1)>>3 == -1) ? 0 : 1);
1769 }
1770 ], ac_cv_rshift_extends_sign=yes, ac_cv_rshift_extends_sign=no)])
1771 AC_MSG_RESULT($ac_cv_rshift_extends_sign)
1772 if test "$ac_cv_rshift_extends_sign" = no
1773 then
1774   AC_DEFINE(SIGNED_RIGHT_SHIFT_ZERO_FILLS)
1775 fi
1776
1777 # check for getc_unlocked and related locking functions
1778 AC_MSG_CHECKING(for getc_unlocked() and friends)
1779 AC_CACHE_VAL(ac_cv_have_getc_unlocked, [
1780 AC_TRY_LINK([#include <stdio.h>],[
1781         FILE *f = fopen("/dev/null", "r");
1782         flockfile(f);
1783         getc_unlocked(f);
1784         funlockfile(f);
1785 ], ac_cv_have_getc_unlocked=yes, ac_cv_have_getc_unlocked=no)])
1786 AC_MSG_RESULT($ac_cv_have_getc_unlocked)
1787 if test "$ac_cv_have_getc_unlocked" = yes
1788 then
1789   AC_DEFINE(HAVE_GETC_UNLOCKED)
1790 fi
1791
1792 # check for readline 4.2
1793 AC_CHECK_LIB(readline, rl_completion_matches,
1794         AC_DEFINE(HAVE_RL_COMPLETION_MATCHES), , -ltermcap)
1795
1796 AC_MSG_CHECKING(for broken nice())
1797 AC_CACHE_VAL(ac_cv_broken_nice, [
1798 AC_TRY_RUN([
1799 int main()
1800 {
1801         int val1 = nice(1);
1802         if (val1 != -1 && val1 == nice(2))
1803                 exit(0);
1804         exit(1);
1805 }
1806 ],ac_cv_broken_nice=yes, ac_cv_broken_nice=no)])
1807 AC_MSG_RESULT($ac_cv_broken_nice)
1808 if test "$ac_cv_broken_nice" = yes
1809 then
1810   AC_DEFINE(HAVE_BROKEN_NICE)
1811 fi
1812
1813 # THIS MUST BE LAST, IT CAN BREAK OTHER TESTS!
1814 # Add sys/socket.h to confdefs.h
1815 cat >> confdefs.h <<\EOF
1816 #ifdef HAVE_SYS_SOCKET_H
1817 #include <sys/socket.h>
1818 #endif
1819 EOF
1820 AC_CHECK_TYPE(socklen_t, int)
1821
1822 # Add Python/ prefix to LIBOBJS
1823 libobjs=$LIBOBJS
1824 LIBOBJS=
1825 for obj in $libobjs; do
1826     LIBOBJS="$LIBOBJS Python/$obj"
1827 done
1828
1829 #AC_MSG_CHECKING(for Modules/Setup)
1830 #if test ! -f Modules/Setup ; then
1831 #    if test ! -d Modules ; then
1832 #        mkdir Modules
1833 #    fi
1834 #    cp "$srcdir/Modules/Setup.dist" Modules/Setup
1835 #    AC_MSG_RESULT(creating)
1836 #else
1837 #    AC_MSG_RESULT(already exists)
1838 #fi
1839
1840 AC_SUBST(SRCDIRS)
1841 SRCDIRS="Parser Grammar Objects Python Modules"
1842 AC_MSG_CHECKING(for build directories)
1843 for dir in $SRCDIRS; do
1844     if test ! -d $dir; then
1845         mkdir $dir
1846     fi
1847 done
1848 AC_MSG_RESULT(done)
1849
1850 # generate output files
1851 AC_OUTPUT(Makefile.pre Modules/Setup.config)
1852
1853 echo "creating Setup"
1854 if test ! -f Modules/Setup
1855 then
1856         cp $srcdir/Modules/Setup.dist Modules/Setup
1857 fi
1858
1859 echo "creating Setup.local"
1860 if test ! -f Modules/Setup.local
1861 then
1862         echo "# Edit this file for local setup changes" >Modules/Setup.local
1863 fi
1864
1865 echo "creating Makefile"
1866 $SHELL $srcdir/Modules/makesetup -c $srcdir/Modules/config.c.in \
1867                         -s Modules Modules/Setup.config \
1868                         Modules/Setup.local Modules/Setup
1869 mv config.c Modules