AC_REVISION("$Id: configure.in,v 1.941 2006/03/16 18:05:05 grubba Exp $") |
AC_INIT(interpret.c) |
AC_CONFIG_HEADER(machine.h) |
|
rm -f config.warnings 2>/dev/null |
|
if_autoconf(2,50,[ |
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 |
], [ |
PIKE_MSG_WARN([configure script has been generated with autoconf 2.13 or earlier.]) |
]) |
|
# 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 |
|
# Check that we can write to the source directory. |
sleep 1 |
if touch "$srcdir/configure~"; then |
# Check that the system time is reasonably correct. |
if test `cd "$srcdir" && ls -1t configure configure~ | head -n 1` = "configure"; then |
echo "Current system time is `date`." |
AC_MSG_ERROR([ |
$srcdir/configure has modification time in the future. |
Check and set your system time. |
]) |
fi |
else |
ls -ld "$srcdir" |
AC_MSG_ERROR([ |
Failed to write in source directory. |
Fix your permissions. |
]) |
fi |
|
# 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. |
# Some OS's also have a seriously broken /bin/sh (eg NetBSD). |
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_CHECKING([if $ac_cv_path_bash_prog works]) |
if "$ac_cv_path_bash_prog" --norc -c : 2>&AC_FD_CC; then |
AC_MSG_RESULT(yes) |
else |
AC_MSG_RESULT(no) |
ac_cv_path_bash_prog=no |
fi |
fi |
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 --norc" |
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 |
|
AC_PROG_MAKE_SET |
|
|
rm -f "conftest_VPATH.in" 2>/dev/null |
touch "$srcdir/conftest_VPATH.in" |
if test -f conftest_VPATH.in; then :; else |
# Not building in source tree. |
AC_MSG_CHECKING([whether ${MAKE-make} supports VPATH]) |
AC_CACHE_VAL(pike_cv_make_supports_VPATH, [ |
cat > conftestmake <<EOF |
VPATH=.:$srcdir |
.SUFFIXES: .in .out |
.in.out: |
cat "\$<" >"\$@" |
EOF |
pike_cv_make_supports_VPATH=no |
if ${MAKE-make} -f conftestmake conftest_VPATH.out >/dev/null 2>&AC_FD_CC; then |
if test -f conftest_VPATH.out; then |
pike_cv_make_supports_VPATH=yes |
else :; fi |
else :; fi |
rm -f conftestmake conftest_VPATH.out |
]) |
AC_MSG_RESULT($pike_cv_make_supports_VPATH) |
if test "x$pike_cv_make_supports_VPATH" = "xno"; then |
AC_ERROR([ |
Building in a separate directory is not supported without VPATH. |
|
Build in the source directory, or try another make (eg gnumake). |
]) |
exit 1 |
else :; fi |
fi |
rm -f "$srcdir/conftest_VPATH.in" 2>/dev/null |
|
if test -d "$srcdir/../bundles"; then |
# Some of the bundled libraries (eg nettle) set SHELL. |
AC_MSG_CHECKING([whether ${MAKE-make} supports spaces in SHELL]) |
AC_CACHE_VAL(pike_cv_make_supports_spaces_in_SHELL, [ |
cat > conftestmake <<EOF |
SHELL=/bin/sh -n |
false: |
/bin/false |
true: |
: |
complex_false: |
test "foo" = "foo" && /bin/false |
complex_true: |
test "foo" = "bar" || : |
EOF |
if ${MAKE-make} -f conftestmake false >&AC_FD_CC 2>&AC_FD_CC; then |
# /bin/sh was found, and /bin/false was not executed. |
pike_cv_make_supports_spaces_in_SHELL=yes |
elif ${MAKE-make} -f conftestmake complex_false >&AC_FD_CC 2>&AC_FD_CC; then |
# SHELL is ignored for simple targets, but not for more |
# complex expressions. |
# When SHELL is used, spaces are supported. |
pike_cv_make_supports_spaces_in_SHELL="complex only" |
elif ${MAKE-make} -f conftestmake complex_true >&AC_FD_CC 2>&AC_FD_CC; then |
# SHELL is ignored for all targets. |
pike_cv_make_supports_spaces_in_SHELL=ignored |
elif ${MAKE-make} -f conftestmake true >&AC_FD_CC 2>&AC_FD_CC; then |
# SHELL is ignored for simple targets, but not for more |
# complex expressions. |
# When SHELL is used, spaces are not supported. |
pike_cv_make_supports_spaces_in_SHELL=no |
else |
# Spaces are not supported in SHELL. |
pike_cv_make_supports_spaces_in_SHELL=no |
fi |
rm -f conftestmake |
]) |
AC_MSG_RESULT($pike_cv_make_supports_spaces_in_SHELL) |
else :; fi |
|
AC_ARG_ENABLE(pikelib, MY_DESCR([--enable-pikelib], |
[build pike as a library]), |
[enable_pikelib=yes], [enable_pikelib=no]) |
|
if test "x$enable_pikelib" != "xno"; then |
PIKE_MSG_WARN([BUILDING PIKE AS A LIBRARY -- HIGHLY EXPERIMENTAL!]) |
AC_DEFINE(LIBPIKE) |
fi |
|
AC_ARG_ENABLE(make_conf, MY_DESCR([--disable-make.conf], |
[do not use settings from /etc/make.conf]), |
[], [enable_make_conf=yes]) |
|
initial_cflags="${CFLAGS}" |
initial_cppflags="${CPPFLAGS}" |
initial_ldflags="${LDFLAGS}" |
|
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 |
|
# if test "x$enable_make_conf" = x"yes" -a -f /etc/make.conf; then |
# set >conftest.tmp |
# echo Using settings from /etc/make.conf... |
# . /etc/make.conf |
# set | diff -u conftest.tmp - | grep '^+C' |
# PIKE_MSG_WARN([Using settings from /etc/make.conf.]) |
# 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" ]) |
|
# Force use of thread libs LIBS |
AC_ARG_WITH(thread-library, |
MY_DESCR([--with-thread-library=lib], |
[Use a specific thread library]), |
[ |
case "x$withval" in |
x-*) |
with_thread_library="$withval" |
;; |
*) |
with_thread_library="-l$withval" |
;; |
esac |
], [ with_thread_library=no ]) |
|
for ac_site_file in $CONFIG_SITE; do |
if test -r "$ac_site_file"; then |
PIKE_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 -f ./config.cache ; CONFIG_SITE=x ./configure ; make]) |
fi |
done |
|
AC_ARG_ENABLE(binary, MY_DESCR([--disable-binary], |
[do not configure for binary build, only do tests for precompilation stuff]), |
[], [enable_binary=yes]) |
|
if test "x$enable_binary" = "xno"; then |
PIKE_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 |
PIKE_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], |
[do not 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 |
|
AC_MSG_CHECKING([whether we are using Intel C]) |
AC_CACHE_VAL(pike_cv_prog_icc, [ |
AC_EGREP_CPP([oui], [ |
#if defined(__ECC) || defined(__ICC) || defined(__INTEL_COMPILER) |
oui; |
#endif |
], pike_cv_prog_icc=yes, pike_cv_prog_icc=no) |
]) |
AC_MSG_RESULT($pike_cv_prog_icc) |
if test "$pike_cv_prog_icc" = "yes"; then |
ICC=yes |
fi |
|
############################################################################# |
|
if test "x$enable_binary" != "xno"; then |
AC_ISC_POSIX |
AC_AIX |
AC_MINIX |
fi |
|
############################################################################# |
|
# ABI selection. |
|
PIKE_SELECT_ABI |
|
############################################################################# |
|
if test "x$GCC" = "x"; then |
GCC=no |
else |
:; |
fi |
|
if test "x$GCC" = "xno" -a "x$TCC" = "xno"; then |
|
if test "x$ac_cv_prog_cc_cross" = "xyes"; then |
# The AIX 5L/cc beta can not generate working binaries without a |
# data-segment... |
AC_MSG_CHECKING([if we are 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 |
PIKE_MSG_WARN(Lost track of data-segment kludge-file.) |
fi |
else |
PIKE_MSG_WARN(Failed to rename data-segment kludge-file.) |
fi |
else |
PIKE_MSG_WARN(Can not find data-segment kludgefile.) |
fi |
else |
PIKE_MSG_WARN(Failed to compile data-segment kludge.) |
fi |
if test "x$pike_cv_datasegment_file" = "xno"; then |
PIKE_MSG_WARN(Some tests may yield false results.) |
else |
LIBS="$pike_cv_datasegment_file $LIBS" |
export LIBS |
PIKE_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 |
], [], [ 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; |
], [], [ 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(oui, [ oui ], , 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)` |
DOCDIR=`(cd $srcdir/../refdoc ; pwd)` |
BASEDIR=`(cd $srcdir/.. ; pwd)` |
BUILDDIR=`pwd` |
AC_SUBST(LIBDIR) |
AC_SUBST(BINDIR) |
AC_SUBST(MANDIR) |
AC_SUBST(DOCDIR) |
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" |
else |
if test "x$cross_compiling" = "xyes"; then |
RUNPIKE="USE_PIKE" |
else |
RUNPIKE="DEFAULT_RUNPIKE" |
fi |
fi |
AC_SUBST(RUNPIKE) |
|
############################################################################# |
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 does not 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 does not 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 |
|
############################################################################# |
|
## Build smartlink |
AC_ARG_ENABLE(smartlink_binary, MY_DESCR([--disable-smartlink-binary], |
[do not build and use the smartlink binary]), |
[], [force_smartlink_script_only=yes]) |
|
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 "$cross_compiling" = "yes"; then |
case "$host_alias" in |
*amigaos*) pike_cv_sys_os="AmigaOS";; |
*linux*) pike_cv_sys_os="Linux";; |
*solaris*) pike_cv_sys_os="Solaris";; |
*sunos*) pike_cv_sys_os="SunOS";; |
*windows*) pike_cv_sys_os="Windows_NT";; |
*mingw*|*MINGW*) |
pike_cv_sys_os="Windows_NT" |
pike_cv_is_mingw="yes";; |
*) pike_cv_sys_os="Unknown";; |
esac |
else |
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" |
;; |
*MINGW*|*mingw*) |
pike_cv_is_mingw="yes" |
pike_cv_sys_os="Windows_NT" |
;; |
|
esac |
else |
pike_cv_sys_os="Not Solaris" |
fi |
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 some OS that have some clues |
case "$pike_cv_sys_os" in |
CYGWIN*) |
# Cygwin has both Windows includes and Unix ones. |
# Hiding them make it a somewhat Unix compliant OS. |
echo 'Cygwin host detected. Enabling workarounds...' |
# winsock.h, winbase.h, winsock2.h, windows.h, wingdi.h, windef.h |
# are part of VC api but given as headers in cygwin. We |
# should not detect them when using cygwin |
ac_cv_header_wingdi_h="no" |
ac_cv_header_windef_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" |
with_machine_code="no" |
;; |
Windows_NT) |
if test "$pike_cv_is_mingw" = "yes"; then |
#with_machine_code="no" |
ac_cv_func_fpclass="no" |
fi |
;; |
FreeBSD*) |
# FreeBSD has different naming convention for gtk-config and sdl-config |
if test "x${GTK_CONFIG}" = "x"; then |
GTK_CONFIG=`which ${ac_tool_prefix}gtk12-config` |
export GTK_CONFIG |
fi |
if test "x${SDL_CONFIG}" = "x"; then |
SDL_CONFIG=`which ${ac_tool_prefix}sdl11-config` |
export SDL_CONFIG |
fi |
;; |
esac |
|
# Skip fi user does not wish to use smartlink binary. |
if test "x$force_smartlink_script_only" = "x"; then |
# Strip smartlink from $CC |
REALCC="`echo $CC|sed -e 's/.*smartlink //'`" |
|
|
# 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.* | GNU/kFreeBSD* ) |
if test "$ICC" = "yes"; then |
# icc or ecc. |
pike_cv_run_path_method=qoption |
else |
pike_cv_run_path_method=wl |
fi |
;; |
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]) |
;; |
qoption) |
AC_DEFINE(USE_Qoption) |
AC_MSG_RESULT([use -Qoption,ld,-rpath]) |
;; |
ld_library_path|*) |
AC_DEFINE(USE_LD_LIBRARY_PATH) |
AC_MSG_RESULT([use LD_LIBRARY_PATH/LD_RUN_PATH]) |
;; |
esac |
|
|
# 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 -n 1 | grep "smartlink.$ac_ext" >/dev/null 2>&AC_FD_CC && "$SMARTLINK" -v >/dev/null 2>&AC_FD_CC; then |
AC_MSG_RESULT(yes) |
else |
AC_MSG_RESULT(no) |
SMARTBUILDCC="${REALCC-cc}" |
|
if echo foo "$CC" | egrep 'rntc.|rnt.cl' >/dev/null; then |
PIKE_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 |
PIKE_MSG_WARN([Crosscompiler detected.]) |
AC_PATH_PROGS(SMARTBUILDCC, gcc cc egcs, gcc, /usr/bin:/bin/:/usr/ccs/bin:/usr/local/bin:/usr/sfw/bin:/opt/sfw/bin:/opt/csw/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>&AC_FD_CC' |
if { (eval echo Compiling smartlink: \"$link_cmd\") 1>&AC_FD_CC; (eval $link_cmd) 2>&AC_FD_CC; } && "$BUILDDIR/smartlink" -v >/dev/null 2>&AC_FD_CC; then |
AC_MSG_RESULT(yes) |
else |
AC_MSG_RESULT(no - use the sh script) |
SMARTLINK="$BINDIR/smartlink" |
fi |
fi |
else # force_smartlink_script_only |
AC_MSG_CHECKING(for smartlink build script) |
SMARTLINK="$BINDIR/smartlink" |
REALCC="$CC" |
AC_MSG_RESULT($SMARTLINK) |
fi # force_smartlink_script_only |
|
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) |
|
# The following segment is obsolete, since executable memory is |
# now allocated with mmap instead of with malloc(). |
# /grubba 2005-06-09 |
# |
# #### For exec-shield in newer linux kernels. |
# #### Linux's mprotect(2) is broken, so we unfortunately |
# #### need to enable executabe stack. |
# #### This test crashes under mingw32 so let's disable for win32 for now. |
# if test "$pike_cv_sys_os" != "Windows_NT"; then |
# AC_SYS_COMPILER_FLAG([[-Wa,--execstack]],executableheap,CFLAGS) |
# fi |
fi |
fi |
|
LD='$(CC) $(CFLAGS)' |
LC_REQ="-lc" |
|
case "$pike_cv_sys_os" in |
Darwin*) |
;; |
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 |
;; |
Linux*) |
if $REALCC -V 2>&1 | head -1 | grep "Intel(R) C" >/dev/null; then |
# icc or ecc. |
LC_REQ="" |
fi |
;; |
esac |
|
AC_SUBST(LD) |
AC_SUBST(LC_REQ) |
|
############################################################################# |
|
AC_ARG_WITH(extra_debug_checks, |
MY_DESCR([--with-extra-debug-checks], |
[enable some extra (possibly verbose) debug checks.]), |
[], [ |
if test "x$pike_cv_sys_os" = "xOSF1"; then |
# Attempt to detect the cause for test_resolv to fail on Unicode.so. |
with_extra_debug_checks="yes" |
else |
with_extra_debug_checks=no |
fi |
]) |
|
if test "x$with_extra_debug_checks" = "xno"; then :; else |
AC_MSG_WARN([Enabling extra debug checks.]) |
AC_DEFINE([PIKE_EXTRA_DEBUG]) |
fi |
|
############################################################################# |
|
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 |
PIKE_MSG_WARN([GNU ld found on Solaris sparc system ($gcc_ld_path/ld). |
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 $CPPFLAGS conftest.c 1>&AC_FD_CC' |
pike_cv_gcc_uaword=no |
if { (eval echo configure: \"$pike_compile\") >&AC_FD_CC; (eval $pike_compile) 2>&AC_FD_CC; }; then |
if grep ".uaword" conftest.s 2>&AC_FD_CC >/dev/null; then |
echo "configure: result contains .uaword:" >&AC_FD_CC |
cat conftest.s >&AC_FD_CC |
pike_cv_gcc_uaword=yes |
else :; fi |
else |
echo "configure: failed program was:" >&AC_FD_CC |
cat conftest.c >&AC_FD_CC |
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 |
PIKE_MSG_WARN([Your gcc/as combo may generate R_SPARC_UA32 relocations. |
R_SPARC_UA32 relocations are unsupported in Solaris >= 2.3, |
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 |
PIKE_MSG_WARN([Back out patch 107058-01, or |
recompile gcc with a modified config/sparc/sol2.h.]) |
else |
PIKE_MSG_WARN([Recompile gcc with a modified config/sparc/sol2.h.]) |
fi |
|
PIKE_MSG_WARN([You may want to try binary patching gcc. |
In that case rerun configure with --with-patch-gcc. |
NOTE: Binary patching is highly experimental and risky, |
and may break your existing gcc even more. |
|
R_SPARC_UA32 relocations are supported on some versions |
of Solaris. If you want to try a binary with R_SPARC_UA32 |
relocations, rerun configure with --with-force-ua32.]) |
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>&AC_FD_CC' |
if { (eval echo Compiling patch_cc1: \"$link_cmd\") 1>&AC_FD_CC; (eval $link_cmd) 2>&AC_FD_CC; } && "$BUILDDIR/patch_cc1" -v >/dev/null 2>&AC_FD_CC; 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>&AC_FD_CC >"$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. |
NOTE: Entering critical section. |
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. |
Please rerun configure.]) |
exit 1 |
fi |
|
AC_MSG_WARN([Moving the patched cc1 into place failed. |
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="" |
;; |
*) |
PIKE_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(bundles, |
MY_DESCR([--without-bundles], |
[do not enable bundled libraries]), |
[], [with_bundles=yes]) |
pike_bundle_dir="" |
if test "$with_bundles" = "no"; then :; else |
if test -d "$with_bundles/."; then |
# The user has specified a bundle directory. Use it. |
pike_bundle_dir="$with_bundles" |
elif test -d "$srcdir/../bundles/."; then |
# We have a bundle directory; enable them if needed. |
pike_bundle_dir=`cd "$srcdir/../bundles" && pwd` |
fi |
test -d bundles/. || mkdir bundles; |
fi |
if test -d bundles/.; then |
touch bundles/no_testsuites |
pike_bundle_prefix="`pwd`/bundles" |
test -d bundles/installed/. || mkdir bundles/installed |
test -d bundles/include/. || mkdir bundles/include |
CPPFLAGS="$CPPFLAGS -I$pike_bundle_prefix/include" |
test -d bundles/lib/. || mkdir bundles/lib |
for d in $pike_cv_abi_suffixes; do |
test -d "bundles/lib$d/." || mkdir "bundles/lib$d" |
LDFLAGS="$LDFLAGS -L$pike_bundle_prefix/lib$d" |
done |
fi |
export pike_bundle_dir |
AC_ARG_WITH(site-prefixes, |
MY_DESCR([--with-site-prefixes], |
[:-separated 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])) |
AC_ARG_WITH(long-int, MY_DESCR([--with-long-int], |
[use long native type int])) |
AC_ARG_WITH(int-int, MY_DESCR([--with-int-int], |
[use int native type int])) |
dnl AC_ARG_WITH(short-int, MY_DESCR([--with-short-int], |
dnl [use short native type int (EXPERIMENTAL)])) |
dnl AC_ARG_WITH(unsigned-long-int, MY_DESCR([--with-unsigned-long-int], |
dnl [use short native type int (EXPERIMENTAL)])) |
dnl AC_ARG_WITH(unsigned-long-long-int, MY_DESCR([--with-unsigned-long-longint], |
dnl [use short native type int (EXPERIMENTAL)])) |
|
MY_AC_ARG_WITH(cleanup-on-exit, |
MY_DESCR([--with-cleanup-on-exit], |
[Do full cleanup at exit to detect leaks better.]), |
[AC_DEFINE(DO_PIKE_CLEANUP)]) |
MY_AC_ARG_WITH(dmalloc, MY_DESCR([--with-dmalloc],[Enable memory leak checks.]), |
[AC_DEFINE(DEBUG_MALLOC,10)]) |
MY_AC_ARG_WITH(dmalloc-malloc, MY_DESCR([--with-dmalloc-malloc], |
[Enable overloading of 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)]) |
MY_AC_ARG_WITH(dmalloc-track-free, MY_DESCR([--with-dmalloc-track-free], |
[track freed memory too]), |
[ with_dmalloc_track_free="yes" |
AC_DEFINE(DMALLOC_TRACK_FREE,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. |
PIKE_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) |
PIKE_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 |
PIKE_MSG_WARN([FreeBSD <= 3.x detected, disabling threads. |
Use --with-threads to force threads support.]) |
with_threads=no |
fi |
;; |
xOpenBSD*) |
if test "`uname -r|sed -e 's/\([[0-9]]*\).*/\1/'`" -lt 4 \ |
-a "x`uname -m`" = "xalpha"; then |
PIKE_MSG_WARN([OpenBSD/alpha <= 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(malloc_overhead, |
MY_DESCR([--with-malloc-overhead=n], |
[tune the malloc block overhead (default is 2 * sizeof(void *))]), |
[AC_DEFINE(PIKE_MALLOC_OVERHEAD,($withval))], |
[AC_DEFINE(PIKE_MALLOC_OVERHEAD,(2 * sizeof(void *)))]) |
AC_ARG_WITH(malloc_page_size, |
MY_DESCR([--with-malloc-page-size=n], |
[tune to the memory page size (default is 4 kb)]), |
[AC_DEFINE(PIKE_MALLOC_PAGE_SIZE,($withval))], |
[AC_DEFINE(PIKE_MALLOC_PAGE_SIZE,(4 * 1024))]) |
AC_ARG_WITH(thread_c_stack, |
MY_DESCR([--with-thread-c-stack=n], |
[tune the thread c-stack (default is 256 * 1024)]), |
[AC_DEFINE_UNQUOTED(PIKE_THREAD_C_STACK_SIZE,($withval))], |
[AC_DEFINE(PIKE_THREAD_C_STACK_SIZE,(256 * 1024))]) |
|
AC_ARG_WITH(devpoll, MY_DESCR([--without-devpoll], |
[disable support for /dev/poll]), |
[],[with_devpoll=yes]) |
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])) |
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(valgrind, MY_DESCR([--with-valgrind=path], |
[Support for running with valgrind. Implies --with-cleanup-on-exit.]), [ |
if test "x$with_valgrind" = "xyes"; then |
AC_PATH_PROG(with_valgrind, valgrind, no) |
if test "x$with_valgrind" = "xno"; then |
PIKE_MSG_WARN(valgrind not found, disabled.) |
else :; fi |
else :; fi |
], [with_valgrind=no]) |
AC_ARG_WITH(checker, MY_DESCR([--with-checker], |
[add extra memory checking overhead (Purify)])) |
AC_ARG_WITH(gcov, MY_DESCR([--with-gcov], |
[compile with support for gcov (gcc-only)])) |
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|UnixWare|OpenUNIX) |
# PIKE_MSG_WARN([Defaulting to --with-poll since the OS is $pike_cv_sys_os.]) |
# Nothing to warn about, really... |
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 |
;; |
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 (INVALID)]), |
[],[ |
AC_MSG_ERROR([Support for out of band data is mandatory in Pike 7.5 and later.]) |
]) |
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 (not recommended)]), |
[],[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], |
[do not try to use of machine code on supported architectures.]), |
[], [ |
case "x$pike_cv_sys_os" in |
xOpenBSD*) |
PIKE_MSG_WARN([OpenBSD detected, disabling machine code. |
Use --with-machine-code to force usage of machine code support.]) |
with_machine_code="no" |
;; |
xFreeBSD*) |
PIKE_MSG_WARN([FreeBSD detected, disabling machine code. |
Use --with-machine-code to force usage of machine code support.]) |
with_machine_code="no" |
;; |
|
esac |
|
if test "x${with_machine_code-}" = x; then |
with_machine_code="yes" |
fi |
|
]) |
AC_ARG_WITH(small-eval-instruction, |
MY_DESCR([--with-small-eval-instruction], |
[attempt to reduce the size of eval_instruction (EXPERIMENTAL).]), [ |
AC_DEFINE(PIKE_SMALL_EVAL_INSTRUCTION) |
with_machine_code="no" |
with_computed_goto="no" |
]) |
|
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(portable-bytecode, |
MY_DESCR([--without-portable-bytecode], |
[disable portable bytecode support.]), |
[AC_DEFINE(PIKE_PORTABLE_BYTECODE)],[], |
[AC_DEFINE(PIKE_PORTABLE_BYTECODE)]) |
|
MY_AC_ARG_WITH(lock, |
MY_DESCR([--without-lock], |
[enable experimental code for multicpu machines (EXPERIMENTAL).]), |
[],[AC_DEFINE(PIKE_RUN_UNLOCKED)]) |
|
AC_ARG_WITH(pike-type, MY_DESCR([--without-pike-type], |
[disable struct pike_type (IGNORED).])) |
|
if test "x$with_pike_type" = "xno"; then |
PIKE_MSG_WARN([Disabling of USE_PIKE_TYPE is no longer supported.]) |
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 |
PIKE_MSG_WARN([****** Compiling without bignum support. This is discouraged. Many |
****** Pike applications might not work correctly.]) |
sleep 10 |
fi |
|
dnl Pike currently breaks miserably if SHARED_NODES is not defined. |
dnl Shared nodes are still disabled bluntly. (See note above.) |
dnl if test "x$with_shared_nodes" != xno; then |
dnl echo 'Enabling the SHARED_NODES mode of the optimizer.' |
AC_DEFINE(SHARED_NODES) |
dnl else :; fi |
|
if test "x$with_poll" = "xyes"; then |
AC_DEFINE(HAVE_AND_USE_POLL) |
else :; fi |
|
if test "x$with_valgrind" = "xno"; then |
VALGRIND="" |
VALGRINDARGS="" |
else |
VALGRIND="$with_valgrind" |
# Make valgrind a bit silent by default. |
VALGRINDARGS="-q --tool=memcheck" |
AC_DEFINE(USE_VALGRIND) |
|
if test "x$with_cleanup_on_exit" = "x"; then |
AC_DEFINE(DO_PIKE_CLEANUP) |
fi |
|
if test "x$with_copt" != "xno"; then |
PIKE_MSG_WARN([--without-copt is advisable when using valgrind!]) |
fi |
fi |
export VALGRIND VALGRINDARGS |
AC_SUBST(VALGRIND) |
AC_SUBST(VALGRINDARGS) |
|
if test "x$with_checker" = "xyes"; then |
AC_DEFINE(__CHECKER__) |
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 |
PIKE_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 |
|
############################################################################# |
|
|
DLOPEN_O="" |
WARN="" |
OPTIMIZE="${OPTFLAGS-}" |
|
AC_ARG_ENABLE(pedantic, MY_DESCR([--enable-pedantic], |
[enable -pedantic compilation])) |
|
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$enable_pedantic" = "xyes"; then |
AC_SYS_COMPILER_FLAG(-pedantic,pedantic,WARN) |
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 |
|
if test "x$with_gcov" = "xyes"; then |
# Support for gcov |
AC_SYS_COMPILER_FLAG(-fprofile-arcs, fprofile_arcs, CFLAGS) |
AC_SYS_COMPILER_FLAG(-ftest-coverage, ftest_coverage, CFLAGS) |
else :; fi |
|
if test "x$with_cdebug" = "xyes" ; then |
AC_SYS_COMPILER_FLAG(-ggdb3,ggdb3,CFLAGS) |
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) |
],[],[ |
# Some versions of gcc define __sparcv9 but aren't LP64. |
# Definition of __sparcv9 causes <sys/isa_defs.h> to define _LP64, |
# which is not a good thing for ILP32 systems... |
# Some versions of gcc define __sparc_v9__, which causes the |
# fix-included <limits.h> to think the same... |
AC_TRY_CPP([#include <limits.h> |
#include <sys/types.h> |
#if defined(_LP64) || (LONG_MAX != 2147483647L) |
#error "We might have a problem." |
#endif |
],[],[ |
# We might have a problem... |
# Check that we indeed have a LP64 system. |
AC_MSG_RESULT([yes, but LP64]) |
AC_CHECK_SIZEOF(long, 4) |
# Note: the result for the following message is provided |
# by SYS_COMPILER_FLAG |
AC_MSG_CHECKING([are we really an LP64 system]) |
if test "x$ac_cv_sizeof_long" = "x8"; then |
:; #OK, we have an LP64 system! |
else |
pike_cv_option_mcpu_ultrasparc=no |
fi |
]) |
]) |
;; |
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) |
;; |
x86_64) |
AC_SYS_COMPILER_FLAG(-m64,m64,CFLAGS,[ |
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) |
]) |
]) |
]) |
], [ |
BUNDLE_FLAGS="$BUNDLE_FLAGS --build=x86_64" |
]) |
;; |
i86pc) |
# Solaris x86 |
case "`optisa \`isalist 2>/dev/null\` 2>/dev/null || isalist 2>/dev/null`" in |
*amd64*) |
AC_SYS_COMPILER_FLAG(-m64,m64,CFLAGS,[ |
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) |
]) |
]) |
]) |
], [ |
BUNDLE_FLAGS="$BUNDLE_FLAGS --build=x86_64" |
]) |
# AC_SYS_COMPILER_FLAG(-march=i686,march_i686,CFLAGS) |
;; |
*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, framework_System, LDFLAGS) |
|
# Needed for MakeDataExecutable which comes from CarbonLib |
AC_SYS_COMPILER_FLAG(-framework CoreServices, framework_CoreServices, LDFLAGS) |
|
# -flat_namespace only needed for linking with libMallocDebug |
# AC_SYS_COMPILER_FLAG(-flat_namespace, flat_namespace, LDFLAGS) |
|
# OS X only runs on G3 or newer. Tuning for recent G4s should help them |
# while being ok for older machines as well. |
AC_SYS_COMPILER_FLAG(-mcpu=750,cpu750,OPTIMIZE) |
AC_SYS_COMPILER_FLAG(-mtune=7450,tune7450,OPTIMIZE) |
]) |
|
DO_IF_OS(Linux, |
[ |
: |
# The following segment is obsolete, since executable memory is |
# now allocated with mmap instead of with malloc(). |
# /grubba 2005-06-09 |
# |
# if test "x$with_machine_code" = "xno"; then :; else |
# # WORKAROUND: mprotect(PROT_EXEC) doesn't work on Linux/x86. |
# # Try to set the stackexec flag on the binary. |
# # First try -z execstack (ld). |
# AC_SYS_COMPILER_FLAG([-z execstack], z_execstack, LDFLAGS, [ |
# # No, try passing it directly to the linker. |
# AC_SYS_COMPILER_FLAG([-Wl,-z,execstack], Wl_z_execstack, LDFLAGS, [ |
# # No, try --execstack (gas). |
# AC_SYS_COMPILER_FLAG([--execstack], execstack, CFLAGS, [ |
# # No, try passing it directly to the assembler. |
# AC_SYS_COMPILER_FLAG([-Wa,--execstack], Wa_execstack, CFLAGS, [ |
# # No. |
# # FIXME: Add support for use of chstk(1). |
# PIKE_MSG_WARN([Could not find any way to enable executable stack.]) |
# ]) |
# ]) |
# ]) |
# ]) |
# fi |
]) |
|
elif 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 -n 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... |
|
|
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 |
|
# Solaris |
DO_IF_OS(Solaris, |
[ |
AC_SYS_COMPILER_FLAG(-fast,fast,OPTIMIZE,,[ |
if test "x$with_abi" = "x64"; then |
# -fast implies -xarch=native, which implies 32-bit ABI. |
AC_SYS_COMPILER_FLAG(-xtarget=generic64, xtarget_generic64, OPTIMIZE) |
AC_SYS_COMPILER_FLAG(-xarch=generic64, xarch_generic64, OPTIMIZE) |
fi |
]) |
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) |
|
# Suppress warnings and informational messages we aren't interested in. |
AC_DEFUN(AC_SYS_COMPILER_FLAG_QSUPPRESS, [ |
AC_SYS_COMPILER_FLAG(-qsuppress=$1, |
translit([qsuppress_$1],[-:],[__]), |
ifelse([$2],,WARN,[$2])) |
]) |
# 1506-010 (W) Macro XX invoked with a null argument for parameter Z. |
AC_SYS_COMPILER_FLAG_QSUPPRESS(1506-010) |
# 1506-219 (W) #line value 40140 too large. |
AC_SYS_COMPILER_FLAG_QSUPPRESS(1506-219, CPPFLAGS) |
|
# 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) |
|
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 affect 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) |
AC_SYS_COMPILER_FLAG(-OPT:Olimit_opt=on,OPT_Olimit_opt_on,OPTIMIZE) |
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 |
PIKE_MSG_NOTE([Enabling dynamic modules for Win32.]) |
# EXTRA_MODULE_REQUIREMENTS="${EXTRA_MODULE_REQUIREMENTS} import_functions.h" |
DLOPEN_O="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 |
|
if test "$ICC" = "yes"; then |
# icc or ecc. |
|
# Modern versions of icc and ecc claim to be gcc, so we need to have |
# this outside the main if-else segment. |
|
DO_IF_OS(Linux, |
[ |
# Linux with Intel C++ |
|
# Disable excessive warnings from Linux's header files: |
# warning #1292: attribute "__nothrow__" ignored |
AC_SYS_COMPILER_FLAG(-wd1292,wd1292,WARN) |
# And from Pike: |
# remark #177: function "MKPCHARP" was declared but never referenced |
AC_SYS_COMPILER_FLAG(-wd177,wd177,WARN) |
# remark #279: controlling expression is constant |
AC_SYS_COMPILER_FLAG(-wd279,wd279,WARN) |
# remark #869: parameter was never referenced |
AC_SYS_COMPILER_FLAG(-wd869,wd869,WARN) |
|
AC_SYS_COMPILER_FLAG(-Ob2,Ob2,OPTIMIZE) |
AC_SYS_COMPILER_FLAG(-ipo,ipo,OPTIMIZE) |
AC_SYS_COMPILER_FLAG(-ipo,ipo,EXTRALDFLAGS) |
AC_SYS_COMPILER_FLAG(-ipo_obj,ipo_obj,OPTIMIZE) |
AC_SYS_COMPILER_FLAG(-parallel, parallel,OPTIMIZE) |
AC_SYS_COMPILER_FLAG(-parallel, parallel,LDFLAGS) |
# arch dependent optimizations while maintaining |
# i386 compatibility |
AC_SYS_COMPILER_FLAG(-axKW,axKW,OPTIMIZE) |
]) |
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 |
|
AC_SUBST(DLOPEN_O) |
|
############################################################################# |
|
# Script to translate from POSIX paths to native paths. |
echo "Creating posix_to_native.sh..." |
if test "x$PIKE_PATH_TRANSLATE" = "x"; then |
if test "x$pike_cv_is_mingw" = "xyes"; then |
# MinGW system. |
cat <<\EOF |
#!/bin/sh |
# Automatically generated by $Id: configure.in,v 1.941 2006/03/16 18:05:05 grubba Exp $. |
# MinGW-version. Do NOT edit. |
posix_name="`cat`" |
posix_prefix="/" |
native_prefix="/" |
case "$posix_name" in |
/*) ;; |
*) posix_name="`pwd`/$posix_name" ;; |
esac |
case "$posix_name" in |
EOF |
# Split and recombine the lines. |
# Sort the lines according to longest path first. |
# Convert backslashes to forward slashes. |
# Escape spaces, tabs and dollars. |
# Note, dollars must be escaped both for sed, sh and sed. |
# Split, and generate the case entries. |
# Remove any duplicate sequences of slashes. |
mount | \ |
sed -e 's/\(.*\) on \(.*\) type user.*/\2 _split_ \1/p' -ed | \ |
sort -r | \ |
sed -e 's/\\/\//g' | \ |
sed -e 's/\([[ ]]\)/\\\1/g' -e 's/\$/\\\\\\\$/g' | \ |
sed -e 's/\(.*\)\\ _split_\\ \(.*\)/ \1|\1\/*)\ |
posix_prefix=\1\ |
native_prefix=\2\/\ |
\;\;/p' -ed | \ |
sed -e 's/\/\//\//g' |
cat <<\EOF |
esac |
echo "$posix_name" | \ |
sed -e "s,^$posix_prefix,$native_prefix," | \ |
sed -e 's/\/\//\//g' |
EOF |
else |
# Native POSIX system. |
cat <<\EOF |
#!/bin/sh |
# Automatically generated by $Id: configure.in,v 1.941 2006/03/16 18:05:05 grubba Exp $. |
# POSIX-version. Do NOT edit. |
cat |
EOF |
fi |
else |
# rntcl-style |
cat <<\EOF |
#!/bin/sh |
# Automatically generated by $Id: configure.in,v 1.941 2006/03/16 18:05:05 grubba Exp $. |
# RNTCL-version. Do NOT edit. |
sed -e "$PIKE_PATH_TRANSLATE" |
EOF |
fi >posix_to_native.sh |
|
chmod a+x posix_to_native.sh |
|
############################################################################# |
|
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 library and include directories... |
|
#Don't add include dirs if they give us warnings... |
OLD_ac_c_preproc_warn_flag="$ac_c_preproc_warn_flag" |
ac_c_preproc_warn_flag=yes |
AC_TRY_CPP([#include <stdio.h>], , [ |
AC_MSG_WARN([Turning on preprocessor warnings causes cpp test to fail.]) |
ac_c_preproc_warn_flag="$OLD_ac_c_preproc_warn_flag" |
]) |
|
PIKE_INIT_REAL_DIRS |
|
if test "x$with_lib_path" = "x"; then :; else |
for dd in `echo $with_lib_path | sed -e 's/:/ /g'`; do |
if test "$dd" = "/lib"; then continue; fi |
if test "$dd" = "/usr/lib"; then continue; fi |
for suff in $pike_cv_abi_suffixes; do |
d="$dd$suff" |
PIKE_CHECK_ABI_LIB_DIR($d) |
done |
done |
fi |
|
if test "x$with_include_path" = "x"; then :; else |
for d in `echo $with_include_path | sed -e 's/:/ /g'`; do |
if test "$d" = "/lib/include"; then continue; fi |
if test "$d" = "/usr/lib/include"; then continue; fi |
AC_MSG_CHECKING($d) |
if test -d "$d/." ; then |
real_dir=`cd "$d/." && /bin/pwd 2>/dev/null` |
if test "x$real_dir" = "x"; then |
real_dir="UNKNOWN" |
else |
case " $real_incs " in |
*\ $real_dir\ *) |
AC_MSG_RESULT(already checked) |
continue |
;; |
esac |
real_incs="$real_incs $real_dir" |
fi |
case " $CPPFLAGS " in |
*\ -I$d\ * | *\ -I$real_dir\ *) |
AC_MSG_RESULT(already added) |
;; |
*) |
OLD_CPPFLAGS="${CPPFLAGS}" |
CPPFLAGS="${CPPFLAGS} -I$d" |
AC_TRY_CPP([#include <stdio.h>], [ |
AC_MSG_RESULT(added) |
], [ |
AC_MSG_RESULT(fails) |
CPPFLAGS="${OLD_CPPFLAGS}" |
]) |
;; |
esac |
else |
AC_MSG_RESULT(no) |
fi |
done |
fi |
|
primary_path="" |
fallback_path="" |
|
if test $ldflags_is_set = yes -a $cppflags_is_set = yes ; then :; else |
for dd in \ |
`echo "${with_site_prefixes}"|sed -e 's/:/ /g'` \ |
`echo $exec_prefix | sed "s@^NONE@$prefix@g" | sed "s@^NONE@$with_root$ac_default_prefix@g"` \ |
$with_root/usr/local $with_root/sw/local $with_root/sw \ |
$with_root/usr/gnu $with_root/opt/gnu $with_root/sw/gnu \ |
$with_root/usr/freeware $with_root/usr/pkg \ |
$with_root/usr/sfw $with_root/opt/sfw $with_root/opt/csw \ |
$with_root/usr/ccs \ |
`echo $with_root/opt/gnome* | sort -r` \ |
`echo $with_root/usr/X* | sort -r` |
do |
if test "$dd" = "/"; then continue; fi |
if test "$dd" = "/usr"; then continue; fi |
AC_MSG_CHECKING($dd) |
if test -d "$dd/."; then :; else |
AC_MSG_RESULT(no) |
continue |
fi |
real_dir=`cd "$dd/." && /bin/pwd 2>/dev/null` |
if test "x$real_dir" = "x"; then |
AC_MSG_RESULT(ok but pwd failed) |
else case " $real_dirs " in |
*\ $real_dir\ *) |
AC_MSG_RESULT(already checked) |
continue |
;; |
esac |
AC_MSG_RESULT(ok) |
real_dirs="$real_dirs $real_dir" |
fi |
libs_found="" |
if test $ldflags_is_set = yes ; then :; else |
for suff in $pike_cv_abi_suffixes; do |
d="$dd/lib$suff" |
PIKE_CHECK_ABI_LIB_DIR($d, [libs_found="yes"], [ |
if test "x$libs_found" = "x"; then |
libs_found="no" |
fi |
], [libs_found="yes"]) |
done |
fi |
AC_MSG_CHECKING($dd/bin) |
if test -d "$dd/bin/."; then |
if test "x$libs_found" = "xno"; then |
AC_MSG_RESULT(yes - use as fallback) |
if test "x$fallback_path" = "x"; then |
fallback_path="$dd/bin" |
else |
fallback_path="$fallback_path:$dd/bin" |
fi |
else |
AC_MSG_RESULT(yes) |
if test "x$primary_path" = "x"; then |
primary_path="$dd/bin" |
else |
primary_path="$primary_path:$dd/bin" |
fi |
fi |
else |
AC_MSG_RESULT(no) |
fi |
if test $cppflags_is_set = no -a "x$C_INCLUDE_PATH" = "x"; then |
d="$dd/include" |
AC_MSG_CHECKING($d) |
if test "x$libs_found" = "xno"; then |
# Don't add includes that correspond to libraries for the wrong ABI. |
AC_MSG_RESULT(skipped - bad libraries) |
continue |
fi |
if test -d "$d/." ; then |
real_dir=`cd "$d/." && /bin/pwd 2>/dev/null` |
if test "x$real_dir" = "x"; then |
real_dir="UNKNOWN" |
else |
case " $real_incs " in |
*\ $real_dir\ *) |
AC_MSG_RESULT(already checked) |
continue |
;; |
esac |
real_incs="$real_incs $real_dir" |
fi |
case " $CPPFLAGS " in |
*\ -I$d\ * | *\ -I$real_dir\ *) |
AC_MSG_RESULT(already added) |
;; |
*) |
OLD_CPPFLAGS="${CPPFLAGS}" |
CPPFLAGS="${CPPFLAGS} -I$d" |
AC_TRY_CPP([#include <stdio.h>], [ |
AC_MSG_RESULT(added) |
], [ |
AC_MSG_RESULT(fails) |
CPPFLAGS="${OLD_CPPFLAGS}" |
]) |
;; |
esac |
else |
AC_MSG_RESULT(no) |
fi |
fi |
done |
fi |
|
if test "x$primary_path" = "x"; then |
EXTRA_PATH="$fallback_path" |
elif test "x$fallback_path" = "x"; then |
EXTRA_PATH="$primary_path" |
else |
EXTRA_PATH="$primary_path:$fallback_path" |
fi |
export EXTRA_PATH |
|
#Restore preprocessor warning sensitivity |
ac_c_preproc_warn_flag="$OLD_ac_c_preproc_warn_flag" |
|
else |
# We are running NT |
: |
fi |
|
# During the configure tests we need some extra includes that |
# shouldn't be there in the final version. |
CONF_CPPFLAGS_EXTRA="-I$srcdir -I`pwd`" |
CPPFLAGS="${CPPFLAGS} ${CONF_CPPFLAGS_EXTRA}" |
|
############################################################################# |
|
## At this point we have at last initialized the compiler! |
|
############################################################################# |
|
if test ! -f confdefs.h ; then |
PIKE_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) |
|
if test "x${RNTANY-}" = x ; then |
AC_PATH_PROG(RNTANY, rntany, rntany, $PATH:$EXTRA_PATH) |
export RNTANY |
fi |
AC_SUBST(RNTANY) |
|
# Wix compiler |
if test "x${CANDLE-}" = x ; then |
AC_PATH_PROG(CANDLE, candle, $RNTANY candle, $PATH:$EXTRA_PATH) |
export CANDLE |
fi |
AC_SUBST(CANDLE) |
|
# Wix linker |
if test "x${LIGHT-}" = x ; then |
AC_PATH_PROG(LIGHT, light, $RNTANY light, $PATH:$EXTRA_PATH) |
export LIGHT |
fi |
AC_SUBST(LIGHT) |
|
# Wix tool |
if test "x${TALLOW-}" = x ; then |
AC_PATH_PROG(TALLOW, tallow, $RNTANY tallow, $PATH:$EXTRA_PATH) |
export TALLOW |
fi |
AC_SUBST(TALLOW) |
|
############################################################################# |
|
# 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>&AC_FD_CC 2>&AC_FD_CC; then |
if test "x$enable_binary" = "xno"; then |
rm -f y.tab.* |
break |
else |
AC_TRY_RUN([ |
#include "y.tab.c" |
],pure_parser_works=yes,pure_parser_works=no,pure_parser_works=no) |
rm -f y.tab.* |
if test "$pure_parser_works" = "yes"; then |
break |
fi |
fi |
else |
rm -f y.tab.* |
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(how bison uses short) |
AC_CACHE_VAL(pike_cv_short_use, |
[ |
pike_cv_short_use=unknown |
for short_use in CT_SHORT CT_SHORT_INT; do |
cat >conftest.y <<EOF |
%{ |
#define $short_use |
#ifdef CT_SHORT |
#define short int |
#else |
#define short |
#endif |
void parse(); |
void yyerror(char *); |
%} |
%% |
foo: 'f' x y ; |
x: 'o' ; |
y: 'o' ; |
%% |
int context = 0; |
|
int yylex(YYSTYPE *yylval) |
{ |
switch(context++) |
{ |
case 0: return 'f'; |
case 1: return 'o'; |
case 2: return 'o'; |
default: return 0; |
} |
} |
|
int errors=0; |
void yyerror(char *fel) { errors++; } |
EOF |
if $YACC -d conftest.y 1>&AC_FD_CC 2>&AC_FD_CC; then |
AC_TRY_COMPILE([ |
#include "y.tab.c" |
],[ |
yyparse(); |
exit(errors); |
],ok=yes,ok=no) |
if test "$ok" = "yes"; then |
pike_cv_short_use=$short_use |
break |
fi |
fi |
done |
]) |
|
case "$pike_cv_short_use" in |
CT_SHORT) |
AC_MSG_RESULT(short) |
AC_DEFINE(BISON_SHORT_EXPANSION,int) |
;; |
CT_SHORT_INT) |
AC_MSG_RESULT(short int) |
AC_DEFINE(BISON_SHORT_EXPANSION,[]) |
;; |
*) |
AC_MSG_RESULT(unknown) |
;; |
esac |
|
############################################################################# |
|
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>&AC_FD_CC |
cat conftest.y 1>&AC_FD_CC |
if $YACC -d conftest.y 1>&AC_FD_CC 2>&AC_FD_CC; 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 restrict keyword is available (C99)]) |
AC_CACHE_VAL(pike_cv_keyword_restrict, [ |
AC_TRY_COMPILE([ |
extern int foo(void *bar[restrict], void *restrict baz); |
], [], [ pike_cv_keyword_restrict="yes" ], [ pike_cv_keyword_restrict="no" ]) |
]) |
AC_MSG_RESULT($pike_cv_keyword_restrict) |
if test "x$pike_cv_keyword_restrict" = "xno"; then |
AC_DEFINE(restrict, [ /* Not supported */ ]) |
fi |
|
AC_C_CHAR_UNSIGNED |
|
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/param.h \ |
sys/mman.h setjmp.h sys/user.h limits.h pthread.h \ |
crt/signal.h sys/id.h mach-o/dyld.h sys/ptrace.h \ |
thread.h dlfcn.h dld.h dl.h sys/times.h sched.h \ |
sys/procfs.h winsock.h sys/ioct.h sys/socket.h \ |
malloc.h netinet/in.h sys/wait.h windows.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 \ |
float.h sys/priocntl.h sys/sched.h winbase.h errno.h \ |
stddef.h mmx.h asm/mmx.h sys/termio.h sys/termios.h \ |
ws2tcpip.h valgrind/memcheck.h memcheck.h valgrind.h \ |
sys/prctl.h sys/ioctl.h mach/task_info.h mach/task.h \ |
mach/mach_init.h syscall.h sys/syscall.h devices/timer.h \ |
CoreServices/CoreServices.h,,,[ |
#if (defined(__WINNT__) || defined(__WIN32__)) && !defined(__NT__) |
#define __NT__ |
#endif |
#ifndef _LARGEFILE_SOURCE |
# define _FILE_OFFSET_BITS 64 |
# define _LARGEFILE_SOURCE |
#endif |
#ifndef __STDC_EXT__ |
# define __STDC_EXT__ |
#endif /* !__STDC_EXT__ */ |
#ifndef _PROTOTYPES |
# define _PROTOTYPES |
#endif /* !_PROTOTYPES */ |
#ifndef _GNU_SOURCE |
#define _GNU_SOURCE |
#endif /* !_GNU_SOURCE */ |
#ifdef __NT__ |
#ifndef WIN32_LEAN_AND_MEAN |
#define WIN32_LEAN_AND_MEAN |
#endif |
#ifndef WIN32 |
#define WIN32 100 /* WinNT 1.0 */ |
#endif |
#if !defined(_WIN32_WINDOWS) || (_WIN32_WINDOWS < 0x500) |
#undef _WIN32_WINDOWS |
#define _WIN32_WINDOWS 0x0500 |
#endif |
#if !defined(_WIN32_WINNT) || (_WIN32_WINNT < 0x500) |
#undef _WIN32_WINNT |
#define _WIN32_WINNT 0x0500 |
#endif |
#endif /* __NT__ */ |
#ifdef __amigaos__ |
#define __USE_NETINET_IN_H |
#endif |
#ifndef __BUILTIN_VA_ARG_INCR |
#define __BUILTIN_VA_ARG_INCR 1 |
#endif /* !__BUILTIN_VA_ARG_INCR */ |
#ifdef HAVE_WINDOWS_H |
#include <windows.h> |
#undef HAVE_WINDOWS_H |
#endif |
/* Necessary to find sys/socket.h on MacOS X 10.3 */ |
#if HAVE_SYS_TYPES_H |
# include <sys/types.h> |
#endif |
/* Necessary to find ws2tcpip.h on WIN32. */ |
#ifdef HAVE_WINSOCK2_H |
# include <winsock2.h> |
#endif |
/* Necessary to find sys/user.h on OpenBSD */ |
#ifdef HAVE_SYS_PARAM_H |
# include <sys/param.h> |
#endif |
]) |
|
# Setjmp. |
# |
# POSIX defines sigsetjmp(). |
# BSD defines both _setjmp() and setjmp(), where setjmp() |
# saves the signal mask. |
# SVID explicitly defines setjmp() not to save the signal mask. |
AC_CHECK_FUNCS(sigsetjmp setjmp _setjmp siglongjmp longjmp _longjmp) |
|
# Make it possible to disable use of /dev/poll. |
if test "x$with_devpoll" = "xno"; then :; else |
AC_CHECK_HEADERS(sys/devpoll.h sys/event.h sys/epoll.h) |
|
AC_CHECK_FUNCS(kqueue) |
|
AC_MSG_CHECKING(for poll device) |
AC_CACHE_VAL(pike_cv_device_devpoll, [ |
pike_cv_poll_device="no" |
for device in /dev/poll /dev/epoll; do |
if test -w "$device"; then |
pike_cv_poll_device="$device" |
break |
fi |
done |
]) |
AC_MSG_RESULT($pike_cv_poll_device) |
if test "x$pike_cv_poll_device" = "xno"; then :; else |
AC_DEFINE_UNQUOTED(PIKE_POLL_DEVICE, "$pike_cv_poll_device") |
fi |
fi |
|
# 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_CHECK_SIZEOF(time_t, 4) |
|
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) |
|
AC_CHECK_SIZEOF(off_t, 4) |
|
AC_MSG_CHECKING(for sizeof anything) |
if test "$ac_cv_sizeof_long_double" != 0 -a \ |
"x$with_long_double_precision" = xyes ; then |
sizeof_float_type="$ac_cv_sizeof_long_double" |
elif test "x$with_double_precision" = xyes ; then |
sizeof_float_type="$ac_cv_sizeof_double" |
else |
sizeof_float_type="$ac_cv_sizeof_float" |
fi |
|
if test "$ac_cv_sizeof_long_long" != 0 -a \ |
"x$with_long_long_int" = xyes ; then |
sizeof_int_type="$ac_cv_sizeof_long_long" |
elif test "$ac_cv_sizeof___int64" != 0 -a \ |
"x$with_long_long_int" = xyes ; then |
sizeof_int_type="$ac_cv_sizeof___int64" |
elif test "x$with_long_int" = xyes ; then |
sizeof_int_type="$ac_cv_sizeof_long" |
elif test "x$with_short_int" = xyes ; then |
sizeof_int_type="$ac_cv_sizeof_short" |
elif test "x$with_unsigned_long_int" = xyes ; then |
sizeof_int_type="$ac_cv_sizeof_long" |
elif test "$ac_cv_sizeof_long_long" != 0 -a \ |
"x$with_unsigned_long_long_int" = xyes ; then |
sizeof_int_type="$ac_cv_sizeof_long_long" |
elif test "$ac_cv_sizeof___int64" != 0 -a \ |
"x$with_unsigned_long_long_int" = xyes ; then |
sizeof_int_type="$ac_cv_sizeof___int64" |
else |
sizeof_int_type="$ac_cv_sizeof_int" |
fi |
sizeof_anything="$ac_cv_sizeof_char_p" |
if test "$sizeof_float_type" -gt "$sizeof_anything"; then |
sizeof_anything="$sizeof_float_type" |
fi |
if test "$sizeof_int_type" -gt "$sizeof_anything"; then |
sizeof_anything="$sizeof_int_type" |
fi |
AC_MSG_RESULT($sizeof_anything) |
|
AC_MSG_CHECKING(for FLOAT_TYPE) |
|
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 "$sizeof_anything" ; then |
with_long_double_precision=yes |
elif test "$ac_cv_sizeof_double" -le "$sizeof_anything" ; then |
with_double_precision=yes |
fi |
fi |
|
if test "$ac_cv_sizeof_long_double" != 0 -a \ |
"x$with_long_double_precision" = xyes ; then |
AC_MSG_RESULT(long double) |
AC_DEFINE(WITH_LONG_DOUBLE_PRECISION_SVALUE) |
AC_DEFINE(FLOAT_TYPE, long double) |
AC_DEFINE(SIZEOF_FLOAT_TYPE, SIZEOF_LONG_DOUBLE) |
float_type="long double" |
sizeof_float_type="$ac_cv_sizeof_long_double" |
elif test "x$with_double_precision" = xyes ; then |
AC_MSG_RESULT(double) |
AC_DEFINE(WITH_DOUBLE_PRECISION_SVALUE) |
AC_DEFINE(FLOAT_TYPE, double) |
AC_DEFINE(SIZEOF_FLOAT_TYPE, SIZEOF_DOUBLE) |
float_type="double" |
sizeof_float_type="$ac_cv_sizeof_double" |
else |
AC_MSG_RESULT(float) |
AC_DEFINE(FLOAT_TYPE, float) |
AC_DEFINE(SIZEOF_FLOAT_TYPE, SIZEOF_FLOAT) |
float_type="float" |
sizeof_float_type="$ac_cv_sizeof_float" |
fi |
|
AC_MSG_CHECKING(for INT_TYPE) |
|
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. |
# 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 "$sizeof_anything" ; 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_MSG_RESULT(long long) |
AC_DEFINE(WITH_LONG_LONG_INT) |
AC_DEFINE(INT_TYPE, long long) |
AC_DEFINE(SIZEOF_INT_TYPE, SIZEOF_LONG_LONG) |
int_type="long long" |
sizeof_int_type="$ac_cv_sizeof_long_long" |
elif test "$ac_cv_sizeof___int64" != 0 -a \ |
"x$with_long_long_int" = xyes ; then |
AC_MSG_RESULT(__int64) |
AC_DEFINE(WITH_LONG_LONG_INT) |
AC_DEFINE(INT_TYPE, __int64) |
AC_DEFINE(SIZEOF_INT_TYPE, SIZEOF___INT64) |
int_type="__int64" |
sizeof_int_type="$ac_cv_sizeof___int64" |
elif test "x$with_long_int" = xyes ; then |
AC_MSG_RESULT(long) |
AC_DEFINE(WITH_LONG_INT) |
AC_DEFINE(INT_TYPE, long) |
AC_DEFINE(SIZEOF_INT_TYPE, SIZEOF_LONG) |
int_type="long" |
sizeof_int_type="$ac_cv_sizeof_long" |
dnl elif test "x$with_short_int" = xyes ; then |
dnl AC_MSG_RESULT(short) |
dnl AC_DEFINE(WITH_SHORT_INT) |
dnl AC_DEFINE(INT_TYPE, short) |
dnl AC_DEFINE(SIZEOF_INT_TYPE, SIZEOF_SHORT) |
dnl elif test "x$with_unsigned_long_int" = xyes ; then |
dnl AC_MSG_RESULT(unsigned long) |
dnl AC_DEFINE(WITH_UNSIGNED_LONG_INT) |
dnl AC_DEFINE(INT_TYPE, unsigned long) |
dnl AC_DEFINE(SIZEOF_INT_TYPE, SIZEOF_LONG) |
dnl elif test "$ac_cv_sizeof_long_long" != 0 -a \ |
dnl "x$with_unsigned_long_long_int" = xyes ; then |
dnl AC_MSG_RESULT(unsigned long long) |
dnl AC_DEFINE(WITH_UNSIGNED_LONG_LONG_INT) |
dnl AC_DEFINE(INT_TYPE, unsigned long long) |
dnl AC_DEFINE(SIZEOF_INT_TYPE, SIZEOF_LONG_LONG) |
dnl elif test "$ac_cv_sizeof___int64" != 0 -a \ |
dnl "x$with_unsigned_long_long_int" = xyes ; then |
dnl AC_MSG_RESULT(unsigned __int64) |
dnl AC_DEFINE(WITH_UNSIGNED_LONG_LONG_INT) |
dnl AC_DEFINE(INT_TYPE, unsigned __int64) |
dnl AC_DEFINE(SIZEOF_INT_TYPE, SIZEOF___INT64) |
else |
AC_MSG_RESULT(int) |
AC_DEFINE(WITH_INT_INT) |
AC_DEFINE(INT_TYPE, int) |
AC_DEFINE(SIZEOF_INT_TYPE, SIZEOF_INT) |
int_type="int" |
sizeof_int_type="$ac_cv_sizeof_int" |
fi |
|
AC_TYPE_SIGNAL |
|
dnl AC_CHECK_LIB(PW, alloca) |
|
dnl Checking if poll() call is in libpoll (in general in Darwin or BSD/OS) |
AC_CHECK_LIB(poll, poll) |
|
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(oui, [ |
#if defined(_WIN64) || defined(__WIN64__) |
oui |
#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 |
PIKE_MSG_WARN(Applying workaround for sched.h typo.) |
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)" |
|
pike_cv_thread_t_type=integer |
|
else |
|
# Test for POSIX threads |
|
if test "x$with_thread_library" != "xno"; then |
AC_MSG_CHECKING([for thread library]) |
AC_MSG_RESULT([$with_thread_library (--with-thread-library)]) |
LIBS="${OLDLIBS} $with_thread_library" |
else |
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) |
|
AC_PATH_PROG(PTHREAD_CONFIG,${ac_tool_prefix}pthread-config,no) |
if test "x$PTHREAD_CONFIG" = xno ; then |
# FIXME: Might want to look at OS version: |
# 500000 <= version < 500016: -pthread |
# 500016 <= version < 502102: -lc_r |
# 502102 <= version : -lpthread |
AC_SYS_COMPILER_FLAG(-pthread, pthread, CFLAGS, LIBS="$LIBS -lc_r") |
LDFLAGS="${LDFLAGS-} -lc_r" |
else |
CFLAGS="$CFLAGS `${PTHREAD_CONFIG} --cflags`" |
LIBS="${OLDLIBS} `${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}" |
;; |
|
*) |