configure.in 50.4 KB
Newer Older
1 2 3
dnl Process this file with autoconf 2.0 or later to make a configure script.
AC_REVISION($Revision$)
AC_PREREQ(2.0)
Guido van Rossum's avatar
Guido van Rossum committed
4
AC_INIT(Include/object.h)
5
AC_CONFIG_HEADER(pyconfig.h)
Guido van Rossum's avatar
Guido van Rossum committed
6

7 8
# Set VERSION so we only need to edit in one place (i.e., here)
AC_SUBST(VERSION)
9
VERSION=2.2
10

11 12 13 14
# Arguments passed to configure.
AC_SUBST(CONFIG_ARGS)
CONFIG_ARGS="$ac_configure_args"

15

16 17 18 19 20
AC_ARG_ENABLE(framework,
[  --enable-framework[=INSTALLDIR] Build (MacOSX|Darwin) framework],[
	case $enableval in
	yes) 
		enableval=/Library/Frameworks
21 22 23 24 25 26 27 28
	esac
	case $enableval in
	no)
		PYTHONFRAMEWORK=
		PYTHONFRAMEWORKDIR=no-framework
		PYTHONFRAMEWORKPREFIX=
		PYTHONFRAMEWORKINSTALLDIR=
		enable_framework=
29 30
		;;
	*)
31 32
		PYTHONFRAMEWORK=Python
		PYTHONFRAMEWORKDIR=Python.framework
33
		PYTHONFRAMEWORKPREFIX=$enableval
34 35
		PYTHONFRAMEWORKINSTALLDIR=$PYTHONFRAMEWORKPREFIX/$PYTHONFRAMEWORKDIR
		prefix=$PYTHONFRAMEWORKINSTALLDIR/Versions/$VERSION
36 37 38
	esac
	],[
	PYTHONFRAMEWORK=
39
	PYTHONFRAMEWORKDIR=no-framework
40 41 42 43 44 45 46 47 48 49 50 51
	PYTHONFRAMEWORKPREFIX=
	PYTHONFRAMEWORKINSTALLDIR=
	enable_framework=
])
AC_SUBST(PYTHONFRAMEWORK)
AC_SUBST(PYTHONFRAMEWORKDIR)
AC_SUBST(PYTHONFRAMEWORKPREFIX)
AC_SUBST(PYTHONFRAMEWORKINSTALLDIR)

##AC_ARG_WITH(dyld,
##[  --with-dyld                     Use (OpenStep|Rhapsody) dynamic linker],,)
##
52 53 54 55 56
# Set name for machine-dependent library files
AC_SUBST(MACHDEP)
AC_MSG_CHECKING(MACHDEP)
if test -z "$MACHDEP"
then
57
	ac_sys_system=`uname -s`
58
	if test "$ac_sys_system" = "AIX" -o "$ac_sys_system" = "Monterey64"; then
59
		ac_sys_release=`uname -v`
60
	else
61
		ac_sys_release=`uname -r`
62
	fi
63 64 65 66
	ac_md_system=`echo $ac_sys_system |
			   tr -d '[/ ]' | tr '[[A-Z]]' '[[a-z]]'`
	ac_md_release=`echo $ac_sys_release |
			   tr -d '[/ ]' | sed 's/\..*//'`
67
	MACHDEP="$ac_md_system$ac_md_release"
68

69
	case $MACHDEP in
70
	cygwin*) MACHDEP="cygwin";;
71
	'')	MACHDEP="unknown";;
72 73
	esac
fi
74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90

#
# SGI compilers allow the specification of the both the ABI and the
# ISA on the command line.  Depending on the values of these switches,
# different and often incompatable code will be generated.
#
# The SGI_ABI variable can be used to modify the CC and LDFLAGS and
# thus supply support for various ABI/ISA combinations.  The MACHDEP
# variable is also adjusted.
#
AC_SUBST(SGI_ABI)
if test ! -z "$SGI_ABI"
then
        CC="cc $SGI_ABI"
        LDFLAGS="$SGI_ABI $LDFLAGS"
        MACHDEP=`echo "${MACHDEP}${SGI_ABI}" | sed 's/ *//g'`
fi
91 92
AC_MSG_RESULT($MACHDEP)

Guido van Rossum's avatar
Guido van Rossum committed
93
# checks for alternative programs
94
AC_MSG_CHECKING(for --without-gcc)
95
AC_ARG_WITH(gcc, [  --without-gcc                   never use gcc], [
96
	case $withval in
97 98 99 100 101 102
	no)	CC=cc
		without_gcc=yes;;
	yes)	CC=gcc
		without_gcc=no;;
	*)	CC=$withval
		without_gcc=$withval;;
103
	esac], [
104
	case $ac_sys_system in
105 106
	AIX*)   CC=cc_r
		without_gcc=;;
107 108 109
	BeOS*)
		case $BE_HOST_CPU in
		ppc)
Fred Drake's avatar
Fred Drake committed
110
			CC=mwcc
111
			without_gcc=yes
Fred Drake's avatar
Fred Drake committed
112
			OPT="-O -D'DL_EXPORT(RTYPE)=__declspec(dllexport) RTYPE' -D'DL_IMPORT(RTYPE)=__declspec(dllexport) RTYPE' -export pragma"
113
			CCSHARED="-UDL_IMPORT -D'DL_IMPORT(RTYPE)=__declspec(dllimport) RTYPE'"
114 115 116
			LDFLAGS="$LDFLAGS -nodup"
			;;
		x86)
Fred Drake's avatar
Fred Drake committed
117
			CC=gcc
118
			without_gcc=no
Fred Drake's avatar
Fred Drake committed
119
			OPT=-O
120 121
			;;
		*)
Fred Drake's avatar
Fred Drake committed
122
			AC_ERROR(Unknown BeOS platform \"$BE_HOST_CPU\")
123 124
			;;
		esac
125 126
		AR="\$(srcdir)/Modules/ar_beos"
		RANLIB=:
127
		;;
128 129
    Monterey*)
        RANLIB=:
130 131
        without_gcc=;;
	*)	without_gcc=no;;
132
	esac])
133 134
AC_MSG_RESULT($without_gcc)

135
AC_SUBST(CXX)
136
AC_SUBST(MAINOBJ)
137
MAINOBJ=python.o
138
AC_MSG_CHECKING(for --with-cxx=<compiler>)
139
AC_ARG_WITH(cxx, [  --with-cxx=<compiler>           enable C++ support],[
140
	check_cxx=no
141 142 143 144
	case $withval in
	no)	CXX=
		with_cxx=no;;
	*)	CXX=$withval
145
		MAINOBJ=ccpython.o
146 147 148
		with_cxx=$withval;;
	esac], [
	with_cxx=no
149
	check_cxx=yes
150 151
])
AC_MSG_RESULT($with_cxx)
152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168

dnl The following fragment works similar to AC_PROG_CXX.
dnl It does not fail if CXX is not found, and it is not executed if 
dnl --with-cxx was given.
dnl Finally, it does not test whether CXX is g++.

if test "$check_cxx" = "yes" 
then
	AC_CHECK_PROGS(CXX, $CCC c++ g++ gcc CC cxx cc++ cl, notfound)
	if test "$CXX" = "notfound"
	then
		CXX=
	else
		AC_PROG_CXX_WORKS
	fi
fi

169 170 171 172 173 174 175
# If the user switches compilers, we can't believe the cache
if test ! -z "$ac_cv_prog_CC" -a ! -z "$CC" -a "$CC" != "$ac_cv_prog_CC"
then
  AC_ERROR(cached CC is different -- throw away $cache_file
(it is also a good idea to do 'make clean' before compiling))
fi

Guido van Rossum's avatar
Guido van Rossum committed
176
AC_PROG_CC
177 178 179 180 181

# checks for UNIX variants that set C preprocessor variables
AC_AIX
AC_MINIX

182
AC_EXEEXT
183 184 185 186 187 188 189 190
AC_MSG_CHECKING(for --with-suffix)
AC_ARG_WITH(suffix, [  --with-suffix=.exe              set executable suffix],[
	case $withval in
	no)	EXEEXT=;;
	yes)	EXEEXT=.exe;;
	*)	EXEEXT=$withval;;
	esac])
AC_MSG_RESULT($EXEEXT)
191 192 193 194 195 196
# Test whether we're running on a non-case-sensitive system, in which
# case we give a warning if no ext is given
if test -d "python" -a -z "$EXEEXT"
then
    AC_MSG_WARN(This filesystem is not case-sensitive so you should probably use --with-suffix)
fi
197

198 199 200 201 202 203 204
case $MACHDEP in
bsdos*)
    case $CC in
    gcc) CC="$CC -D_HAVE_BSDI";;
    esac;;
esac

205 206 207
case $ac_sys_system in
hp*|HP*)
    case $CC in
208
    cc|*/cc) CC="$CC -Ae";;
209
    esac;;
210 211 212 213
Monterey*)
    case $CC in
    cc) CC="$CC -Wl,-Bexport";;
    esac;;
214 215 216 217
SunOS*)
    # Some functions have a prototype only with that define, e.g. confstr
    AC_DEFINE(__EXTENSIONS__)
    ;;
218 219
esac

220

221 222 223 224 225 226 227 228
AC_SUBST(LIBRARY)
AC_MSG_CHECKING(LIBRARY)
if test -z "$LIBRARY"
then
	LIBRARY='libpython$(VERSION).a'
fi
AC_MSG_RESULT($LIBRARY)

229
# LDLIBRARY is the name of the library to link against (as opposed to the
230 231 232 233 234 235 236 237
# name of the library into which to insert object files). BLDLIBRARY is also
# the library to link against, usually. On Mac OS X frameworks, BLDLIBRARY
# is blank as the main program is not linked directly against LDLIBRARY.
# LDLIBRARYDIR is the path to LDLIBRARY, which is made in a subdirectory. On
# systems without shared libraries, LDLIBRARY is the same as LIBRARY
# (defined in the Makefiles). On Cygwin LDLIBRARY is the import library,
# DLLLIBRARY is the shared (i.e., DLL) library.
# 
238
AC_SUBST(LDLIBRARY)
239
AC_SUBST(DLLLIBRARY)
240 241
AC_SUBST(BLDLIBRARY)
AC_SUBST(LDLIBRARYDIR)
242
LDLIBRARY="$LIBRARY"
243
BLDLIBRARY='$(LDLIBRARY)'
244
DLLLIBRARY=''
245
LDLIBRARYDIR=''
246

247
# LINKCC is the command that links the python executable -- default is $(CC).
Fred Drake's avatar
Fred Drake committed
248
# This is altered for AIX in order to build the export list before 
249
# linking.
250 251 252 253 254 255
AC_SUBST(LINKCC)
AC_MSG_CHECKING(LINKCC)
if test -z "$LINKCC"
then
	case $ac_sys_system in
	AIX*)
256
	   LINKCC="\$(srcdir)/Modules/makexp_aix Modules/python.exp \"\" \$(LIBRARY); \$(PURIFY) \$(CC)";;
257 258
	dgux*)
	   LINKCC="LD_RUN_PATH=$libdir \$(PURIFY) \$(CC)";;
259 260
	Monterey64*)
	   LINKCC="\$(PURIFY) \$(CC) -L/usr/lib/ia64l64";;
261
	*) LINKCC="\$(PURIFY) \$(CC)";;
262 263 264 265
	esac
fi
AC_MSG_RESULT($LINKCC)

266 267 268
AC_MSG_CHECKING(LDLIBRARY)

# DG/UX requires some fancy ld contortions to produce a .so from an .a
Fred Drake's avatar
Fred Drake committed
269 270 271 272 273 274 275 276
case $MACHDEP in
dguxR4)
      LDLIBRARY='libpython$(VERSION).so'
      OPT="$OPT -pic"
      ;;
beos*)
      LDLIBRARY='libpython$(VERSION).so'
      ;;
277 278
cygwin*)
      LDLIBRARY='libpython$(VERSION).dll.a'
279
      DLLLIBRARY='libpython$(VERSION).dll'
280
      ;;
Fred Drake's avatar
Fred Drake committed
281
esac
282

283 284 285 286 287 288
# MacOSX framework builds need more magic. LDLIBRARY is the dynamic
# library that we build, but we do not want to link against it (we
# will find it with a -framework option). For this reason there is an
# extra variable BLDLIBRARY against which Python and the extension
# modules are linked, BLDLIBRARY. This is normally the same as
# LDLIBRARY, but empty for MacOSX framework builds.
289 290 291 292 293 294 295 296 297
if test "$enable_framework"
then
  LDLIBRARY='$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
  LDLIBRARYDIR='$(PYTHONFRAMEWORKDIR)'
  BLDLIBRARY=''
else
  BLDLIBRARY='$(LDLIBRARY)'
fi  

298 299
AC_MSG_RESULT($LDLIBRARY)

Guido van Rossum's avatar
Guido van Rossum committed
300
AC_PROG_RANLIB
301
AC_SUBST(AR)
302
AC_CHECK_PROGS(AR, ar aal, ar)
303 304 305 306 307 308 309 310 311

case $MACHDEP in
bsdos*)
	# install -d does not work on BSDI
	if test -z "$INSTALL"
	then
		INSTALL="${srcdir}/install-sh -c"
	fi
esac
312
AC_PROG_INSTALL
313

314 315 316 317 318
# Not every filesystem supports hard links
AC_SUBST(LN)
if test -z "$LN" ; then
	case $ac_sys_system in
		BeOS*) LN="ln -s";;
319
		CYGWIN*) LN="ln -s";;
320 321 322 323
		*) LN=ln;;
	esac
fi

324 325 326 327 328 329 330 331 332 333
# Check for --with-pydebug
AC_MSG_CHECKING(for --with-pydebug)
AC_ARG_WITH(pydebug, 
[  --with-pydebug                  build with Py_DEBUG defined], [
if test "$withval" != no
then AC_DEFINE(Py_DEBUG) AC_MSG_RESULT(yes); Py_DEBUG='true'
else AC_MSG_RESULT(no); Py_DEBUG='false'
fi],
[AC_MSG_RESULT(no)])

334
# Optimizer/debugger flags
335
AC_SUBST(OPT)
336
if test -z "$OPT"
337
then
338 339 340
	case $GCC in
	yes)
		case $ac_cv_prog_cc_g in
341
	yes)
342 343 344 345 346 347 348
	    if test "$Py_DEBUG" = 'true' ; then
		# Optimization messes up debuggers, so turn it off for
		# debug builds.
		OPT="-g -Wall -Wstrict-prototypes"
	    else
		OPT="-g -O3 -Wall -Wstrict-prototypes"
	    fi;;
349
	*)
350 351 352
	    OPT="-O3 -Wall -Wstrict-prototypes";;
	esac
	;;
353 354
    *)
	case $ac_sys_system in
355
	OpenUNIX*|UnixWare*)
356 357 358
	    OPT="-O -K pentium,host,inline,loop_unroll,alloca ";;
	*)
	    OPT="-O";;
359
	esac
360
    esac
361 362 363 364
    case $ac_sys_system in
    Darwin*)
    	OPT="$OPT -no-cpp-precomp";;
    esac
365
fi
Guido van Rossum's avatar
Guido van Rossum committed
366

367 368 369 370 371
# The current (beta) Monterey compiler dies with optimizations
case $ac_sys_system in
Monterey*) OPT="";;
esac

372
if test "$ac_arch_flags"
Guido van Rossum's avatar
Guido van Rossum committed
373 374 375
then
	OPT="$OPT $ac_arch_flags"
fi
376

377 378 379 380 381 382
AC_MSG_CHECKING(whether $CC accepts -OPT:Olimit=0)
AC_CACHE_VAL(ac_cv_opt_olimit_ok,
[ac_save_cc="$CC"
CC="$CC -OPT:Olimit=0"
AC_TRY_RUN([int main() { return 0; }],
  ac_cv_opt_olimit_ok=yes,
383
  ac_cv_opt_olimit_ok=no,
384 385 386
  ac_cv_opt_olimit_ok=no)
CC="$ac_save_cc"])
AC_MSG_RESULT($ac_cv_opt_olimit_ok)
387
if test $ac_cv_opt_olimit_ok = yes; then
388 389 390 391
    case $ac_sys_system in
      Darwin*) OPT="$OPT" ;;
      *) OPT="$OPT -OPT:Olimit=0";;
    esac
392 393 394 395 396 397 398
else
  AC_MSG_CHECKING(whether $CC accepts -Olimit 1500)
  AC_CACHE_VAL(ac_cv_olimit_ok,
  [ac_save_cc="$CC"
  CC="$CC -Olimit 1500"
  AC_TRY_RUN([int main() { return 0; }],
    ac_cv_olimit_ok=yes,
399
    ac_cv_olimit_ok=no,
400 401 402 403 404 405
    ac_cv_olimit_ok=no)
  CC="$ac_save_cc"])
  AC_MSG_RESULT($ac_cv_olimit_ok)
  if test $ac_cv_olimit_ok = yes; then
    OPT="$OPT -Olimit 1500"
  fi
406
fi
407

408 409
# -Kpthread, if available, provides the right #defines
# and linker options to make pthread_create available
410 411 412
# Some compilers won't report that they do not support -Kpthread,
# so we need to run a program to see whether it really made the
# function available.
413 414 415 416
AC_MSG_CHECKING(whether $CC accepts -Kpthread)
AC_CACHE_VAL(ac_cv_kpthread,
[ac_save_cc="$CC"
CC="$CC -Kpthread"
417 418 419 420 421 422 423 424 425 426 427 428
AC_TRY_RUN([
#include <pthread.h>

void* routine(void* p){return NULL;}

int main(){
  pthread_t p;
  if(pthread_create(&p,NULL,routine,NULL)!=0)
    return 1;
  return 0;
}
],
429
  ac_cv_kpthread=yes,
430
  ac_cv_kpthread=no,
431 432 433 434
  ac_cv_kpthread=no)
CC="$ac_save_cc"])
AC_MSG_RESULT($ac_cv_kpthread)

435 436 437 438 439 440 441 442
dnl # check for ANSI or K&R ("traditional") preprocessor
dnl AC_MSG_CHECKING(for C preprocessor type)
dnl AC_TRY_COMPILE([
dnl #define spam(name, doc) {#name, &name, #name "() -- " doc}
dnl int foo;
dnl struct {char *name; int *addr; char *doc;} desc = spam(foo, "something");
dnl ], [;], cpp_type=ansi, AC_DEFINE(HAVE_OLD_CPP) cpp_type=traditional)
dnl AC_MSG_RESULT($cpp_type)
Guido van Rossum's avatar
Guido van Rossum committed
443

Guido van Rossum's avatar
Guido van Rossum committed
444
# checks for header files
445
AC_HEADER_STDC
446 447
AC_CHECK_HEADERS(dlfcn.h fcntl.h limits.h langinfo.h locale.h \
ncurses.h poll.h pthread.h \
448
signal.h stdarg.h stddef.h stdlib.h thread.h unistd.h utime.h termios.h \
449
sys/audioio.h sys/file.h sys/lock.h sys/modem.h db_185.h db.h \
450
sys/param.h sys/poll.h sys/select.h sys/socket.h sys/time.h sys/times.h \
451
sys/un.h sys/utsname.h sys/wait.h pty.h libutil.h \
452
ndbm.h db1/ndbm.h gdbm/ndbm.h sys/resource.h netpacket/packet.h)
453
AC_HEADER_DIRENT
Guido van Rossum's avatar
Guido van Rossum committed
454 455

# checks for typedefs
456 457 458 459 460
was_it_defined=no
AC_MSG_CHECKING(for clock_t in time.h)
AC_EGREP_HEADER(clock_t, time.h, was_it_defined=yes, AC_DEFINE(clock_t, long))
AC_MSG_RESULT($was_it_defined)

461 462 463 464 465
# Two defines needed to enable largefile support on various platforms
# These may affect some typedefs
AC_DEFINE(_LARGEFILE_SOURCE)
AC_DEFINE(_FILE_OFFSET_BITS, 64)

Guido van Rossum's avatar
Guido van Rossum committed
466 467 468 469 470 471 472
# Add some code to confdefs.h so that the test for off_t works on SCO
cat >> confdefs.h <<\EOF
#if defined(SCO_DS)
#undef _OFF_T
#endif
EOF

473
# Type availability checks
474 475 476 477 478 479
AC_TYPE_MODE_T
AC_TYPE_OFF_T
AC_TYPE_PID_T
AC_TYPE_SIGNAL
AC_TYPE_SIZE_T
AC_TYPE_UID_T
Guido van Rossum's avatar
Guido van Rossum committed
480

481
# Sizes of various common basic types
482 483 484 485 486 487 488 489
AC_CHECK_SIZEOF(int, 4)
AC_CHECK_SIZEOF(long, 4)
AC_CHECK_SIZEOF(void *, 4)
AC_CHECK_SIZEOF(char, 1)
AC_CHECK_SIZEOF(short, 2)
AC_CHECK_SIZEOF(float, 4)
AC_CHECK_SIZEOF(double, 8)
AC_CHECK_SIZEOF(fpos_t, 4)
490

491 492 493 494
AC_MSG_CHECKING(for long long support)
have_long_long=no
AC_TRY_COMPILE([], [long long x; x = (long long)0;], AC_DEFINE(HAVE_LONG_LONG) have_long_long=yes)
AC_MSG_RESULT($have_long_long)
495
if test "$have_long_long" = yes ; then
496
AC_CHECK_SIZEOF(long long, 8)
497 498
fi

499 500 501 502 503
AC_MSG_CHECKING(for uintptr_t support)
have_uintptr_t=no
AC_TRY_COMPILE([], [uintptr_t x; x = (uintptr_t)0;], AC_DEFINE(HAVE_UINTPTR_T) have_uintptr_t=yes)
AC_MSG_RESULT($have_uintptr_t)
if test "$have_uintptr_t" = yes ; then
504
AC_CHECK_SIZEOF(uintptr_t, 4)
505 506
fi

507 508 509 510 511 512 513 514 515 516 517
# Hmph. AC_CHECK_SIZEOF() doesn't include <sys/types.h>.
AC_MSG_CHECKING(size of off_t)
AC_CACHE_VAL(ac_cv_sizeof_off_t,
[AC_TRY_RUN([#include <stdio.h>
#include <sys/types.h>
main()
{
  FILE *f=fopen("conftestval", "w");
  if (!f) exit(1);
  fprintf(f, "%d\n", sizeof(off_t));
  exit(0);
518 519 520 521
}],
ac_cv_sizeof_off_t=`cat conftestval`,
ac_cv_sizeof_off_t=0,
ac_cv_sizeof_off_t=4)
522 523 524 525 526
])
AC_MSG_RESULT($ac_cv_sizeof_off_t)
AC_DEFINE_UNQUOTED(SIZEOF_OFF_T, $ac_cv_sizeof_off_t)

AC_MSG_CHECKING(whether to enable large file support)
527 528 529
if test "$have_long_long" = yes -a \
	"$ac_cv_sizeof_off_t" -gt "$ac_cv_sizeof_long" -a \
	"$ac_cv_sizeof_long_long" -ge "$ac_cv_sizeof_off_t"; then
530 531 532 533 534 535
  AC_DEFINE(HAVE_LARGEFILE_SUPPORT)
  AC_MSG_RESULT(yes)
else
  AC_MSG_RESULT(no)
fi

536 537 538 539 540 541 542 543 544 545 546
# AC_CHECK_SIZEOF() doesn't include <time.h>.
AC_MSG_CHECKING(size of time_t)
AC_CACHE_VAL(ac_cv_sizeof_time_t,
[AC_TRY_RUN([#include <stdio.h>
#include <time.h>
main()
{
  FILE *f=fopen("conftestval", "w");
  if (!f) exit(1);
  fprintf(f, "%d\n", sizeof(time_t));
  exit(0);
547 548 549 550
}],
ac_cv_sizeof_time_t=`cat conftestval`,
ac_cv_sizeof_time_t=0,
ac_cv_sizeof_time_t=4)
551 552 553 554
])
AC_MSG_RESULT($ac_cv_sizeof_time_t)
AC_DEFINE_UNQUOTED(SIZEOF_TIME_T, $ac_cv_sizeof_time_t)

555

556
# if have pthread_t then define SIZEOF_PTHREAD_T
557 558 559 560
ac_save_cc="$CC"
if test "$ac_cv_kpthread" = "yes"
then CC="$CC -Kpthread"
fi
561 562
AC_MSG_CHECKING(for pthread_t)
have_pthread_t=no
563
AC_TRY_COMPILE([#include <pthread.h>], [pthread_t x; x = *(pthread_t*)0;], have_pthread_t=yes)
564 565 566 567 568 569 570 571 572 573 574 575 576
AC_MSG_RESULT($have_pthread_t)
if test "$have_pthread_t" = yes ; then
  # AC_CHECK_SIZEOF() doesn't include <pthread.h>.
  AC_MSG_CHECKING(size of pthread_t)
  AC_CACHE_VAL(ac_cv_sizeof_pthread_t,
  [AC_TRY_RUN([#include <stdio.h>
  #include <pthread.h>
  main()
  {
    FILE *f=fopen("conftestval", "w");
    if (!f) exit(1);
    fprintf(f, "%d\n", sizeof(pthread_t));
    exit(0);
577 578 579 580
  }],
  ac_cv_sizeof_pthread_t=`cat conftestval`,
  ac_cv_sizeof_pthread_t=0,
  ac_cv_sizeof_pthread_t=4)
581 582 583 584
  ])
  AC_MSG_RESULT($ac_cv_sizeof_pthread_t)
  AC_DEFINE_UNQUOTED(SIZEOF_PTHREAD_T, $ac_cv_sizeof_pthread_t)
fi
585
CC="$ac_save_cc"
586

587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603
AC_MSG_CHECKING(for --enable-toolbox-glue)
AC_ARG_ENABLE(toolbox-glue,
[  --enable-toolbox-glue            disable/enable MacOSX glue code for extensions])

if test -z "$enable_toolbox_glue"
then 
	case $ac_sys_system/$ac_sys_release in
	Darwin/*)
		enable_toolbox_glue="yes";;
	*)
		enable_toolbox_glue="no";;
	esac
fi
case "$enable_toolbox_glue" in
yes)
	extra_frameworks="-framework Carbon -framework Foundation"
	extra_machdep_objs="Python/mactoolboxglue.o"
604
	extra_undefs="-u __dummy -u _PyMac_Error"
605 606 607 608 609
	AC_DEFINE(USE_TOOLBOX_OBJECT_GLUE)
	;;
*)
	extra_frameworks=""
	extra_machdep_objs=""
610
	extra_undefs=""
611 612 613 614
	;;
esac
AC_MSG_RESULT($enable_toolbox_glue)

615 616
AC_SUBST(LIBTOOL_CRUFT)
case $ac_sys_system/$ac_sys_release in
617 618 619 620 621 622
  Darwin/1.4*)
    ns_undef_sym='_environ'
    LIBTOOL_CRUFT="-lcc_dynamic -arch_only ppc -flat_namespace -U $ns_undef_sym"
      LIBTOOL_CRUFT="$LIBTOOL_CRUFT $extra_frameworks"
    LIBTOOL_CRUFT=$LIBTOOL_CRUFT' -install_name $(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/Python'
    LIBTOOL_CRUFT=$LIBTOOL_CRUFT' -compatibility_version $(VERSION) -current_version $(VERSION)';;
623 624
  Darwin/*)
    ns_undef_sym='_environ'
625 626 627 628
    LIBTOOL_CRUFT="-lcc_dynamic -arch_only ppc -U $ns_undef_sym"
   	LIBTOOL_CRUFT="$LIBTOOL_CRUFT $extra_frameworks"
    LIBTOOL_CRUFT=$LIBTOOL_CRUFT' -install_name $(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/Python'
    LIBTOOL_CRUFT=$LIBTOOL_CRUFT' -compatibility_version $(VERSION) -current_version $(VERSION)';;
629 630
esac

631 632
AC_MSG_CHECKING(for --enable-framework)
if test "$enable_framework"
633
then
634
	OPT="$OPT -fno-common -dynamic"
635 636
	# -U __environ is needed since bundles don't have access
	# to crt0 when built but will always be linked against it
637 638 639
	# -F. is needed to allow linking to the framework while 
	# in the build location.
	
640 641 642 643
	case $ac_sys_system/$ac_sys_release in
	    Darwin/1.4*)LDFLAGS="$LDFLAGS -Wl,-F. -Wl,-flat_namespace,-U,$ns_undef_sym";;
	    Darwin/*)LDFLAGS="$LDFLAGS -Wl,-F. -Wl,-U,$ns_undef_sym";;
	esac
644 645 646 647 648 649
	AC_DEFINE(WITH_NEXT_FRAMEWORK)
	AC_MSG_RESULT(yes)
else
	AC_MSG_RESULT(no)
fi

650
AC_MSG_CHECKING(for dyld)
651 652 653 654 655 656
case $ac_sys_system/$ac_sys_release in
  Darwin/*)
  	AC_DEFINE(WITH_DYLD)
  	AC_MSG_RESULT(always on for Darwin)
  	;;
  *)
657 658
	AC_MSG_RESULT(no)
	;;
659
esac
660

661 662 663
# Set info about shared libraries.
AC_SUBST(SO)
AC_SUBST(LDSHARED)
664
AC_SUBST(BLDSHARED)
665 666 667
AC_SUBST(CCSHARED)
AC_SUBST(LINKFORSHARED)
# SO is the extension of shared libraries `(including the dot!)
668
# -- usually .so, .sl on HP-UX, .dll on Cygwin
669
AC_MSG_CHECKING(SO)
670 671
if test -z "$SO"
then
672
	case $ac_sys_system in
673
	hp*|HP*)   SO=.sl;;
674
	CYGWIN*)   SO=.dll;;
675
	*)	   SO=.so;;
676 677
	esac
fi
678
AC_MSG_RESULT($SO)
679
# LDSHARED is the ld *command* used to create shared library
680
# -- "ld" on SunOS 4.x.x, "cc -G" on SunOS 5.x, "ld -shared" on IRIX 5
681 682
# (Shared libraries in this instance are shared modules to be loaded into
# Python, as opposed to building Python itself as a shared library.)
683
AC_MSG_CHECKING(LDSHARED)
684 685
if test -z "$LDSHARED"
then
686
	case $ac_sys_system/$ac_sys_release in
687 688
	AIX*)
		BLDSHARED="\$(srcdir)/Modules/ld_so_aix \$(CC) -bI:Modules/python.exp"
689
		LDSHARED="\$(BINLIBDEST)/config/ld_so_aix \$(CC) -bI:\$(BINLIBDEST)/config/python.exp"
690 691 692
		;;
	BeOS*)
		BLDSHARED="\$(srcdir)/Modules/ld_so_beos $LDLIBRARY"
693
		LDSHARED="\$(BINLIBDEST)/config/ld_so_beos \$(LIBDIR)/$LDLIBRARY"
694
		;;
695
	IRIX/5*) LDSHARED="ld -shared";;
696
	IRIX*/6*) LDSHARED="ld ${SGI_ABI} -shared -all";;
697
	SunOS/4*) LDSHARED="ld";;
698 699
	SunOS/5*) 
		if test "$GCC" = "yes"
700
		then LDSHARED='$(CC) -shared'
701
		else LDSHARED="$(CC) -G";
702
		fi ;;
703
	hp*|HP*) LDSHARED="ld -b";;
704
	OSF*) LDSHARED="ld -shared -expect_unresolved \"*\"";;
705
	DYNIX/ptx*) LDSHARED="ld -G";;
706 707 708 709 710 711 712 713 714
	Darwin/1.4*)
		LDSHARED='$(CC) $(LDFLAGS) -bundle'
		if test "$enable_framework" ; then
			# Link against the framework. All externals should be defined.
			LDSHARED="$LDSHARED "'-framework $(PYTHONFRAMEWORK)'
		else
			# No framework. Ignore undefined symbols, assuming they come from Python
			LDSHARED="$LDSHARED -flat_namespace -undefined suppress"
		fi ;;
715 716 717 718 719 720 721 722
	Darwin/*)
		LDSHARED='$(CC) $(LDFLAGS) -bundle'
		if test "$enable_framework" ; then
			# Link against the framework. All externals should be defined.
			LDSHARED="$LDSHARED "'-framework $(PYTHONFRAMEWORK)'
		else
			# No framework. Ignore undefined symbols, assuming they come from Python
			LDSHARED="$LDSHARED -undefined suppress"
723
		fi ;;
724
	Linux*) LDSHARED="gcc -shared";;
725
	dgux*) LDSHARED="ld -G";;
726
	BSD/OS*/4*) LDSHARED="gcc -shared";;
727
	OpenBSD*|NetBSD*|FreeBSD*)
728
		if [[ "`$CC -dM -E - </dev/null | grep __ELF__`" != "" ]]
729 730 731 732 733
		then
			LDSHARED="cc -shared ${LDFLAGS}"
		else
			LDSHARED="ld -Bshareable ${LDFLAGS}"
		fi;;
734
	OpenUNIX*|UnixWare*)
735 736
		if test "$GCC" = "yes"
		then LDSHARED="$(CC) -shared"
737
		else LDSHARED="$(CC) -G"
738
		fi;;
Guido van Rossum's avatar
Guido van Rossum committed
739
	SCO_SV*) LDSHARED="cc -G -KPIC -Ki486 -belf -Wl,-Bexport";;
740
	Monterey*) LDSHARED="cc -G -dy -Bdynamic -Bexport -L/usr/lib/ia64l64";;
741
	CYGWIN*) LDSHARED="gcc -shared -Wl,--enable-auto-image-base";;
742 743 744
	*)	LDSHARED="ld";;
	esac
fi
745
AC_MSG_RESULT($LDSHARED)
746
BLDSHARED=${BLDSHARED-$LDSHARED}
747
# CCSHARED are the C *flags* used to create objects to go into a shared
748
# library (module) -- this is only needed for a few systems
749
AC_MSG_CHECKING(CCSHARED)
750 751
if test -z "$CCSHARED"
then
752
	case $ac_sys_system/$ac_sys_release in
753 754 755
	SunOS*) if test "$GCC" = yes;
	        then CCSHARED="-fPIC";
	        fi;;
Guido van Rossum's avatar
Guido van Rossum committed
756
	hp*|HP*) if test "$GCC" = yes;
757
		 then CCSHARED="-fPIC";
Guido van Rossum's avatar
Guido van Rossum committed
758 759
		 else CCSHARED="+z";
		 fi;;
760
	Linux*) CCSHARED="-fPIC";;
761
	BSD/OS*/4*) CCSHARED="-fpic";;
762
	FreeBSD*|NetBSD*|OpenBSD*) CCSHARED="-fPIC";;
763
	OpenUNIX*|UnixWare*)
764 765
		if test "$GCC" = "yes"
		then CCSHARED="-fPIC"
766
		else CCSHARED="-KPIC"
767
		fi;;
Guido van Rossum's avatar
Guido van Rossum committed
768
	SCO_SV*) CCSHARED="-KPIC -dy -Bdynamic";;
769
	Monterey*) CCSHARED="-G";;
770 771
	IRIX*/6*)  case $CC in
		   *gcc*) CCSHARED="-shared";;
772
		   *) CCSHARED="";;
773
		   esac;;
774
	CYGWIN*) CCSHARED="-DUSE_DL_IMPORT";;
775 776
	esac
fi
777
AC_MSG_RESULT($CCSHARED)
778
# LINKFORSHARED are the flags passed to the $(CC) command that links
779
# the python executable -- this is only needed for a few systems
780
AC_MSG_CHECKING(LINKFORSHARED)
781 782
if test -z "$LINKFORSHARED"
then
783
	case $ac_sys_system/$ac_sys_release in
784
	AIX*)	LINKFORSHARED='-Wl,-bE:Modules/python.exp -lld';;
Guido van Rossum's avatar
Guido van Rossum committed
785
	hp*|HP*)
786
	    LINKFORSHARED="-Wl,-E -Wl,+s -Wl,+b\$(BINLIBDEST)/lib-dynload";;
787
	BSD/OS/4*) LINKFORSHARED="-Xlinker -export-dynamic";;
788
	Linux*) LINKFORSHARED="-Xlinker -export-dynamic";;
789
	# -u libsys_s pulls in all symbols in libsys
790 791 792 793 794 795 796 797
	Darwin/*) 
		# -u __dummy makes the linker aware of the objc runtime
		# in System.framework; otherwise, __objcInit (referenced in
		# crt1.o) gets erroneously defined as common, which breaks dynamic
		# loading of any modules which reference it in System.framework.
		# -u _PyMac_Error is needed to pull in the mac toolbox glue, which is
		# not used by the core itself but which needs to be in the core so
		# that dynamically loaded extension modules have access to it.
798
		LINKFORSHARED="$extra_undefs -framework System"
799 800 801 802 803
		if test "$enable_framework"
		then
			LINKFORSHARED="$LINKFORSHARED -framework Python"
		fi
		LINKFORSHARED="$LINKFORSHARED $extra_frameworks";;
804
	OpenUNIX*|UnixWare*) LINKFORSHARED="-Wl,-Bexport";;
Guido van Rossum's avatar
Guido van Rossum committed
805
	SCO_SV*) LINKFORSHARED="-Bdynamic -dy -Wl,-Bexport";;
806
	ReliantUNIX*) LINKFORSHARED="-W1 -Blargedynsym";;
807
	FreeBSD*|NetBSD*|OpenBSD*) 
Guido van Rossum's avatar
Guido van Rossum committed
808 809 810 811
		if [[ "`$CC -dM -E - </dev/null | grep __ELF__`" != "" ]]
		then
			LINKFORSHARED="-Wl,--export-dynamic"
		fi;;
812 813
	SunOS/5*) case $CC in
		  *gcc*)
814
		    if $CC -Xlinker -V 2>&1 | grep BFD >/dev/null
815 816
		    then
			LINKFORSHARED="-Xlinker --export-dynamic"
817 818
		    fi;;
		  esac;;
819 820
	esac
fi
821
AC_MSG_RESULT($LINKFORSHARED)
822

823 824 825 826
AC_SUBST(CFLAGSFORSHARED)
AC_MSG_CHECKING(CFLAGSFORSHARED)
if test ! "$LIBRARY" = "$LDLIBRARY"
then
827 828 829 830 831 832 833 834
	case $ac_sys_system in
	CYGWIN*)
		# Cygwin needs CCSHARED when building extension DLLs
		# but not when building the interpreter DLL.
		CFLAGSFORSHARED='';;
	*)
		CFLAGSFORSHARED='$(CCSHARED)'
	esac
835 836 837
fi
AC_MSG_RESULT($CFLAGSFORSHARED)

Guido van Rossum's avatar
Guido van Rossum committed
838
# checks for libraries
839 840
AC_CHECK_LIB(dl, dlopen)	# Dynamic linking for SunOS/Solaris and SYSV
AC_CHECK_LIB(dld, shl_load)	# Dynamic linking for HP-UX
841 842 843 844 845 846 847 848 849 850 851 852

# checks for system dependent C++ extensions support
case "$ac_sys_system" in
	AIX*)	AC_MSG_CHECKING(for genuine AIX C++ extensions support)
		AC_TRY_LINK([#include "/usr/lpp/xlC/include/load.h"],
			    [loadAndInit("", 0, "")],
			    [AC_DEFINE(AIX_GENUINE_CPLUSPLUS)
			     AC_MSG_RESULT(yes)],
			    [AC_MSG_RESULT(no)]);;
	*) ;;
esac

853 854
# Most SVR4 platforms (e.g. Solaris) need -lsocket and -lnsl.
# However on SGI IRIX, these exist but are broken.
855 856 857
# BeOS' sockets are stashed in libnet.
case "$ac_sys_system" in
IRIX*) ;;
858
*)
859 860
AC_CHECK_LIB(nsl, t_open, [LIBS="-lnsl $LIBS"]) # SVR4
AC_CHECK_LIB(socket, socket, [LIBS="-lsocket $LIBS"], [], $LIBS) # SVR4 sockets
861 862 863 864
;;
esac
case "$ac_sys_system" in
BeOS*)
865 866 867
AC_CHECK_LIB(net, socket, [LIBS="-lnet $LIBS"], [], $LIBS) # BeOS
;;
esac
868

Guido van Rossum's avatar
Guido van Rossum committed
869
AC_MSG_CHECKING(for --with-libs)
870 871
AC_ARG_WITH(libs,
[  --with-libs='lib1 ...'          link against additional libs], [
Guido van Rossum's avatar
Guido van Rossum committed
872 873 874
AC_MSG_RESULT($withval)
LIBS="$withval $LIBS"
], AC_MSG_RESULT(no))
875

876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895
# Determine if signalmodule should be used.
AC_SUBST(USE_SIGNAL_MODULE)
AC_SUBST(SIGNAL_OBJS)
AC_MSG_CHECKING(for --with-signal-module)
AC_ARG_WITH(signal-module,
[  --with-signal-module            disable/enable signal module])

if test -z "$with_signal_module"
then with_signal_module="yes"
fi
AC_MSG_RESULT($with_signal_module)

if test "${with_signal_module}" = "yes"; then
	USE_SIGNAL_MODULE=""
	SIGNAL_OBJS=""
else
	USE_SIGNAL_MODULE="#"
	SIGNAL_OBJS="Parser/intrcheck.o Python/sigcheck.o"
fi

896
# This is used to generate Setup.config
897
AC_SUBST(USE_THREAD_MODULE)
898
USE_THREAD_MODULE=""
899

900 901 902
AC_MSG_CHECKING(for --with-dec-threads)
AC_SUBST(LDLAST)
AC_ARG_WITH(dec-threads,
903 904
[  --with-dec-threads              use DEC Alpha/OSF1 thread-safe libraries], [
AC_MSG_RESULT($withval)
905
LDLAST=-threads
906
if test "${with_thread+set}" != set; then
907 908 909 910 911
   with_thread="$withval";
fi],
AC_MSG_RESULT(no))

AC_MSG_CHECKING(for --with-threads)
912 913
AC_ARG_WITH(threads,
[  --with(out)-threads[=DIRECTORY] disable/enable thread support])
914

915
# --with-thread is deprecated, but check for it anyway
916 917 918
AC_ARG_WITH(thread,
[  --with(out)-thread[=DIRECTORY]  deprecated; use --with(out)-threads],[
with_threads=$with_thread])
919 920 921 922 923 924 925 926 927

if test -z "$with_threads"
then with_threads="yes"
fi
AC_MSG_RESULT($with_threads)

if test "$with_threads" = "no"
then
    USE_THREAD_MODULE="#"
928 929 930 931 932
elif test "$ac_cv_kpthread" = "yes"
then
    CC="$CC -Kpthread"
    AC_DEFINE(WITH_THREAD)
    AC_DEFINE(_POSIX_THREADS)
933
    posix_threads=yes
934
    LIBOBJS="$LIBOBJS thread.o"
935
else
936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954
    if test ! -z "$with_threads" -a -d "$with_threads"
    then LDFLAGS="$LDFLAGS -L$with_threads"
    fi
    if test ! -z "$withval" -a -d "$withval"
    then LDFLAGS="$LDFLAGS -L$withval"
    fi
    AC_DEFINE(_REENTRANT)
    AC_CHECK_HEADER(mach/cthreads.h, [AC_DEFINE(WITH_THREAD)
    AC_DEFINE(C_THREADS)
    LIBOBJS="$LIBOBJS thread.o"],[
    AC_MSG_CHECKING(for --with-pth)
    AC_ARG_WITH(pth,
    [  --with-pth                      use GNU pth threading libraries], [
    AC_MSG_RESULT($withval)
    AC_DEFINE(WITH_THREAD)
    AC_DEFINE(HAVE_PTH)
    LIBS="-lpth $LIBS"
    LIBOBJS="$LIBOBJS thread.o"],[
    AC_MSG_RESULT(no)
955 956 957 958 959 960 961 962 963 964 965 966 967

    # Just looking for pthread_create in libpthread is not enough:
    # on HP/UX, pthread.h renames pthread_create to a different symbol name.
    # So we really have to include pthread.h, and then link.
    _libs=$LIBS
    LIBS="$LIBS -lpthread"
    AC_MSG_CHECKING([for pthread_create in -lpthread])
    AC_TRY_LINK([#include <pthread.h>

void * start_routine (void *arg) { exit (0); }], [
pthread_create (NULL, NULL, start_routine, NULL)], [
    AC_MSG_RESULT(yes)
    AC_DEFINE(WITH_THREAD)
968 969
    case $ac_sys_system in
      Darwin*) ;;
970 971 972
      *) AC_DEFINE(_POSIX_THREADS)
         posix_threads=yes
         ;;
973
    esac
974
    LIBOBJS="$LIBOBJS thread.o"],[
975
    LIBS=$_libs
976 977 978
    AC_CHECK_FUNC(pthread_detach, [AC_DEFINE(WITH_THREAD)
    case $ac_sys_system in
      Darwin*) ;;
979 980 981
      *) AC_DEFINE(_POSIX_THREADS)
         posix_threads=yes
         ;;
982 983 984 985 986 987 988
    esac
    LIBOBJS="$LIBOBJS thread.o"],[
    AC_CHECK_HEADER(kernel/OS.h, [AC_DEFINE(WITH_THREAD)
    AC_DEFINE(BEOS_THREADS)
    LIBOBJS="$LIBOBJS thread.o"],[
    AC_CHECK_LIB(pthreads, pthread_create, [AC_DEFINE(WITH_THREAD)
    AC_DEFINE(_POSIX_THREADS)
989
    posix_threads=yes
990 991 992 993
    LIBS="$LIBS -lpthreads"
    LIBOBJS="$LIBOBJS thread.o"], [
    AC_CHECK_LIB(c_r, pthread_create, [AC_DEFINE(WITH_THREAD)
    AC_DEFINE(_POSIX_THREADS)
994
    posix_threads=yes
995 996 997 998
    LIBS="$LIBS -lc_r"
    LIBOBJS="$LIBOBJS thread.o"], [
    AC_CHECK_LIB(thread, __d6_pthread_create, [AC_DEFINE(WITH_THREAD)
    AC_DEFINE(_POSIX_THREADS)
999
    posix_threads=yes
1000 1001 1002 1003
    LIBS="$LIBS -lthread"
    LIBOBJS="$LIBOBJS thread.o"], [
    AC_CHECK_LIB(pthread, __pthread_create_system, [AC_DEFINE(WITH_THREAD)
    AC_DEFINE(_POSIX_THREADS)
1004
    posix_threads=yes
1005 1006 1007 1008
    LIBS="$LIBS -lpthread"
    LIBOBJS="$LIBOBJS thread.o"], [
    AC_CHECK_LIB(cma, pthread_create, [AC_DEFINE(WITH_THREAD)
    AC_DEFINE(_POSIX_THREADS)
1009
    posix_threads=yes
1010 1011 1012 1013 1014
    LIBS="$LIBS -lcma"
    LIBOBJS="$LIBOBJS thread.o"],[
    USE_THREAD_MODULE="#"])
    ])])])])])])])])])

1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027
    if test "$posix_threads" = "yes"; then
      AC_MSG_CHECKING(if PTHREAD_SCOPE_SYSTEM is supported)
      AC_CACHE_VAL(ac_cv_pthread_system_supported,
      [AC_TRY_RUN([#include <pthread.h>
      void *foo(void *parm) {
        return NULL;
      }
      main() {
        pthread_attr_t attr;
        if (pthread_attr_init(&attr)) exit(-1);
        if (pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM)) exit(-1);
        if (pthread_create(NULL, &attr, foo, NULL)) exit(-1);
        exit(0);
1028 1029 1030 1031
      }],
      ac_cv_pthread_system_supported=yes,
      ac_cv_pthread_system_supported=no,
      ac_cv_pthread_system_supported=no)
1032 1033 1034 1035 1036 1037 1038
      ])
      AC_MSG_RESULT($ac_cv_pthread_system_supported)
      if test "$ac_cv_pthread_system_supported" = "yes"; then
        AC_DEFINE(PTHREAD_SYSTEM_SCHED_SUPPORTED)
      fi
    fi

1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054
    AC_CHECK_LIB(mpc, usconfig, [AC_DEFINE(WITH_THREAD)
    LIBS="$LIBS -lmpc"
    LIBOBJS="$LIBOBJS thread.o"
    USE_THREAD_MODULE=""])
    AC_CHECK_LIB(thread, thr_create, [AC_DEFINE(WITH_THREAD)
    LIBS="$LIBS -lthread"
    LIBOBJS="$LIBOBJS thread.o"
    USE_THREAD_MODULE=""])

    if test "$USE_THREAD_MODULE" != "#"
    then
        # If the above checks didn't disable threads, (at least) OSF1
        # needs this '-threads' argument during linking.
        case $ac_sys_system in
        OSF1) LDLAST=-threads;;
        esac
1055
    fi
Guido van Rossum's avatar
Guido van Rossum committed
1056
fi
1057

1058
# Check for enable-ipv6
1059
AC_MSG_CHECKING([if --enable-ipv6 is specified])
1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073
AC_ARG_ENABLE(ipv6,
[  --enable-ipv6                   Enable ipv6 (with ipv4) support
  --disable-ipv6                  Disable ipv6 support],
[ case "$enableval" in
  no)
       AC_MSG_RESULT(no)
       ipv6=no
       ;;
  *)   AC_MSG_RESULT(yes)
       AC_DEFINE(ENABLE_IPV6)
       ipv6=yes
       ;;
  esac ],

1074 1075
[
dnl the check does not work on cross compilation case...
1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092
  AC_TRY_RUN([ /* AF_INET6 available check */
#include <sys/types.h>
#include <sys/socket.h>
main()
{
 if (socket(AF_INET6, SOCK_STREAM, 0) < 0)
   exit(1);
 else
   exit(0);
}
],
  AC_MSG_RESULT(yes)
  ipv6=yes,
  AC_MSG_RESULT(no)
  ipv6=no,
  AC_MSG_RESULT(no)
  ipv6=no
1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110
)

if test "$ipv6" = "yes"; then
	AC_MSG_CHECKING(if RFC2553 API is available)
	AC_TRY_COMPILE([#include <sys/types.h>
#include <netinet/in.h>],
	[struct sockaddr_in6 x;
x.sin6_scope_id;],
		AC_MSG_RESULT(yes)
		ipv6=yes,
		AC_MSG_RESULT(no, IPv6 disabled)
		ipv6=no)
fi

if test "$ipv6" = "yes"; then
	AC_DEFINE(ENABLE_IPV6)
fi
])
1111 1112 1113 1114 1115 1116 1117

ipv6type=unknown
ipv6lib=none
ipv6trylibc=no

if test "$ipv6" = "yes"; then
	AC_MSG_CHECKING([ipv6 stack type])
1118 1119
	for i in inria kame linux-glibc linux-inet6 solaris toshiba v6d zeta;
	do
1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229
		case $i in
		inria)
			dnl http://www.kame.net/
			AC_EGREP_CPP(yes, [dnl
#include <netinet/in.h>
#ifdef IPV6_INRIA_VERSION
yes
#endif],
				[ipv6type=$i;
				OPT="-DINET6 $OPT"])
			;;
		kame)
			dnl http://www.kame.net/
			AC_EGREP_CPP(yes, [dnl
#include <netinet/in.h>
#ifdef __KAME__
yes
#endif],
				[ipv6type=$i;
				ipv6lib=inet6
				ipv6libdir=/usr/local/v6/lib
				ipv6trylibc=yes
				OPT="-DINET6 $OPT"])
			;;
		linux-glibc)
			dnl http://www.v6.linux.or.jp/
			AC_EGREP_CPP(yes, [dnl
#include <features.h>
#if defined(__GLIBC__) && ((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 1) || (__GLIBC__ > 2))
yes
#endif],
				[ipv6type=$i;
				ipv6trylibc=yes
				OPT="-DINET6 $OPT"])
			;;
		linux-inet6)
			dnl http://www.v6.linux.or.jp/
			if test -d /usr/inet6; then
				ipv6type=$i
				ipv6lib=inet6
				ipv6libdir=/usr/inet6/lib
				OPT="-DINET6 -I/usr/inet6/include $OPT"
			fi
			;;
		solaris)
			if test -f /etc/netconfig; then
                          if /usr/xpg4/bin/grep -q tcp6 /etc/netconfig; then
				ipv6type=$i
				ipv6trylibc=yes
				OPT="-DINET6 $OPT"
                          fi
                        fi
			;;
		toshiba)
			AC_EGREP_CPP(yes, [dnl
#include <sys/param.h>
#ifdef _TOSHIBA_INET6
yes
#endif],
				[ipv6type=$i;
				ipv6lib=inet6;
				ipv6libdir=/usr/local/v6/lib;
				OPT="-DINET6 $OPT"])
			;;
		v6d)
			AC_EGREP_CPP(yes, [dnl
#include </usr/local/v6/include/sys/v6config.h>
#ifdef __V6D__
yes
#endif],
				[ipv6type=$i;
				ipv6lib=v6;
				ipv6libdir=/usr/local/v6/lib;
				OPT="-I/usr/local/v6/include $OPT"])
			;;
		zeta)
			AC_EGREP_CPP(yes, [dnl
#include <sys/param.h>
#ifdef _ZETA_MINAMI_INET6
yes
#endif],
				[ipv6type=$i;
				ipv6lib=inet6;
				ipv6libdir=/usr/local/v6/lib;
				OPT="-DINET6 $OPT"])
			;;
		esac
		if test "$ipv6type" != "unknown"; then
			break
		fi
	done
	AC_MSG_RESULT($ipv6type)
fi

if test "$ipv6" = "yes" -a "$ipv6lib" != "none"; then
	if test -d $ipv6libdir -a -f $ipv6libdir/lib$ipv6lib.a; then
		LIBS="-L$ipv6libdir -l$ipv6lib $LIBS"
		echo "using lib$ipv6lib"
	else
		if test $ipv6trylibc = "yes"; then
			echo "using libc"
		else
			echo 'Fatal: no $ipv6lib library found.  cannot continue.'
			echo "You need to fetch lib$ipv6lib.a from appropriate"
			echo 'ipv6 kit and compile beforehand.'
			exit 1
		fi
	fi
fi

1230 1231 1232 1233 1234 1235 1236 1237
# Check for GC support
AC_MSG_CHECKING(for --with-cycle-gc)
AC_ARG_WITH(cycle-gc,
[  --with(out)-cycle-gc            disable/enable garbage collection])

if test -z "$with_cycle_gc"
then with_cycle_gc="yes"
fi
1238
if test "$with_cycle_gc" != "no"
1239 1240 1241 1242 1243
then
    AC_DEFINE(WITH_CYCLE_GC)
fi
AC_MSG_RESULT($with_cycle_gc)

1244 1245 1246 1247 1248 1249 1250 1251 1252 1253
# Check for Python-specific malloc support
AC_MSG_CHECKING(for --with-pymalloc)
AC_ARG_WITH(pymalloc,
[  --with(out)-pymalloc            disable/enable specialized mallocs], [
if test "$withval" != no
then AC_DEFINE(WITH_PYMALLOC) AC_MSG_RESULT(yes)
else AC_MSG_RESULT(no)
fi],
[AC_MSG_RESULT(no)])

1254 1255 1256 1257 1258 1259 1260 1261 1262 1263
# Check for --with-wctype-functions
AC_MSG_CHECKING(for --with-wctype-functions)
AC_ARG_WITH(wctype-functions, 
[  --with-wctype-functions         use wctype.h functions], [
if test "$withval" != no
then AC_DEFINE(WANT_WCTYPE_FUNCTIONS) AC_MSG_RESULT(yes)
else AC_MSG_RESULT(no)
fi],
[AC_MSG_RESULT(no)])

1264
# -I${DLINCLDIR} is added to the compile rule for importdl.o
1265
AC_SUBST(DLINCLDIR)
1266
DLINCLDIR=.
Guido van Rossum's avatar
Guido van Rossum committed
1267

1268
AC_MSG_CHECKING(for --with-sgi-dl)
1269 1270
AC_ARG_WITH(sgi-dl,
[  --with-sgi-dl=DIRECTORY         IRIX 4 dynamic linking], [
1271
AC_MSG_RESULT($withval)
1272
AC_DEFINE(WITH_SGI_DL)
1273
DYNLOADFILE="dynload_dl.o"
1274
dldir=$withval
1275
if test ! -z "$dldir" -a -d "$dldir"
Guido van Rossum's avatar
Guido van Rossum committed
1276
then LDFLAGS="$LDFLAGS -L$dldir"
1277
else AC_ERROR(proper usage is --with-sgi-dl=DIRECTORY)
Guido van Rossum's avatar
Guido van Rossum committed
1278
fi
1279
DLINCLDIR=${dldir}
1280
LIBS="$LIBS -ldl -lmld"], AC_MSG_RESULT(no))
1281

1282
AC_MSG_CHECKING(for --with-dl-dld)
1283
AC_ARG_WITH(dl-dld, [  --with-dl-dld=DL_DIR,DLD_DIR    GNU dynamic linking], [
1284
AC_MSG_RESULT($withval)
1285
AC_DEFINE(WITH_DL_DLD)
1286
DYNLOADFILE="dynload_dl.o"
1287 1288
dldir=`echo "$withval" | sed 's/,.*//'`
dlddir=`echo "$withval" | sed 's/.*,//'`
Barry Warsaw's avatar
Barry Warsaw committed
1289
if test ! -z "$dldir" -a -d "$dldir" -a ! -z "$dlddir" -a -d "$dlddir"
Guido van Rossum's avatar
Guido van Rossum committed
1290
then LDFLAGS="$LDFLAGS -L$dldir -L$dlddir"
1291 1292 1293
else AC_ERROR(proper usage is --with-dl-dld=DL_DIRECTORY,DLD_DIRECTORY)
fi
DLINCLDIR=${dldir}
1294
LIBS="$LIBS -ldl -ldld"], AC_MSG_RESULT(no))
Guido van Rossum's avatar
Guido van Rossum committed
1295

1296 1297
# the dlopen() function means we might want to use dynload_shlib.o. some
# platforms, such as AIX, have dlopen(), but don't want to use it.
1298
AC_CHECK_FUNCS(dlopen)
1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309

# DYNLOADFILE specifies which dynload_*.o file we will use for dynamic
# loading of modules.
AC_SUBST(DYNLOADFILE)
AC_MSG_CHECKING(DYNLOADFILE)
if test -z "$DYNLOADFILE"
then
	case $ac_sys_system/$ac_sys_release in
	AIX*) DYNLOADFILE="dynload_aix.o";;
	BeOS*) DYNLOADFILE="dynload_beos.o";;
	hp*|HP*) DYNLOADFILE="dynload_hpux.o";;
1310
	Darwin/*) DYNLOADFILE="dynload_next.o";;
1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326
	*)
	# use dynload_shlib.c and dlopen() if we have it; otherwise stub
	# out any dynamic loading
	if test "$ac_cv_func_dlopen" = yes
	then DYNLOADFILE="dynload_shlib.o"
	else DYNLOADFILE="dynload_stub.o"
	fi
	;;
	esac
fi
AC_MSG_RESULT($DYNLOADFILE)
if test "$DYNLOADFILE" != "dynload_stub.o"
then
	AC_DEFINE(HAVE_DYNAMIC_LOADING)
fi

1327 1328 1329 1330 1331 1332
# MACHDEP_OBJS can be set to platform-specific object files needed by Python

AC_SUBST(MACHDEP_OBJS)
AC_MSG_CHECKING(MACHDEP_OBJS)
if test -z "$MACHDEP_OBJS"
then
1333 1334 1335
	MACHDEP_OBJS=$extra_machdep_objs
else
	MACHDEP_OBJS="$MACHDEP_OBJS $extra_machdep_objs"
1336
fi
1337
AC_MSG_RESULT(MACHDEP_OBJS)
1338

Guido van Rossum's avatar
Guido van Rossum committed
1339
# checks for library functions
1340
AC_CHECK_FUNCS(alarm chown chroot clock confstr ctermid ctermid_r execv \
1341
 flock fork fsync fdatasync fpathconf ftime ftruncate \
1342
 gai_strerror getgroups getlogin getpeername getpid getpwent getwd \
1343
 hstrerror inet_pton kill link lstat mkfifo mktime mremap \
1344
 nice pathconf pause plock poll pthread_init \
1345
 putenv readlink \
1346
 select setegid seteuid setgid \
1347
 setlocale setregid setreuid setsid setpgid setuid setvbuf snprintf \
1348
 sigaction siginterrupt sigrelse strftime strptime symlink sysconf \
1349
 tcgetpgrp tcsetpgrp tempnam timegm times tmpfile tmpnam tmpnam_r \
1350
 truncate uname waitpid _getpty getpriority)
1351

1352 1353 1354 1355 1356
# check for openpty and forkpty

AC_CHECK_FUNCS(openpty,, AC_CHECK_LIB(util,openpty, [AC_DEFINE(HAVE_OPENPTY)] [LIBS="$LIBS -lutil"]))
AC_CHECK_FUNCS(forkpty,, AC_CHECK_LIB(util,forkpty, [AC_DEFINE(HAVE_FORKPTY)] [LIBS="$LIBS -lutil"]))

1357 1358 1359
# check for long file support functions
AC_CHECK_FUNCS(fseek64 fseeko fstatvfs ftell64 ftello statvfs)

1360
AC_REPLACE_FUNCS(dup2 getcwd strdup strerror memmove)
1361 1362 1363
AC_CHECK_FUNCS(getpgrp, AC_TRY_COMPILE([#include <unistd.h>], [getpgrp(0);], AC_DEFINE(GETPGRP_HAVE_ARG)))
AC_CHECK_FUNCS(setpgrp, AC_TRY_COMPILE([#include <unistd.h>], [setpgrp(0,0);], AC_DEFINE(SETPGRP_HAVE_ARG)))
AC_CHECK_FUNCS(gettimeofday, AC_TRY_COMPILE([#include <sys/time.h>], [gettimeofday((struct timeval*)0,(struct timezone*)0);], ,AC_DEFINE(GETTIMEOFDAY_NO_TZ)))
Guido van Rossum's avatar
Guido van Rossum committed
1364

1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466
AC_CHECK_FUNCS(getaddrinfo, [dnl
AC_MSG_CHECKING(getaddrinfo bug)
AC_TRY_RUN([
#include <sys/types.h>
#include <netdb.h>
#include <string.h>
#include <sys/socket.h>
#include <netinet/in.h>

main()
{
  int passive, gaierr, inet4 = 0, inet6 = 0;
  struct addrinfo hints, *ai, *aitop;
  char straddr[INET6_ADDRSTRLEN], strport[16];

  for (passive = 0; passive <= 1; passive++) {
    memset(&hints, 0, sizeof(hints));
    hints.ai_family = AF_UNSPEC;
    hints.ai_flags = passive ? AI_PASSIVE : 0;
    hints.ai_socktype = SOCK_STREAM;
    if ((gaierr = getaddrinfo(NULL, "54321", &hints, &aitop)) != 0) {
      (void)gai_strerror(gaierr);
      goto bad;
    }
    for (ai = aitop; ai; ai = ai->ai_next) {
      if (ai->ai_addr == NULL ||
          ai->ai_addrlen == 0 ||
          getnameinfo(ai->ai_addr, ai->ai_addrlen,
                      straddr, sizeof(straddr), strport, sizeof(strport),
                      NI_NUMERICHOST|NI_NUMERICSERV) != 0) {
        goto bad;
      }
      switch (ai->ai_family) {
      case AF_INET:
        if (strcmp(strport, "54321") != 0) {
          goto bad;
        }
        if (passive) {
          if (strcmp(straddr, "0.0.0.0") != 0) {
            goto bad;
          }
        } else {
          if (strcmp(straddr, "127.0.0.1") != 0) {
            goto bad;
          }
        }
        inet4++;
        break;
      case AF_INET6:
        if (strcmp(strport, "54321") != 0) {
          goto bad;
        }
        if (passive) {
          if (strcmp(straddr, "::") != 0) {
            goto bad;
          }
        } else {
          if (strcmp(straddr, "::1") != 0) {
            goto bad;
          }
        }
        inet6++;
        break;
      case AF_UNSPEC:
        goto bad;
        break;
      default:
        /* another family support? */
        break;
      }
    }
  }

  if (!(inet4 == 0 || inet4 == 2))
    goto bad;
  if (!(inet6 == 0 || inet6 == 2))
    goto bad;

  if (aitop)
    freeaddrinfo(aitop);
  exit(0);

 bad:
  if (aitop)
    freeaddrinfo(aitop);
  exit(1);
}
],
AC_MSG_RESULT(good)
buggygetaddrinfo=no,
AC_MSG_RESULT(buggy)
buggygetaddrinfo=yes,
AC_MSG_RESULT(buggy)
buggygetaddrinfo=yes)], [buggygetaddrinfo=yes])

if test "$buggygetaddrinfo" = "yes"; then
	if test "$ipv6" = "yes"; then
		echo 'Fatal: You must get working getaddrinfo() function.'
		echo '       or you can specify "--disable-ipv6"'.
		exit 1
	fi
fi
1467
AC_CHECK_FUNCS(getnameinfo)
1468

Guido van Rossum's avatar
Guido van Rossum committed
1469
# checks for structures
1470
AC_HEADER_TIME
Guido van Rossum's avatar
Guido van Rossum committed
1471
AC_STRUCT_TM
1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483
AC_STRUCT_TIMEZONE

AC_MSG_CHECKING(for time.h that defines altzone)
AC_CACHE_VAL(ac_cv_header_time_altzone,
[AC_TRY_COMPILE([#include <time.h>], [return altzone;],
  ac_cv_header_time_altzone=yes,
  ac_cv_header_time_altzone=no)])
AC_MSG_RESULT($ac_cv_header_time_altzone)
if test $ac_cv_header_time_altzone = yes; then
  AC_DEFINE(HAVE_ALTZONE)
fi

1484 1485
was_it_defined=no
AC_MSG_CHECKING(whether sys/select.h and sys/time.h may both be included)
1486
AC_TRY_COMPILE([
1487 1488 1489
#include <sys/types.h>
#include <sys/select.h>
#include <sys/time.h>
1490 1491
], [;], [AC_DEFINE(SYS_SELECT_WITH_SYS_TIME) was_it_defined=yes])
AC_MSG_RESULT($was_it_defined)
Guido van Rossum's avatar
Guido van Rossum committed
1492

1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517
AC_MSG_CHECKING(for addrinfo)
AC_CACHE_VAL(ac_cv_struct_addrinfo,
AC_TRY_COMPILE([
#		include <netdb.h>],
	[struct addrinfo a],
	ac_cv_struct_addrinfo=yes,
	ac_cv_struct_addrinfo=no))
AC_MSG_RESULT($ac_cv_struct_addrinfo)
if test $ac_cv_struct_addrinfo = yes; then
	AC_DEFINE(HAVE_ADDRINFO)
fi

AC_MSG_CHECKING(for sockaddr_storage)
AC_CACHE_VAL(ac_cv_struct_sockaddr_storage,
AC_TRY_COMPILE([
#		include <sys/types.h>
#		include <sys/socket.h>],
	[struct sockaddr_storage s],
	ac_cv_struct_sockaddr_storage=yes,
	ac_cv_struct_sockaddr_storage=no))
AC_MSG_RESULT($ac_cv_struct_sockaddr_storage)
if test $ac_cv_struct_sockaddr_storage = yes; then
	AC_DEFINE(HAVE_SOCKADDR_STORAGE)
fi

Guido van Rossum's avatar
Guido van Rossum committed
1518
# checks for compiler characteristics
1519

1520 1521
AC_C_CHAR_UNSIGNED
AC_C_CONST
1522

1523 1524 1525 1526
works=no
AC_MSG_CHECKING(for working volatile)
AC_TRY_COMPILE([],[volatile int x; x = 0;], works=yes, AC_DEFINE(volatile, []))
AC_MSG_RESULT($works)
Guido van Rossum's avatar
Guido van Rossum committed
1527

1528 1529 1530 1531
works=no
AC_MSG_CHECKING(for working signed char)
AC_TRY_COMPILE([], [signed char c;], works=yes, AC_DEFINE(signed, []))
AC_MSG_RESULT($works)
1532

1533 1534
have_prototypes=no
AC_MSG_CHECKING(for prototypes)
1535 1536
AC_TRY_COMPILE([int foo(int x) { return 0; }], [return foo(10);],
AC_DEFINE(HAVE_PROTOTYPES) have_prototypes=yes)
1537
AC_MSG_RESULT($have_prototypes)
1538

1539 1540
works=no
AC_MSG_CHECKING(for variable length prototypes and stdarg.h)
1541
AC_TRY_COMPILE([
1542
#include <stdarg.h>
1543 1544 1545 1546 1547 1548 1549 1550 1551
int foo(int x, ...) {
	va_list va;
	va_start(va, x);
	va_arg(va, int);
	va_arg(va, char *);
	va_arg(va, double);
	return 0;
}
], [return foo(10, "", 3.14);],
1552 1553
AC_DEFINE(HAVE_STDARG_PROTOTYPES) works=yes)
AC_MSG_RESULT($works)
1554

1555 1556 1557 1558 1559 1560
if test "$have_prototypes" = yes; then
bad_prototypes=no
AC_MSG_CHECKING(for bad exec* prototypes)
AC_TRY_COMPILE([#include <unistd.h>], [char **t;execve("@",t,t);], ,
	AC_DEFINE(BAD_EXEC_PROTOTYPES) bad_prototypes=yes)
AC_MSG_RESULT($bad_prototypes)
Guido van Rossum's avatar
Guido van Rossum committed
1561 1562
fi

1563 1564 1565 1566 1567 1568 1569 1570 1571 1572
# check if sockaddr has sa_len member
AC_MSG_CHECKING(if sockaddr has sa_len member)
AC_TRY_COMPILE([#include <sys/types.h>
#include <sys/socket.h>],
[struct sockaddr x;
x.sa_len = 0;],
	AC_MSG_RESULT(yes)
	AC_DEFINE(HAVE_SOCKADDR_SA_LEN),
	AC_MSG_RESULT(no))

1573
AC_MSG_CHECKING(for bad static forward)
1574 1575
AC_CACHE_VAL(ac_cv_bad_static_forward,
[AC_TRY_RUN([
1576 1577
struct s { int a; int b; };
static struct s foo;
Guido van Rossum's avatar
Guido van Rossum committed
1578 1579 1580 1581 1582
int foobar() {
 static int random;
 random = (int) &foo;
 return random;
}
1583
static struct s foo = { 1, 2 };
Guido van Rossum's avatar
Guido van Rossum committed
1584 1585
main() {
 exit(!((int)&foo == foobar()));
1586 1587 1588 1589
}],
ac_cv_bad_static_forward=no,
ac_cv_bad_static_forward=yes,
ac_cv_bad_static_forward=no)])
1590 1591 1592 1593 1594
AC_MSG_RESULT($ac_cv_bad_static_forward)
if test "$ac_cv_bad_static_forward" = yes
then
    AC_DEFINE(BAD_STATIC_FORWARD)
fi
1595

1596 1597
va_list_is_array=no
AC_MSG_CHECKING(whether va_list is an array)
1598 1599 1600 1601 1602 1603
AC_TRY_COMPILE([
#ifdef HAVE_STDARG_PROTOTYPES
#include <stdarg.h>
#else
#include <varargs.h>
#endif
1604 1605 1606
], [va_list list1, list2; list1 = list2;], , 
AC_DEFINE(VA_LIST_IS_ARRAY) va_list_is_array=yes)
AC_MSG_RESULT($va_list_is_array)
1607

1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624
# sigh -- gethostbyname_r is a mess; it can have 3, 5 or 6 arguments :-(
AC_CHECK_FUNC(gethostbyname_r, [
  AC_DEFINE(HAVE_GETHOSTBYNAME_R)
  AC_MSG_CHECKING([gethostbyname_r with 6 args])
  OLD_CFLAGS=$CFLAGS
  CFLAGS="$CFLAGS $MY_CPPFLAGS $MY_THREAD_CPPFLAGS $MY_CFLAGS"
  AC_TRY_COMPILE([
#   include <netdb.h>
  ], [
    char *name;
    struct hostent *he, *res;
    char buffer[2048];
    int buflen = 2048;
    int h_errnop;

    (void) gethostbyname_r(name, he, buffer, buflen, &res, &h_errnop)
  ], [
1625
    AC_DEFINE(HAVE_GETHOSTBYNAME_R)
1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641
    AC_DEFINE(HAVE_GETHOSTBYNAME_R_6_ARG)
    AC_MSG_RESULT(yes)
  ], [
    AC_MSG_RESULT(no)
    AC_MSG_CHECKING([gethostbyname_r with 5 args])
    AC_TRY_COMPILE([
#     include <netdb.h>
    ], [
      char *name;
      struct hostent *he;
      char buffer[2048];
      int buflen = 2048;
      int h_errnop;

      (void) gethostbyname_r(name, he, buffer, buflen, &h_errnop)
    ], [
1642
      AC_DEFINE(HAVE_GETHOSTBYNAME_R)
1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656
      AC_DEFINE(HAVE_GETHOSTBYNAME_R_5_ARG)
      AC_MSG_RESULT(yes)
    ], [
      AC_MSG_RESULT(no)
      AC_MSG_CHECKING([gethostbyname_r with 3 args])
      AC_TRY_COMPILE([
#       include <netdb.h>
      ], [
        char *name;
        struct hostent *he;
        struct hostent_data data;

        (void) gethostbyname_r(name, he, &data);
      ], [
1657
        AC_DEFINE(HAVE_GETHOSTBYNAME_R)
1658 1659 1660 1661 1662 1663 1664 1665 1666
        AC_DEFINE(HAVE_GETHOSTBYNAME_R_3_ARG)
        AC_MSG_RESULT(yes)
      ], [
        AC_MSG_RESULT(no)
      ])
    ])
  ])
  CFLAGS=$OLD_CFLAGS
], [
1667
  AC_CHECK_FUNCS(gethostbyname)
1668 1669 1670 1671
])
AC_SUBST(HAVE_GETHOSTBYNAME_R_6_ARG)
AC_SUBST(HAVE_GETHOSTBYNAME_R_5_ARG)
AC_SUBST(HAVE_GETHOSTBYNAME_R_3_ARG)
1672
AC_SUBST(HAVE_GETHOSTBYNAME_R)
1673 1674
AC_SUBST(HAVE_GETHOSTBYNAME)

Guido van Rossum's avatar
Guido van Rossum committed
1675 1676 1677
# checks for system services
# (none yet)

1678
# Linux requires this for correct f.p. operations
1679 1680 1681 1682
AC_CHECK_FUNC(__fpu_control,
  [],
  [AC_CHECK_LIB(ieee, __fpu_control)
])
Guido van Rossum's avatar
Guido van Rossum committed
1683

1684 1685
# Check for --with-fpectl
AC_MSG_CHECKING(for --with-fpectl)
1686 1687
AC_ARG_WITH(fpectl,
[  --with-fpectl                   enable SIGFPE catching], [
1688 1689 1690
if test "$withval" != no
then AC_DEFINE(WANT_SIGFPE_HANDLER) AC_MSG_RESULT(yes)
else AC_MSG_RESULT(no)
1691 1692
fi],
[AC_MSG_RESULT(no)])
1693

1694 1695
# check for --with-libm=...
AC_SUBST(LIBM)
1696
case $ac_sys_system in
1697
Darwin) ;;
1698
BeOS) ;;
1699 1700
*) LIBM=-lm
esac
1701
AC_MSG_CHECKING(for --with-libm=STRING)
1702
AC_ARG_WITH(libm, [  --with-libm=STRING              math library], [
1703 1704 1705 1706
if test "$withval" = no
then LIBM=
     AC_MSG_RESULT(force LIBM empty)
elif test "$withval" != yes
1707
then LIBM=$withval
1708
     AC_MSG_RESULT(set LIBM=\"$withval\")
1709
else AC_ERROR(proper usage is --with-libm=STRING)
1710 1711
fi],
[AC_MSG_RESULT(default LIBM=\"$LIBM\")])
1712 1713 1714

# check for --with-libc=...
AC_SUBST(LIBC)
1715
AC_MSG_CHECKING(for --with-libc=STRING)
1716
AC_ARG_WITH(libc, [  --with-libc=STRING              C library], [
1717 1718 1719 1720
if test "$withval" = no
then LIBC=
     AC_MSG_RESULT(force LIBC empty)
elif test "$withval" != yes
1721
then LIBC=$withval
1722
     AC_MSG_RESULT(set LIBC=\"$withval\")
1723
else AC_ERROR(proper usage is --with-libc=STRING)
1724 1725
fi],
[AC_MSG_RESULT(default LIBC=\"$LIBC\")])
1726

1727 1728 1729
# check for hypot() in math library
LIBS_SAVE=$LIBS
LIBS="$LIBS $LIBM"
1730
AC_REPLACE_FUNCS(hypot)
1731 1732
LIBS=$LIBS_SAVE

1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750
# check whether malloc(0) returns NULL or not
AC_MSG_CHECKING(what malloc(0) returns)
AC_CACHE_VAL(ac_cv_malloc_zero,
[AC_TRY_RUN([#include <stdio.h>
#ifdef HAVE_STDLIB
#include <stdlib.h>
#else
char *malloc(), *realloc();
int *free();
#endif
main() {
	char *p;
	p = malloc(0);
	if (p == NULL) exit(1);
	p = realloc(p, 0);
	if (p == NULL) exit(1);
	free(p);
	exit(0);
1751 1752 1753 1754
}],
ac_cv_malloc_zero=nonnull,
ac_cv_malloc_zero=null,
ac_cv_malloc_zero=nonnull)]) # XXX arm cross-compile?
1755 1756 1757 1758 1759 1760
AC_MSG_RESULT($ac_cv_malloc_zero)
if test "$ac_cv_malloc_zero" = null
then
  AC_DEFINE(MALLOC_ZERO_RETURNS_NULL)
fi

1761 1762 1763 1764 1765 1766
# check for wchar.h
AC_CHECK_HEADER(wchar.h,
AC_DEFINE(HAVE_WCHAR_H) wchar_h="yes",
wchar_h="no"
)

1767 1768 1769
# determine wchar_t size
if test "$wchar_h" = yes
then
1770
  AC_CHECK_SIZEOF(wchar_t, 4)
1771 1772 1773 1774 1775 1776 1777 1778
fi

AC_MSG_CHECKING(what type to use for unicode)
AC_ARG_ENABLE(unicode, 
[  --enable-unicode[=ucs2,ucs4]    Enable Unicode strings (default is yes)],,enable_unicode=yes)

if test $enable_unicode = yes
then
1779 1780
  # Without any arguments, Py_UNICODE defaults to two-byte mode
  enable_unicode="ucs2"
1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791
fi

case "$enable_unicode" in
ucs2) unicode_size="2"
      AC_DEFINE(Py_UNICODE_SIZE,2)
      ;;
ucs4) unicode_size="4"
      AC_DEFINE(Py_UNICODE_SIZE,4)
      ;;
esac

1792
AC_SUBST(UNICODE_OBJS)
1793 1794
if test "$enable_unicode" = "no"
then
1795
  UNICODE_OBJS=""
1796 1797
  AC_MSG_RESULT(not used)
else
1798
  UNICODE_OBJS="Objects/unicodeobject.o Objects/unicodectype.o"
1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817
  AC_DEFINE(Py_USING_UNICODE)
  if test "$unicode_size" = "$ac_cv_sizeof_wchar_t"
  then
    PY_UNICODE_TYPE="wchar_t"
    AC_DEFINE(HAVE_USABLE_WCHAR_T)
    AC_DEFINE(PY_UNICODE_TYPE,wchar_t)
  elif test "$ac_cv_sizeof_short" = "$unicode_size"
  then
       PY_UNICODE_TYPE="unsigned short"
       AC_DEFINE(PY_UNICODE_TYPE,unsigned short)
  elif test "$ac_cv_sizeof_long" = "$unicode_size"
  then
       PY_UNICODE_TYPE="unsigned long"
       AC_DEFINE(PY_UNICODE_TYPE,unsigned long)
  else
       PY_UNICODE_TYPE="no type found"
  fi
  AC_MSG_RESULT($PY_UNICODE_TYPE)
fi
1818 1819 1820 1821

# check for endianness
AC_C_BIGENDIAN

1822 1823 1824
# Check whether right shifting a negative integer extends the sign bit
# or fills with zeros (like the Cray J90, according to Tim Peters).
AC_MSG_CHECKING(whether right shift extends the sign bit)
1825
AC_CACHE_VAL(ac_cv_rshift_extends_sign, [
1826 1827 1828
AC_TRY_RUN([
int main()
{
1829
	exit(((-1)>>3 == -1) ? 0 : 1);
1830
}
1831 1832 1833 1834
],
ac_cv_rshift_extends_sign=yes,
ac_cv_rshift_extends_sign=no,
ac_cv_rshift_extends_sign=yes)])
1835 1836 1837 1838 1839 1840
AC_MSG_RESULT($ac_cv_rshift_extends_sign)
if test "$ac_cv_rshift_extends_sign" = no
then
  AC_DEFINE(SIGNED_RIGHT_SHIFT_ZERO_FILLS)
fi

1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854
# check for getc_unlocked and related locking functions
AC_MSG_CHECKING(for getc_unlocked() and friends)
AC_CACHE_VAL(ac_cv_have_getc_unlocked, [
AC_TRY_LINK([#include <stdio.h>],[
	FILE *f = fopen("/dev/null", "r");
	flockfile(f);
	getc_unlocked(f);
	funlockfile(f);
], ac_cv_have_getc_unlocked=yes, ac_cv_have_getc_unlocked=no)])
AC_MSG_RESULT($ac_cv_have_getc_unlocked)
if test "$ac_cv_have_getc_unlocked" = yes
then
  AC_DEFINE(HAVE_GETC_UNLOCKED)
fi
1855

1856 1857 1858 1859
# check for readline 4.0
AC_CHECK_LIB(readline, rl_pre_input_hook,
	AC_DEFINE(HAVE_RL_PRE_INPUT_HOOK), , -ltermcap)

1860 1861 1862 1863
# check for readline 4.2
AC_CHECK_LIB(readline, rl_completion_matches,
	AC_DEFINE(HAVE_RL_COMPLETION_MATCHES), , -ltermcap)

1864 1865 1866 1867 1868 1869 1870 1871 1872 1873
AC_MSG_CHECKING(for broken nice())
AC_CACHE_VAL(ac_cv_broken_nice, [
AC_TRY_RUN([
int main()
{
	int val1 = nice(1);
	if (val1 != -1 && val1 == nice(2))
		exit(0);
	exit(1);
}
1874 1875 1876 1877
],
ac_cv_broken_nice=yes,
ac_cv_broken_nice=no,
ac_cv_broken_nice=no)])
1878 1879 1880 1881 1882 1883
AC_MSG_RESULT($ac_cv_broken_nice)
if test "$ac_cv_broken_nice" = yes
then
  AC_DEFINE(HAVE_BROKEN_NICE)
fi

1884 1885 1886 1887 1888 1889 1890 1891 1892
# THIS MUST BE LAST, IT CAN BREAK OTHER TESTS!
# Add sys/socket.h to confdefs.h
cat >> confdefs.h <<\EOF
#ifdef HAVE_SYS_SOCKET_H
#include <sys/socket.h>
#endif
EOF
AC_CHECK_TYPE(socklen_t, int)

1893 1894 1895 1896 1897 1898 1899
# Add Python/ prefix to LIBOBJS
libobjs=$LIBOBJS
LIBOBJS=
for obj in $libobjs; do
    LIBOBJS="$LIBOBJS Python/$obj"
done

1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911
#AC_MSG_CHECKING(for Modules/Setup)
#if test ! -f Modules/Setup ; then
#    if test ! -d Modules ; then
#        mkdir Modules
#    fi
#    cp "$srcdir/Modules/Setup.dist" Modules/Setup
#    AC_MSG_RESULT(creating)
#else
#    AC_MSG_RESULT(already exists)
#fi

AC_SUBST(SRCDIRS)
1912
SRCDIRS="Parser Grammar Objects Python Modules"
1913
AC_MSG_CHECKING(for build directories)
1914 1915 1916
for dir in $SRCDIRS; do
    if test ! -d $dir; then
        mkdir $dir
1917
    fi
1918 1919
done
AC_MSG_RESULT(done)
1920

Guido van Rossum's avatar
Guido van Rossum committed
1921
# generate output files
1922
AC_OUTPUT(Makefile.pre Modules/Setup.config)
1923

1924 1925 1926 1927 1928
echo "creating Setup"
if test ! -f Modules/Setup
then
	cp $srcdir/Modules/Setup.dist Modules/Setup
fi
1929

1930 1931 1932 1933 1934 1935 1936 1937 1938
echo "creating Setup.local"
if test ! -f Modules/Setup.local
then
	echo "# Edit this file for local setup changes" >Modules/Setup.local
fi

echo "creating Makefile"
$SHELL $srcdir/Modules/makesetup -c $srcdir/Modules/config.c.in \
			-s Modules Modules/Setup.config \
1939
			Modules/Setup.local Modules/Setup
1940
mv config.c Modules