AC_REVISION("$Id: configure.in,v 1.632 2002/10/04 17:49:28 grubba Exp $") |
AC_INIT(interpret.c) |
AC_CONFIG_HEADER(machine.h) |
|
if test "0`echo 'if(AC_ACVERSION >= 2.50)1'|bc`" = "01"; then |
AC_MSG_WARN([configure script has been generated with autoconf 2.50 or later.]) |
if test "x$cache_file" = "x/dev/null"; then |
cache_file=./config.cache |
if test -r "$cache_file"; then |
echo "loading cache $cache_file" |
. $cache_file |
else |
echo "creating cache $cache_file" |
> $cache_file |
fi |
fi |
fi |
|
# We want an absolute path to the source-dir. |
case "$srcdir" in |
/*) |
;; |
*) |
oldsrcdir="$srcdir" |
srcdir="`cd \"$srcdir\";pwd`" |
AC_MSG_WARN([ Converted $oldsrcdir to $srcdir, |
If this does not work, please use an absolute path to the configure script. ]) |
;; |
esac |
|
# Attempt to use bash instead of /bin/sh to run configure |
# since bash is usually several orders of magnitude faster |
# on machines that have a real /bin/sh. |
if test "x$CONFIG_SHELL" = "x"; then |
AC_PATH_PROG(bash_prog, bash, no) |
if test "x$ac_cv_path_bash_prog" = "xno"; then :; else |
AC_MSG_WARN([Found bash as $ac_cv_path_bash_prog. |
Will attempt to restart configure with bash for performance. |
|
If this fails, please set CONFIG_SHELL to /bin/sh before starting configure. |
|
]) |
CONFIG_SHELL="$ac_cv_path_bash_prog" |
export CONFIG_SHELL |
echo $CONFIG_SHELL "$srcdir/configure" $ac_configure_args |
eval exec $CONFIG_SHELL "$srcdir/configure" $ac_configure_args |
exit 17 |
fi |
else :; fi |
|
if test "x${CFLAGS-}" = x ; then |
cflags_is_set=no |
else |
cflags_is_set=yes |
fi |
|
if test "x${CPPFLAGS-}" = x ; then |
cppflags_is_set=no |
else |
cppflags_is_set=yes |
fi |
|
if test "x${LDFLAGS-}" = x ; then |
ldflags_is_set=no |
else |
ldflags_is_set=yes |
fi |
|
AC_ARG_WITH(cflags, MY_DESCR([--with-cflags=cflags], |
[specify extra c compiler flags]), |
[ CFLAGS="$with_cflags $CFLAGS" ]) |
AC_ARG_WITH(cppflags, MY_DESCR([--with-cppflags=cppflags], |
[specify extra c preprocessor flags]), |
[ CPPFLAGS="$with_cppflags $CPPFLAGS" ]) |
AC_ARG_WITH(ldflags, MY_DESCR([--with-ldflags=ldflags], |
[specify extra linker flags]), |
[ LDFLAGS="$with_ldflags $LDFLAGS" ]) |
|
for ac_site_file in $CONFIG_SITE; do |
if test -r "$ac_site_file"; then |
AC_MSG_WARN([You are using a site file to initialize configure, please |
note that this can lead to problems if anything in |
$ac_site_file is not correct. If Pike does not compile, or |
does not run, please try this to compile Pike again: |
rm ./config.cache ; CONFIG_SITE=x ./configure ; make]) |
fi |
done |
|
AC_ARG_ENABLE(binary, MY_DESCR([--disable-binary], |
[don't configure for binary build, only do tests for precompilation stuff]), |
[], [enable_binary=yes]) |
|
if test "x$enable_binary" = "xno"; then |
AC_MSG_WARN([ |
|
Short-circuiting configure tests for binary building. Only some |
targets in the Makefile can be used, typically those that only |
operates on the source directory, e.g. depend. |
|
]) |
AC_DEFINE(DISABLE_BINARY) |
else |
|
if test ! -z "$pike_cv_prog_CC_save" -a ! -z "$CC" -a "$CC" != "$pike_cv_prog_CC_save" |
then |
AC_MSG_WARN([CC is different than last time Pike was compiled, |
It is probably best to delete ./config.cache before proceeding]) |
fi |
|
pike_cv_prog_CC_save="$CC" |
|
fi |
|
AC_ARG_ENABLE(noopt-retry, MY_DESCR([--disable-noopty-retry], |
[don't retry compilation without optimizations if it fails]), |
[], [noopt_retry=yes]) |
|
# Do the below even when --disable-binary is used, since we need a |
# real $CPP, and AC_PROG_CPP wants AC_PROG_CC to be called earlier. |
# $CC will be overridden with a dummy later on. |
|
# MY_AC_PROG_CC |
# The above has problems if the smartlink binary is removed. /grubba |
AC_PROG_CC |
AC_PROG_CPP |
|
############################################################################# |
|
if test "x$enable_binary" != "xno"; then |
AC_ISC_POSIX |
AC_AIX |
AC_MINIX |
fi |
|
############################################################################# |
|
# option, cache_name, variable |
AC_DEFUN(AC_SYS_COMPILER_FLAG, |
[ |
AC_MSG_CHECKING($1) |
AC_CACHE_VAL(pike_cv_option_$2, |
[ |
OLD_CFLAGS="[$]CFLAGS" |
CFLAGS="[$]OLD_CFLAGS $1" |
old_ac_link="[$]ac_link" |
ac_link="[$]old_ac_link 2>conftezt.out.2" |
AC_TRY_RUN([ |
int foo; |
int main(int argc, char **argv) |
{ |
/* The following code triggs gcc's generation of aline opcodes, |
* which some versions of as does not support. |
*/ |
if (argc > 0) argc = 0; |
return argc; |
} |
],pike_cv_option_$2=yes, |
pike_cv_option_$2=no, [ |
AC_TRY_LINK([], [], pike_cv_option_$2=yes, pike_cv_option_$2=no) |
]) |
CFLAGS="[$]OLD_CFLAGS" |
ac_link="[$]old_ac_link" |
if grep -i 'unrecognized option' <conftezt.out.2 >/dev/null; then |
pike_cv_option_$2=no |
elif grep -i 'unknown option' <conftezt.out.2 >/dev/null; then |
# cc/HPUX says the following regarding -q64: |
# |
# cc: warning 422: Unknown option "6" ignored. |
# cc: warning 422: Unknown option "4" ignored. |
pike_cv_option_$2=no |
elif grep -i 'optimizer bugs' <conftezt.out.2 >/dev/null; then |
# gcc/FreeBSD-4.6/alpha says the following regarding -O2: |
# |
# cc1: warning: |
# *** |
# *** The -O2 flag TRIGGERS KNOWN OPTIMIZER BUGS ON THIS PLATFORM |
# *** |
pike_cv_option_$2=no |
elif grep -i 'not found' <conftezt.out.2 >/dev/null; then |
# cc/AIX says the following regarding +O3: |
# |
# cc: 1501-228 input file +O3 not found |
pike_cv_option_$2=no |
elif grep -i 'ignored' <conftezt.out.2 >/dev/null; then |
# gcc/AIX says the following regarding -fpic: |
# |
# cc1: warning: -fpic ignored (all code is position independent) |
pike_cv_option_$2=no |
else :; fi |
rm conftezt.out.2 |
]) |
|
if test x"[$]pike_cv_option_$2" = "xyes" ; then |
$3="[$]$3 $1" |
case "$3" in |
OPTIMIZE) |
CFLAGS="[$]CFLAGS $1" |
;; |
esac |
AC_MSG_RESULT(yes) |
$5 |
else |
AC_MSG_RESULT(no) |
$4 |
fi |
]) |
|
# arch, option, cache_name, variable |
AC_DEFUN(AC_SYS_CPU_COMPILER_FLAG, |
[ |
if test "`uname -m 2>/dev/null`" = "$1" ; then |
AC_SYS_COMPILER_FLAG($2,$3,$4,$5,$6) |
$7 |
fi |
]) |
|
# os, option, cache_name, variable |
AC_DEFUN(AC_SYS_OS_COMPILER_FLAG, |
[ |
if test "x$pike_cv_sys_os" = "x$1" ; then |
AC_SYS_COMPILER_FLAG($2,$3,$4,$5,$6) |
$7 |
fi |
]) |
|
define([DO_IF_OS], |
[ |
if test "x$pike_cv_sys_os" = "x$1" ; then |
$2 |
fi |
]) |
|
define([DO_IF_CPU], |
[ |
if test "`uname -m 2>/dev/null`" = "$1" ; then |
$2 |
fi |
]) |
|
############################################################################# |
|
if test "x$GCC" = "x"; then |
GCC=no |
else |
:; |
fi |
|
if test "x$GCC" = "xno" -a "x$TCC" = "xno"; then |
# |
# We want 64bit mode if possible. |
# |
|
AC_SYS_COMPILER_FLAG(-q64, q64, CFLAGS) |
|
if test "x$ac_cv_prog_cc_cross" = "xyes"; then |
# The AIX 5L/cc beta can't generate working binaries without a |
# data-segment... |
AC_MSG_CHECKING([if we're really using a cross-compiler]) |
|
AC_CACHE_VAL(pike_cv_datasegment_required, [ |
ac_cv_prog_cc_cross=no; |
AC_TRY_RUN([int foo;main(){return(0);}], [ |
pike_cv_datasegment_required=yes |
], [ |
pike_cv_datasegment_required=no |
ac_cv_prog_cc_cross=yes |
], [ |
pike_cv_datasegment_required=no |
ac_cv_prog_cc_cross=yes |
]) |
]) |
if test "x$pike_cv_datasegment_required" = "xyes"; then |
AC_MSG_RESULT([no -- Applying data-segment kludge]) |
ac_cv_prog_cc_cross=no |
cat >conftest.c <<EOF |
static int foo; |
EOF |
pike_cv_datasegemnt_file=no |
if AC_TRY_EVAL(ac_compile); then |
if test -f "conftest.$ac_objext"; then |
rm -f "data-segment.$ac_objext" |
if mv "conftest.$ac_objext" "data-segment.$ac_objext"; then |
if test -f "`pwd`/data-segment.$ac_objext"; then |
pike_cv_datasegemnt_file="`pwd`/data-segment.$ac_objext" |
else |
AC_MSG_WARN(Lost track of data-segment kludge-file.) |
fi |
else |
AC_MSG_WARN(Failed to rename data-segment kludge-file.) |
fi |
else |
AC_MSG_WARN(Can not find data-segment kludgefile.) |
fi |
else |
AC_MSG_WARN(Failed to compile data-segment kludge.) |
fi |
if test "x$pike_cv_datasegment_file" = "xno"; then |
AC_MSG_WARN(Some tests may yield false results.) |
else |
LIBS="$pike_cv_datasegment_file $LIBS" |
export LIBS |
AC_MSG_WARN(Data-segment kludge applied.) |
fi |
else |
AC_MSG_RESULT(yes) |
fi |
fi |
else |
if test "x$TCC" = "xyes"; then |
AC_MSG_CHECKING(if we can use pragma TenDRA longlong) |
AC_CACHE_VAL(pike_cv_pragma_tendra_longlong, [ |
AC_TRY_COMPILE([ |
#pragma TenDRA longlong type allow |
int main(int argc, char **argv) |
{ |
exit(0); |
} |
], [ pike_cv_pragma_tendra_longlong=yes |
], [ pike_cv_pragma_tendra_longlong=no ]) |
]) |
if test "x$pike_cv_pragma_tendra_longlong" = "xyes"; then |
AC_MSG_RESULT(yes) |
AC_DEFINE(HAVE_PRAGMA_TENDRA_LONGLONG) |
else |
AC_MSG_RESULT(no) |
fi |
|
AC_MSG_CHECKING(if we can use pragma TenDRA set longlong type) |
AC_CACHE_VAL(pike_cv_pragma_tendra_set_longlong_type, [ |
AC_TRY_COMPILE([ |
#ifdef HAVE_TENDRA_LONGLONG |
#pragma TenDRA longlong type allow |
#endif /* HAVE_TENDRA_LONGLONG */ |
#pragma TenDRA set longlong type : long long |
|
long long foo; |
|
int main(int argc, char **argv) |
{ |
exit(0); |
} |
], [ pike_cv_pragma_tendra_set_longlong_type=yes |
], [ pike_cv_pragma_tendra_set_longlong_type=no ]) |
]) |
if test "x$pike_cv_pragma_tendra_set_longlong_type" = "xyes"; then |
AC_MSG_RESULT(yes) |
AC_DEFINE(HAVE_PRAGMA_TENDRA_SET_LONGLONG_TYPE) |
else |
AC_MSG_RESULT(no) |
fi |
else :; fi |
fi |
|
############################################################################# |
|
if test "x$enable_binary" != "xno"; then |
|
# |
# The purpose of this test is to check that there is no filesystem |
# caching preventing pike from compiling correctly. |
# |
AC_MSG_CHECKING([filesystem synchronization]) |
|
AC_CACHE_VAL(pike_cv_filesystem_syncronization, |
[ |
pike_cv_filesystem_syncronization=working |
|
AC_EGREP_CPP(true, [ true ], , pike_cv_filesystem_syncronization=broken) |
AC_EGREP_CPP(false, [ false ], , pike_cv_filesystem_syncronization=broken) |
AC_EGREP_CPP(yes, [ yes ], , pike_cv_filesystem_syncronization=broken) |
AC_EGREP_CPP(no, [ no ], , pike_cv_filesystem_syncronization=broken) |
AC_EGREP_CPP(near, [ far ], pike_cv_filesystem_syncronization=broken, ) |
AC_EGREP_CPP(up, [ up ], , pike_cv_filesystem_syncronization=broken) |
AC_EGREP_CPP(down, [ down], , pike_cv_filesystem_syncronization=broken) |
]) |
|
AC_MSG_RESULT($pike_cv_filesystem_syncronization) |
if test "x$pike_cv_filesystem_syncronization" = xbroken ; then |
AC_MSG_ERROR([Filesystem caching is too aggressive. If you are using |
Samba, make sure to have the following line in your smb.conf: |
oplocks = False |
]) |
exit 1 |
fi |
|
fi |
|
############################################################################# |
|
LIBDIR=`(cd $srcdir/../lib ; pwd)` |
BINDIR=`(cd $srcdir/../bin ; pwd)` |
MANDIR=`(cd $srcdir/../man ; pwd)` |
BASEDIR=`(cd $srcdir/.. ; pwd)` |
BUILDDIR=`pwd` |
AC_SUBST(LIBDIR) |
AC_SUBST(BINDIR) |
AC_SUBST(MANDIR) |
AC_SUBST(BASEDIR) |
AC_SUBST(BUILDDIR) |
|
############################################################################# |
|
# |
# Some cross-compilation support and --disable-binary stuff |
# |
|
if test "x$enable_binary" = "xno"; then |
CROSS=yes |
else |
CROSS="$ac_cv_prog_cc_cross" |
fi |
AC_SUBST(CROSS) |
|
if test "x$enable_binary" = "xno"; then |
CC="$BINDIR/nobinary_dummy cc" |
RUNPIKE="USE_PIKE" |
RUNTPIKE="USE_PIKE" |
elif test "x$ac_cv_prog_cc_cross" = "xyes"; then |
RUNPIKE="DEFAULT_RUNPIKE" |
RUNTPIKE="USE_PIKE" |
else |
RUNPIKE="DEFAULT_RUNPIKE" |
RUNTPIKE="USE_TPIKE" |
fi |
AC_SUBST(RUNPIKE) |
AC_SUBST(RUNTPIKE) |
|
############################################################################# |
if test "x$enable_binary" != "xno"; then |
# The following tests are only relevant if we intend to build binaries. |
############################################################################# |
|
AC_CHECK_HEADERS(fnord/fnord/fnord.h) |
|
AC_MSG_CHECKING([if CHECK_HEADERS works]) |
if test "x$ac_cv_header_fnord_fnord_fnord_h" = xyes ; then |
AC_MSG_RESULT(no) |
exit 1 |
fi |
AC_MSG_RESULT(yes) |
|
############################################################################# |
|
AC_MSG_CHECKING(if we can allocate large auto variables) |
AC_CACHE_VAL(pike_cv_C_supports_large_auto, [ |
AC_TRY_LINK([ |
#include <stdio.h> |
int eat_stack(int foo) |
{ |
char large_array[131072] = ""; |
int i, sum = 0; |
|
for (i = 0; i < foo; i++) { |
/* Make sure the compiler doesn't optimize away the array. */ |
large_array[i] = sum; |
sum += foo; |
} |
for (i = 0; i < foo; i++) { |
sum += large_array[i] - large_array[foo-1-i]; |
} |
return sum; |
} |
], [ |
return !eat_stack(4711); |
], [ |
pike_cv_C_supports_large_auto=yes |
], [ |
pike_cv_C_supports_large_auto=no |
]) |
]) |
if test "$pike_cv_C_supports_large_auto" = "yes"; then |
AC_MSG_RESULT([yes - good]) |
else |
AC_MSG_RESULT([no]) |
AC_MSG_CHECKING([if we can make a workaround by defining _chkstk to call __chkstk]) |
AC_CACHE_VAL([pike_cv_kludge__chkstk], |
[ |
AC_TRY_LINK([ |
#include <stdio.h> |
int eat_stack(int foo) |
{ |
char large_array[131072] = ""; |
int i, sum = 0; |
|
for (i = 0; i < foo; i++) { |
/* Make sure the compiler doesn't optimize away the array. */ |
large_array[i] = sum; |
sum += foo; |
} |
for (i = 0; i < foo; i++) { |
sum += large_array[i] - large_array[foo-1-i]; |
} |
return sum; |
} |
|
extern size_t __chkstk(); |
size_t _chkstk() { return __chkstk(); } |
|
], [ |
return !eat_stack(4711); |
], [ |
pike_cv_kludge__chkstk=yes |
], [ |
pike_cv_kludge__chkstk=no |
]) |
]) |
if test "$pike_cv_kludge__chkstk" = "yes"; then |
AC_MSG_RESULT([yes - applying workaround]) |
AC_DEFINE(HAVE_BROKEN_CHKSTK) |
else |
AC_MSG_RESULT([no]) |
AC_ERROR([Your C compiler does not link code that uses large auto variables. |
|
Please check config.log, and fix the problem.]) |
exit 1 |
fi |
fi |
|
############################################################################# |
|
if test $ac_cv_prog_gcc = yes; then |
AC_MSG_CHECKING(for libgcc file name) |
AC_CACHE_VAL(pike_cv_libgcc_filename, |
[ |
pike_cv_libgcc_filename="`${CC-cc} -print-libgcc-file-name`" |
if test -z "$pike_cv_libgcc_filename"; then |
pike_cv_libgcc_filename=no |
else |
if test -f "$pike_cv_libgcc_filename"; then |
: |
else |
pike_cv_libgcc_filename=no |
fi |
fi |
]) |
AC_MSG_RESULT($pike_cv_libgcc_filename) |
if test x"$pike_cv_libgcc_filename" = xno; then |
LIBGCC="" |
else |
LIBGCC="$pike_cv_libgcc_filename" |
fi |
else |
LIBGCC="" |
fi |
AC_SUBST(LIBGCC) |
|
############################################################################# |
|
## Build smartlink |
|
AC_CHECK_HEADERS(stdlib.h string.h unistd.h sys/stat.h sys/types.h sys/errno.h) |
|
if test -x /usr/bin/uname 2>/dev/null; then |
UNAME=`/usr/bin/uname -sr` |
elif test -x /bin/uname 2>/dev/null; then |
UNAME=`/bin/uname -sr` |
else |
UNAME=unknown |
fi |
|
# We need some special hacks when running slowaris |
AC_PATH_PROG(uname_prog,uname,no) |
AC_MSG_CHECKING(operating system) |
AC_CACHE_VAL(pike_cv_sys_os, |
[ |
if test "$uname_prog" != "no"; then |
# uname on UNICOS doesn't work like other people's uname... |
if getconf CRAY_RELEASE >/dev/null 2>&1; then |
pike_cv_sys_os="UNICOS" |
else |
pike_cv_sys_os="`uname`" |
fi |
|
case "$pike_cv_sys_os" in |
SunOS) |
case "`uname -r`" in |
5.*) pike_cv_sys_os="Solaris" ;; |
esac |
;; |
Monterey64) |
# According to the release notes, the string "Monterey64" |
# will be changed to "AIX" in the final release. |
# (Monterey 64 is also known as AIX 5L). |
pike_cv_sys_os="AIX" |
;; |
*Windows*|*windows*) |
pike_cv_sys_os="Windows_NT" |
;; |
esac |
else |
pike_cv_sys_os="Not Solaris" |
fi |
]) |
AC_MSG_RESULT($pike_cv_sys_os) |
|
if test "$GCC" = "yes"; then :; else |
# |
# Special hack for HP-UX stupid cc |
# |
if test "$pike_cv_sys_os" = "HP-UX"; then |
AC_TRY_COMPILE([int foo(int bar);],[],[], |
[ |
OLD_CC="${CC-cc}" |
OLD_CFLAGS="$CFLAGS" |
case "/$CC" in |
*/smartlink\ cc) |
if test -x /usr/bin/cc; then |
CC="`echo $CC|sed -e 's/ cc/ \/usr\/bin\/cc/`" |
else |
: ; |
fi |
;; |
esac |
CFLAGS="-Ae +Olibcalls $CFLAGS" |
AC_TRY_COMPILE([int foo(int bar);],[],[],[ |
CC="$OLD_CC" |
CFLAGS="$OLD_CFLAGS" |
]) |
pike_cv_prog_CC="${CC}" |
]) |
fi |
fi |
|
if test "$pike_cv_sys_os" = "Solaris" ; then |
AC_DEFINE(SOLARIS) |
else |
: |
fi |
|
# Workaround for compiling Pike on Cygwin |
case "$pike_cv_sys_os" in |
CYGWIN*) |
echo 'Cygwin host detected. Enabling workarounds...' |
# winsock.h, winbase.h, winsock2.h, windows.h, wingdi.h |
# are part of VC api but given as headers in cygwin. We |
# should detect them when using cygwin |
ac_cv_header_wingdi_h="no" |
ac_cv_header_winsock_h="no" |
ac_cv_header_winsock2_h="no" |
ac_cv_header_winbase_h="no" |
ac_cv_header_windows_h="no" |
;; |
esac |
|
# FIXME: Add proper tests |
AC_MSG_CHECKING([for ld.so run path method]) |
AC_CACHE_VAL(pike_cv_ld_so_run_path_method, [ |
case "$UNAME" in |
OSF1\ V4.*|OSF1\ V5.*|OSF1\ V6.*) |
pike_cv_run_path_method=rpath |
;; |
HPUX\ 11.*) |
pike_cv_run_path_method=plus_b |
;; |
IRIX\ 6.*) |
pike_cv_run_path_method=rpath |
;; |
IRIX\ 5.*) |
pike_cv_run_path_method=rpath |
;; |
SunOS\ 5.*) |
if test "$TCC" = "yes"; then |
# tcc doesn't know about -R |
pike_cv_run_path_method=wl_r |
else |
pike_cv_run_path_method=r |
fi |
;; |
Linux\ 2.*) |
pike_cv_run_path_method=wl |
;; |
UnixWare\ 7.*|OpenUNIX\ 8.*) |
if test "$ac_cv_prog_gcc" = "yes"; then |
pike_cv_run_path_method=xlinker_yp_ |
else |
pike_cv_run_path_method=yp_ |
fi |
;; |
*) |
pike_cv_run_path_method=ld_library_path |
;; |
esac |
]) |
case "$pike_cv_run_path_method" in |
rpath) |
AC_DEFINE(USE_RPATH) |
AC_MSG_RESULT([use -rpath]) |
;; |
plus_b) |
AC_DEFINE(USE_PLUS_b) |
AC_MSG_RESULT([use +b]) |
;; |
yp_) |
AC_DEFINE(USE_YP_) |
AC_MSG_RESULT([use -Yp,]) |
;; |
xlinker_yp_) |
AC_DEFINE(USE_XLINKER_YP_) |
AC_MSG_RESULT([use -Xlinker -Yp, -Xlinker]) |
;; |
wl_r) |
AC_DEFINE(USE_Wl_R) |
AC_MSG_RESULT([use -Wl,-R]) |
;; |
r) |
AC_DEFINE(USE_R) |
AC_MSG_RESULT([use -R]) |
;; |
wl) |
AC_DEFINE(USE_Wl) |
AC_MSG_RESULT([use -Wl,-rpath]) |
;; |
ld_library_path|*) |
AC_DEFINE(USE_LD_LIBRARY_PATH) |
AC_MSG_RESULT([use LD_LIBRARY_PATH/LD_RUN_PATH]) |
;; |
esac |
|
|
# Strip smartlink from $CC |
REALCC="`echo $CC|sed -e 's/.*smartlink //'`" |
|
# Fix a smartlink |
SMARTLINK="$BUILDDIR/smartlink" |
|
AC_MSG_CHECKING(if $SMARTLINK exists is up to date and works) |
if ls -1tr "$SMARTLINK${ac_exeext}" "$srcdir/smartlink.$ac_ext" 2>/dev/null | head -1 | grep "smartlink.$ac_ext" >/dev/null 2>&5 && "$SMARTLINK" -v >/dev/null 2>&5; then |
AC_MSG_RESULT(yes) |
else |
AC_MSG_RESULT(no) |
SMARTBUILDCC="${REALCC-cc}" |
|
if echo foo "$CC" | egrep 'rntc.|rnt.cl' >/dev/null; then |
AC_MSG_WARN([rntcc/rntcl/rnticl/rntecl detected.]) |
AC_PATH_PROGS(SMARTBUILDCC,gcc cc egcs,gcc, $PATH:$EXTRA_PATH) |
echo Using $SMARTBUILDCC to compile smartlink. |
else |
if test "x$ac_cv_prog_cc_cross" = "xyes"; then |
AC_MSG_WARN([Crosscompiler detected.]) |
AC_PATH_PROGS(SMARTBUILDCC, gcc cc egcs, gcc, /usr/bin:/bin/:/usr/ccs/bin:/usr/local/bin:$PATH:$EXTRA_PATH) |
echo Using $SMARTBUILDCC to compile smartlink. |
fi |
fi |
|
rm -f "$SMARTLINK" |
|
AC_MSG_CHECKING(whether smartlink compiles) |
|
link_cmd='${SMARTBUILDCC-cc} -o smartlink${ac_exeext} $CFLAGS -I. $CPPFLAGS $LDFLAGS $srcdir/smartlink.$ac_ext $LIBS 2>&5' |
if { (eval echo Compiling smartlink: \"$link_cmd\") 1>&5; (eval $link_cmd) 2>&5; } && "$BUILDDIR/smartlink" -v >/dev/null 2>&5; then |
AC_MSG_RESULT(yes) |
else |
AC_MSG_RESULT(no - use the sh script) |
SMARTLINK="$BINDIR/smartlink" |
fi |
fi |
|
CC="$SMARTLINK $REALCC" |
pike_cv_prog_CC="$CC" |
|
AC_SUBST(SMARTLINK) |
AC_SUBST(REALCC) |
export REALCC SMARTLINK |
|
AC_MSG_CHECKING([for a fallback compiler]) |
# Strip smartlink from $FALLBACK_CC |
FALLBACK_CC="`echo $FALLBACK_CC|sed -e 's/.*smartlink //'`" |
if test "x$FALLBACK_CC" = "x"; then |
AC_MSG_RESULT(no) |
else |
FALLBACK_CC="$SMARTLINK $FALLBACK_CC" |
AC_MSG_RESULT($FALLBACK_CC) |
fi |
AC_SUBST(FALLBACK_CC) |
export FALLBACK_CC |
|
############################################################################# |
fi #if test "x$enable_binary" != "xno" |
############################################################################# |
|
# Restore the -O2 that the default AC_PROG_CC adds. |
AC_SYS_COMPILER_FLAG(+O3,plus_O3,OPTIMIZE, [ |
AC_SYS_COMPILER_FLAG(-O2,O2,OPTIMIZE, [ |
AC_SYS_COMPILER_FLAG(-O,O,OPTIMIZE) |
]) |
]) |
|
if test "$GCC" = "yes"; then |
if test "$cflags_is_set" = "no"; then |
AC_SYS_COMPILER_FLAG(-pipe, pipe, OPTIMIZE) |
fi |
fi |
|
LD='$(CC) $(CFLAGS)' |
LC_REQ="-lc" |
|
case "$pike_cv_sys_os" in |
Darwin*) |
LC_REQ="-lc -lcc_dynamic" |
;; |
SCO*) |
case "$CFLAGS" in |
*-belf*) |
AC_SYS_COMPILER_FLAG(-belf,sco_belf_option,CFLAGS,[],[ |
case "$LDFLAGS" in |
*-belf*) ;; |
*) |
echo "Adding -belf option to ldflags." |
LDFLAGS="$LDFLAGS -belf" |
;; |
esac |
]) |
;; |
*) |
AC_SYS_COMPILER_FLAG(-belf,belf,CFLAGS) |
;; |
esac |
case "$LDFLAGS" in |
*-belf*) ;; |
*) |
AC_SYS_COMPILER_FLAG(-belf,belf,LDFLAGS) |
;; |
esac |
;; |
SunOS*) |
# gcc on SunOS 4 forgets to define this: |
echo "SunOS. Adding -D__USE_FIXED_PROTOTYPES__" |
CFLAGS="$CFLAGS -D__USE_FIXED_PROTOTYPES__" |
;; |
BSD/OS*) |
case "`uname -r`" in |
[4-9].*) ;; |
*) LD="$BINDIR/smartlink shlicc";; |
esac |
;; |
UnixWare*|OpenUNIX*) |
case "$CFLAGS" in |
*-Kalloca*) ;; |
*) |
if test "$GCC" != "yes"; then |
# We are using built-in inline function |
CFLAGS="$CFLAGS -Kalloca" |
CXX="$CXX -DNO_CPLUSPLUS_ALLOCA" |
LC_REQ="" |
fi |
;; |
esac |
;; |
esac |
|
AC_SUBST(LD) |
AC_SUBST(LC_REQ) |
|
############################################################################# |
|
AC_ARG_WITH(patch_gcc, MY_DESCR([--with-patch-gcc], |
[attempt to patch the UA32 relocation bug.]), |
[], [with_patch_gcc=no]) |
|
AC_ARG_WITH(force_ua32, MY_DESCR([--with-force-ua32], |
[ignore the UA32 relocation bug.]), |
[], [with_force_ua32=no]) |
|
# Some sanity checks. |
|
if test "$GCC" = "yes" -a "$pike_cv_sys_os" = "Solaris" && test "`uname -p`" = "sparc"; then |
# Solaris/sparc: |
# Check that gnu ld isn't used. |
# It's usually hidden in $prefix/sparc-sun-solaris2.?/bin/. |
# NOTE: M4 uses [] as quotes. |
gcc_ld_path="`$CC -v 2>&1 | sed -e '1,1s/[[^\/]]*\(\/.*\/\)[[^\/]]*$/\1/p;d' | sed -e '/lib\/gcc-lib\//s/lib\/gcc-lib\///;s/\/[[0-9]]*\.[[0-9]]*\.[[0-9]]*\/$/\/bin/'`" |
if test "x$gcc_ld_path" = "x"; then :; else |
if test -d "$gcc_ld_path/."; then |
if "$gcc_ld_path/ld" -v 2>&1 | grep -i GNU >/dev/null; then |
AC_MSG_WARN([GNU ld found on Solaris sparc system ($gcc_ld_path/ld).]) |
AC_MSG_WARN([This may cause the dynamic module support to fail.]) |
else :; fi |
else :; fi |
fi |
unset gcc_ld_path |
|
|
# Watch out for gcc-2.8.1 on Solaris 7 sparc machines. It generates |
# assembler code which contains .uaword directives, which in turn |
# generates code with R_SPARC_UA32 relocations, which /usr/bin/ld.so |
# has buggy support for (it doesn't relocate the MSB). |
|
# Check that gcc doesn't generate uaword opcodes |
AC_MSG_CHECKING(if your gcc generates uaword opcodes) |
AC_CACHE_VAL(pike_cv_gcc_uaword, [ |
cat > conftest.c <<EOF |
char *foo[[]] = { "bar" }; |
EOF |
pike_compile='${CC-cc} -S $CFLAGS $CPPFLAGS conftest.c 1>&5' |
pike_cv_gcc_uaword=no |
if { (eval echo configure: \"$pike_compile\") >&5; (eval $pike_compile) 2>&5; }; then |
if grep ".uaword" conftest.s 2>&5 >/dev/null; then |
echo "configure: result contains .uaword:" >&5 |
cat conftest.s >&5 |
pike_cv_gcc_uaword=yes |
else :; fi |
else |
echo "configure: failed program was:" >&5 |
cat conftest.c >&5 |
fi |
rm -rf conftest.* |
]) |
AC_MSG_RESULT($pike_cv_gcc_uaword) |
|
# Check if as generates R_SPARC_UA32 relocations from .uaword. |
if test "$pike_cv_gcc_uaword" = "yes"; then |
AC_MSG_CHECKING([if your as generates R_SPARC_UA32 relocations]) |
AC_CACHE_VAL(pike_cv_as_r_sparc_ua32, [ |
AC_TRY_ASSEMBLE([ |
.section ".rodata" |
.align 8 |
.STRING: |
.asciz "String" |
.section ".data" |
.align 4 |
.type string,#object |
.size string,4 |
string: |
.uaword .STRING |
],[ |
if /usr/ccs/bin/elfdump -r conftest.o | grep -i R_SPARC_UA32 >/dev/null 2>&AC_FD_CC; then |
pike_cv_ac_r_sparc_ua32=yes |
else |
pike_cv_ac_r_sparc_ua32=no |
fi |
],[ |
pike_cv_ac_r_sparc_ua32=no |
]) |
]) |
AC_MSG_RESULT($pike_cv_ac_r_sparc_ua32) |
if test "$pike_cv_ac_r_sparc_ua32" = "yes"; then |
AC_MSG_WARN([Your gcc/as combo may generate R_SPARC_UA32 relocations.]) |
AC_MSG_WARN([R_SPARC_UA32 relocations are unsupported in Solaris >= 2.3,]) |
AC_MSG_WARN([and have broken support in Solaris 7.]) |
|
if test "x$with_patch_gcc$with_force_ua32" = "xnono"; then |
if test -d "/var/sadm/patch/107058-01/."; then |
AC_MSG_WARN([Back out patch 107058-01, or]) |
AC_MSG_WARN([recompile gcc with a modified config/sparc/sol2.h.]) |
else |
AC_MSG_WARN([Recompile gcc with a modified config/sparc/sol2.h.]) |
fi |
|
AC_MSG_WARN([]) |
AC_MSG_WARN([You may want to try binary patching gcc.]) |
AC_MSG_WARN([In that case rerun configure with --with-patch-gcc.]) |
AC_MSG_WARN([NOTE: Binary patching is highly experimental and risky,]) |
AC_MSG_WARN([ and may break your existing gcc even more.]) |
AC_MSG_WARN([]) |
AC_MSG_WARN([R_SPARC_UA32 relocations are supported on some versions]) |
AC_MSG_WARN([of Solaris. If you want to try a binary with R_SPARC_UA32]) |
AC_MSG_WARN([relocations, rerun configure with --with-force-ua32.]) |
AC_MSG_WARN([]) |
exit 1 |
fi |
|
if test "x$with_patch_gcc" = "xno"; then :; else |
AC_MSG_WARN([Will attempt to patch gcc.]) |
|
AC_MSG_CHECKING([for cc1]) |
if test "x$with_patch_gcc" = "xyes"; then |
cc1="`$CC -v 2>&1|sed -e '/\//s!^[[^/]]*\(/.*\)/specs$!\1/cc1!p' -ed`" |
else |
cc1="$with_patch_gcc"; |
fi |
if test -f "$cc1"; then |
AC_MSG_RESULT($cc1) |
else |
AC_MSG_RESULT(not found. Tried $cc1) |
exit 1 |
fi |
|
AC_MSG_CHECKING(if $cc1 looks unpatched) |
if /usr/bin/strings "$cc1" | grep uaword >/dev/null 2>&1; then |
AC_MSG_RESULT(yes) |
else |
AC_MSG_RESULT(no -- strange) |
exit 1 |
fi |
|
AC_MSG_CHECKING(if patch_cc1 compiles) |
link_cmd='${CC-cc} -o patch_cc1${ac_exeext} $CFLAGS -I. $CPPFLAGS $LDFLAGS $srcdir/patch_cc1.$ac_ext $LIBS 2>&5' |
if { (eval echo Compiling patch_cc1: \"$link_cmd\") 1>&5; (eval $link_cmd) 2>&5; } && "$BUILDDIR/patch_cc1" -v >/dev/null 2>&5; then |
AC_MSG_RESULT(yes) |
|
if test -f "$cc1.patched"; then |
AC_MSG_ERROR([$cc1.patched already exists. |
Please move it out of the way.]) |
exit 1; |
fi |
|
if test -f "$cc1.orig"; then |
AC_MSG_ERROR([$cc1.orig already exists. |
Please move it out of the way.]) |
exit 1; |
fi |
|
AC_MSG_CHECKING(if patch_cc1 works) |
if ./patch_cc1 "$cc1" 2>&5 >"$cc1.patched"; then |
if test -f "$cc1.patched"; then :; else |
AC_MSG_RESULT(no - failed to create $cc1.patched) |
exit 1 |
fi |
if chmod 755 "$cc1.patched"; then :; else |
AC_MSG_RESULT(no - failed to set permission to 755 on $cc1.patched) |
exit 1 |
fi |
|
if test "`/bin/ls -l \"$cc1\"|awk '{print $5}'`" = "`/bin/ls -l \"$cc1.patched\"|awk '{print $5}'`"; then |
if /usr/bin/strings "$cc1.patched" | grep uaword >/dev/null 2>&1; then |
rm -f "$cc1.patched" |
AC_MSG_RESULT(no -- patching failed) |
exit 1 |
fi |
|
if "$cc1.patched" --help >/dev/null 2>&1; then :; else |
AC_MSG_RESULT(no -- the patched binary does not seem to work) |
exit 1 |
fi |
|
AC_MSG_RESULT(yes) |
|
AC_MSG_WARN(Activating the patched cc1.) |
AC_MSG_WARN(NOTE: Entering critical section.) |
AC_MSG_WARN(If configure fails at this point a broken gcc my result.) |
if /usr/bin/mv -f "$cc1" "$cc1.orig"; then |
|
AC_MSG_WARN(Moved $cc1 to $cc1.orig.) |
|
if /usr/bin/mv -f "$cc1.patched" "$cc1"; then |
AC_MSG_WARN(Patching seems to have succeeded.) |
AC_MSG_WARN(Please rerun configure.) |
exit 1 |
fi |
|
AC_MSG_WARN(Moving the patched cc1 into place failed.) |
AC_MSG_WARN(Will try to restore the old cc1.) |
|
if /usr/bin/mv -f "$cc1.orig" "$cc1"; then |
AC_MSG_WARN(The old cc1 has been restored.) |
exit 1 |
fi |
|
AC_MSG_ERROR([Restoring the old cc1 failed. |
Your installation of gcc is most likely broken now. |
Sorry, you will have to restore it yourself. |
Please move $cc1.orig to $cc1.]) |
exit 1 |
else |
AC_MSG_ERROR([Failed to move the old cc1 to safety. |
Please replace $cc1 with $cc1.patched by hand.]) |
exit 1 |
fi |
else |
rm -f "$cc1.patched" |
AC_MSG_ERROR([The size has changed. |
You need to patch cc1 by hand.]) |
exit 1 |
fi |
else |
AC_MSG_RESULT(no -- you need to patch cc1 by hand) |
exit 1 |
fi |
else |
AC_MSG_RESULT(no -- you need to patch cc1 by hand) |
exit 1 |
fi |
fi |
else :; fi |
else :; fi |
else :; fi |
|
############################################################################# |
|
|
AC_ARG_WITH(root, MY_DESCR([--with-root=path], |
[specify a cross-compilation root-directory]),[ |
case "$with_root" in |
/) |
with_root="" |
;; |
/*) |
;; |
no) |
with_root="" |
;; |
*) |
AC_MSG_WARN([Root path $with_root is not absolute. Ignored.]) |
with_root="" |
;; |
esac |
],[with_root=""]) |
MY_AC_ARG_WITH(relocatable_dumped_modules, |
MY_DESCR([--with-relocatable-dumped-modules], |
[make dumped modules relocatable]), |
[with_relocatable_dumped_modules=yes]) |
AC_ARG_WITH(dynamic_modules, MY_DESCR([--without-dynamic-modules], |
[link modules statically])) |
MY_AC_ARG_WITH(static_linking, MY_DESCR([--with-static-linking], |
[link statically, if possible]), |
[with_static_linking=yes]) |
AC_ARG_WITH(site-prefixes, |
MY_DESCR([--with-site-prefixes], |
[list of prefixes to search for include, lib and bin dirs.])) |
AC_ARG_WITH(include-path, |
MY_DESCR([--with-include-path], |
[a list of paths to search for include files.])) |
AC_ARG_WITH(lib-path, |
MY_DESCR([--with-lib-path], |
[a list of paths to search for libraries.])) |
|
AC_ARG_WITH(long-double-precision, MY_DESCR([--with-long-double-precision], |
[use long double precision floats])) |
AC_ARG_WITH(double-precision, MY_DESCR([--with-double-precision], |
[use double precision floats])) |
|
AC_ARG_WITH(long-long-int, MY_DESCR([--with-long-long-int], |
[use long long native type int (EXPERIMENTAL)])) |
AC_ARG_WITH(long-int, MY_DESCR([--with-long-int], |
[use long native type int (EXPERIMENTAL)])) |
AC_ARG_WITH(int-int, MY_DESCR([--with-int-int], |
[use int native type int])) |
AC_ARG_WITH(short-int, MY_DESCR([--with-short-int], |
[use short native type int (EXPERIMENTAL)])) |
|
AC_ARG_WITH(gdbm, MY_DESCR([--without-gdbm],[no GNU database manager support])) |
AC_ARG_WITH(gmp, MY_DESCR([--without-gmp],[no support for Gmp bignums])) |
MY_AC_ARG_WITH(dmalloc, MY_DESCR([--with-dmalloc],[enable memory-leak tests]), |
[AC_DEFINE(DEBUG_MALLOC,10)]) |
MY_AC_ARG_WITH(dmalloc-malloc, MY_DESCR([--with-dmalloc-malloc], |
[Enable overloading malloc(3)]), |
[ AC_DEFINE(ENCAPSULATE_MALLOC,1) ]) |
MY_AC_ARG_WITH(dmalloc-malloc-leaks, |
MY_DESCR([--with-dmalloc-malloc-leaks], |
[Report memory allocated by malloc(3) as leaks.]), |
[ AC_DEFINE(REPORT_ENCAPSULATED_MALLOC,1) ]) |
MY_AC_ARG_WITH(dmalloc-trace, MY_DESCR([--with-dmalloc-trace], |
[enable tracepoints]), |
[with_dmalloc_trace="yes" AC_DEFINE(DMALLOC_TRACE,10)]) |
AC_ARG_WITH(debug, MY_DESCR([--with-debug],[same as --with-cdebug --with-rtldebug]), |
[],[with_debug=]) |
AC_ARG_WITH(debug, MY_DESCR([--without-debug],[same as --without-cdebug --without-rtldebug]), |
[],[with_debug=]) |
AC_ARG_WITH(rtldebug, MY_DESCR([--with-rtldebug],[enable run time self tests]), |
[],[with_rtldebug=]) |
AC_ARG_WITH(cdebug, MY_DESCR([--without-cdebug],[disable -g]),[],[ |
case "$pike_cv_sys_os:$GCC" in |
Solaris:no) |
# Solaris/cc has problems with combining optimizations and debuginfo. |
AC_MSG_WARN([Defaulting to --without-cdebug since the OS is Solaris, |
and gcc is not being used.]) |
with_cdebug=no |
;; |
HP-UX:no|HPUX:no) |
# HP-UX/cc has problems with combining optimizations and debuginfo. |
# |
# cc: internal panic 7815: Malloc: underflow detected in free(). (7815) |
AC_MSG_WARN([Defaulting to --without-cdebug since the OS is HP-UX, |
and gcc is not being used.]) |
with_cdebug=no |
;; |
*) |
with_cdebug= |
;; |
esac |
]) |
AC_ARG_WITH(copt, MY_DESCR([--without-copt], [disable -O2]), [], [with_copt=]) |
AC_ARG_WITH(threads, MY_DESCR([--without-threads], [disable threads support]), |
[],[ |
case "x$pike_cv_sys_os" in |
xFreeBSD*) |
if test "`uname -r|sed -e 's/\([[0-9]]*\).*/\1/'`" -lt 4; then |
AC_MSG_WARN([ |
FreeBSD <= 3.x detected, disabling threads. |
Use --with-threads to force threads support. |
]) |
with_threads=no |
fi |
;; |
esac |
|
if test "x${with_threads-}" = x; then |
with_threads=yes |
fi |
]) |
AC_ARG_WITH(zlib, MY_DESCR([--without-zlib],[disable gz compression support]), |
[],[with_zlib=yes]) |
AC_ARG_WITH(ssleay, |
MY_DESCR([--with-ssleay], |
[support for the secure socket protocol (OBSOLETE)]), |
[],[with_ssleay=no]) |
AC_ARG_WITH(mysql, MY_DESCR([--without-mysql], |
[disable support for the Mysql database]), |
[],[with_mysql=yes]) |
AC_ARG_WITH(gif-rle, MY_DESCR([--with-gif-rle], |
[use kind-of-rle packing instead of lzw])) |
AC_ARG_WITH(rsaref, MY_DESCR([--with-rsaref=path],[Support for RSAREF])) |
AC_ARG_WITH(checker, MY_DESCR([--with-checker], |
[add extra memory checking overhead (Purify)])) |
MY_AC_ARG_WITH(profiling, MY_DESCR([--with-profiling], |
[add code used to profile pike code]), |
[AC_DEFINE(PROFILING)]) |
MY_AC_ARG_WITH(internal-profiling, MY_DESCR([--with-internal-profiling], |
[add profiling code for various internal things]), |
[AC_DEFINE(INTERNAL_PROFILING)]) |
MY_AC_ARG_WITH(pg, MY_DESCR([--with-pg],[use the gcc -pg option]), |
[PROFIL=-pg]) |
AC_ARG_WITH(poll, MY_DESCR([--with-poll], [use poll instead of select]), [], [ |
# Neither --with-poll nor --without-poll was specified |
case "$pike_cv_sys_os" in |
Solaris|HP-UX|OSF1|IRIX|Linux|Darwin|UnixWare|OpenUNIX) |
AC_MSG_WARN([Defaulting to --with-poll since the OS is $pike_cv_sys_os.]) |
with_poll=yes |
;; |
AIX) |
# poll(2) is broken on AIX 4.1 and earlier. |
if test "`uname -r`" -ge 2 -a "`uname -v`" -ge 4 ; then |
with_poll=yes |
else if test "`uname -v`" -gt 4 ; then |
with_poll=yes |
else :; fi |
fi |
if test "$with_poll" = "yes" ; then |
AC_MSG_WARN([Defaulting to --with-poll since the OS is AIX 4.2 or later.]) |
else :; fi |
;; |
esac |
]) |
AC_ARG_WITH(max-fd, |
MY_DESCR([--with-max-fd=X], |
[set how many filedescriptors can be used at once]), |
[pike_cv_max_open_fd=$withval]) |
MY_AC_ARG_WITH(oob, MY_DESCR([--without-oob], |
[disable out-of-band data handling]),[],[ |
if test "$pike_cv_sys_os" = "Windows_NT"; then |
AC_MSG_ERROR([Support for out of band data is mandatory on NT.]) |
else :; fi |
],[with_oob=yes]) |
AC_ARG_WITH(thread-trace, MY_DESCR([--without-thread-trace], |
[disable individual tracing of threads]), |
[],[with_thread_trace=yes]) |
MY_AC_ARG_WITH(compiler-trace, MY_DESCR([--with-compiler-trace], |
[enable tracing of the compiler]), |
[AC_DEFINE(YYDEBUG)]) |
AC_ARG_WITH(security, MY_DESCR([--with-security], |
[enable internal pike security system]), |
[AC_DEFINE(PIKE_SECURITY)]) |
AC_ARG_WITH(bignums, MY_DESCR([--without-bignums], |
[disable internal conversion to bignums]), |
[],[with_bignums=yes]) |
dnl Shared nodes has been disabled in an ugly way. To enable it you |
dnl need to remove the line that sets the OPT_NOT_SHARED flag at the |
dnl top of freeze_node in src/las.c. /mast |
dnl AC_ARG_WITH(shared-nodes, |
dnl MY_DESCR([--without-shared-nodes], |
dnl [disable the SHARED_NODES mode of the optimizer]), |
dnl [],[with_shared_nodes=yes]) |
AC_ARG_WITH(computed-goto, |
MY_DESCR([--with-computed-goto], |
[enable use of gcc-style computed goto (EXPERIMENTAL).]), |
[], [with_computed_goto=no]) |
AC_ARG_WITH(machine-code, |
MY_DESCR([--without-machine-code], |
[don't try to use of machine code on supported architectures.]), |
[], [ |
# Currently only supported with gcc. |
# |
# Further tests later on. |
with_machine_code="$GCC" |
]) |
|
MY_AC_ARG_WITH(keypair-loop, |
MY_DESCR([--with-keypair-loop], |
[enable use of keypair mapping loop method (EXPERIMENTAL).]), |
[AC_DEFINE(PIKE_MAPPING_KEYPAIR_LOOP)]) |
|
MY_AC_ARG_WITH(lock, |
MY_DESCR([--without-lock], |
[enable experimental code for multicpu machines (EXPERIMENTAL).]), |
[],[AC_DEFINE(PIKE_RUN_UNLOCKED)]) |
|
MY_AC_ARG_WITH(new-multisets, |
MY_DESCR([--with-new-multisets], |
[enable new multiset implementation (EXPERIMENTAL).]), |
[AC_DEFINE(PIKE_NEW_MULTISETS)],[]) |
|
AC_ARG_WITH(pike-type, MY_DESCR([--without-pike-type], |
[disable struct pike_type (IGNORED).])) |
|
if test "x$with_pike_type" = "xno"; then |
AC_MSG_WARN([Disabling of USE_PIKE_TYPE is no longer supported.]) |
fi |
|
if test "x$with_oob" = "xno"; then :; else |
AC_DEFINE(WITH_OOB) |
fi |
|
if test "x$with_bignums" = xyes; then |
AC_DEFINE(AUTO_BIGNUM) |
if test "x$with_gmp" = xno; then |
AC_MSG_ERROR([Cannot compile --with-bignums without the GMP library |
It is highly recommended that you install a working GMP |
library on your system as that will add features to Pike |
required by many applications (such as Roxen). However, |
if you know that you do not need GMP, you may re-run configure |
with the option --without-bignums instead. |
]) |
else :; fi |
else :; fi |
|
if test "x$with_shared_nodes" != xno; then |
echo 'Enabling the SHARED_NODES mode of the optimizer.' |
AC_DEFINE(SHARED_NODES) |
else :; fi |
|
if test "x$with_poll" = "xyes"; then |
AC_DEFINE(HAVE_AND_USE_POLL) |
else :; fi |
|
if test "x$with_checker" = "xyes"; then |
AC_DEFINE(__CHECKER__) |
else :; fi |
|
if test "x$with_thread_trace" = "xyes"; then |
AC_DEFINE(THREAD_TRACE) |
else :; fi |
|
if test "x$with_relocatable_dumped_modules" = xyes; then |
PIKE_MODULE_RELOC=1 |
else |
PIKE_MODULE_RELOC="" |
fi |
AC_SUBST(PIKE_MODULE_RELOC) |
|
|
# |
# Allow --with(out)-debug to toggle both cdebug and rtldebug, but |
# let --with(out)-{c,rtl}debug take precedence. |
# |
if test "x$with_cdebug" = x ; then |
with_cdebug="$with_debug" |
fi |
|
if test "x$with_rtldebug" = x ; then |
with_rtldebug="$with_debug" |
fi |
|
|
# |
# --with-dmalloc requires --with-rtldebug |
# |
if test "x$with_dmalloc" = "x"; then :; else |
if test "x$with_rtldebug" = "xyes"; then :; else |
AC_MSG_WARN([Debug malloc requires rtldebug. Enabling rtldebug.]) |
with_rtldebug=yes |
fi |
fi |
|
|
# |
# Defaults for cdebug and rtldebug here: |
# |
|
if test "x$with_cdebug" = x ; then |
with_cdebug=yes |
fi |
|
if test "x$with_rtldebug" = x ; then |
with_rtldebug=no |
# with_rtldebug=yes |
fi |
|
if test "x$with_rtldebug" = xyes ; then |
AC_DEFINE(PIKE_DEBUG) |
fi |
|
############################################################################# |
|
|
WARN="" |
OPTIMIZE="${OPTFLAGS-}" |
|
if test "$cflags_is_set" = "no"; then |
if test "x$with_cdebug" = "xno" ; then |
CFLAGS=`echo " $CFLAGS " | sed -e 's@ -g @ @g'` |
else |
: |
fi |
|
|
if test "x${GCC-}" = xyes ; then |
# Do not use -Wall, since that produces a lot of warnings that are not |
# really interresting (such as the warning for if( ... ) ... if( |
# ... ) .... else |
AC_SYS_COMPILER_FLAG(-W,W,WARN) |
AC_SYS_COMPILER_FLAG(-Wall,Wall,WARN) |
AC_SYS_COMPILER_FLAG(-Wno-unused,Wno_unused,WARN) |
AC_SYS_COMPILER_FLAG(-Wcomment,Wcomment,WARN) |
AC_SYS_COMPILER_FLAG(-Wformat,Wformat,WARN) |
AC_SYS_COMPILER_FLAG(-Wimplicit-function-declaration,Wimplicit_function_declaration,WARN) |
AC_SYS_COMPILER_FLAG(-Wmultichar,Wmultichar,WARN) |
AC_SYS_COMPILER_FLAG(-Wswitch,Wswitch,WARN) |
if test "x$with_copt" != xno; then |
# gcc complains that it doesn't support this when compiling |
# without optimizations. |
AC_SYS_COMPILER_FLAG(-Wuninitialized,Wuninitialized,WARN) |
fi |
AC_SYS_COMPILER_FLAG(-Wpointer-arith,Wpointer_arith,WARN) |
AC_SYS_COMPILER_FLAG(-Wchar-subscripts,Wchar_subscripts,WARN) |
AC_SYS_COMPILER_FLAG(-Wno-long-long,Wno_long_long,WARN) |
|
if test "x${with_static_linking-}" = "xyes" ; then |
AC_SYS_COMPILER_FLAG(-static,link_static,CFLAGS) |
else |
: |
fi |
|
## |
## -fomit-frame-pointer does not work with egcs 1.1.1 |
## /Hubbe 1998-12-20 |
## |
#if test "x$with_cdebug" = "xno" ; then |
# AC_SYS_COMPILER_FLAG(-fomit-frame-pointer,fomit_frame_pointer,OPTIMIZE) |
#else |
# : |
#fi |
|
### Optimize for different SUN machines. If there is no working 'uname' |
### no extra optimization will be done, but nothing should break either. |
case "`uname -m 2>/dev/null`" in |
sun4c) |
# The -msparclite option seems to generate assembler that /bin/as doesn't |
# understand. /grubba 1998-07-17 |
# AC_SYS_COMPILER_FLAG(-msparclite,sparclite,CFLAGS) |
;; |
sun4m) |
AC_SYS_COMPILER_FLAG(-mv8,microsparc,CFLAGS) |
;; |
sun4d) |
AC_SYS_COMPILER_FLAG(-msupersparc,supersparc,CFLAGS) |
;; |
sun4u) |
AC_SYS_COMPILER_FLAG(-mcpu=ultrasparc,mcpu_ultrasparc,CFLAGS,[ |
AC_SYS_COMPILER_FLAG(-msupersparc,supersparc,CFLAGS) |
]) |
;; |
i586) |
AC_SYS_COMPILER_FLAG(-mcpu=pentium,mcpu_pentium,CFLAGS,[ |
AC_SYS_COMPILER_FLAG(-mpentium,pentium,CFLAGS) |
]) |
;; |
i686) |
AC_SYS_COMPILER_FLAG(-mcpu=i686,mcpu_i686,CFLAGS,[ |
AC_SYS_COMPILER_FLAG(-mpentiumpro,pentiumpro,CFLAGS,[ |
AC_SYS_COMPILER_FLAG(-mcpu=pentium,mcpu_pentium,CFLAGS,[ |
AC_SYS_COMPILER_FLAG(-mpentium,pentium,CFLAGS) |
]) |
]) |
]) |
# AC_SYS_COMPILER_FLAG(-march=i686,march_i686,CFLAGS) |
;; |
i86pc) |
case "`isalist 2>/dev/null`" in |
*pentium_pro*) |
AC_SYS_COMPILER_FLAG(-mcpu=i686,mcpu_i686,CFLAGS,[ |
AC_SYS_COMPILER_FLAG(-mpentiumpro,pentiumpro,CFLAGS,[ |
AC_SYS_COMPILER_FLAG(-mcpu=pentium,mcpu_pentium,CFLAGS,[ |
AC_SYS_COMPILER_FLAG(-mpentium,pentium,CFLAGS) |
]) |
]) |
]) |
# AC_SYS_COMPILER_FLAG(-march=i686,march_i686,CFLAGS) |
;; |
*pentium*) |
AC_SYS_COMPILER_FLAG(-mcpu=pentium,mcpu_pentium,CFLAGS,[ |
AC_SYS_COMPILER_FLAG(-mpentium,pentium,CFLAGS,[ |
AC_SYS_COMPILER_FLAG(-m486,486,CFLAGS) |
]) |
]) |
;; |
esac |
;; |
esac |
|
# AIX |
DO_IF_OS(AIX, |
[ |
# Tell the linker to generate a large toc if needed |
# |
# This option is not needed on AIX 5L/ia64. |
if test "x`uname -p`" = "xia64"; then :; else |
AC_SYS_COMPILER_FLAG(-bbigtoc,bbigtoc,LDFLAGS) |
AC_SYS_COMPILER_FLAG([-Wl,-bbigtoc],Wlbbigtoc,LDFLAGS) |
fi |
]) |
|
DO_IF_OS(Darwin, |
[ |
# aka MacOS X. |
# Foundation framework needed by JavaVM.framework. The OS X 10.1 linker |
# no longer includes indirect dependencies so we need to add them here. |
AC_SYS_COMPILER_FLAG(-framework Foundation, framework_Foundation, LDFLAGS) |
AC_SYS_COMPILER_FLAG(-framework System, fraework_System, LDFLAGS) |
|
# -flat_namespace only needed for linking with libMallocDebug |
# AC_SYS_COMPILER_FLAG(-flat_namespace, flat_namespace, LDFLAGS) |
]) |
|
else if test "x${TCC-}" = xyes ; then |
|
# Yikes! We're using the TenDRA compiler! |
|
# Make sure we can use the system headerfiles... |
# Already done by the CC test in aclocal.m4. |
# AC_SYS_COMPILER_FLAG(-Ysystem, ysystem, CPPFLAGS) |
|
# Use lenient ANSI compliance... |
#AC_SYS_COMPILER_FLAG(-Xa, xa, CFLAGS) |
|
# Find out where libtdf.a is hidden. |
AC_MSG_CHECKING(for machine dependant library directory) |
AC_CACHE_VAL(pike_cv_tcc_lib_path, |
[ |
pike_cv_tcc_lib_path="`${CC-cc} -dry conftest.c -i 2>&1 | sed -e '/tdfc/s/bin\/tdfc.*/lib\/sys/p' -ed| head -1`" |
if test -d "$pike_cv_tcc_lib_path/." ; then :; else |
# Failed. |
pike_cv_tcc_lib_path="no" |
fi |
]) |
AC_MSG_RESULT($pike_cv_tcc_lib_path) |
|
if test "$pike_cv_tcc_lib_path" = "no" ; then :; else |
LDFLAGS="$LDFLAGS -L$pike_cv_tcc_lib_path" |
|
# This library is needed for 64bit support on 32bit machines/OS's. |
AC_CHECK_LIB(tdf, __TDFUnot) |
fi |
|
else |
|
# Assume system compiler "cc". |
|
if test "x${with_static_linking-}" = "xyes" ; then |
DO_IF_OS(AIX, |
[ |
AC_SYS_COMPILER_FLAG([-Wl,-bstatic],wl_link_static,CFLAGS) |
LD_FALLBACK_FLAGS="${LD_FALLBACK_FLAGS} -bstatic" |
]) |
|
DO_IF_OS(OSF1, |
[ |
AC_SYS_COMPILER_FLAG(-non_shared,non_shared,CFLAGS) |
LD_FALLBACK_FLAGS="${LD_FALLBACK_FLAGS} -non_shared" |
]) |
|
DO_IF_OS(IRIX, |
[ |
AC_SYS_COMPILER_FLAG(-non_shared,non_shared,CFLAGS) |
LD_FALLBACK_FLAGS="${LD_FALLBACK_FLAGS} -B static" |
]) |
|
# how do you link statically on HP-UX ? |
else |
: |
fi |
|
### Non-gcc thingies. This should probably be enhanced... |
|
# Solaris |
DO_IF_OS(Solaris, |
[ |
AC_SYS_COMPILER_FLAG(-fast,fast,OPTIMIZE) |
AC_SYS_COMPILER_FLAG(-xdepend,xdepend,OPTIMIZE) |
AC_SYS_COMPILER_FLAG(-xs,xs,CFLAGS) |
# Causes __STDC__ to be 1 which causes several headerfiles to behave |
# differently. |
# AC_SYS_OS_COMPILER_FLAG(-Xc,Xc,WARN) |
]) |
|
# AIX |
DO_IF_OS(AIX, |
[ |
# This one is needed to get the compiler to fail on errors, |
# which is needed for several configure-tests. |
AC_SYS_COMPILER_FLAG(-qhalt=e,qhalt_e,CFLAGS) |
AC_SYS_COMPILER_FLAG(-qro,qro,OPTIMIZE) |
AC_SYS_COMPILER_FLAG(-qfold,qfold,OPTIMIZE) |
AC_SYS_COMPILER_FLAG(-qwarn64,qwarn64,WARN) |
AC_SYS_COMPILER_FLAG(-qflag=w:w,qflag_w_w,WARN) |
AC_DEFUN(AC_SYS_COMPILER_FLAG_QINFO, [ |
AC_SYS_COMPILER_FLAG(-qinfo=$1,qinfo_$1,WARN) |
]) |
AC_SYS_COMPILER_FLAG_QINFO(cmp) |
AC_SYS_COMPILER_FLAG_QINFO(cnd) |
AC_SYS_COMPILER_FLAG_QINFO(cns) |
AC_SYS_COMPILER_FLAG_QINFO(cnv) |
AC_SYS_COMPILER_FLAG_QINFO(dcl) |
AC_SYS_COMPILER_FLAG_QINFO(eff) |
AC_SYS_COMPILER_FLAG_QINFO(enu) |
AC_SYS_COMPILER_FLAG_QINFO(ext) |
AC_SYS_COMPILER_FLAG_QINFO(gen) |
AC_SYS_COMPILER_FLAG_QINFO(gnr) |
AC_SYS_COMPILER_FLAG_QINFO(got) |
AC_SYS_COMPILER_FLAG_QINFO(ini) |
AC_SYS_COMPILER_FLAG_QINFO(inl) |
AC_SYS_COMPILER_FLAG_QINFO(lan) |
AC_SYS_COMPILER_FLAG_QINFO(obs) |
AC_SYS_COMPILER_FLAG_QINFO(ord) |
AC_SYS_COMPILER_FLAG_QINFO(par) |
AC_SYS_COMPILER_FLAG_QINFO(por) |
# ppc disabled since it complains about the system header files. |
# AC_SYS_COMPILER_FLAG_QINFO(ppc) |
# ppt disabled since tracing the preprocessor isn't interresting. |
# AC_SYS_COMPILER_FLAG_QINFO(ppt) |
AC_SYS_COMPILER_FLAG_QINFO(pro) |
AC_SYS_COMPILER_FLAG_QINFO(rea) |
AC_SYS_COMPILER_FLAG_QINFO(ret) |
# trd disabled, since it adds extra errors (in particular 1506-419). |
# AC_SYS_COMPILER_FLAG_QINFO(trd) |
AC_SYS_COMPILER_FLAG_QINFO(tru) |
AC_SYS_COMPILER_FLAG_QINFO(uni) |
AC_SYS_COMPILER_FLAG_QINFO(use) |
# AC_SYS_COMPILER_FLAG(-qalias=addr,qalias_addr,OPTIMIZE) |
# AC_SYS_COMPILER_FLAG(-qlibansi,qlibansi,OPTIMIZE) |
# Tell the linker to generate a large toc if needed |
# Tell the linker to generate a large toc if needed |
# |
# This option is not needed on AIX 5L/ia64. |
if test "x`uname -p`" = "xia64"; then :; else |
AC_SYS_COMPILER_FLAG(-bbigtoc,bbigtoc,LDFLAGS) |
fi |
]) |
|
# HP-UX |
DO_IF_OS(HP-UX, |
[ |
AC_SYS_COMPILER_FLAG(-D__STDC_EXT__,stdc_ext,CFLAGS) |
AC_SYS_COMPILER_FLAG([-Wp,-H50000],cpp_buffer_size,CFLAGS) |
AC_SYS_COMPILER_FLAG(+ESlit,plus_ESlit,OPTIMIZE) |
AC_SYS_COMPILER_FLAG(+Odataprefetch,plus_Odataprefetch,OPTIMIZE) |
AC_SYS_COMPILER_FLAG(+Ofailsafe,plus_Ofailsafe,OPTIMIZE) |
# Ignore the following warnings if you enable +w1 |
# 414 Optimization reduced to +O2 for compatibility with Debug. |
# 530 Casting from loose to strict alignment |
# 558 Empty declaration. |
# AC_SYS_COMPILER_FLAG(+w1,plus_w1,WARN) |
]) |
|
# OSF/1 |
DO_IF_OS(OSF1, |
[ |
AC_SYS_COMPILER_FLAG(-fast,fast,OPTIMIZE) |
# The need for -ieee is not detected properly by the FPE tests below. |
# AC_SYS_COMPILER_FLAG(-ieee,ieee,CFLAGS) |
AC_SYS_COMPILER_FLAG(-readonly_strings,readonly_strings,OPTIMIZE) |
AC_SYS_COMPILER_FLAG(-assume trusted_short_alignment, |
assume_trusted_short_alignment,OPTIMIZE) |
AC_SYS_COMPILER_FLAG(-assume aligned_objects, |
assume_aligned_objects,OPTIMIZE) |
AC_SYS_COMPILER_FLAG(-no_misalign,no_misalign,OPTIMIZE) |
|
if test "x$with_cdebug" = "xyes" ; then |
# FIXME: |
# Maybe should remove the -g flag if this succeeds. |
AC_SYS_COMPILER_FLAG(-g3,g3,CFLAGS) |
AC_SYS_COMPILER_FLAG(-trapuv,trapuv,WARN) |
fi |
AC_SYS_COMPILER_FLAG(-host,host,OPTIMIZE) |
|
# Flags that cause errors or change compiler behaviour |
# must go in CFLAGS, they can not go in WARN |
# /Hubbe |
AC_SYS_COMPILER_FLAG(-std1,std1,CFLAGS) |
AC_SYS_COMPILER_FLAG(-warnprotos,warnprotos,WARN) |
]) |
|
# IRIX |
DO_IF_OS(IRIX, |
[ |
# sopt disabled since it takes too long time on interpret.c (>45min on an O²) |
# AC_SYS_COMPILER_FLAG(-sopt,sopt,OPTIMIZE) |
|
# -n32 moved to smartlink so it will affekt cc as well as linker |
# this way the user can override it by setting LDFLAGS and/or CFLAGS |
# AC_SYS_COMPILER_FLAG(-n32,n32,CFLAGS) |
AC_SYS_COMPILER_FLAG(-fullwarn,fullwarn,WARN) |
AC_SYS_COMPILER_FLAG(-woff 1209,woff_1209,WARN) |
if test x$with_cdebug = xyes ; then |
AC_SYS_COMPILER_FLAG(-g3,g3,CFLAGS) |
fi |
if test x$with_rtldebug = xyes ; then |
AC_SYS_COMPILER_FLAG(-trapuw,trapuw,WARN) |
fi |
]) |
|
# Windows NT |
DO_IF_OS(Windows_NT, |
[ |
# FIXME: The test below probably doesn't work. |
if echo "x$CC" | grep "rntecl" >/dev/null 2>&1; then |
# Some options used by ecl (Intel's IA64 compiler). |
|
# We want threads, and link libc statically. |
AC_SYS_COMPILER_FLAG(-MT,MT,LDFLAGS) |
|
# Interprocedural optimizations. |
# For some reason this seems to cause the error: |
# dynamic_buffer.obj : error LNK2001: unresolved external symbol "[Entry] ?1memcpy" (.?1memcpy) |
# AC_SYS_COMPILER_FLAG(-Qip,Qip,OPTIMIZE) |
|
# More warnings. |
AC_SYS_COMPILER_FLAG(-W3,W3,WARN) |
|
if test x$with_rtldebug = xyes ; then |
# Initialize auto variables to 0xcc. |
# (Only if optimizations are turned off with -Od). |
AC_SYS_COMPILER_FLAG(-GZ,GZ,WARN) |
fi |
else :; fi |
|
if test x$with_dynamic_modules = xno ; then :; else |
AC_MSG_WARN([Enabling dynamic modules for Win32]) |
# EXTRA_MODULE_REQUIREMENTS="${EXTRA_MODULE_REQUIREMENTS} import_functions.h" |
EXTRA_OBJS="${EXTRA_OBJS} dlopen.o" |
pike_cv_sys_dynamic_loading=yes |
with_dynamic_modules=yes |
AC_DEFINE(USE_MY_WIN32_DLOPEN) |
fi |
]) |
|
dnl |
dnl This does not work with Digital UNIX cc/ld (cc thinks it is ok, ld does not) |
dnl |
dnl AC_SYS_COMPILER_FLAG(-native,native,OPTIMIZE) |
dnl |
|
dnl ### Ok. This is for apcc... |
case "$CC" in |
*apcc) |
AC_SYS_COMPILER_FLAG(-XO=5,apcc_opt,OPTIMIZE) |
AC_SYS_COMPILER_FLAG(-Xcallmod=2,apcc_opt_2,OPTIMIZE) |
;; |
esac |
|
# Old cc for solaris. |
# AC_SYS_CPU_COMPILER_FLAG(sun4m,-Xpipe=micro,microsparc,OPTIMIZE) |
# AC_SYS_CPU_COMPILER_FLAG(sun4d,-Xpipe=super,supersparc,OPTIMIZE) |
# AC_SYS_CPU_COMPILER_FLAG(sun4u,-Xpipe=super,ultrasparc,OPTIMIZE) |
|
case "${CFLAGS-} $OPTIMIZE" in |
*-O*) ;; |
*+O*) ;; |
*-fast*) ;; |
*) |
case "$pike_cv_sys_os:$GCC" in |
UnixWare*:no|OpenUNIX*:no) |
;; |
*) |
;; |
esac |
;; |
esac |
fi |
fi |
else |
# CFLAGS has already been set by the user. |
# Avoid adding anything that isn't essential. |
DO_IF_OS(AIX, |
[ |
# This one is needed to get the compiler to fail on errors, |
# which is needed for several configure-tests. |
AC_SYS_COMPILER_FLAG(-qhalt=e,qhalt_e,CFLAGS) |
]) |
fi |
|
############################################################################# |
|
if test ! -d modules/. ; then |
mkdir modules |
fi |
|
############################################################################# |
|
## Search for some popular places where libraries may be hidden. |
|
############################################################################# |
|
if test x$"pike_cv_sys_os" != xWindows_NT ; then |
|
echo Searching for include-file directories... |
|
if test $cppflags_is_set = no -a x${C_INCLUDE_PATH-} = x ; then |
real_include_dirs='' |
for d in `echo ${with_include_path} | sed 's/:/ /g'` \ |
`echo "${with_site_prefixes}/include"|sed -e 's/:/\/include /g'` \ |
`echo $prefix | sed "s@^NONE@$with_root$ac_default_prefix@g"`/include \ |
$with_root/usr/local/include $with_root/sw/local/include \ |
$with_root/usr/gnu/include $with_root/opt/gnu/include \ |
$with_root/sw/gnu/include $with_root/sw/include \ |
$with_root/usr/freeware/include $with_root/usr/pkg/include \ |
$with_root/opt/sfw/include \ |
`echo $with_root/opt/gnome*/include | sort -r` \ |
`echo $with_root/usr/X11*/include | sort -r` |
do |
AC_MSG_CHECKING($d) |
case x$d in |
x/usr/include | x/usr//include) |
;; |
*) |
if test -d "$d/." ; then |
REALDIR="`cd $d/. ; /bin/pwd`" |
if test "x$REALDIR" = x ; then |
REALDIR=UNKNOWN |
else |
: |
fi |
|
case " $CPPFLAGS $real_include_dirs " in |
*\ -I$d\ * | *\ -I$REALDIR\ *) |
AC_MSG_RESULT(already added) |
;; |
*) |
OLD_CPPFLAGS="${CPPFLAGS}" |
CPPFLAGS="${CPPFLAGS} -I$d" |
AC_TRY_CPP([include <stdio.h>], [ |
AC_MSG_RESULT(added) |
if test "x$REALDIR" != xUNKNOWN; then |
real_include_dirs="${real_include_dirs} -I$REALDIR" |
else |
: |
fi |
], [ |
AC_MSG_RESULT(fails) |
CPPFLAGS="${OLD_CPPFLAGS}" |
]) |
;; |
esac |
else |
AC_MSG_RESULT(no) |
fi |
;; |
esac |
done |
else |
: |
fi |
|
#CPPFLAGS="${CPPFLAGS} -I$srcdir -I`pwd`" |
|
echo Searching for library directories... |
if test $ldflags_is_set = no ; then |
for dd in `echo ${with_lib_path} | sed 's/:/ /g'` \ |
`echo "${with_site_prefixes}/lib"|sed -e 's/:/\/lib /g'` \ |
`echo $exec_prefix | sed "s@^NONE@$prefix/lib@g" | sed "s@^NONE@$with_root$ac_default_prefix@g"` \ |
$with_root/usr/local/lib $with_root/sw/local/lib $with_root/sw/lib \ |
$with_root/usr/gnu/lib $with_root/opt/gnu/lib $with_root/sw/gnu/lib \ |
$with_root/usr/freeware/lib $with_root/usr/pkg/lib \ |
$with_root/opt/sfw/lib $with_root/opt/gnome-1.4/lib \ |
`echo $with_root/usr/X11*/lib | sort -r` |
do |
for suff in '' 32 64 '/64'; do |
d="$dd$suff" |
AC_MSG_CHECKING($d) |
if test -d "$d/." ; then |
case " $LDFLAGS " in |
*\ -L$d\ -R$d\ * | *\ -R$d\ -L$d\ *) |
AC_MSG_RESULT(already added) |
;; |
*) |
OLD_LDFLAGS="${LDFLAGS}" |
LDFLAGS="${LDFLAGS} -R$d -L$d -lm" |
AC_TRY_RUN([ |
#include <stdio.h> |
#include <math.h> |
int main(int argc, char **argv) |
{ |
double (*foo)(double) = ceil; |
exit(0); |
} |
],[ LDFLAGS="$OLD_LDFLAGS -R$d -L$d" |
AC_MSG_RESULT(yes) |
],[ LDFLAGS="$OLD_LDFLAGS" |
AC_MSG_RESULT(no) |
],[AC_TRY_LINK([ |
#include <stdio.h> |
#include <math.h> |
],[ |
double (*foo)(double) = ceil; |
exit(0); |
],[ LDFLAGS="$OLD_LDFLAGS -R$d -L$d" |
AC_MSG_RESULT(probably) |
],[ LDFLAGS="$OLD_LDFLAGS" |
AC_MSG_RESULT(no)])]) |
;; |
esac |
else |
AC_MSG_RESULT(no) |
fi |
done |
done |
else |
: |
fi |
|
echo Searching for binary directories... |
for d in `echo $exec_prefix | sed "s@^NONE@$prefix@g" | sed "s@^NONE@$with_root$ac_default_prefix@g"` \ |
`echo "${with_site_prefixes}"|sed -e 's/:/ /g'` \ |
"$with_root" $with_root/usr $with_root/usr/ccs $with_root/usr/vac \ |
$with_root/usr/local $with_root/sw/local $with_root/usr/gnu \ |
$with_root/opt/gnu $with_root/sw/gnu $with_root/sw \ |
$with_root/opt/sfw $with_root/opt/gnome-1.4 \ |
$with_root/usr/freeware $with_root/usr/pkg |
do |
AC_MSG_CHECKING($d/bin) |
if test -d "$d/bin/." ; then |
AC_MSG_RESULT(added) |
EXTRA_PATH="${EXTRA_PATH}:$d/bin" |
else |
AC_MSG_RESULT(no) |
fi |
done |
export EXTRA_PATH |
|
else |
# We are running NT |
CPPFLAGS="${CPPFLAGS} -I$srcdir -I`pwd`" |
fi |
|
############################################################################# |
|
## At this point we have at last initialized the compiler! |
|
############################################################################# |
|
if test ! -f confdefs.h ; then |
AC_MSG_WARN([Warning, lost confdefs.h, testing will be flawed!! |
You might need to use bash instead of /bin/sh to get correct results. |
To do this, please type the following at an sh prompt: |
\$ rm ./config.cache |
\$ CONFIG_SHELL=/path/to/bash |
\$ export CONFIG_SHELL |
\$ $CONFIG_SHELL ./configure |
]) |
fi |
|
############################################################################# |
|
AC_DEFINE(POSIX_SOURCE) |
|
AC_MSG_CHECKING(ansi prototype capability) |
AC_CACHE_VAL(pike_cv_sys_ansi_prototypes, |
[ |
AC_TRY_COMPILE([int foo(int bar);],[], |
[pike_cv_sys_ansi_prototypes=yes], |
[pike_cv_sys_ansi_prototypes=no]) |
]) |
|
if test "$pike_cv_sys_ansi_prototypes" = "yes"; then |
AC_MSG_RESULT(yes) |
else |
AC_MSG_RESULT([no, giving up...]) |
exit 1 |
fi |
|
############################################################################# |
|
# The AC_PROG_INSTALL test is broken if $INSTALL is specified by hand. |
# The FreeBSD ports system does this... |
# Workaround: |
|
if test "x$INSTALL" = "x"; then :; else |
# $INSTALL overrides ac_cv_path_install anyway... |
ac_cv_path_install="$INSTALL" |
fi |
|
AC_PROG_INSTALL |
AC_PROG_CPP |
AC_PROG_RANLIB |
|
if test "x${AR-}" = x ; then |
AC_PATH_PROG(AR, ar, ar, $PATH:$EXTRA_PATH) |
export AR |
fi |
|
AC_SUBST(AR) |
|
############################################################################# |
|
# installbsd seems to be broken on some versions of AIX |
# |
# /grubba 1997-08-16 |
|
case "$ac_cv_path_install" in |
*installbsd*) |
AC_MSG_CHECKING(if $ac_cv_path_install works) |
AC_CACHE_VAL(pike_cv_install_works, |
[ |
if $ac_cv_path_install "$srcdir/configure.in" ./conftest >/dev/null 2>&1 |
then |
if cmp "$srcdir/configure.in" ./conftest >/dev/null 2>&1; then |
pike_cv_install_works=yes; |
else |
pike_cv_install_works=no; |
fi |
else |
pike_cv_install_works=no; |
fi |
if test -f ./conftest; then |
rm -f ./conftest |
fi |
]) |
AC_MSG_RESULT($pike_cv_install_works) |
if test "$pike_cv_install_works" = "no"; then |
echo "Warning: Falling back to $ac_install_sh" |
INSTALL="$ac_install_sh" |
fi |
;; |
esac |
|
############################################################################# |
|
AC_MSG_CHECKING(for yacc clone that handles %pure_parser) |
AC_CACHE_VAL(pike_cv_prog_working_yacc, |
[ |
for YACC in pyacc byacc "bison -y" yacc "None"; do |
set dummy $YACC; ac_word=$2 |
has_it=no |
IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}:" |
for ac_dir in $PATH; do |
test -z "$ac_dir" && ac_dir=. |
if test -f $ac_dir/$ac_word; then |
has_it="yes" |
break |
fi |
done |
IFS="$ac_save_ifs" |
|
if test "$has_it" = "yes"; then |
cat >conftest.y<<\EOF |
%pure_parser |
%{ |
void parse(); |
void yyerror(char *); |
%} |
%% |
all: foo bar |
foo: 'f' 'o' 'o' { parse(); } ; |
bar: 'b' 'a' 'r' ; |
%% |
int context; |
|
int yylex(YYSTYPE *yylval) |
{ |
switch(context++) |
{ |
case 0: return 'f'; |
case 1: return 'o'; |
case 2: return 'o'; |
case 3: return 'b'; |
case 4: return 'a'; |
case 5: return 'r'; |
default: return 0; |
} |
} |
|
int depth=0; |
void parse() |
{ |
int tmp; |
if(depth++>5) return; |
tmp=context; |
context=0; |
yyparse(); |
context=tmp; |
} |
int errors=0; |
void yyerror(char *fel) { errors++; } |
int main() |
{ |
parse(); |
exit(errors); |
} |
EOF |
if $YACC -d conftest.y 1>&5 2>&5; then |
if test "x$enable_binary" = "xno"; then |
break |
else |
AC_TRY_RUN([ |
#include "y.tab.c" |
],pure_parser_works=yes,pure_parser_works=no,pure_parser_works=no) |
if test "$pure_parser_works" = "yes"; then |
break |
fi |
fi |
fi |
fi |
done |
pike_cv_prog_working_yacc="$YACC" |
]) |
|
YACC="$pike_cv_prog_working_yacc" |
|
if test "x$YACC" = "xNone" ; then |
AC_MSG_RESULT([Get bison if you want to do "make export"]) |
YACC="bison -y" |
else |
AC_MSG_RESULT($YACC) |
fi |
|
############################################################################# |
|
AC_MSG_CHECKING(for the type of __yy_memcpy) |
AC_CACHE_VAL(pike_cv___yy_memcpy_count_type, [ |
pike_cv___yy_memcpy_from_const= |
pike_cv___yy_memcpy_count_type=unknown |
for count_type in "unsigned int" "size_t" "unsigned long" "int"; do |
for from_const in "const" ""; do |
cat >conftest.y <<EOF |
%pure_parser |
%{ |
#include <stdio.h> |
|
#ifndef __GNUC__ |
#ifndef __cplusplus |
static void __yy_memcpy(char *to, $from_const char *from, $count_type count); |
#endif /* !__cplusplus */ |
#endif /* !__GNUC__ */ |
|
void yyerror(char *); |
int yylex(void *); |
%} |
%% |
all: foo bar |
foo: 'f' 'o' 'o' { fprintf(stderr, "foo\\n"); } ; |
bar: 'b' 'a' 'r' ; |
%% |
int yylex(void *yylval) { return 'f'; } |
void yyerror(char *err) { fprintf(stderr, "ERR: %s\\n", err); } |
EOF |
echo conftest.y: 1>&5 |
cat conftest.y 1>&5 |
if $YACC -d conftest.y 1>&5 2>&5; then |
AC_TRY_LINK([ |
#include "y.tab.c" |
], [ |
yyparse(); |
exit(0); |
], [ |
pike_cv___yy_memcpy_count_type=$count_type |
pike_cv___yy_memcpy_from_const="$from_const" |
break |
]) |
fi |
done |
if test "x$pike_cv___yy_memcpy_count_type" = "xunknown"; then :; else |
break |
fi |
done |
]) |
if test "x$pike_cv___yy_memcpy_count_type" = "xunknown"; then |
AC_MSG_RESULT($pike_cv___yy_memcpy_count_type) |
AC_MSG_WARN([Defaulting to unsigned int.]) |
YY_COUNT_TYPE="unsigned int" |
YY_FROM_CONST="" |
else |
AC_MSG_RESULT(void __yy_memcpy(char *, $pike_cv___yy_memcpy_from_const char *, $pike_cv___yy_memcpy_count_type)) |
YY_COUNT_TYPE="$pike_cv___yy_memcpy_count_type" |
YY_FROM_CONST="$pike_cv___yy_memcpy_from_const" |
fi |
AC_SUBST(YY_COUNT_TYPE) |
AC_SUBST(YY_FROM_CONST) |
|
############################################################################# |
|
## At this point we have found all binaries we are going to use. |
|
############################################################################# |
|
AC_C_CONST |
|
# The above doesn't find IBM C's buggy const. |
|
if test "$ac_cv_c_const" = "yes"; then |
AC_MSG_CHECKING(if const really does work) |
AC_CACHE_VAL(pike_cv_c_really_const,[ |
AC_TRY_COMPILE([ |
const int foo(int bar) { return bar; } |
], [ |
return bar(0); |
], [ |
pike_cv_c_really_const=yes |
], [ |
pike_cv_c_really_const=no |
]) |
]) |
|
AC_MSG_RESULT($pike_cv_c_really_const) |
if test "x$pike_cv_c_really_const" = xno ; then |
AC_DEFINE(const, []) |
else |
: |
fi |
fi |
|
AC_MSG_CHECKING(if we can cast void * to a function pointer) |
AC_CACHE_VAL(pike_cv_function_cast, [ |
AC_TRY_COMPILE([ |
void *foo = 0; |
],[ |
void (*bar)(void) = (void (*)(void)) foo; |
],[ pike_cv_function_cast="yes" ], [ pike_cv_function_cast="no" ]) |
]) |
if test "$pike_cv_function_cast" = "yes"; then |
AC_MSG_RESULT(yes) |
else |
AC_MSG_RESULT(no) |
AC_DEFINE(NO_CAST_TO_FUN) |
fi |
|
############################################################################# |
|
AC_HEADER_TIME |
AC_HEADER_STDC |
AC_CHECK_HEADERS(sys/rusage.h time.h sys/time.h sys/types.h unistd.h stdlib.h \ |
memory.h values.h string.h strings.h fcntl.h sys/filio.h sys/sockio.h crypt.h \ |
locale.h sys/select.h net/socket.h sys/mman.h setjmp.h \ |
limits.h pthread.h crt/signal.h sys/id.h mach-o/dyld.h \ |
thread.h dlfcn.h dld.h dl.h sys/times.h sched.h sys/procfs.h sys/param.h \ |
winsock.h sys/ioct.h sys/socket.h malloc.h netinet/in.h sys/wait.h winbase.h \ |
grp.h pwd.h passwd.h group.h winsock2.h signal.h sys/file.h poll.h sys/poll.h \ |
socket.h ieeefp.h fp_class.h floatingpoint.h sys/priocntl.h sys/sched.h \ |
windows.h float.h errno.h stddef.h mmx.h sys/termio.h sys/termios.h) |
|
# some Linux systems have a broken resource.h that compiles anyway /Mirar |
AC_MSG_CHECKING([for sys/resource.h]) |
AC_CACHE_VAL(pike_cv_sys_resource_h, [ |
AC_TRY_COMPILE([ |
#ifdef HAVE_SYS_TYPES_H |
#include <sys/types.h> |
#endif /* HAVE_SYS_TYPES_H */ |
#ifdef HAVE_TIME_H |
#include <time.h> |
#endif /* HAVE_TIME_H */ |
#ifdef HAVE_SYS_TIME_H |
#include <sys/time.h> |
#endif /* HAVE_SYS_TIME_H */ |
|
#include <sys/resource.h> |
|
],[], |
[pike_cv_sys_resource_h=yes], [pike_cv_sys_resource_h=no]) |
]) |
if test "x$pike_cv_sys_resource_h" = "xyes"; then |
AC_MSG_RESULT(yes) |
AC_DEFINE(HAVE_SYS_RESOURCE_H) |
else |
AC_MSG_RESULT(no) |
fi |
|
AC_CHECK_SIZEOF(char *,4) |
AC_CHECK_SIZEOF(int, 4) |
AC_CHECK_SIZEOF(short, 2) |
AC_CHECK_SIZEOF(float, 4) |
AC_CHECK_SIZEOF(double, 8) |
AC_CHECK_SIZEOF(long double, 0) |
AC_CHECK_SIZEOF(long, 4) |
AC_CHECK_SIZEOF(long long, 0) |
AC_CHECK_SIZEOF(__int64, 0) |
|
AC_MY_CHECK_TYPE(size_t,unsigned long) |
AC_MY_CHECK_TYPE(ptrdiff_t,long) |
AC_MY_CHECK_TYPE(off_t,long) |
AC_MY_CHECK_TYPE(pid_t,int) |
AC_MY_CHECK_TYPE(uid_t,int) |
AC_MY_CHECK_TYPE(gid_t,int) |
AC_MY_CHECK_TYPE(time_t,INT32) |
AC_MY_CHECK_TYPE(pri_t, short) |
|
if test "x$with_long_double_precision" = x -a \ |
"x$with_double_precision" = x ; then |
# Choose the longest available float that fits in a pointer. |
if test $ac_cv_sizeof_long_double != 0 -a \ |
$ac_cv_sizeof_long_double -le $ac_cv_sizeof_char_p ; then |
with_long_double_precision=yes |
elif test $ac_cv_sizeof_double -le $ac_cv_sizeof_char_p ; then |
with_double_precision=yes |
fi |
fi |
|
if test $ac_cv_sizeof_long_double != 0 -a \ |
"x$with_long_double_precision" = xyes ; then |
AC_DEFINE(WITH_LONG_DOUBLE_PRECISION_SVALUE) |
AC_DEFINE(FLOAT_TYPE, long double) |
AC_DEFINE(SIZEOF_FLOAT_TYPE, SIZEOF_LONG_DOUBLE) |
elif test "x$with_double_precision" = xyes ; then |
AC_DEFINE(WITH_DOUBLE_PRECISION_SVALUE) |
AC_DEFINE(FLOAT_TYPE, double) |
AC_DEFINE(SIZEOF_FLOAT_TYPE, SIZEOF_DOUBLE) |
else |
AC_DEFINE(FLOAT_TYPE, float) |
AC_DEFINE(SIZEOF_FLOAT_TYPE, SIZEOF_FLOAT) |
fi |
|
if test "x$with_long_long_int" = x -a \ |
"x$with_long_int" = x -a \ |
"x$with_int_int" = x -a \ |
"x$with_short_int" = x ; then |
# Choose the longest available integer that fits in a pointer. |
# Turn this on when it works and the typing is corrected everywhere. |
# if test $ac_cv_sizeof_long_long != 0 -a \ |
# $ac_cv_sizeof_long_long -le $ac_cv_sizeof_char_p ; then |
# # This isn't a good idea on architectures where |
# # sizeof(long int) < sizeof(LONGEST). |
# # This is due to the gmp mpz api's using long int instead of |
# # mp_limb_{signed_}t. |
# #with_long_long_int=yes |
# : |
# fi |
# if test $ac_cv_sizeof_long -le $ac_cv_sizeof_char_p ; then |
# with_long_int=yes |
# else |
# with_int_int=yes |
# fi |
: |
fi |
|
if test $ac_cv_sizeof_long_long != 0 -a \ |
"x$with_long_long_int" = xyes ; then |
AC_DEFINE(WITH_LONG_LONG_INT) |
AC_DEFINE(INT_TYPE, long long) |
AC_DEFINE(SIZEOF_INT_TYPE, SIZEOF_LONG_LONG) |
elif test "x$with_long_int" = xyes ; then |
AC_DEFINE(WITH_LONG_INT) |
AC_DEFINE(INT_TYPE, long) |
AC_DEFINE(SIZEOF_INT_TYPE, SIZEOF_LONG) |
elif test "x$with_short_int" = xyes ; then |
AC_DEFINE(WITH_SHORT_INT) |
AC_DEFINE(INT_TYPE, short) |
AC_DEFINE(SIZEOF_INT_TYPE, SIZEOF_SHORT) |
else |
AC_DEFINE(WITH_INT_INT) |
AC_DEFINE(INT_TYPE, int) |
AC_DEFINE(SIZEOF_INT_TYPE, SIZEOF_INT) |
fi |
|
AC_TYPE_SIGNAL |
|
dnl AC_CHECK_LIB(PW, alloca) |
|
AC_CHECK_LIB(m, floor) |
|
AC_CHECK_LIB(socket, socket) |
|
if test x"$pike_cv_sys_os" = xWindows_NT ; then |
AC_MSG_CHECKING(if we should use the 64 bit API) |
AC_CACHE_VAL(pike_cv_sys_win64, [ |
AC_EGREP_CPP(yes, [ |
#if defined(_WIN64) || defined(__WIN64__) |
yes |
#else |
no |
#endif |
], [ pike_cv_sys_win64=yes ], [ pike_cv_sys_win64=no ]) |
]) |
if test "x$pike_cv_sys_win64" = "xyes"; then |
AC_MSG_RESULT(yes) |
# Apparently the libraries are stilled named *32... |
# LIBS="-lkernel64 -lws2_64 -ladvapi64 $LIBS" |
LIBS="-lshell32 -lkernel32 -lws2_32 -ladvapi32 $LIBS" |
else |
AC_MSG_RESULT(no) |
LIBS="-lshell32 -lkernel32 -lws2_32 -ladvapi32 $LIBS" |
fi |
fi |
|
AC_CHECK_LIB(nsl, gethostbyname) |
AC_CHECK_LIB(rt, nanosleep) |
|
AC_CHECK_LIB(dl, dlopen) |
AC_CHECK_LIB(dld, shl_load) |
AC_CHECK_LIB(dld, dld_link) |
|
|
if test "${pike_cv_sys_os}" = "Linux"; then |
if test "${ac_cv_lib_m_floor}" = "no"; then |
AC_MSG_WARN(I will compensate for this by adding -lc -lm) |
LIBS="${LIBS} -lc -lm" |
fi |
|
if test "$ac_cv_header_sched_h" = "yes"; then |
AC_MSG_CHECKING(if sched.h has a typo) |
AC_CACHE_VAL(pike_cv_broken_sched_h, [ |
AC_TRY_COMPILE([ |
#include <sched.h> |
],[ ],[ pike_cv_broken_shed_h=no ], [ |
OLDCPPFLAGS="$CPPFLAGS" |
CPPFLAGS="$CPPFLAGS -D_P=__P" |
AC_TRY_COMPILE([ |
#include <sched.h> |
],[ ],[ pike_cv_broken_sched_h=yes ],[ |
pike_cv_broken_sched_h="very broken" |
]) |
CPPFLAGS="$OLDCPPFLAGS" |
]) |
]) |
AC_MSG_RESULT($pike_cv_broken_sched_h) |
if test "$pike_cv_broken_sched_h" = "yes"; then |
AC_MSG_WARN(Applying workaround) |
CPPFLAGS="$CPPFLAGS -D_P=__P" |
fi |
fi |
fi |
|
######################################################################## |
|
using_threads="no (forced)" |
|
if test x$with_threads = xyes ; then |
using_threads="no (no known threads found)" |
OLDLIBS="$LIBS" |
OLDCFLAGS="$CFLAGS" |
|
if test "x$pike_cv_sys_os" = "xWindows_NT" ; then |
# NT has threads... |
|
AC_DEFINE(_REENTRANT) |
AC_DEFINE(_THREAD_SAFE) |
AC_DEFINE(_UNIX_THREADS) |
AC_DEFINE(NT_THREADS) |
AC_DEFINE(PIKE_THREADS) |
using_threads="yes (nt)" |
|
else |
|
# Test for POSIX threads |
|
case "x$pike_cv_sys_os" in |
xOSF1*) |
# LIBS="${OLDLIBS} -lpthread -lmach -lexc -lc" |
LIBS="${OLDLIBS} -lpthread -lmach -lexc" |
;; |
|
xBSD/OS*) |
LIBS="${OLDLIBS}" |
;; |
|
xUnixWare*|xOpenUNIX*) |
if test "$GCC" = yes ; then |
CFLAGS="${CFLAGS} -pthread" |
else |
CFLAGS="${CFLAGS} -Kthread" |
fi |
;; |
|
xOpenBSD*) |
CFLAGS="${CFLAGS} -pthread" |
LDFLAGS="${LDFLAGS} -pthread" |
;; |
|
xFreeBSD*) |
# Threads on FreeBSD earlier than 1998-06-07 are broken. |
LIBS="${OLDLIBS}" |
AC_MSG_CHECKING(if this version of FreeBSD may have working threads) |
AC_CACHE_VAL(pike_cv_freebsd_threads, [ |
AC_TRY_RUN([ |
#include <osreldate.h> |
|
int main(int argc, char **argv) |
{ |
/* FreeBSD before 228000 and 300000 - 300005 have broken threads. |
*/ |
if (__FreeBSD_version < 228000) |
return(1); |
if (__FreeBSD_version < 300000) |
return(0); |
if (__FreeBSD_version < 300006) |
return(1); |
return(0); |
} |
], pike_cv_freebsd_threads=yes, pike_cv_freebsd_threads=no, |
pike_cv_freebsd_threads=yes) |
]) |
if test "x$pike_cv_freebsd_threads" = "xno"; then |
AC_MSG_RESULT(no) |
else |
AC_MSG_RESULT(yes) |
using_threads="yes (freebsd)" |
|
AC_PATH_PROG(PTHREAD_CONFIG,pthread-config,no) |
if test "x$PTHREAD_CONFIG" = xno ; then |
CFLAGS="${CFLAGS} -pthread" |
LD_FALLBACK_FLAGS="${LD_FALLBACK_FLAGS-} -lc_r" |
|
AC_MSG_CHECKING(Initial stack limit) |
AC_CACHE_VAL(pike_cv_initial_stack_size,[ |
AC_TRY_RUN([ |
#include <stdio.h> |
|
static int depth=0; |
FILE *f; |
|
void save_depth(void); |
|
void use_stack(void *page) |
{ |
void *X[8190]; |
X[0]=page; |
save_depth(); |
use_stack(&X); |
} |
|
void save_depth(void) |
{ |
depth+=sizeof(void *)*8192; |
fprintf(f,"%d\n",depth); |
fflush(f); |
if(depth>0x80000000) exit(0); |
} |
|
int main(int argc) |
{ |
f=fopen("confdefs.out.2","w"); /* weird filename to circumvent configure weirdness */ |
save_depth(); |
use_stack(0); |
} |
], |
pike_cv_initial_stack_size='', |
while read x; do pike_cv_initial_stack_size=$x ; done <confdefs.out.2) |
rm confdefs.out.2 >/dev/null 2>/dev/null || : |
]) |
if test x$pike_cv_initial_stack_size = x ; then |
AC_MSG_RESULT(unlimited) |
else |
AC_MSG_RESULT($pike_cv_initial_stack_size) |
AC_DEFINE_UNQUOTED(Pike_INITIAL_STACK_SIZE,$pike_cv_initial_stack_size) |
fi |
|
else |
CFLAGS="$CFLAGS `pthread-config --cflags`" |
LIBS="$LIBS `pthread-config --libs`" |
LDFLAGS="$CFLAGS `pthread-config --ldflags`" |
fi |
fi |
;; |
|
xAIX*) |
if test "`uname -v`" -gt 4 ; then |
LIBS="${OLDLIBS} -lpthread" |
else |
LIBS="${OLDLIBS} -lpthreads -lc_r" |
fi |
;; |
|
xSolaris*) |
# Some versions of Solaris 2.5.1 require linking with -lthread too. |
LIBS="${OLDLIBS} -lpthread -lthread" |
;; |
|
xDarwin*) |
LIBS="${OLDLIBS}" |
;; |
|
*) |
LIBS="${OLDLIBS} -lpthread" |
;; |
esac |
|
AC_CHECK_FUNCS(pthread_init pthread_mutexattr_init pthread_kill) |
|
AC_MSG_CHECKING(posix threads) |
|
AC_CACHE_VAL(pike_cv_posix_threads, [ |
AC_TRY_RUN([ |
#define _REENTRANT |
#define _THREAD_SAFE |
#define _MIT_POSIX_THREADS 1 |
|
#include <pthread.h> |
|
void *foo(void *bar) { pthread_exit(0); return 0; } |
pthread_mutexattr_t attr; |
pthread_mutex_t tmp; |
pthread_t gazonk; |
|
int main() |
{ |
void *sune; |
#ifdef HAVE_PTHREAD_INIT |
pthread_init(); |
#endif /* HAVE_PTHREAD_INIT */ |
#ifdef HAVE_PTHREAD_MUTEXATTR_INIT |
pthread_mutexattr_init(&attr); |
#else |
memset(&attr, 0, sizeof(attr)); |
#endif /* HAVE_PTHREAD_MUTEXATTR_INIT */ |
pthread_mutex_init(&tmp, &attr); |
pthread_mutex_lock(&tmp); |
pthread_create(&gazonk,0,foo,0); |
pthread_join(gazonk,&sune); |
exit(0); |
} |
], [ pike_cv_posix_threads=yes ], [ pike_cv_posix_threads=no ], [ |
AC_TRY_LINK([ |
#define _REENTRANT |
#define _THREAD_SAFE |
#define _MIT_POSIX_THREADS 1 |
|
#include <pthread.h> |
|
void *foo(void *bar) { pthread_exit(0); return 0; } |
pthread_mutexattr_t attr; |
pthread_mutex_t tmp; |
pthread_t gazonk; |
|
], [ |
{ |
void *sune; |
#ifdef HAVE_PTHREAD_INIT |
pthread_init(); |
#endif /* HAVE_PTHREAD_INIT */ |
#ifdef HAVE_PTHREAD_MUTEXATTR_INIT |
pthread_mutexattr_init(&attr); |
#else |
memset(&attr, 0, sizeof(attr)); |
#endif /* HAVE_PTHREAD_MUTEXATTR_INIT */ |
pthread_mutex_init(&tmp, &attr); |
pthread_mutex_lock(&tmp); |
pthread_create(&gazonk,0,foo,0); |
pthread_join(gazonk,&sune); |
exit(0); |
} |
], [ pike_cv_posix_threads=yes ], [ pike_cv_posix_threads=no ]) |
]) |
]) |
|
if test $pike_cv_posix_threads = yes ; then |
AC_MSG_RESULT(yes) |
AC_DEFINE(_REENTRANT) |
AC_DEFINE(_THREAD_SAFE) |
AC_DEFINE(_MIT_POSIX_THREADS,1) |
AC_DEFINE(PIKE_THREADS) |
using_threads="yes (posix)" |
|
########################################################################## |
|
AC_MSG_CHECKING(for pthread_attr_setstacksize) |
AC_CACHE_VAL(pike_cv_have_pthread_attr_setstacksize,[ |
AC_TRY_LINK([#include <pthread.h> |
void foo(pthread_attr_t*x) { pthread_attr_setstacksize(x, 1024*1024); } |
],[],[ |
pike_cv_have_pthread_attr_setstacksize=yes |
],[ |
pike_cv_have_pthread_attr_setstacksize=no |
]) |
]) |
AC_MSG_RESULT($pike_cv_have_pthread_attr_setstacksize) |
if test x$pike_cv_have_pthread_attr_setstacksize = xyes ; then |
AC_DEFINE(HAVE_PTHREAD_ATTR_SETSTACKSIZE) |
else |
: |
fi |
|
########################################################################## |
|
AC_MSG_CHECKING(for pthread_atfork) |
AC_CACHE_VAL(pike_cv_have_pthread_atfork,[ |
AC_TRY_LINK([#include <pthread.h> |
void foo(void) { pthread_atfork(0,0,0); } |
],[],[ |
pike_cv_have_pthread_atfork=yes |
],[ |
pike_cv_have_pthread_atfork=no |
]) |
]) |
if test x$pike_cv_have_pthread_atfork = xyes ; then |
AC_MSG_RESULT(yes) |
AC_DEFINE(HAVE_PTHREAD_ATFORK) |
else |
AC_MSG_RESULT([no - FreeBSD?]) |
fi |
|
########################################################################## |
|
AC_MSG_CHECKING(for pthread_yield) |
AC_CACHE_VAL(pike_cv_have_pthread_yield,[ |
AC_TRY_LINK([#include <pthread.h> |
void foo(void) { pthread_yield(); } |
],[],[ |
pike_cv_have_pthread_yield=yes |
],[ |
pike_cv_have_pthread_yield=no |
]) |
]) |
AC_MSG_RESULT($pike_cv_have_pthread_yield) |
if test x$pike_cv_have_pthread_yield = xyes ; then |
AC_DEFINE(HAVE_PTHREAD_YIELD) |
else |
: |
fi |
|
########################################################################## |
|
AC_MSG_CHECKING(for pthread_cond_init) |
AC_CACHE_VAL(pike_cv_have_pthread_cond_init,[ |
AC_TRY_LINK([#include <pthread.h> |
void foo(pthread_cond_t*x, pthread_condattr_t*y) { pthread_cond_init(x,y); } |
],[],[ |
pike_cv_have_pthread_cond_init=yes |
],[ |
pike_cv_have_pthread_cond_init=no |
]) |
]) |
AC_MSG_RESULT($pike_cv_have_pthread_cond_init) |
if test x$pike_cv_have_pthread_cond_init = xyes ; then |
AC_DEFINE(HAVE_PTHREAD_COND_INIT) |
else |
: |
fi |
|
########################################################################## |
|
AC_MSG_CHECKING(if pthread_condattr_default is defined) |
AC_CACHE_VAL(pike_cv_have_pthread_condattr_default,[ |
AC_TRY_LINK([#include <pthread.h> |
void foo(pthread_cond_t *bar) { pthread_cond_init(bar, pthread_condattr_default); } |
],[],[ |
pike_cv_have_pthread_condattr_default=yes |
],[ |
pike_cv_have_pthread_condattr_default=no |
]) |
]) |
|
AC_MSG_RESULT($pike_cv_have_pthread_condattr_default) |
|
if test x$pike_cv_have_pthread_condattr_default = xyes ; then |
AC_DEFINE(HAVE_PTHREAD_CONDATTR_DEFAULT) |
else |
: |
fi |
|
|
# |
# FreeBSD doesn't like the &, while AIX requires it... |
# |
|
AC_MSG_CHECKING(if pthread_condattr_default is needs an & (AIX)) |
AC_CACHE_VAL(pike_cv_have_pthread_condattr_default_aix,[ |
AC_TRY_LINK([#include <pthread.h> |
void foo(pthread_cond_t *bar) { pthread_cond_init(bar, &pthread_condattr_default); } |
],[],[ |
pike_cv_have_pthread_condattr_default_aix=yes |
],[ |
pike_cv_have_pthread_condattr_default_aix=no |
]) |
]) |
|
AC_MSG_RESULT($pike_cv_have_pthread_condattr_default_aix) |
|
if test x$pike_cv_have_pthread_condattr_default_aix = xyes ; then |
AC_DEFINE(HAVE_PTHREAD_CONDATTR_DEFAULT_AIX) |
else |
: |
fi |
|
########################################################################## |
|
AC_MSG_CHECKING(for __pthread_initial_thread_bos) |
AC_CACHE_VAL(pike_cv_have_pthread_initial_thread_bos,[ |
AC_TRY_LINK([#include <pthread.h> |
char *foo(void) { extern char *__pthread_initial_thread_bos; |
return __pthread_initial_thread_bos; } |
],[],[ |
pike_cv_have_pthread_initial_thread_bos=yes |
],[ |
pike_cv_have_pthread_initial_thread_bos=no |
]) |
]) |
|
AC_MSG_RESULT($pike_cv_have_pthread_initial_thread_bos) |
|
if test x$pike_cv_have_pthread_initial_thread_bos = xyes ; then |
AC_DEFINE(HAVE_PTHREAD_INITIAL_THREAD_BOS) |
else |
: |
fi |
|
########################################################################## |
|
# On Linux the threads don't inherit euid & egid from the main thread. |
# FIXME: Add a real test here! |
if test "x$pike_cv_sys_os" = "xLinux"; then |
AC_DEFINE(HAVE_BROKEN_LINUX_THREAD_EUID) |
else :; fi |
|
else |
AC_MSG_RESULT(no) |
LIBS="$OLDLIBS" |
CFLAGS="$OLDCFLAGS" |
|
# No POSIX threads. |
|
# Try UNIX threads instead |
|
AC_MSG_CHECKING(unix threads) |
case "x$pike_cv_sys_os" in |
xUnixWare*|xOpenUNIX*) |
if test "$GCC" = yes ; then |
CFLAGS="${CFLAGS} -pthread" |
else |
CFLAGS="${CFLAGS} -Kthread" |
fi |
CFLAGS="${CFLAGS} -D_UNIXWARE_THREADS_" |
;; |
*) |
LIBS="${LIBS} -lthread" |
;; |
esac |
|
AC_CACHE_VAL(pike_cv_unix_threads, [ |
AC_TRY_RUN([ |
#define _REENTRANT |
#define _THREAD_SAFE |
#define _MIT_POSIX_THREADS 1 |
#include <thread.h> |
#ifdef _UNIXWARE_THREADS_ |
#include <synch.h> |
#endif |
|
void *foo(void *bar) { thr_exit(0); return 0; } |
mutex_t tmp; |
thread_t gazonk; |
|
int main() |
{ |
void *sune; |
mutex_lock(& tmp); |
thr_create(0,0,foo,0,0,&gazonk); |
thr_join(gazonk,0,&sune); |
exit(0); |
} |
],pike_cv_unix_threads=yes,pike_cv_unix_threads=no,pike_cv_unix_threads=no) |
]) |
|
if test x$pike_cv_unix_threads = xyes ; then |
AC_MSG_RESULT(yes) |
AC_DEFINE(_REENTRANT) |
AC_DEFINE(_THREAD_SAFE) |
AC_DEFINE(_UNIX_THREADS) |
AC_DEFINE(PIKE_THREADS) |
using_threads="yes (unix)" |
else |
AC_MSG_RESULT(no) |
LIBS="$OLDLIBS" |
CFLAGS="$OLDCFLAGS" |
|
# Now we've sunk really low -- test for proprietary threads |
|
# SGI old-style shared group processes |
# AC_CHECK_FUNCS(sproc oserror) |
# |
# AC_MSG_CHECKING(Fallback to sproc) |
# |
# if test x$ac_cv_func_sproc$ac_cv_func_oserror = xyesyes; then |
# AC_MSG_RESULT(yes) |
# AC_DEFINE(_REENTRANT) |
# AC_DEFINE(_THREAD_SAFE) |
# AC_DEFINE(_SGI_SPROC_THREADS) |
# AC_DEFINE(_SGI_MP_SOURCE) |
# using_threads="yes (sgi)" |
# else |
# AC_MSG_RESULT(no) |
# : |
# fi |
fi # UNIX threads |
fi # POSIX threads |
fi # NT |
else |
# Without threads |
: |
fi |
|
######################################################################## |
|
# NOTE: The following test is hardcoded to fail when crosscompiling |
# It also clobbers $LIBOBJS. |
|
OLD_LIBOBJS="${LIBOBJS}" |
|
AC_FUNC_MEMCMP |
|
if test "x$ac_cv_func_memcmp_clean" = "xyes"; then |
AC_DEFINE(HAVE_MEMCMP) |
fi |
|
LIBOBJS="${OLD_LIBOBJS}" |
|
######################################################################## |
|
AC_FUNC_MMAP |
|
AC_CHECK_FUNCS( \ |
_crypt \ |
poll \ |
bcopy \ |
bzero \ |
clock \ |
crypt \ |
fchmod \ |
gethrtime \ |
gethrvtime \ |
getenv \ |
getrlimit \ |
getrusage \ |
gettimeofday \ |
index \ |
localtime \ |
gmtime \ |
memchr \ |
mktime \ |
perror \ |
rindex \ |
setbuf \ |
setlocale \ |
setrlimit \ |
setresuid \ |
setvbuf \ |
sigaction \ |
sigblock \ |
sigprocmask \ |
sigvec \ |
strcasecmp \ |
strnlen \ |
strncmp \ |
strchr \ |
strcspn \ |
strerror \ |
strrchr \ |
strtod \ |
strtok \ |
strtol \ |
time \ |
times \ |
tzset \ |
vfprintf \ |
vsprintf \ |
vsnprintf \ |
wait3 \ |
wait4 \ |
waitpid \ |
munmap \ |
shl_load \ |
dld_link \ |
dld_get_func \ |
pipe \ |
strdup \ |
strstr \ |
kill \ |
alarm \ |
fork1 \ |
flock \ |
lockf \ |
setuid getuid seteuid geteuid \ |
setgid getgid setegid getegid \ |
getpwent getpwnam getpwuid \ |
getgrent getgrnam \ |
setsid setpgrp getpgrp setpgid getpgid \ |
initgroups setgroups \ |
socketpair \ |
fpclass \ |
fp_class_d \ |
isinf \ |
isnan \ |
iszero \ |
finite \ |
signbit \ |
nan \ |
nice \ |
__priocntl \ |
sched_setscheduler \ |
setpriority \ |
usleep \ |
nanosleep \ |
thr_yield \ |
) |
|
AC_MSG_CHECKING(for the type of the last argument to accept) |
AC_CACHE_VAL(pike_cv_accept_size_t, [ |
for t in socklen_t size_t int; do |
AC_TRY_COMPILE([ |
#ifndef _LARGEFILE_SOURCE |
# define _FILE_OFFSET_BITS 64 |
# define _LARGEFILE_SOURCE |
# define _LARGEFILE64_SOURCE 1 |
#endif |
/* HPUX needs these too... */ |
#ifndef __STDC_EXT__ |
# define __STDC_EXT__ |
#endif /* !__STDC_EXT__ */ |
|
#include <sys/types.h> |
#ifdef HAVE_UNISTD_H |
#include <unistd.h> |
#endif |
#ifdef HAVE_SYS_SOCKET_H |
#include <sys/socket.h> |
#endif |
|
/* NT */ |
#ifdef HAVE_WINSOCK_H |
#include <winsock.h> |
#endif |
|
/* Here's the actual test: */ |
int accept(int, struct sockaddr *, $t *); |
], [ |
/* EMPTY */ |
], [ |
pike_cv_accept_size_t=$t |
break |
], [ |
AC_TRY_COMPILE([ |
#ifndef _LARGEFILE_SOURCE |
# define _FILE_OFFSET_BITS 64 |
# define _LARGEFILE_SOURCE |
# define _LARGEFILE64_SOURCE 1 |
#endif |
/* HPUX needs these too... */ |
#ifndef __STDC_EXT__ |
# define __STDC_EXT__ |
#endif /* !__STDC_EXT__ */ |
|
#include <sys/types.h> |
#ifdef HAVE_UNISTD_H |
#include <unistd.h> |
#endif |
#ifdef HAVE_SYS_SOCKET_H |
#include <sys/socket.h> |
#endif |
|
/* NT */ |
#ifdef HAVE_WINSOCK_H |
#include <winsock.h> |
#endif |
|
/* Here's the actual test: */ |
SOCKET accept(SOCKET, struct sockaddr *, $t *); |
], [ |
/* EMPTY */ |
], [ |
pike_cv_accept_size_t=$t |
break |
], []) |
]) |
done |
if test "x$pike_cv_accept_size_t" = "x"; then |
# Check if it could be a Psocklen_t |
# Psocklen_t is a stupid typedef of socklen_t *. |
AC_TRY_COMPILE([ |
#ifndef _LARGEFILE_SOURCE |
# define _FILE_OFFSET_BITS 64 |
# define _LARGEFILE_SOURCE |
# define _LARGEFILE64_SOURCE 1 |
#endif |
/* HPUX needs these too... */ |
#ifndef __STDC_EXT__ |
# define __STDC_EXT__ |
#endif /* !__STDC_EXT__ */ |
|
#include <sys/types.h> |
#ifdef HAVE_UNISTD_H |
#include <unistd.h> |
#endif |
#ifdef HAVE_SYS_SOCKET_H |
#include <sys/socket.h> |
#endif |
|
/* NT */ |
#ifdef HAVE_WINSOCK_H |
#include <winsock.h> |
#endif |
|
/* Here's the actual test: */ |
int accept(int, struct sockaddr *, Psocklen_t); |
], [ |
/* EMPTY */ |
], [ |
pike_cv_accept_size_t=socklen_t |
], [ |
# FIXME: Should probably have a warning here. |
# FIXME: Should we check if socklen_t exists, and use that? |
pike_cv_accept_size_t=int |
]) |
fi |
]) |
AC_MSG_RESULT($pike_cv_accept_size_t *) |
AC_DEFINE_UNQUOTED(ACCEPT_SIZE_T, $pike_cv_accept_size_t) |
|
if test x"$pike_cv_sys_os" = xWindows_NT ; then |
AC_DEFINE(HAVE_LOADLIBRARY) |
AC_DEFINE(HAVE_FREELIBRARY) |
AC_DEFINE(HAVE_GETPROCADDRESS) |
AC_DEFINE(DL_EXPORT, _dlspec(export)) |
else |
AC_DEFINE(DL_EXPORT, []) |
fi |
|
if test $ac_cv_func_crypt$ac_cv_func__crypt = nono ; then |
AC_CHECK_LIB(crypt,crypt,[LIBS="${LIBS} -lcrypt" ; AC_DEFINE(HAVE_CRYPT)], |
[ |
if test -f "$srcdir/crypt.c"; then |
AC_MSG_RESULT(Using crypt.c for BSD style crypt()) |
EXTRA_OBJS="${EXTRA_OBJS} crypt.o" |
AC_DEFINE(HAVE_CRYPT) |
AC_DEFINE(USE_CRYPT_C) |
else |
: |
fi |
]) |
|
fi |
|
|
############################################################################# |
MY_CHECK_FUNCTION(infnan, |
[ |
#include <errno.h> |
#include <math.h> |
], [ |
double pinf = infnan(ERANGE); |
double ninf = infnan(-ERANGE); |
double nan = infnan(EDOM); |
exit(!(isinf(pinf)>0 && isinf(ninf)<0 && isnan(nan))); |
]) |
############################################################################# |
MY_CHECK_FUNCTION(_isnan, |
[ |
#include <float.h> |
], [ |
exit(_isnan(0.0)); |
]) |
############################################################################# |
|
# FreeBSD 3.0 has broken F_SETFD when running with threads. |
|
AC_MSG_CHECKING(whether F_SETFD exists and works) |
|
AC_CACHE_VAL(pike_cv_broken_f_setfd, [ |
AC_TRY_RUN([ |
#ifdef HAVE_SYS_TYPES_H |
#include <sys/types.h> |
#endif /* HAVE_SYS_TYPES_H */ |
#include <sys/stat.h> |
#ifdef HAVE_FCNTL_H |
#include <fcntl.h> |
#endif /* HAVE_FCNTL_H */ |
#include <stdio.h> |
#ifndef FD_CLOEXEC |
#define FD_CLOEXEC 1 |
#endif /* FD_CLOEXEC */ |
int main(int argc, char **argv) |
{ |
int fd = 0; |
if (fcntl(fd, F_SETFD, FD_CLOEXEC) < 0) { |
exit(1); |
} |
if (fcntl(fd, F_GETFD) != FD_CLOEXEC) { |
exit(1); |
} |
exit(0); |
} |
], pike_cv_broken_f_setfd=no, pike_cv_broken_f_setfd=yes, |
pike_cv_broken_f_setfd=yes) |
]) |
|
if test "x$pike_cv_broken_f_setfd" = "xyes"; then |
AC_MSG_RESULT(no) |
AC_DEFINE(HAVE_BROKEN_F_SETFD) |
else |
AC_MSG_RESULT(yes) |
fi |
|
############################################################################# |
|
AC_STRUCT_TM |
|
############################################################################# |
|
AC_MSG_CHECKING(extern int timezone) |
|
AC_CACHE_VAL(pike_cv_has_external_timezone,[ |
AC_TRY_LINK([ |
#include <time.h> |
],[ |
int _tz; |
_tz=timezone; |
timezone=_tz; |
],pike_cv_has_external_timezone=yes,pike_cv_has_external_timezone=no) |
]) |
|
if test "$pike_cv_has_external_timezone" = "yes"; then |
AC_DEFINE(HAVE_EXTERNAL_TIMEZONE) |
fi |
|
AC_MSG_RESULT($pike_cv_has_external_timezone) |
|
############################################################################# |
|
# No test for this yet... |
AC_DEFINE(HAVE_STRUCT_TIMEVAL) |
|
############################################################################# |
|
if test "x$ac_cv_func_strtol" = "xyes"; then |
AC_MSG_CHECKING(if strtol works for large hexadecimal constants) |
AC_CACHE_VAL(pike_cv_func_strtol_works, [ |
AC_TRY_RUN([ |
#include <stdlib.h> |
int main(int argc, char **argv) |
{ |
/* On some OS's strtol() rounds this to 0x7fffffff. */ |
return(strtol("0xffffffff", NULL, 0) != 0xffffffff); |
} |
], pike_cv_func_strtol_works=yes, |
pike_cv_func_strtol_works=no, |
pike_cv_func_strtol_works=no) |
]) |
AC_MSG_RESULT($pike_cv_func_strtol_works) |
if test "x$pike_cv_func_strtol_works" = "xyes"; then |
AC_DEFINE(HAVE_WORKING_STRTOL) |
else :; fi |
else :; fi |
|
############################################################################# |
|
AC_MSG_CHECKING(if gettimeofday takes two arguments) |
AC_CACHE_VAL(pike_cv_func_gettimeofday_has_two_args, |
[ |
AC_TRY_RUN([ |
#if TIME_WITH_SYS_TIME |
# include <sys/time.h> |
# include <time.h> |
#else |
# if HAVE_SYS_TIME_H |
# include <sys/time.h> |
# else |
# if HAVE_TIME_H |
# include <time.h> |
# endif |
# endif |
#endif |
|
#ifndef HAVE_STRUCT_TIMEVAL |
struct timeval |
{ |
long tv_sec; |
long tv_usec; |
}; |
#endif |
|
int main() { |
struct timeval tv; |
gettimeofday(&tv,(void *)0); |
exit(0); |
} |
], [ pike_cv_func_gettimeofday_has_two_args=yes |
], [ pike_cv_func_gettimeofday_has_two_args=no |
], [ |
AC_TRY_LINK([ |
#if TIME_WITH_SYS_TIME |
# include <sys/time.h> |
# include <time.h> |
#else |
# if HAVE_SYS_TIME_H |
# include <sys/time.h> |
# else |
# if HAVE_TIME_H |
# include <time.h> |
# endif |
# endif |
#endif |
|
#ifndef HAVE_STRUCT_TIMEVAL |
struct timeval |
{ |
long tv_sec; |
long tv_usec; |
}; |
#endif |
], [ |
{ |
struct timeval tv; |
gettimeofday(&tv,(void *)0); |
exit(0); |
} |
], [ pike_cv_func_gettimeofday_has_two_args=yes ], [pike_cv_func_gettimeofday_has_two_args=no]) |
]) |
]) |
|
if test $pike_cv_func_gettimeofday_has_two_args = yes; then |
AC_DEFINE(GETTIMEOFDAY_TAKES_TWO_ARGS) |
fi |
|
AC_MSG_RESULT($pike_cv_func_gettimeofday_has_two_args) |
|
# if test "x$ac_cv_func_gethrtime" != "xyes"; then |
# AC_MSG_CHECKING(if we can make gethrtime by the RDTSC instruction) |
# AC_CACHE_VAL(pike_cv_own_gethrtime_rdtsc, [ |
# AC_TRY_RUN([ |
# #include <unistd.h> |
# #include <stdio.h> |
# #include <sys/time.h> |
# |
# static long long hrtime_rtsc_zero; |
# static long long hrtime_rtsc_last; |
# static long long hrtime_max; |
# static struct timeval hrtime_timeval_zero; |
# static long double hrtime_conv=0.0; |
# |
# #define GETTIMEOFDAY(PTR) gettimeofday(PTR,NULL) |
# |
# #define RTSC(x) \ |
# __asm__ __volatile__ ( "rdtsc" \ |
# :"=a" (((unsigned long*)&x)[0]), \ |
# "=d" (((unsigned long*)&x)[1])) |
# |
# void own_gethrtime_init() |
# { |
# GETTIMEOFDAY(&hrtime_timeval_zero); |
# RTSC(hrtime_rtsc_zero); |
# hrtime_rtsc_last=hrtime_rtsc_zero; |
# hrtime_max=0; |
# } |
# |
# int own_gethrtime_update(struct timeval *ptr) |
# { |
# long long td,t,now; |
# GETTIMEOFDAY(ptr); |
# RTSC(now); |
# td=((long long)ptr->tv_sec-hrtime_timeval_zero.tv_sec)*1000000000+ |
# ((long long)ptr->tv_usec-hrtime_timeval_zero.tv_usec)*1000; |
# |
# hrtime_rtsc_last=now; |
# t=now-hrtime_rtsc_zero; |
# if (t) hrtime_conv=((long double)td)/t; |
# |
# return 1; |
# } |
# |
# /* this is very sensitive to the compiler; keep all crap */ |
# |
# long long gethrtime() |
# { |
# long long now; |
# struct timeval tv; |
# |
# if (hrtime_conv==0.0) |
# { |
# if (!own_gethrtime_update(&tv)) /* not calibrated yet */ |
# { |
# return |
# hrtime_max= |
# ((long long)tv.tv_sec-hrtime_timeval_zero.tv_sec)*1000000000+ |
# ((long long)tv.tv_usec-hrtime_timeval_zero.tv_usec)*1000; |
# } |
# } |
# |
# RTSC(now); |
# |
# if (now-hrtime_rtsc_last > 2000000000) |
# { |
# own_gethrtime_update(&tv); |
# return gethrtime(); |
# } |
# |
# now = (long long) ( (long double)(now-hrtime_rtsc_zero) * hrtime_conv ); |
# |
# if (now<hrtime_max) now=hrtime_max; |
# return hrtime_max=now; |
# } |
# |
# #include <stdio.h> |
# |
# int main() |
# { |
# struct timeval tv1,tv2; |
# long long td,t1,t2; |
# own_gethrtime_init(); |
# |
# usleep(10); |
# own_gethrtime_update(&tv2); |
# |
# t1=gethrtime(); |
# |
# gettimeofday(&tv1,NULL); |
# for (;;) /* busy loop */ |
# { |
# GETTIMEOFDAY(&tv2); |
# td=((long long)tv2.tv_sec-tv1.tv_sec)*1000000000+ |
# ((long long)tv2.tv_usec-tv1.tv_usec)*1000; |
# if (td>1000000) break; |
# } |
# t2=gethrtime(); |
# |
# /* printf("t2-t1=%lld\n",t2-t1); */ |
# |
# if (t2==hrtime_rtsc_zero || |
# t2-t1>1100000 || |
# t2-t1<900000) return 1; |
# |
# return 0; |
# }], pike_cv_own_gethrtime_rdtsc=yes, |
# pike_cv_own_gethrtime_rdtsc=no, pike_cv_own_gethrtime_rdtsc=no) |
# ]) |
# if test "x$pike_cv_own_gethrtime_rdtsc" = "xyes"; then |
# AC_MSG_RESULT(yes) |
# AC_DEFINE(OWN_GETHRTIME) |
# AC_DEFINE(OWN_GETHRTIME_RDTSC) |
# AC_DEFINE(HAVE_GETHRTIME) |
# else |
# AC_MSG_RESULT([no]) |
# fi |
# fi |
# |
AC_MSG_CHECKING(if struct tm has tm_gmtoff) |
|
AC_CACHE_VAL(pike_cv_struct_tm_has_gmtoff,[ |
AC_TRY_COMPILE([ |
#ifdef TM_IN_SYS_TIME |
#include <sys/time.h> |
#else |
#include <time.h> |
#endif |
],[ |
int _tz; |
struct tm foo; |
_tz=foo.tm_gmtoff; |
],pike_cv_struct_tm_has_gmtoff=yes,pike_cv_struct_tm_has_gmtoff=no) |
]) |
|
if test "$pike_cv_struct_tm_has_gmtoff" = "yes"; then |
AC_DEFINE(STRUCT_TM_HAS_GMTOFF) |
fi |
|
AC_MSG_RESULT($pike_cv_struct_tm_has_gmtoff) |
|
AC_MSG_CHECKING(if struct tm has __tm_gmtoff) |
|
AC_CACHE_VAL(pike_cv_struct_tm_has___tm_gmtoff,[ |
AC_TRY_COMPILE([ |
#ifdef TM_IN_SYS_TIME |
#include <sys/time.h> |
#else |
#include <time.h> |
#endif |
],[ |
int _tz; |
struct tm foo; |
_tz=foo.__tm_gmtoff; |
],pike_cv_struct_tm_has___tm_gmtoff=yes,pike_cv_struct_tm_has___tm_gmtoff=no) |
]) |
|
if test "$pike_cv_struct_tm_has___tm_gmtoff" = "yes"; then |
AC_DEFINE(STRUCT_TM_HAS___TM_GMTOFF) |
fi |
|
AC_MSG_RESULT($pike_cv_struct_tm_has___tm_gmtoff) |
|
AC_MSG_CHECKING(for USHRT_MAX definition) |
|
AC_CACHE_VAL(pike_cv_ushrt_max_is_defined,[ |
AC_EGREP_CPP(yes,[ |
#include <limits.h> |
#ifdef USHRT_MAX |
yes |
#endif |
],pike_cv_ushrt_max_is_defined=yes,pike_cv_ushrt_max_is_defined=no) |
]) |
|
if test "$pike_cv_ushrt_max_is_defined" = "no" ; then |
AC_DEFINE(USHRT_MAX,65535) |
fi |
|
AC_MSG_RESULT($pike_cv_ushrt_max_is_defined) |
|
define(MY_CHECK_HEADERS, |
[ |
AC_MSG_CHECKING(for $1 declaration) |
AC_CACHE_VAL(pike_cv_decl_$1, |
[ |
OLD_CPPFLAGS="$CPPFLAGS" |
pike_cv_decl_$1=nonexistant |
for a in $2 |
do |
AC_EGREP_HEADER($1,$a,[ pike_cv_decl_$1=existant; break ]) |
|
# Kludge for MacOS X. Retry with the traditional cpp... |
CPPFLAGS="$CPPFLAGS -traditional-cpp" |
AC_EGREP_HEADER($1,$a,[ pike_cv_decl_$1=existant; break ]) |
CPPFLAGS="$OLD_CPPFLAGS" |
done |
CPPFLAGS="$OLD_CPPFLAGS" |
]) |
AC_MSG_RESULT($pike_cv_decl_$1) |
if test "$pike_cv_decl_$1" = nonexistant; then |
AC_DEFINE(translit($1,[a-z],[A-Z])[]_DECL_MISSING) |
fi |
]) |
|
MY_CHECK_HEADERS(strchr,string.h unistd.h stdlib.h) |
MY_CHECK_HEADERS(malloc,memory.h unistd.h stdlib.h) |
MY_CHECK_HEADERS(getpeername,sys/socket.h sys/socketvar.h sys/socketio.h winsock.h winsock2.h) |
MY_CHECK_HEADERS(popen,stdio.h unistd.h) |
MY_CHECK_HEADERS(getenv,unistd.h stdlib.h) |
MY_CHECK_HEADERS(gethostname,unistd.h netdb.h winsock.h winsock2.h) |
|
AC_ALLOCA |
|
AC_C_CONST |
AC_C_INLINE |
|
AC_CHECK_FUNCS(ualarm setitimer) |
|
if test "x$ac_cv_func_ualarm" = "xyes"; then |
AC_MSG_CHECKING(no of arguments to ualarm) |
AC_CACHE_VAL(pike_cv_ualarm_takes_two_args, |
[ |
AC_TRY_COMPILE([ |
#ifdef HAVE_UNISTD_H |
#include <unistd.h> |
#endif /* HAVE_UNISTD_H */ |
],[ |
ualarm(0,0); |
],pike_cv_ualarm_takes_two_args=yes,pike_cv_ualarm_takes_two_args=no) |
]) |
if test "$pike_cv_ualarm_takes_two_args" = yes; then |
AC_MSG_RESULT(2) |
AC_DEFINE(UALARM_TAKES_TWO_ARGS) |
else |
AC_MSG_RESULT(1) |
fi |
fi |
|
######################################################################## |
AC_MSG_CHECKING(stack direction) |
AC_CACHE_VAL(pike_cv_hardware_stack_direction, |
[ |
AC_TRY_RUN([ |
#include <stdio.h> |
static int find_stack_direction(void *foo) |
{ |
if (((void *)&foo) > foo) { |
return 1; |
} else { |
return -1; |
} |
} |
|
int main() { void *bar; exit( find_stack_direction(&bar) > 0); } |
], [ pike_cv_hardware_stack_direction=down |
], [ pike_cv_hardware_stack_direction=up |
], [ |
AC_MSG_WARN([defaulting to down.]) |
pike_cv_hardware_stack_direction=down |
]) |
]) |
|
AC_MSG_RESULT($pike_cv_hardware_stack_direction) |
|
if grep STACK_DIRECTION confdefs.h >/dev/null 2>&1; then |
: |
else |
if test "x$pike_cv_hardware_stack_direction" = "xup" ; then |
AC_DEFINE(STACK_DIRECTION, 1) |
else |
AC_DEFINE(STACK_DIRECTION, -1) |
fi |
fi |
|
######################################################################## |
|
AC_MSG_CHECKING(byteorder) |
AC_CACHE_VAL(pike_cv_hardware_byteorder, |
[ |
if test "x$enable_binary" = "xno"; then |
pike_cv_hardware_byteorder=0 |
else |
AC_TRY_RUN([ |
#include <stdio.h> |
|
int main() |
{ |
#if SIZEOF_INT == 4 |
#define T int |
#else |
#define T long |
#endif |
FILE *f; |
T a; |
int e; |
for(e=0;e<sizeof(T);e++) |
((char *)&a)[e]=(e+1) % 10; |
|
f=fopen("conftest.out.2","w"); |
for(e=0;e<sizeof(T);e++) |
{ |
fprintf(f,"%d",(int)(a & 255)); |
a>>=8; |
} |
fprintf(f,"\n"); |
fclose(f); |
|
return 0; |
}], |
pike_cv_hardware_byteorder=`cat conftest.out.2` |
, |
pike_cv_hardware_byteorder=0 |
, |
pike_cv_hardware_byteorder=0 |
) |
fi |
]) |
|
AC_MSG_RESULT($pike_cv_hardware_byteorder) |
AC_DEFINE_UNQUOTED(PIKE_BYTEORDER,$pike_cv_hardware_byteorder) |
|
######################################################################## |
|
AC_MSG_CHECKING(INT32 alignment) |
AC_CACHE_VAL(pike_cv_hardware_alignment, |
[ |
if test "x$enable_binary" = "xno"; then |
pike_cv_hardware_alignment=4 |
else |
AC_TRY_RUN([ |
#include <stdio.h> |
|
#if SIZEOF_SHORT >= 4 |
#define INT32 short |
#else |
#if SIZEOF_INT >= 4 |
#define INT32 int |
#else |
#define INT32 long |
#endif |
#endif |
|
struct x { char a; INT32 b; }; |
|
int main(int argc, char *argv[]) |
{ |
FILE f; |
struct x x; |
if(!(f=fopen("conftest.out.2","w"))) |
return 1; |
fprintf(f, "%u\n", (unsigned int)(((char *)&x.b)-((char*)&x))); |
fclose(f); |
return 0; |
}], |
pike_cv_hardware_alignment=`cat conftest.out.2`, |
pike_cv_hardware_alignment=4, |
pike_cv_hardware_alignment=4 |
) |
fi |
]) |
|
AC_MSG_RESULT($pike_cv_hardware_alignment) |
AC_DEFINE_UNQUOTED(PIKE_INT32_ALIGNMENT,$pike_cv_hardware_alignment) |
|
############################################################################# |
|
## Check if we should default to --with-machine-code |
|
############################################################################# |
|
if test "$with_machine_code" = "no"; then :; else |
|
AC_MSG_CHECKING(machine code architecture) |
AC_CACHE_VAL(pike_cv_machine_code_arch, [ |
pike_cv_machine_code_arch=unknown |
AC_TRY_COMPILE([ |
#if !defined(__i386__) && !defined(__i386) |
#error Not ia32 architecture |
#endif |
], [], [pike_cv_machine_code_arch=ia32], []) |
AC_TRY_COMPILE([ |
#if !defined(sparc) && !defined(__sparc__) && !defined(__sparc) |
#error Not sparc architecture |
#endif |
], [], [pike_cv_machine_code_arch=sparc], []) |
AC_TRY_COMPILE([ |
#if !defined(__ppc__) && !defined(__powerpc__) && !defined(_POWER) |
#error Not ppc32 architecture |
#endif |
], [], [pike_cv_machine_code_arch=ppc32], []) |
]) |
AC_MSG_RESULT($pike_cv_machine_code_arch) |
if test "x$pike_cv_machine_code_arch" = xunknown ; then |
with_machine_code="no" |
else |
with_machine_code="yes" |
AC_DEFINE(PIKE_USE_MACHINE_CODE) |
fi |
fi |
|
######################################################################## |
|
if test yes = "$with_machine_code"; then |
AC_MSG_CHECKING(register name convention) |
AC_CACHE_VAL(pike_cv_cpu_reg_prefix, |
[ |
for pike_cv_cpu_reg_prefix in "default" "" "r" "%%" "%%r" "unknown"; do |
AC_TRY_COMPILE([ |
#define REGPREFIX "$pike_cv_cpu_reg_prefix" |
], [ |
#if defined(__ppc__) || defined(__powerpc__) || defined(_POWER) |
__asm__ __volatile__(" li "REGPREFIX"11,1"); |
#else |
; /* Don't need to find out */ |
#endif |
],[break]) |
done |
]) |
case "$pike_cv_cpu_reg_prefix" in |
default|unknown) AC_MSG_RESULT($pike_cv_cpu_reg_prefix);; |
*) AC_MSG_RESULT(${pike_cv_cpu_reg_prefix}0) |
AC_DEFINE_UNQUOTED(PIKE_CPU_REG_PREFIX,"$pike_cv_cpu_reg_prefix");; |
esac |
else :; fi |
|
######################################################################## |
MY_CHECK_FUNCTION(fork, |
[ |
#ifdef HAVE_SYS_TYPES_H |
#include <sys/types.h> |
#endif |
#ifdef HAVE_UNISTD_H |
#include <unistd.h> |
#endif |
], [ |
exit(fork()==-1); |
]) |
|
######################################################################## |
MY_CHECK_FUNCTION(PTHREAD_MUTEX_RECURSIVE, |
[ |
#include <pthread.h> |
], [ |
PTHREAD_MUTEX_RECURSIVE; |
exit(0); |
]) |
######################################################################## |
MY_CHECK_FUNCTION(PTHREAD_MUTEX_RECURSIVE_NP, |
[ |
#include <pthread.h> |
], [ |
PTHREAD_MUTEX_RECURSIVE_NP; |
exit(0); |
]) |
######################################################################## |
MY_CHECK_FUNCTION(fpsetmask, |
[ |
#include <math.h> |
#ifdef HAVE_FLOATINGPOINT_H |
#include <floatingpoint.h> |
#endif |
|
#ifdef HAVE_IEEEFP_H |
#include <ieeefp.h> |
#endif |
], [ |
fpsetmask(0); |
exit(0); |
]) |
######################################################################## |
MY_CHECK_FUNCTION(fpsetround, |
[ |
#include <math.h> |
#ifdef HAVE_FLOATINGPOINT_H |
#include <floatingpoint.h> |
#endif |
|
#ifdef HAVE_IEEEFP_H |
#include <ieeefp.h> |
#endif |
|
#ifndef FP_RN |
#define FP_RN 0 |
#endif /* FP_RN */ |
], [ |
fpsetround(FP_RN); |
exit(0); |
]) |
######################################################################## |
MY_CHECK_FUNCTION(isless, |
[ |
#include <math.h> |
#ifdef HAVE_FLOATINGPOINT_H |
#include <floatingpoint.h> |
#endif |
|
#ifdef HAVE_IEEEFP_H |
#include <ieeefp.h> |
#endif |
|
], [ |
int t = isless(0.0, 0.0); |
exit(0); |
]) |
######################################################################## |
|
MY_CHECK_FUNCTION(dlopen, |
[ |
#include <dlfcn.h> |
], [ |
dlopen(0, 0); |
exit(0); |
]) |
######################################################################## |
|
MY_CHECK_FUNCTION(ldexp, |
[ |
#include <math.h> |
], [ |
double x; |
int p; |
|
for(x=0.0;x<2.0;x+=1.0/64.0) |
for(p=-6;p<7;p++) |
if(ldexp(x,p) != x*pow(2.0, (double)p)) |
exit(1); |
exit(0); |
]) |
|
######################################################################## |
MY_CHECK_FUNCTION(rint, |
[ |
#include <math.h> |
#ifdef HAVE_FLOATINGPOINT_H |
#include <floatingpoint.h> |
#endif |
|
#ifdef HAVE_IEEEFP_H |
#include <ieeefp.h> |
#endif /* HAVE_IEEEFP_H */ |
], [ |
#ifdef HAVE_FPSETROUND |
/* Round to nearest */ |
#ifndef FP_RN |
#define FP_RN 0 |
#endif /* FP_RN */ |
fpsetround(FP_RN); |
#endif /* HAVE_FPSETROUND */ |
if(rint(0.1) != 0.0 || |
rint(0.6) != 1.0) exit(1); |
exit(0); |
]) |
|
######################################################################## |
|
MY_CHECK_FUNCTION(frexp, |
[ |
#include <math.h> |
], [ |
double x,y; |
int p,e; |
|
x=frexp(1.0, &e); |
if(x * pow(2.0,(double)e) != 1.0) exit(3); |
|
p=-7; |
for(x=3.0/4.0*pow(2.0,(double)p);x<50000.0;x*=2.0,p++) |
{ |
if(frexp(x, &e)!=3.0/4.0) exit(1); |
if(e!=p) exit(2); |
} |
exit(0); |
]) |
|
############################################################################# |
MY_CHECK_FUNCTION(GetSystemTimeAsFileTime, |
[ |
#include <windows.h> |
#include <winbase.h> |
], [ |
FILETIME f; |
GetSystemTimeAsFileTime(&f); |
exit(0); |
]) |
############################################################################# |
MY_CHECK_FUNCTION(gethostname, |
[ |
#ifdef HAVE_UNISTD_H |
#include <unistd.h> |
#endif |
#ifdef HAVE_WINSOCK_H |
#include <winsock.h> |
#endif |
], [ |
char buffer[10000]; |
char *x=gethostname(buffer,sizeof(buffer)); |
exit(0); |
]) |
############################################################################# |
MY_CHECK_FUNCTION(strcoll, |
[ |
#include <string.h> |
#include <locale.h> |
], [ |
setlocale(LC_CTYPE, "ISO-8859-1"); |
exit(strcoll("abc", "def") >= 0 || |
strcoll("ABC", "DEF") >= 0 || |
strcoll("ABC", "ABCD") >= 0 || |
strcoll("ABCD", "ABC") <= 0 || |
strcoll("*^#", "*^#") != 0 || |
strcoll("123", "456") >= 0); |
]) |
|
######################################################################## |
|
MY_CHECK_FUNCTION(memmem, |
[ |
#include <string.h> |
char *a="foo bar gazonk"; |
char *b="foo"; |
char *c="bar"; |
char *d="gazonk"; |
], [ |
if(((char *)memmem(b,strlen(b),a,strlen(a)))!=a || |
((char *)memmem(c,strlen(c),a,strlen(a)))!=(a+4) || |
((char *)memmem(d,strlen(d),a,strlen(a)))!=(a+8) || |
((char *)memmem(d,0,a,strlen(a)))!=a || |
memmem(d,strlen(d)+1,a,strlen(a))!=0) |
exit(1); |
exit(0); |
]) |
|
######################################################################## |
|
MY_CHECK_FUNCTION(memcpy, |
[ |
#include <string.h> |
char *a="foo bar gazonk"; |
char foo[23]; |
], [ |
memcpy(foo, a, strlen(a)+1); |
memcpy(foo, a+4, 3); |
if(strcmp(foo,"bar bar gazonk")) exit(1); |
exit(0); |
]) |
|
######################################################################## |
|
MY_CHECK_FUNCTION(memset, |
[ |
#ifdef HAVE_STDDEF_H |
#include <stddef.h> |
#endif /* HAVE_STDDEF_H */ |
#ifdef HAVE_SYS_TYPES_H |
#include <sys/types.h> |
#endif /* HAVE_SYS_TYPES_H */ |
#ifdef HAVE_STDLIB_H |
#include <stdlib.h> |
#endif /* HAVE_STDLIB_H */ |
#include <stdio.h> |
#include <string.h> |
char foo[23]; |
|
struct pike_string { |
int refs; |
int size_shift; |
ptrdiff_t len; |
size_t hval; |
struct pike_string *next; |
char str[1]; |
}; |
|
struct pike_string *begin_shared_string(int len) |
{ |
return (struct pike_string *)malloc(sizeof(struct pike_string) + len); |
} |
|
], [ |
int i; |
struct pike_string *str; |
ptrdiff_t len; |
|
memset(foo, 0, 11); |
memset(foo, 'a', 10); |
memset(foo, 'b', 5); |
fprintf(stderr, "1\n"); |
if(strcmp(foo,"bbbbbaaaaa")) { |
exit(1); |
} |
memset(foo, 0, 6); |
fprintf(stderr, "2\n"); |
for (i=6; i--;) { |
if (foo[i]) { |
exit(1); |
} |
} |
memset(foo+1, 1, 6); |
fprintf(stderr, "3\n"); |
for (i=6; i--;) { |
if (foo[i+1] != 1) { |
exit(1); |
} |
} |
memset(foo+2, 0, 6); |
fprintf(stderr, "4\n"); |
for (i=6; i--;) { |
if (foo[i+2]) { |
exit(1); |
} |
} |
memset(foo+3, 1, 6); |
fprintf(stderr, "5\n"); |
for (i=6; i--;) { |
if (foo[i+3] != 1) { |
exit(1); |
} |
} |
memset(foo+4, 0, 6); |
fprintf(stderr, "6\n"); |
for (i=6; i--;) { |
if (foo[i+4]) { |
exit(1); |
} |
} |
memset(foo+5, 1, 6); |
fprintf(stderr, "7\n"); |
for (i=6; i--;) { |
if (foo[i+5] != 1) { |
exit(1); |
} |
} |
memset(foo+6, 0, 6); |
fprintf(stderr, "8\n"); |
for (i=6; i--;) { |
if (foo[i+6]) { |
exit(1); |
} |
} |
memset(foo+7, 1, 6); |
fprintf(stderr, "9\n"); |
for (i=6; i--;) { |
if (foo[i+7] != 1) { |
exit(1); |
} |
} |
|
len = 6; |
str = begin_shared_string(len); |
|
fprintf(stderr, "string start\n"); |
if (!str) exit(1); |
|
for (i=len; i--;) { |
str->str[i] = ~0; |
} |
memset(str->str, 0, len); |
fprintf(stderr, "string end\n"); |
for (i = len; i--;) { |
if (str->str[i]) { |
exit(1); |
} |
} |
free(str); |
exit(0); |
]) |
|
######################################################################## |
|
MY_CHECK_FUNCTION(memmove, |
[ |
#include <string.h> |
char buf[100]; |
], [ |
strcpy(buf,"foo bar gazonk elefantsnabel."); |
if(strcmp(buf,"foo bar gazonk elefantsnabel.")) exit(1); |
memmove(buf,buf+1,7); |
if(strcmp(buf,"oo bar gazonk elefantsnabel.")) exit(1); |
memmove(buf+1,buf+1,9); |
if(strcmp(buf,"oo bar gazonk elefantsnabel.")) exit(1); |
memmove(buf+1,buf,11); |
if(strcmp(buf,"ooo bar gaznk elefantsnabel.")) exit(1); |
exit(0); |
]) |
|
######################################################################## |
|
MY_CHECK_FUNCTION(isspace, |
[ |
#include <ctype.h> |
], [ |
if(isspace(' ')) exit(0); |
exit(1); |
]) |
|
############################################################################# |
|
AC_MSG_CHECKING(if we can declare environ) |
AC_CACHE_VAL(pike_cv_declare_environ,[ |
AC_TRY_COMPILE([ |
#include <stdlib.h> |
],[ |
extern char **environ; |
exit(0); |
],pike_cv_declare_environ=yes,pike_cv_declare_environ=no,pike_cv_declare_environ=yes) |
]) |
|
AC_MSG_RESULT($pike_cv_declare_environ) |
if test "x$pike_cv_declare_environ" = xyes ; then |
AC_DEFINE(DECLARE_ENVIRON) |
fi |
|
############################################################################# |
|
AC_MSG_CHECKING([for union wait (old BSD convention)]) |
AC_CACHE_VAL(pike_cv_union_wait, [ AC_TRY_COMPILE([ |
#ifdef HAVE_SYS_WAIT_H |
#include <sys/wait.h> |
#endif /* HAVE_SYS_WAIT_H */ |
], [ |
union wait status; |
exit(0); |
], pike_cv_union_wait=yes, pike_cv_union_wait=no) |
]) |
|
AC_MSG_RESULT($pike_cv_union_wait) |
if test "x$pike_cv_union_wait" = "xyes" ; then |
AC_MSG_CHECKING([whether union wait is really needed]) |
AC_CACHE_VAL(pike_cv_union_wait_needed, [ AC_TRY_COMPILE([ |
#ifdef HAVE_SYS_WAIT_H |
#include <sys/wait.h> |
#endif /* HAVE_SYS_WAIT_H */ |
], [ |
int status; |
return WIFEXITED(status) || 0; |
], pike_cv_union_wait_needed=no, pike_cv_union_wait_needed=yes) |
]) |
AC_MSG_RESULT($pike_cv_union_wait_needed) |
if test "x$pike_cv_union_wait_needed" = "xyes" ; then |
AC_DEFINE(HAVE_UNION_WAIT) |
else :; fi |
else :; fi |
|
############################################################################# |
|
AC_MSG_CHECKING(how to extract an unsigned char) |
AC_CACHE_VAL(pike_cv_method_extract_uchar, |
[ |
AC_TRY_RUN([ |
int main() |
{ |
char i,*p; |
i=-10; |
p=&i; |
if(*(unsigned char *)(p)!= 0x100 - 10) exit(1); |
exit(0); |
} |
],pike_cv_method_extract_uchar=by_cast, |
pike_cv_method_extract_uchar=not_by_cast, |
pike_cv_method_extract_uchar=not_by_cast)]) |
|
if test "$pike_cv_method_extract_uchar" = by_cast; then |
AC_MSG_RESULT(by cast) |
AC_DEFINE(EXTRACT_UCHAR_BY_CAST) |
else |
AC_MSG_RESULT(not by cast) |
fi |
|
######################################################################## |
|
AC_MSG_CHECKING(how to extract a signed char) |
AC_CACHE_VAL(pike_cv_method_extract_char, |
[ |
AC_TRY_RUN([ |
int main() |
{ |
char i,*p; |
i=-10; |
p=&i; |
if(*(signed char *)(p)!= -10) exit(1); |
exit(0); |
} |
],pike_cv_method_extract_char=by_cast, |
pike_cv_method_extract_char=not_by_cast, |
pike_cv_method_extract_char=not_by_cast)]) |
|
if test "$pike_cv_method_extract_char" = by_cast; then |
AC_MSG_RESULT(by cast) |
AC_DEFINE(EXTRACT_CHAR_BY_CAST) |
else |
AC_MSG_RESULT(not by cast) |
fi |
|
############################################################################# |
mmx_reason=' (no mmx.h found)' |
if test "x$ac_cv_header_mmx_h" = xyes; then |
AC_MSG_CHECKING(for working MMX) |
mmx_reason=' (mmx.h found, but mmx operations failed)' |
|
AC_CACHE_VAL(pike_cv_sys_has_working_mmx, |
[ |
AC_TRY_LINK([ |
#ifdef HAVE_MMX_H |
#include <mmx.h> |
#endif |
],[ |
{ |
int try_use_mmx; |
char a[8]; |
movq_m2r( *a, mm0 ); |
paddb_r2r( mm0, mm0 ); |
movq_r2m( mm0, *a ); |
try_use_mmx=mmx_ok(); |
} |
],pike_cv_sys_has_working_mmx=yes,pike_cv_sys_has_working_mmx=no) |
]) |
|
AC_MSG_RESULT($pike_cv_sys_has_working_mmx) |
|
if test "x$pike_cv_sys_has_working_mmx" = xyes ; then |
AC_DEFINE(TRY_USE_MMX) |
mmx_reason='' |
else :; fi |
else :; fi |
|
############################################################################# |
|
AC_MSG_CHECKING(if float conversion can cause SIGFPE) |
AC_CACHE_VAL(pike_cv_sys_idiot_sigfpe, |
[ |
AC_TRY_RUN([ |
#include <math.h> |
|
#ifdef HAVE_FLOATINGPOINT_H |
#include <floatingpoint.h> |
#endif |
|
#ifdef HAVE_IEEEFP_H |
#include <ieeefp.h> |
#endif |
|
float foo_float = 0.0; |
|
int main(int argc, char **argv) |
{ |
float x=2.0, y=-128.0; |
#ifdef HAVE_FPSETMASK |
fpsetmask(0); |
#endif |
x = pow(2.0, -128.0); |
foo_float = x; |
if (x == 2.0) exit(1); |
x = pow(2.0, 1024.0); |
foo_float = x; |
if(x == 2.0) exit(1); |
exit(0); |
} |
],pike_cv_sys_idiot_sigfpe=no,pike_cv_sys_idiot_sigfpe=yes, |
pike_cv_sys_idiot_sigfpe=yes) |
]) |
|
if test $pike_cv_sys_idiot_sigfpe = yes ; then |
AC_MSG_RESULT(yes) |
|
IEEE_FLAG=no |
if test "x${GCC-}" = xyes ; then |
AC_SYS_COMPILER_FLAG(-mieee, mieee, CFLAGS,[],IEEE_FLAG=yes) |
else |
AC_SYS_COMPILER_FLAG(-ieee, ieee, CFLAGS,[],IEEE_FLAG=yes) |
fi |
TEST_IGNORE_SIGFPE=yes |
|
if test $IEEE_FLAG = yes; then |
AC_MSG_CHECKING(if float conversion is still broken) |
AC_CACHE_VAL(pike_cv_sys_idiot_sigfpe_with_ieee, |
[ |
OLD_CFLAGS="$CFLAGS" |
CFLAGS="$CFLAGS $OPTIMIZE" |
AC_TRY_RUN([ |
#include <math.h> |
|
#ifdef HAVE_FLOATINGPOINT_H |
#include <floatingpoint.h> |
#endif |
|
#ifdef HAVE_IEEEFP_H |
#include <ieeefp.h> |
#endif |
|
float foo_float = 0.0; |
|
int main(int argc, char **argv) |
{ |
float x=2.0, y=-128.0; |
#ifdef HAVE_FPSETMASK |
fpsetmask(0); |
#endif |
x = pow(2.0, -128.0); |
foo_float = x; |
if (x == 2.0) exit(1); |
x = pow(2.0, 1024.0); |
foo_float = x; |
if(x == 2.0) exit(1); |
exit(0); |
} |
],pike_cv_sys_idiot_sigfpe_with_ieee=no,pike_cv_sys_idiot_sigfpe_with_ieee=yes, |
pike_cv_sys_idiot_sigfpe_with_ieee=yes) |
CFLAGS="$OLD_CFLAGS" |
]) |
|
if test $pike_cv_sys_idiot_sigfpe_with_ieee = yes ; then |
AC_MSG_RESULT(yes) |
else |
AC_MSG_RESULT(no) |
TEST_IGNORE_SIGFPE=no |
fi |
fi # IEEE_FLAG |
|
if test $TEST_IGNORE_SIGFPE = yes; then |
AC_MSG_CHECKING(if ignoring SIGFPE helps) |
AC_CACHE_VAL(pike_cv_sys_ignore_sigfpe, |
[ |
OLD_CFLAGS="$CFLAGS" |
CFLAGS="$CFLAGS $OPTIMIZE" |
AC_TRY_RUN([ |
#include <signal.h> |
#include <math.h> |
int counter=0; |
RETSIGTYPE func(void) |
{ |
if(counter++>10) exit(7); |
signal(SIGFPE,func); |
} |
|
float foo_float = 0.0; |
|
int main(int argc, char **argv) |
{ |
float x=2.0, y=-128.0; |
signal(SIGFPE,func); |
x = pow(2.0, -128.0); |
foo_float = x; |
if (x == 2.0) exit(1); |
x = pow(2.0, 1024.0); |
foo_float = x; |
if(x == 2.0) exit(1); |
exit(0); |
} |
],pike_cv_sys_ignore_sigfpe=yes,pike_cv_sys_ignore_sigfpe=no, |
pike_cv_sys_ignore_sigfpe=yes) |
CFLAGS="$OLD_CFLAGS" |
]) |
|
if test "$pike_cv_sys_ignore_sigfpe" = yes; then |
AC_MSG_RESULT(yes) |
AC_DEFINE(IGNORE_SIGFPE) |
else |
AC_MSG_RESULT(no) |
fi |
fi # TEST_IGNORE_SIGFPE |
|
else |
AC_MSG_RESULT(no) |
fi # pike_cv_sys_idiot_sigfpe |
|
############################################################################# |
|
define(float_check, [[ |
#include <math.h> |
#define TY $1 |
#define TEST_$1 |
#define TEST_$2 |
#define EXPECTED_SIZE_float 4 |
#define EXPECTED_SIZE_double 8 |
void check(TY n, char *pf, char *pd) |
{ |
int i; |
char *p, *p2 = (char*)&n; |
#ifdef TEST_float |
p = pf; |
#else |
p = pd; |
#endif |
for(i=0; i<sizeof(TY); i++) |
#ifdef TEST_BIG |
if(p[i] != p2[i]) |
exit(1); |
#else |
if(p[i] != p2[sizeof(TY)-i-1]) |
exit(1); |
#endif |
} |
int main() |
{ |
if(sizeof(TY)!=EXPECTED_SIZE_$1) |
exit(1); |
check((TY)0.0, "\000\000\000\000", "\000\000\000\000\000\000\000\000"); |
check((TY)1.0, "\077\200\000\000", "\077\360\000\000\000\000\000\000"); |
check((TY)-1.0, "\277\200\000\000", "\277\360\000\000\000\000\000\000"); |
check((TY)2.0, "\100\000\000\000", "\100\000\000\000\000\000\000\000"); |
check((TY)1.5, "\077\300\000\000", "\077\370\000\000\000\000\000\000"); |
check((TY)0.032999999821186065673828125, "\075\007\053\002", "\077\240\345\140\100\000\000\000"); |
exit(0); |
} |
]]) |
|
AC_MSG_CHECKING(for type of float) |
AC_CACHE_VAL(pike_cv_float_type, [ |
AC_TRY_RUN(float_check(float,BIG), pike_cv_float_type=ieee_big, [ |
AC_TRY_RUN(float_check(float,LITTLE), pike_cv_float_type=ieee_little, |
pike_cv_float_type=not_ieee, pike_cv_float_type=not_ieee) |
], [ |
echo $ac_n "crosscompiling... $ac_c" 1>&6 |
# Use some magical constants... |
cat > conftest.$ac_ext <<EOF |
dnl This sometimes fails to find confdefs.h, for some reason. |
dnl [#]line __oline__ "[$]0" |
[#]line __oline__ "configure" |
#include "confdefs.h" |
#include <stdio.h> |
float float_info[[]] = { |
0.0, |
14914788644012054221422592.0, 16305677175569252352.0, |
0.0 |
}; |
EOF |
if AC_TRY_EVAL(ac_compile); then |
if test -f "conftest.$ac_objext"; then |
if strings "conftest.$ac_objext" | grep "iEeE_bIg" >/dev/null; then |
pike_cv_float_type=ieee_big |
else |
if strings "conftest.$ac_objext" | grep "EeEigIb_" >/dev/null; then |
pike_cv_float_type=ieee_little |
else |
pike_cv_float_type=not_ieee |
fi |
fi |
else |
AC_MSG_WARN([Object file not found.]) |
pike_cv_float_type=not_ieee |
fi |
else |
pike_cv_float_type=not_ieee |
fi |
rm -rf conftest* |
]) |
]) |
if test "$pike_cv_float_type" = ieee_big; then |
AC_MSG_RESULT(IEEE big endian) |
AC_DEFINE(FLOAT_IS_IEEE_BIG) |
else |
if test "$pike_cv_float_type" = ieee_little; then |
AC_MSG_RESULT(IEEE little endian) |
AC_DEFINE(FLOAT_IS_IEEE_LITTLE) |
else |
AC_MSG_RESULT(not IEEE) |
fi |
fi |
|
AC_MSG_CHECKING(for type of double) |
AC_CACHE_VAL(pike_cv_double_type, [ |
AC_TRY_RUN(float_check(double,BIG), pike_cv_double_type=ieee_big, [ |
AC_TRY_RUN(float_check(double,LITTLE), pike_cv_double_type=ieee_little, |
pike_cv_double_type=not_ieee, pike_cv_double_type=not_ieee) |
], [ |
echo $ac_n "crosscompiling... $ac_c" 1>&6 |
# Use some magical constants... |
cat > conftest.$ac_ext <<EOF |
dnl This sometimes fails to find confdefs.h, for some reason. |
dnl [#]line __oline__ "[$]0" |
[#]line __oline__ "configure" |
#include "confdefs.h" |
#include <stdio.h> |
double double_info[[]] = { |
0.0, |
12794738495187527498222028847205909954314554441725728393516969126669975252147490126864122090122288822751876426313291683594796075946303753742007913302630260537160845833197547903208108732031187791380480.0, |
0.0 |
}; |
EOF |
if AC_TRY_EVAL(ac_compile); then |
if test -f "conftest.$ac_objext"; then |
if strings "conftest.$ac_objext" | grep "iEeE_bIg" >/dev/null; then |
pike_cv_double_type=ieee_big |
else |
if strings "conftest.$ac_objext" | grep "gIb_EeEi" >/dev/null; then |
pike_cv_double_type=ieee_little |
else |
pike_cv_double_type=not_ieee |
fi |
fi |
else |
AC_MSG_WARN([Object file not found.]) |
pike_cv_float_type=not_ieee |
fi |
else |
pike_cv_float_type=not_ieee |
fi |
rm -rf conftest* |
]) |
]) |
if test "$pike_cv_double_type" = ieee_big; then |
AC_MSG_RESULT(IEEE big endian) |
AC_DEFINE(DOUBLE_IS_IEEE_BIG) |
else |
if test "$pike_cv_double_type" = ieee_little; then |
AC_MSG_RESULT(IEEE little endian) |
AC_DEFINE(DOUBLE_IS_IEEE_LITTLE) |
else |
AC_MSG_RESULT(not IEEE) |
fi |
fi |
|
############################################################################# |
|
AC_MSG_CHECKING(for volatile) |
AC_CACHE_VAL(pike_cv_volatile, |
[ |
AC_TRY_COMPILE([],[ volatile int foo=1;], pike_cv_volatile=yes,pike_cv_volatile=no) |
]) |
|
if test "$pike_cv_volatile" = yes; then |
AC_MSG_RESULT(yes) |
AC_DEFINE(VOLATILE,volatile) |
else |
AC_MSG_RESULT(no) |
AC_DEFINE(VOLATILE,) |
fi |
|
######################################################################## |
|
AC_MSG_CHECKING(for sig_atomic_t) |
AC_CACHE_VAL(ac_cv_type_sig_atomic_t, |
[ |
AC_EGREP_CPP(sig_atomic_t, [ |
#ifdef HAVE_SIGNAL_H |
#include <signal.h> |
#endif |
#ifdef HAVE_CRT_SIGNAL_H |
#include <crt/signal.h> |
#endif |
#include <sys/types.h> |
#if STDC_HEADERS |
#include <stdlib.h> |
#include <stddef.h> |
#endif], ac_cv_type_sig_atomic_t=yes, ac_cv_type_sig_atomic_t=no)]) |
AC_MSG_RESULT($ac_cv_type_sig_atomic_t) |
if test x"$ac_cv_type_sig_atomic_t" = xno; then |
AC_DEFINE(sig_atomic_t, int) |
else |
: |
fi |
|
AC_MSG_CHECKING(if signal handlers reset automatically) |
AC_CACHE_VAL(pike_cv_sys_signal_oneshot, |
[ |
AC_TRY_RUN([ |
#ifdef HAVE_SIGNAL_H |
#include <signal.h> |
#endif |
#include <sys/types.h> |
#if STDC_HEADERS |
#include <stdlib.h> |
#include <stddef.h> |
#endif |
VOLATILE sig_atomic_t sigrun[2]= { 0, 0 }; |
RETSIGTYPE func(int sig) |
{ |
write(2, "func called\n", sizeof("func called\n") - sizeof("")); |
sigrun[0] = -1; |
} |
|
int main() |
{ |
#define sig SIGSEGV |
|
#ifdef HAVE_SIGACTION |
{ |
static struct sigaction action; |
action.sa_handler= func; |
sigfillset(&action.sa_mask); |
#ifdef SA_INTERRUPT |
action.sa_flags=SA_INTERRUPT; |
#endif |
sigaction(sig,&action,0); |
} |
#else |
#ifdef HAVE_SIGVEC |
{ |
static struct sigvec action; |
action.sv_handler= func; |
action.sv_mask=-1; |
#ifdef SV_INTERRUPT |
action.sv_flags=SV_INTERRUPT; |
#endif |
sigvec(sig,&action,0); |
} |
#else |
signal(sig, func); |
#endif |
#endif |
|
kill(getpid(), sig); |
#ifdef HAVE_POLL |
while(!strlen((char *)sigrun)) poll(0,0,100); |
#else |
while(!strlen((char *)sigrun)) sleep(1); |
#endif |
sigrun[0]=0; |
kill(getpid(), sig); |
#ifdef HAVE_POLL |
while(!strlen((char *)sigrun)) poll(0,0,100); |
#else |
while(!strlen((char *)sigrun)) sleep(1); |
#endif |
sigrun[0]=0; |
exit(0); |
} |
],pike_cv_sys_signal_oneshot=no,pike_cv_sys_signal_oneshot=yes,pike_cv_sys_signal_oneshot=yes)]) |
|
if test "$pike_cv_sys_signal_oneshot" = yes; then |
AC_MSG_RESULT(yes) |
AC_DEFINE(SIGNAL_ONESHOT) |
else |
AC_MSG_RESULT(no) |
fi |
|
######################################################################## |
|
AC_MSG_CHECKING(available file descriptors) |
AC_CACHE_VAL(pike_cv_max_open_fd, |
[ |
if test "x$enable_binary" = "xno"; then |
pike_cv_max_open_fd=256 |
else |
AC_TRY_RUN([ |
#include <stdio.h> |
#ifdef HAVE_SYS_TIME_H |
#include <sys/time.h> |
#endif |
#ifdef HAVE_SYS_RESOURCE_H |
#include <sys/resource.h> |
#endif |
|
#ifndef MAX_FD |
#define MAX_FD 65536 |
#endif |
|
int main() |
{ |
FILE *f; |
long limit; |
|
#if !defined(RLIMIT_NOFILE) && defined(RLIMIT_OFILE) |
#define RLIMIT_NOFILE RLIMIT_OFILE |
#endif |
|
#if defined(HAVE_SETRLIMIT) && defined(RLIMIT_NOFILE) |
struct rlimit lim; |
|
if(getrlimit(RLIMIT_NOFILE,&lim)) |
{ |
limit = MAX_FD; |
}else{ |
if(lim.rlim_max == RLIM_INFINITY) |
{ |
limit = 1024 * 1024 * 2; /* Noone needs more :-) */ |
}else{ |
limit=lim.rlim_max; |
if(limit > 1024 * 1024 * 2) limit= 1024 * 1024 * 2; |
} |
} |
#else |
limit = MAX_FD; |
#endif |
|
f=fopen("conftest.out.2","w"); |
fprintf(f,"%ld\n",(long)limit); |
fclose(f); |
|
return 0; |
} |
], |
pike_cv_max_open_fd=`cat conftest.out.2` |
, |
pike_cv_max_open_fd=256 |
, |
pike_cv_max_open_fd=256 |
) |
fi |
]) |
AC_MSG_RESULT($pike_cv_max_open_fd) |
AC_DEFINE_UNQUOTED(MAX_OPEN_FILEDESCRIPTORS,$pike_cv_max_open_fd) |
|
AC_MSG_CHECKING(full availability of struct rusage members) |
AC_CACHE_VAL(pike_cv_func_getrusage_full, |
[ |
AC_TRY_LINK([ |
#include <sys/time.h> |
#ifdef HAVE_SYS_RUSAGE_H |
#include <sys/rusage.h> |
#endif |
#include <sys/resource.h> |
#ifndef RUSAGE_SELF |
#define RUSAGE_SELF 0 |
#endif |
],[ |
struct rusage rus; |
long *v = (long *)main; |
getrusage(RUSAGE_SELF, &rus); |
*v++ = rus.ru_maxrss; |
*v++ = rus.ru_ixrss; |
*v++ = rus.ru_idrss; |
*v++ = rus.ru_isrss; |
*v++ = rus.ru_minflt; |
*v++ = rus.ru_majflt; |
*v++ = rus.ru_nswap; |
*v++ = rus.ru_inblock; |
*v++ = rus.ru_oublock; |
*v++ = rus.ru_msgsnd; |
*v++ = rus.ru_msgrcv; |
*v++ = rus.ru_nsignals; |
*v++ = rus.ru_nvcsw; |
*v++ = rus.ru_nivcsw; |
], |
pike_cv_func_getrusage_full=yes |
, |
pike_cv_func_getrusage_full=no |
)]) |
|
if test "$pike_cv_func_getrusage_full" = yes; then |
AC_MSG_RESULT(all there) |
else |
AC_MSG_RESULT(getrusage is restricted) |
AC_DEFINE(GETRUSAGE_RESTRICTED) |
fi |
|
######################################################################## |
# |
# IRIX also has procfs support, but it it different, a separate test |
# should be made. /Hubbe |
# |
|
if test "$ac_cv_header_sys_procfs_h" = "yes"; then |
AC_MSG_CHECKING(getrusage() through procfs) |
AC_CACHE_VAL(pike_cv_getrusage_procfs, [ |
AC_TRY_COMPILE([ |
#ifndef _LARGEFILE_SOURCE |
# define _FILE_OFFSET_BITS 64 |
# define _LARGEFILE_SOURCE |
# define _LARGEFILE64_SOURCE 1 |
#endif |
#include <sys/procfs.h> |
#include <sys/fcntl.h> |
int proc_fd; |
long tmp; |
char proc_name[20]; |
prusage_t pru; |
],[ |
sprintf(proc_name, "/proc/%05d", getpid()); |
proc_fd = open(proc_name, O_RDONLY); |
ioctl(proc_fd, PIOCUSAGE, &pru); |
tmp=pru.pr_utime.tv_sec; |
], |
pike_cv_getrusage_procfs=yes |
, |
pike_cv_getrusage_procfs=no |
) |
]) |
|
if test "$pike_cv_getrusage_procfs" = yes; then |
AC_MSG_RESULT(yes) |
AC_DEFINE(GETRUSAGE_THROUGH_PROCFS) |
else |
AC_MSG_RESULT(no) |
fi |
fi |
|
############################################################################# |
|
if test "$ac_cv_getrusage_procfs" = "yes"; then |
AC_MSG_CHECKING(prstatus_t contains pr_brksize and pr_stksize) |
AC_CACHE_VAL(pike_cv_getrusage_procfs_prs, [ |
AC_TRY_COMPILE([ |
#ifndef _LARGEFILE_SOURCE |
# define _FILE_OFFSET_BITS 64 |
# define _LARGEFILE_SOURCE |
# define _LARGEFILE64_SOURCE 1 |
#endif |
#include <sys/procfs.h> |
#include <sys/fcntl.h> |
int proc_fd; |
long tmp; |
char proc_name[20]; |
prstatus_t prs; |
],[ |
sprintf(proc_name, "/proc/%05d", getpid()); |
proc_fd = open(proc_name, O_RDONLY); |
ioctl(proc_fd, PIOCSTATUS, &prs); |
tmp=prs.pr_brksize + prs.pr_stksize; |
], |
pike_cv_getrusage_procfs_prs=yes |
, |
pike_cv_getrusage_procfs_prs=no |
) |
]) |
|
if test "$pike_cv_getrusage_procfs_prs" = yes; then |
AC_MSG_RESULT(yes) |
AC_DEFINE(GETRUSAGE_THROUGH_PROCFS_PRS) |
else |
AC_MSG_RESULT(no) |
fi |
fi |
|
############################################################################# |
|
AC_MSG_CHECKING(for isgraph) |
AC_CACHE_VAL(pike_cv_func_isgraph, [ AC_TRY_LINK([ |
#include <ctype.h> |
], [ |
return(!isgraph('A')); |
], pike_cv_func_isgraph=yes, pike_cv_func_isgraph=no) |
]) |
AC_MSG_RESULT($pike_cv_func_isgraph) |
if test "x$pike_cv_func_isgraph" = "xyes" ; then |
AC_DEFINE(HAVE_ISGRAPH) |
else :; fi |
|
############################################################################# |
# |
# __func__ is new in ISO C 9x |
# |
# It should expand to the name of the current function, and is |
# useful for debug. |
|
AC_MSG_CHECKING(if __func__ exists and works) |
AC_CACHE_VAL(pike_cv_have_working___func__, |
[ |
AC_TRY_RUN([ |
#ifdef HAVE_STRING_H |
#include <string.h> |
#else /* !HAVE_STRING_H */ |
#ifdef HAVE_STRINGS_H |
#include <strings.h> |
#endif /* HAVE_STRIGNS_H */ |
#endif /* HAVE_STRING_H */ |
int main() |
{ |
exit(strcmp("main", __func__)); |
} |
], pike_cv_have_working___func__=yes, pike_cv_have_working___func__=no, |
pike_cv_have_working___func__=no) |
]) |
AC_MSG_RESULT($pike_cv_have_working___func__) |
if test "$pike_cv_have_working___func__" = yes; then |
AC_DEFINE(HAVE_WORKING___FUNC__) |
else :; fi |
|
# gcc has __FUNCTION__ instead. |
|
AC_MSG_CHECKING(if __FUNCTION__ exists and works) |
AC_CACHE_VAL(pike_cv_have_working___FUNCTION__, |
[ |
AC_TRY_RUN([ |
#ifdef HAVE_STRING_H |
#include <string.h> |
#else /* !HAVE_STRING_H */ |
#ifdef HAVE_STRINGS_H |
#include <strings.h> |
#endif /* HAVE_STRIGNS_H */ |
#endif /* HAVE_STRING_H */ |
int main() |
{ |
exit(strcmp("main", __FUNCTION__)); |
} |
], pike_cv_have_working___FUNCTION__=yes, |
pike_cv_have_working___FUNCTION__=no, |
pike_cv_have_working___FUNCTION__=no) |
]) |
AC_MSG_RESULT($pike_cv_have_working___FUNCTION__) |
if test "$pike_cv_have_working___FUNCTION__" = yes; then |
AC_DEFINE(HAVE_WORKING___FUNCTION__) |
else :; fi |
|
############################################################################# |
|
if test "x$with_computed_goto" = "xyes"; then |
AC_MSG_CHECKING(for gcc-style computed goto) |
AC_CACHE_VAL(pike_cv_gcc_computed_goto, [ |
AC_TRY_COMPILE([], [ |
void *skip = &&label; |
|
goto *skip; |
|
return 1; |
|
label: |
return 0; |
], [ pike_cv_gcc_computed_goto=yes ], [ pike_cv_gcc_computed_goto=no ]) |
]) |
AC_MSG_RESULT($pike_cv_gcc_computed_goto) |
if test "x$pike_cv_gcc_computed_goto" = "xyes"; then |
AC_MSG_WARN([Enabling computed goto (EXPERIMENTAL).]) |
AC_DEFINE(HAVE_COMPUTED_GOTO) |
else :; fi |
else :; fi |
|
############################################################################# |
|
if test "$with_machine_code" = "yes" ; then |
AC_DEFINE_UNQUOTED(PIKE_BYTECODE_METHOD, [[PIKE_BYTECODE_`echo $pike_cv_machine_code_arch | tr '[a-z]' '[A-Z]'`]]) |
| < |