AC_REVISION("$Id: configure.in,v 1.270 1999/03/08 05:34:35 hubbe Exp $") |
AC_INIT(interpret.c) |
AC_CONFIG_HEADER(machine.h) |
|
# 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 |
|
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 |
|
for ac_site_file in $CONFIG_SITE; do |
if test -r "$ac_site_file"; then |
AC_MSG_WARN([You are using a site file to initialize configure, please |
note that this can lead to problems if anything in |
$ac_site_file is not correct. If Pike does not compile, or |
does not run, please try this to compile Pike again: |
rm ./config.cache ; CONFIG_SITE=x ./configure ; make]) |
fi |
done |
|
if test ! -z "$pike_cv_prog_CC_save" -a ! -z "$CC" -a "$CC" != "$pike_cv_prog_CC_save" |
then |
AC_MSG_WARN([CC is different than last time Pike was compiled, |
It is probably best to delete ./config.cache before proceeding]) |
fi |
|
pike_cv_prog_CC_save="$CC" |
|
# MY_AC_PROG_CC |
# The above has problems if the smartlink binary is removed. /grubba |
AC_PROG_CC |
AC_ISC_POSIX |
AC_MINIX |
|
if test $ac_cv_prog_gcc = yes; then |
AC_MSG_CHECKING(for libgcc file name) |
AC_CACHE_VAL(pike_cv_libgcc_filename, |
[ |
pike_cv_libgcc_filename="`${CC-cc} -print-libgcc-file-name`" |
if test -z "$pike_cv_libgcc_filename"; then |
pike_cv_libgcc_filename=no |
else |
if test -f "$pike_cv_libgcc_filename"; then |
: |
else |
pike_cv_libgcc_filename=no |
fi |
fi |
]) |
AC_MSG_RESULT($pike_cv_libgcc_filename) |
if test x"$pike_cv_libgcc_filename" = xno; then |
LIBGCC="" |
else |
LIBGCC="$pike_cv_libgcc_filename" |
fi |
else |
LIBGCC="" |
fi |
AC_SUBST(LIBGCC) |
|
############################################################################# |
|
LIBDIR=`(cd $srcdir/../lib ; pwd)` |
BINDIR=`(cd $srcdir/../bin ; pwd)` |
BUILDDIR=`pwd` |
AC_SUBST(LIBDIR) |
AC_SUBST(BINDIR) |
AC_SUBST(BUILDDIR) |
|
############################################################################# |
|
## Build smartlink |
|
AC_CHECK_HEADERS(stdlib.h string.h unistd.h sys/stat.h sys/types.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 |
|
# FIXME: Add proper tests |
case "$UNAME" in |
OSF1\ V4.*) |
AC_DEFINE(USE_RPATH) |
;; |
IRIX\ 6.*) |
AC_DEFINE(USE_RPATH) |
;; |
IRIX\ 5.*) |
AC_DEFINE(USE_RPATH) |
;; |
SunOS\ 5.*) |
AC_DEFINE(USE_R) |
;; |
Linux\ 2.*) |
AC_DEFINE(USE_Wl) |
;; |
*) |
AC_DEFINE(USE_LD_LIBRARY_PATH) |
;; |
esac |
|
# Strip smartlink from $CC |
REALCC="`echo $CC|sed -e 's/.*smartlink //'`" |
|
# Fix a smartlink |
SMARTLINK="$BUILDDIR/smartlink" |
|
AC_MSG_CHECKING(if $SMARTLINK exists is up to date and works) |
if ls -1tr "$SMARTLINK${ac_exeext}" "$srcdir/smartlink.$ac_ext" | head -1 | grep "smartlink.$ac_ext" >/dev/null 2>&5 && "$SMARTLINK" -v >/dev/null 2>&5; then |
AC_MSG_RESULT(yes) |
else |
AC_MSG_RESULT(no) |
|
if echo foo "$CC" | grep rntcc >/dev/null; then |
echo Warning: rntcc detected. Using the smartlink /bin/sh script. |
SMARTLINK="$BINDIR/smartlink" |
else |
rm -f "$SMARTLINK" |
|
AC_MSG_CHECKING(whether smartlink compiles) |
|
link_cmd='${REALCC-cc} -o smartlink${ac_exeext} $CFLAGS -I. $CPPFLAGS $LDFLAGS $srcdir/smartlink.$ac_ext $LIBS 2>&5' |
if { (eval echo Compiling smartlink: \"$link_cmd\") 1>&5; (eval $link_cmd) 2>&5; } && "$BUILDDIR/smartlink" -v >/dev/null 2>&5; then |
AC_MSG_RESULT(yes) |
else |
AC_MSG_RESULT(no - use the sh script) |
|
SMARTLINK="$BINDIR/smartlink" |
fi |
fi |
fi |
|
CC="$SMARTLINK $REALCC" |
pike_cv_prog_CC="$CC" |
|
AC_SUBST(SMARTLINK REALCC) |
export REALCC SMARTLINK |
|
############################################################################# |
|
AC_AIX |
AC_MINIX |
|
# We need some special hacks when running slowaris |
AC_PATH_PROG(uname_prog,uname,no) |
AC_MSG_CHECKING(operating system) |
AC_CACHE_VAL(pike_cv_sys_os, |
[ |
if test "$uname_prog" != "no"; then |
pike_cv_sys_os="`uname`" |
|
case "$pike_cv_sys_os" in |
SunOS) |
case "`uname -r`" in |
5.*) pike_cv_sys_os="Solaris" ;; |
esac |
;; |
esac |
else |
pike_cv_sys_os="Not Solaris" |
fi |
]) |
AC_MSG_RESULT($pike_cv_sys_os) |
|
LD='$(CC) $(CFLAGS)' |
|
case "$pike_cv_sys_os" in |
SCO*) |
case "$CFLAGS" in |
*-belf*) ;; |
*) |
echo "Adding -belf option." |
CFLAGS="$CFLAGS -belf" |
;; |
esac |
case "$LDFLAGS" in |
*-belf*) ;; |
*) |
echo "Adding -belf option." |
LDFLAGS="$LDFLAGS -belf" |
;; |
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*) |
LD="$BINDIR/smartlink shlicc" |
;; |
UnixWare*) |
if test "$GCC" != "yes"; then |
# We are using built-in inline function |
CFLAGS="$CFLAGS -Kalloca" |
fi |
;; |
esac |
|
AC_SUBST(LD) |
|
############################################################################# |
|
|
|
AC_ARG_WITH(dynamic_modules, [ --without-dynamic-modules link modules statically],[],[with_dynamic_modules=yes]) |
AC_ARG_WITH(static_linking, [ --with-static-linking link statically, if possible],[with_static_linking=yes],[]) |
AC_ARG_WITH(include-path,[ --with-include-path A list of paths to search for include files.]) |
AC_ARG_WITH(lib-path, [ --with-lib-path A list of paths to search for libraries.]) |
AC_ARG_WITH(gdbm, [ --without-gdbm no GNU database manager support ]) |
AC_ARG_WITH(gmp, [ --without-gmp no Support bignums]) |
AC_ARG_WITH(readline, [ --without-readline no support for command line editing]) |
AC_ARG_WITH(debug, [ --without-debug disable run debugging],[],[with_debug=]) |
AC_ARG_WITH(rtldebug, [ --without-rtldebug disable run time self tests],[],[with_rtldebug=]) |
AC_ARG_WITH(cdebug, [ --without-cdebug disable -g],[],[with_cdebug=]) |
AC_ARG_WITH(threads, [ --without-threads no threads support],[],[with_threads=yes]) |
AC_ARG_WITH(zlib, [ --without-zlib no gz compression support],[],[with_zlib=yes]) |
AC_ARG_WITH(ssleay, [ --without-ssleay no support for the secure socket protocol],[],[with_ssleay=yes]) |
AC_ARG_WITH(mysql, [ --without-mysql no support for the Mysql database],[],[with_mysql=yes]) |
AC_ARG_WITH(dmalloc, [ --with-dmalloc enable memory-leak tests],[AC_DEFINE(DEBUG_MALLOC,10)],[]) |
AC_ARG_WITH(checker, [ --with-checker add extra memory checking overhead (Purify)]) |
AC_ARG_WITH(profiling, [ --with-profiling add code used to profile pike code ],[AC_DEFINE(PROFILING)],[]) |
AC_ARG_WITH(poll, [ --with-poll use poll instead of select],[],[ |
# Neither --with-poll nor --without-poll was specified |
case "$pike_cv_sys_os" in |
Solaris|AIX|HP-UX|OSF1|IRIX) |
AC_MSG_WARN([Defaulting to --with-poll since the OS is $pike_cv_sys_os.]) |
with_poll=yes |
;; |
esac |
]) |
AC_ARG_WITH(max-fd, [ --with-max-fd=X set how many filedescriptors can be used at once],[pike_cv_max_open_fd=$withval],[]) |
AC_ARG_WITH(oob, [ --with-oob enable out-of-band data handling],[AC_DEFINE(WITH_OOB)],[]) |
AC_ARG_WITH(thread-trace,[ --with-trace-threads enable individual tracing of threads],[AC_DEFINE(TRACE_THREADS)],[]) |
AC_ARG_WITH(compiler-trace,[ --with-compiler-trace enable tracing of the compiler],[AC_DEFINE(YYDEBUG)],[]) |
AC_ARG_WITH(security, [ --with-security enable internal pike security system],[AC_DEFINE(PIKE_SECURITY)],[]) |
|
if test "x$with_poll" = "xyes"; then |
AC_DEFINE(HAVE_AND_USE_POLL) |
else :; fi |
|
if test "x$with_checker" = "xyes"; then |
AC_DEFINE(__CHECKER__) |
else :; fi |
|
# |
# 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 |
|
|
# |
# 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=yes |
fi |
|
if test "x$with_rtldebug" = xyes ; then |
AC_DEFINE(PIKE_DEBUG) |
fi |
|
############################################################################# |
|
|
# option, cache_name, variable |
AC_DEFUN(AC_SYS_COMPILER_FLAG, |
[ |
AC_MSG_CHECKING($1) |
OLD_CFLAGS="[$]CFLAGS" |
AC_CACHE_VAL(pike_cv_option_$2, |
[ |
CFLAGS="[$]OLD_CFLAGS $1" |
AC_TRY_RUN([int main(){exit(0);}],pike_cv_option_$2=yes,pike_cv_option_$2=no,pike_cv_option_$2=no) |
]) |
|
CFLAGS="[$]OLD_CFLAGS" |
|
if test x"[$]pike_cv_option_$2" = "xyes" ; then |
$3="[$]$3 $1" |
AC_MSG_RESULT(yes) |
$5 |
else |
AC_MSG_RESULT(no) |
$4 |
fi |
]) |
|
# arch, option, cache_name, variable |
AC_DEFUN(AC_SYS_CPU_COMPILER_FLAG, |
[ |
if test "`uname -m 2>/dev/null`" = "$1" ; then |
AC_SYS_COMPILER_FLAG($2,$3,$4,$5,$6) |
$7 |
fi |
]) |
|
# os, option, cache_name, variable |
AC_DEFUN(AC_SYS_OS_COMPILER_FLAG, |
[ |
if test "x$pike_cv_sys_os" = "x$1" ; then |
AC_SYS_COMPILER_FLAG($2,$3,$4,$5,$6) |
$7 |
fi |
]) |
|
define([DO_IF_OS], |
[ |
if test "x$pike_cv_sys_os" = "x$1" ; then |
$2 |
fi |
]) |
|
define([DO_IF_CPU], |
[ |
if test "`uname -m 2>/dev/null`" = "$1" ; then |
$2 |
fi |
]) |
|
WARN="" |
OPTIMIZE="" |
|
if test $cflags_is_set = no; then |
if test "x$with_cdebug" = "xno" ; then |
CFLAGS=`echo " $CFLAGS " | sed -e 's@ -g @ @g'` |
else |
: |
fi |
|
|
if test "x${GCC-}" = xyes ; then |
WARN="-W -Wall -Wpointer-arith -Wno-unused" |
|
if test "x${with_static_linking-}" = "xyes" ; then |
AC_SYS_COMPILER_FLAG(-static,link_static,CFLAGS) |
else |
: |
fi |
|
## |
## -fomit-frame-pointer does not work with egcs 1.1.1 |
## /Hubbe 1998-12-20 |
## |
#if test "x$with_cdebug" = "xno" ; then |
# AC_SYS_COMPILER_FLAG(-fomit-frame-pointer,fomit_frame_pointer,OPTIMIZE) |
#else |
# : |
#fi |
|
### Optimize for different SUN machines. If there is no working 'uname' |
### no extra optimization will be done, but nothing should break either. |
case "`uname -m 2>/dev/null`" in |
sun4c) |
# The -sparclite option seems to generate assembler that /bin/as doesn't |
# understand. /grubba 1998-07-17 |
# AC_SYS_COMPILER_FLAG(-msparclite,sparclite,OPTIMIZE) |
;; |
sun4m) |
AC_SYS_COMPILER_FLAG(-mv8,microsparc,OPTIMIZE) |
;; |
sun4d) |
AC_SYS_COMPILER_FLAG(-msupersparc,supersparc,OPTIMIZE) |
;; |
sun4u) |
# FIXME: Optimize for V9 |
AC_SYS_COMPILER_FLAG(-msupersparc,ultrasparc,OPTIMIZE) |
;; |
i586) |
AC_SYS_COMPILER_FLAG(-mpentium,pentium,OPTIMIZE) |
;; |
i686) |
AC_SYS_COMPILER_FLAG(-mpentiumpro,pentiumpro,OPTIMIZE,[ |
AC_SYS_COMPILER_FLAG(-mpentium,pentium,OPTIMIZE) |
]) |
;; |
esac |
else |
|
|
if test "x${with_static_linking-}" = "xyes" ; then |
DO_IF_OS(AIX, |
[ |
AC_SYS_COMPILER_FLAG(-Wl,-bstatic,wl_link_static,CFLAGS) |
LD_FALLBACK_FLAGS="${LD_FALLBACK_FLAGS} -bstatic" |
]) |
|
DO_IF_OS(OSF1, |
[ |
AC_SYS_COMPILER_FLAG(-non_shared,non_shared,CFLAGS) |
LD_FALLBACK_FLAGS="${LD_FALLBACK_FLAGS} -non_shared" |
]) |
|
DO_IF_OS(IRIX, |
[ |
AC_SYS_COMPILER_FLAG(-non_shared,non_shared,CFLAGS) |
LD_FALLBACK_FLAGS="${LD_FALLBACK_FLAGS} -B static" |
]) |
|
# how do you link statically on HP-UX ? |
else |
: |
fi |
|
### Non-gcc thingies. This should probably be enhanced... |
|
# Solaris |
DO_IF_OS(Solaris, |
[ |
AC_SYS_COMPILER_FLAG(-fast,fast,OPTIMIZE) |
AC_SYS_COMPILER_FLAG(-xdepend,xdepend,OPTIMIZE) |
AC_SYS_COMPILER_FLAG(-xs,xs,CFLAGS) |
# Causes __STDC__ to be 1 which causes several headerfiles to behave |
# differently. |
# AC_SYS_OS_COMPILER_FLAG(-Xc,Xc,WARN) |
]) |
|
# AIX |
DO_IF_OS(AIX, |
[ |
# This one is needed to get the compiler to fail on errors, |
# which is needed for several configure-scripts. |
AC_SYS_COMPILER_FLAG(-qhalt=e,qhalt_e,CFLAGS) |
AC_SYS_COMPILER_FLAG(-qro,qro,OPTIMIZE) |
]) |
|
# HP-UX |
DO_IF_OS(HP-UX, |
[ |
AC_SYS_COMPILER_FLAG(-D__STDC_EXT__,stdc_ext,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) |
AC_SYS_COMPILER_FLAG(+O3,plus_O3,OPTIMIZE) |
# Ignore the following warnings if you enable +w1 |
# 414 Optimization reduced to +O2 for compatibility with Debug. |
# 530 Casting from loose to strict alignment |
# 558 Empty declaration. |
# AC_SYS_COMPILER_FLAG(+w1,plus_w1,WARN) |
]) |
|
# OSF/1 |
DO_IF_OS(OSF1, |
[ |
AC_SYS_COMPILER_FLAG(-fast,fast,OPTIMIZE) |
# The need for -ieee is not detected properly by the FPE tests below. |
# AC_SYS_COMPILER_FLAG(-ieee,ieee,CFLAGS) |
AC_SYS_COMPILER_FLAG(-readonly_strings,readonly_strings,OPTIMIZE) |
AC_SYS_COMPILER_FLAG(-assume trusted_short_alignment, |
assume_trusted_short_alignment,OPTIMIZE) |
AC_SYS_COMPILER_FLAG(-assume aligned_objects, |
assume_aligned_objects,OPTIMIZE) |
AC_SYS_COMPILER_FLAG(-no_misalign,no_misalign,OPTIMIZE) |
|
if test "x$with_cdebug" = "xyes" ; then |
# FIXME: |
# Maybe should remove the -g flag if this succeeds. |
AC_SYS_COMPILER_FLAG(-g3,g3,OPTIMIZE) |
AC_SYS_COMPILER_FLAG(-trapuv,trapuv,WARN) |
fi |
AC_SYS_COMPILER_FLAG(-host,host,OPTIMIZE) |
|
# Flags that cause errors or change compiler behaviour |
# must go in CFLAGS, they can not go in WARN |
# /Hubbe |
AC_SYS_COMPILER_FLAG(-std1,std1,CFLAGS) |
AC_SYS_COMPILER_FLAG(-warnprotos,warnprotos,WARN) |
]) |
|
# IRIX |
DO_IF_OS(IRIX, |
[ |
# sopt disabled since it takes too long time on interpret.c (>45min on an O²) |
# AC_SYS_COMPILER_FLAG(-sopt,sopt,OPTIMIZE) |
|
# -n32 moved to smartlink so it will affekt cc as well as linker |
# this way the user can override it by setting LDFLAGS and/or CFLAGS |
# AC_SYS_COMPILER_FLAG(-n32,n32,CFLAGS) |
AC_SYS_COMPILER_FLAG(-fullwarn,fullwarn,WARN) |
if test x$with_cdebug = xyes ; then |
AC_SYS_COMPILER_FLAG(-g3,g3,OPTIMIZE) |
fi |
if test x$with_rtldebug = xyes ; then |
AC_SYS_COMPILER_FLAG(-trapuw,trapuw,WARN) |
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*) ;; |
*) |
AC_SYS_COMPILER_FLAG(-O2,O2,OPTIMIZE) |
if test "x$pike_cv_option_O2" != "xyes"; then |
AC_SYS_COMPILER_FLAG(-O,O,OPTIMIZE) |
fi |
;; |
esac |
fi |
fi |
|
|
|
if test "$GCC" = "yes"; then |
if test $cflags_is_set = no; then |
AC_SYS_COMPILER_FLAG(-pipe, pipe, CFLAGS) |
fi |
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" |
if test "$CC" = "$BINDIR/smartlink cc" -a -x /usr/bin/cc ; then |
CC="$SMARTLINK /usr/bin/cc" |
fi |
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) |
AC_DEFINE(USE_WAIT_THREAD) |
else |
AC_DEFINE(USE_SIGCHILD) |
fi |
|
if test ! -d modules/. ; then |
mkdir modules |
fi |
|
############################################################################# |
|
## Search for some popular places where libraries may be hidden. |
|
############################################################################# |
|
if test x$pike_cv_sys_os != xWindows_NT ; then |
|
echo Searching for include-file directories... |
|
if test $cppflags_is_set = no -a x${C_INCLUDE_PATH-} = x ; then |
real_include_dirs='' |
for d in `echo ${with_include_path} | sed 's/:/ /g'` \ |
`echo $prefix | sed "s@^NONE@$ac_default_prefix@g"`/include \ |
/usr/local/include /sw/local/include /usr/gnu/include /opt/gnu/include \ |
/sw/gnu/include /sw/include /usr/freeware/include \ |
`echo /usr/X11*/include | sort -r` $srcdir `pwd` |
do |
AC_MSG_CHECKING($d) |
case x$d in |
x/usr/include | x/usr//include) |
;; |
*) |
if test -d "$d/." ; then |
REALDIR="`cd $d/. ; /bin/pwd`" |
if test "x$REALDIR" = x ; then |
REALDIR=UNKNOWN |
else |
: |
fi |
|
case " $CPPFLAGS $real_include_dirs " in |
*\ -I$d\ * | *\ -I$REALDIR\ *) |
AC_MSG_RESULT(already added) |
;; |
*) |
AC_MSG_RESULT(added) |
CPPFLAGS="${CPPFLAGS} -I$d" |
if test "x$REALDIR" != xUNKNOWN; then |
real_include_dirs="${real_include_dirs} -I$REALDIR" |
else |
: |
fi |
;; |
esac |
else |
AC_MSG_RESULT(no) |
fi |
;; |
esac |
done |
else |
: |
fi |
|
#CPPFLAGS="${CPPFLAGS} -I$srcdir -I`pwd`" |
|
echo Searching for library directories... |
if test $ldflags_is_set = no ; then |
for d in `echo ${with_lib_path} | sed 's/:/ /g'` \ |
`echo $exec_prefix | sed "s@^NONE@$prefix/lib@g" | sed "s@^NONE@$ac_default_prefix/lib@g"` \ |
/usr/local/lib /sw/local/lib /sw/lib \ |
/usr/gnu/lib /opt/gnu/lib /sw/gnu/lib /usr/freeware/lib \ |
`echo /usr/X11*/lib | sort -r` |
do |
AC_MSG_CHECKING($d) |
if test -d "$d/." ; then |
case " $LDFLAGS " in |
*\ -L$d\ -R$d\ * | *\ -R$d\ -L$d\ *) |
AC_MSG_RESULT(already added) |
;; |
*) |
AC_MSG_RESULT(added) |
LDFLAGS="${LDFLAGS} -R$d -L$d" |
;; |
esac |
else |
AC_MSG_RESULT(no) |
fi |
done |
else |
: |
fi |
|
echo Searching for binary directories... |
for d in `echo $exec_prefix | sed "s@^NONE@$prefix@g" | sed "s@^NONE@$ac_default_prefix@g"` \ |
"" /usr /usr/ccs /usr/local /sw/local /usr/gnu /opt/gnu /sw/gnu \ |
/sw /usr/freeware |
do |
AC_MSG_CHECKING($d/bin) |
if test -d "$d/bin/." ; then |
AC_MSG_RESULT(added) |
EXTRA_PATH="${EXTRA_PATH}:$d/bin" |
else |
AC_MSG_RESULT(no) |
fi |
done |
export EXTRA_PATH |
|
else |
: # We are running NT |
fi |
|
############################################################################# |
|
## At this point we have at last initialized the compiler! |
|
############################################################################# |
|
if test ! -f confdefs.h ; then |
AC_MSG_WARN([Warning, lost confdefs.h, testing will be flawed!! |
You might need to use bash instead of /bin/sh to get correct results. |
To do this, please type the following at an sh prompt: |
\$ rm ./config.cache |
\$ CONFIG_SHELL=/path/to/bash |
\$ export CONFIG_SHELL |
\$ $CONFIG_SHELL ./configure |
]) |
fi |
|
############################################################################# |
|
AC_DEFINE(POSIX_SOURCE) |
|
AC_MSG_CHECKING(ansi prototype capability) |
AC_CACHE_VAL(pike_cv_sys_ansi_prototypes, |
[ |
AC_TRY_COMPILE([int foo(int bar);],[], |
[pike_cv_sys_ansi_prototypes=yes], |
[pike_cv_sys_ansi_prototypes=no]) |
]) |
|
if test "$pike_cv_sys_ansi_prototypes" = "yes"; then |
AC_MSG_RESULT(yes) |
else |
AC_MSG_RESULT(no, giving up...) |
exit 1 |
fi |
|
|
############################################################################# |
|
# The AC_PROG_INSTALL test is broken if $INSTALL is specified by hand. |
# The FreeBSD ports system does this... |
# Workaround: |
|
if test "x$INSTALL" = "x"; then :; else |
# $INSTALL overrides ac_cv_path_install anyway... |
ac_cv_path_install="$INSTALL" |
fi |
|
AC_PROG_INSTALL |
AC_PROG_CPP |
AC_PROG_RANLIB |
AC_SET_MAKE |
|
AC_PATH_PROG(AR, ar, ar, $PATH:$EXTRA_PATH) |
export AR |
AC_SUBST(AR) |
|
############################################################################# |
|
# installbsd seems to be broken on some versions of AIX |
# |
# /grubba 1997-08-16 |
|
case "$ac_cv_path_install" in |
*installbsd*) |
AC_MSG_CHECKING(if $ac_cv_path_install works) |
AC_CACHE_VAL(pike_cv_install_works, |
[ |
if $ac_cv_path_install "$srcdir/configure.in" ./conftest >/dev/null 2>&1 |
then |
if cmp "$srcdir/configure.in" ./conftest >/dev/null 2>&1; then |
pike_cv_install_works=yes; |
else |
pike_cv_install_works=no; |
fi |
else |
pike_cv_install_works=no; |
fi |
if test -f ./conftest; then |
rm -f ./conftest |
fi |
]) |
AC_MSG_RESULT($pike_cv_install_works) |
if test "$pike_cv_install_works" = "no"; then |
echo "Warning: Falling back to $ac_install_sh" |
INSTALL="$ac_install_sh" |
fi |
;; |
esac |
|
############################################################################# |
|
AC_MSG_CHECKING(for yacc clone that handles %pure_parser) |
AC_CACHE_VAL(pike_cv_prog_working_yacc, |
[ |
for YACC in pyacc byacc "bison -y" yacc "None"; do |
set dummy $YACC; ac_word=$2 |
has_it=no |
IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}:" |
for ac_dir in $PATH; do |
test -z "$ac_dir" && ac_dir=. |
if test -f $ac_dir/$ac_word; then |
has_it="yes" |
break |
fi |
done |
IFS="$ac_save_ifs" |
|
if test "$has_it" = "yes"; then |
cat >conftest.y<<\EOF |
%pure_parser |
%{ |
void parse(); |
void yyerror(char *); |
%} |
%% |
all: foo bar |
foo: 'f' 'o' 'o' { parse(); } ; |
bar: 'b' 'a' 'r' ; |
%% |
int context; |
|
int yylex(YYSTYPE *yylval) |
{ |
switch(context++) |
{ |
case 0: return 'f'; |
case 1: return 'o'; |
case 2: return 'o'; |
case 3: return 'b'; |
case 4: return 'a'; |
case 5: return 'r'; |
default: return 0; |
} |
} |
|
int depth=0; |
void parse() |
{ |
int tmp; |
if(depth++>5) return; |
tmp=context; |
context=0; |
yyparse(); |
context=tmp; |
} |
int errors=0; |
void yyerror(char *fel) { errors++; } |
int main() |
{ |
parse(); |
exit(errors); |
} |
EOF |
if $YACC -d conftest.y 1>&5 2>&5; then |
AC_TRY_RUN([ |
#include "y.tab.c" |
],pure_parser_works=yes,pure_parser_works=no,pure_parser_works=no) |
if test "$pure_parser_works" = "yes"; then |
break |
fi |
fi |
fi |
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 |
|
############################################################################# |
|
## 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_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/resource.h sys/select.h sys/mman.h setjmp.h limits.h pthread.h \ |
thread.h dlfcn.h dld.h dl.h sys/times.h sched.h sys/procfs.h sys/param.h \ |
winsock.h sys/ioct.h sys/socket.h malloc.h netinet/in.h sys/wait.h winbase.h \ |
grp.h pwd.h passwd.h group.h winsock2.h signal.h sys/file.h poll.h sys/poll.h \ |
socket.h ieeefp.h fp_class.h floatingpoint.h sys/priocntl.h sched.h ) |
|
AC_CHECK_SIZEOF(char *,4) |
AC_CHECK_SIZEOF(long,4) |
AC_CHECK_SIZEOF(int,4) |
AC_CHECK_SIZEOF(short,2) |
AC_CHECK_SIZEOF(float,4) |
AC_CHECK_SIZEOF(double,8) |
|
AC_TYPE_SIZE_T |
AC_TYPE_PID_T |
AC_TYPE_UID_T |
AC_TYPE_SIGNAL |
AC_CHECK_TYPE(time_t,INT32) |
|
dnl AC_CHECK_LIB(PW, alloca) |
|
AC_CHECK_LIB(m, floor) |
|
AC_CHECK_LIB(socket, socket) |
|
if test x$pike_cv_sys_os = xWindows_NT ; then |
LIBS="-lkernel32 $LIBS" |
fi |
|
AC_CHECK_LIB(nsl, gethostbyname) |
|
AC_CHECK_LIB(dl, dlopen) |
AC_CHECK_LIB(dld, shl_load) |
AC_CHECK_LIB(dld, dld_link) |
|
|
if test "${pike_cv_sys_os}" = "Linux"; then |
if test "${ac_cv_lib_m_floor}" = "no"; then |
AC_MSG_WARN(I will compensate for this by adding -lc -lm) |
LIBS="${LIBS} -lc -lm" |
fi |
|
if test "$ac_cv_header_sched_h" = "yes"; then |
AC_MSG_CHECKING(if sched.h has a typo) |
AC_CACHE_VAL(pike_cv_broken_sched_h, [ |
AC_TRY_COMPILE([ |
#include <sched.h> |
],[ ],[ pike_cv_broken_shed_h=no ], [ |
OLDCPPFLAGS="$CPPFLAGS" |
CPPFLAGS="$CPPFLAGS -D_P=__P" |
AC_TRY_COMPILE([ |
#include <sched.h> |
],[ ],[ pike_cv_broken_sched_h=yes ],[ |
pike_cv_broken_sched_h="very broken" |
]) |
CPPFLAGS="$OLDCPPFLAGS" |
]) |
]) |
AC_MSG_RESULT($pike_cv_broken_sched_h) |
if test "$pike_cv_broken_sched_h" = "yes"; then |
AC_MSG_WARN(Applying workaround) |
CPPFLAGS="$CPPFLAGS -D_P=__P" |
fi |
fi |
fi |
|
######################################################################## |
|
if test x$with_threads = xyes ; then |
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) |
|
else |
|
# Test for POSIX threads |
|
case "x$pike_cv_sys_os" in |
xOSF1) |
LIBS="${OLDLIBS} -lpthread -lmach -lexc -lc" |
;; |
|
xBSD/OS*) |
LIBS="${OLDLIBS}" |
;; |
|
xUnixWare) |
if test "$GCC" = yes ; then |
LIBS="${LIBS} -lthread" |
else |
CFLAGS="${CFLAGS} -Kthread" |
fi |
;; |
|
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) |
CFLAGS="${CFLAGS} -pthread" |
LD_FALLBACK_FLAGS="${LD_FALLBACK_FLAGS-} -lc_r" |
fi |
;; |
|
xAIX*) |
LIBS="${OLDLIBS} -lpthreads -lc_r" |
;; |
|
*) |
LIBS="${OLDLIBS} -lpthread" |
;; |
esac |
|
AC_CHECK_FUNCS(pthread_init) |
AC_CHECK_FUNCS(pthread_mutexattr_init) |
|
AC_MSG_CHECKING(posix threads) |
|
AC_CACHE_VAL(pike_cv_posix_threads, [ |
AC_TRY_RUN([ |
#define _REENTRANT |
#define _THREAD_SAFE |
#define _MIT_POSIX_THREADS 1 |
|
#include <pthread.h> |
|
void *foo(void *bar) { pthread_exit(0); return 0; } |
pthread_mutexattr_t attr; |
pthread_mutex_t tmp; |
pthread_t gazonk; |
|
int main() |
{ |
void *sune; |
#ifdef HAVE_PTHREAD_INIT |
pthread_init(); |
#endif /* HAVE_PTHREAD_INIT */ |
#ifdef HAVE_PTHREAD_MUTEXATTR_INIT |
pthread_mutexattr_init(&attr); |
#else |
memset(&attr, 0, sizeof(attr)); |
#endif /* HAVE_PTHREAD_MUTEXATTR_INIT */ |
pthread_mutex_init(&tmp, &attr); |
pthread_mutex_lock(&tmp); |
pthread_create(&gazonk,0,foo,0); |
pthread_join(gazonk,&sune); |
exit(0); |
} |
],pike_cv_posix_threads=yes,pike_cv_posix_threads=no,pike_cv_posix_threads=no) |
]) |
|
if test $pike_cv_posix_threads = yes ; then |
AC_MSG_RESULT(yes) |
AC_DEFINE(_REENTRANT) |
AC_DEFINE(_THREAD_SAFE) |
AC_DEFINE(_MIT_POSIX_THREADS,1) |
|
AC_MSG_CHECKING(for pthread_attr_setstacksize) |
AC_CACHE_VAL(pike_cv_have_pthread_attr_setstacksize,[ |
AC_TRY_LINK([#include <pthread.h> |
void foo(pthread_attr_t*x) { pthread_attr_setstacksize(x, 1024*1024); } |
],[],[ |
pike_cv_have_pthread_attr_setstacksize=yes |
],[ |
pike_cv_have_pthread_attr_setstacksize=no |
]) |
]) |
AC_MSG_RESULT($pike_cv_have_pthread_attr_setstacksize) |
if test x$pike_cv_have_pthread_attr_setstacksize = xyes ; then |
AC_DEFINE(HAVE_PTHREAD_ATTR_SETSTACKSIZE) |
else |
: |
fi |
|
AC_MSG_CHECKING(for pthread_yield) |
AC_CACHE_VAL(pike_cv_have_pthread_yield,[ |
AC_TRY_LINK([#include <pthread.h> |
void foo(void) { pthread_yield(); } |
],[],[ |
pike_cv_have_pthread_yield=yes |
],[ |
pike_cv_have_pthread_yield=no |
]) |
]) |
AC_MSG_RESULT($pike_cv_have_pthread_yield) |
if test x$pike_cv_have_pthread_yield = xyes ; then |
AC_DEFINE(HAVE_PTHREAD_YIELD) |
else |
: |
fi |
|
AC_MSG_CHECKING(for pthread_cond_init) |
AC_CACHE_VAL(pike_cv_have_pthread_cond_init,[ |
AC_TRY_LINK([#include <pthread.h> |
void foo(pthread_cond_t*x, pthread_condattr_t*y) { pthread_cond_init(x,y); } |
],[],[ |
pike_cv_have_pthread_cond_init=yes |
],[ |
pike_cv_have_pthread_cond_init=no |
]) |
]) |
AC_MSG_RESULT($pike_cv_have_pthread_cond_init) |
if test x$pike_cv_have_pthread_cond_init = xyes ; then |
AC_DEFINE(HAVE_PTHREAD_COND_INIT) |
else |
: |
fi |
|
AC_MSG_CHECKING(if pthread_condattr_default is defined) |
AC_CACHE_VAL(pike_cv_have_pthread_condattr_default,[ |
AC_TRY_LINK([#include <pthread.h> |
void foo(pthread_cond_t *bar) { pthread_cond_init(bar, pthread_condattr_default); } |
],[],[ |
pike_cv_have_pthread_condattr_default=yes |
],[ |
pike_cv_have_pthread_condattr_default=no |
]) |
]) |
|
AC_MSG_RESULT($pike_cv_have_pthread_condattr_default) |
|
if test x$pike_cv_have_pthread_condattr_default = xyes ; then |
AC_DEFINE(HAVE_PTHREAD_CONDATTR_DEFAULT) |
else |
: |
fi |
|
# |
# FreeBSD doesn't like the &, while AIX requires it... |
# |
|
AC_MSG_CHECKING(if pthread_condattr_default is needs an & (AIX)) |
AC_CACHE_VAL(pike_cv_have_pthread_condattr_default_aix,[ |
AC_TRY_LINK([#include <pthread.h> |
void foo(pthread_cond_t *bar) { pthread_cond_init(bar, &pthread_condattr_default); } |
],[],[ |
pike_cv_have_pthread_condattr_default_aix=yes |
],[ |
pike_cv_have_pthread_condattr_default_aix=no |
]) |
]) |
|
AC_MSG_RESULT($pike_cv_have_pthread_condattr_default_aix) |
|
if test x$pike_cv_have_pthread_condattr_default_aix = xyes ; then |
AC_DEFINE(HAVE_PTHREAD_CONDATTR_DEFAULT_AIX) |
else |
: |
fi |
|
else |
AC_MSG_RESULT(no) |
LIBS="$OLDLIBS" |
CFLAGS="$OLDCFLAGS" |
|
# No POSIX threads. |
|
# Try UNIX threads instead |
|
AC_MSG_CHECKING(unix threads) |
case "x$pike_cv_sys_os" in |
xUnixWare) |
if test "$GCC" = yes ; then |
LIBS="${LIBS} -lthread" |
else |
CFLAGS="${CFLAGS} -Kthread" |
fi |
CFLAGS="${CFLAGS} -D_UNIXWARE_THREADS_" |
;; |
*) |
LIBS="${LIBS} -lthread" |
;; |
esac |
|
AC_CACHE_VAL(pike_cv_unix_threads, [ |
AC_TRY_RUN([ |
#define _REENTRANT |
#define _THREAD_SAFE |
#define _MIT_POSIX_THREADS 1 |
#include <thread.h> |
#ifdef _UNIXWARE_THREADS_ |
#include <synch.h> |
#endif |
|
void *foo(void *bar) { thr_exit(0); return 0; } |
mutex_t tmp; |
thread_t gazonk; |
|
int main() |
{ |
void *sune; |
mutex_lock(& tmp); |
thr_create(0,0,foo,0,0,&gazonk); |
thr_join(gazonk,0,&sune); |
exit(0); |
} |
],pike_cv_unix_threads=yes,pike_cv_unix_threads=no,pike_cv_unix_threads=no) |
]) |
|
if test x$pike_cv_unix_threads = xyes ; then |
AC_MSG_RESULT(yes) |
AC_DEFINE(_REENTRANT) |
AC_DEFINE(_THREAD_SAFE) |
AC_DEFINE(_UNIX_THREADS) |
else |
AC_MSG_RESULT(no) |
LIBS="$OLDLIBS" |
CFLAGS="$OLDCFLAGS" |
|
# Now we've sunk really low -- test for proprietary threads |
|
# SGI old-style shared group processes |
# AC_CHECK_FUNCS(sproc oserror) |
# |
# AC_MSG_CHECKING(Fallback to sproc) |
# |
# if test x$ac_cv_func_sproc$ac_cv_func_oserror = xyesyes; then |
# AC_MSG_RESULT(yes) |
# AC_DEFINE(_REENTRANT) |
# AC_DEFINE(_THREAD_SAFE) |
# AC_DEFINE(_SGI_SPROC_THREADS) |
# AC_DEFINE(_SGI_MP_SOURCE) |
# else |
# AC_MSG_RESULT(no) |
# : |
# fi |
fi # UNIX threads |
fi # POSIX threads |
fi # NT |
else |
# Without threads |
: |
fi |
|
######################################################################## |
|
AC_FUNC_MEMCMP |
|
if test "${OLD_LIBOBJS}" = "${LIBOBJS}" ; then |
AC_DEFINE(HAVE_MEMCMP) |
fi |
|
LIBOBJS="${OLD_LIBOBJS}" |
|
AC_FUNC_MMAP |
|
AC_CHECK_FUNCS( \ |
_crypt \ |
poll \ |
bcopy \ |
bzero \ |
clock \ |
crypt \ |
fchmod \ |
gethrtime \ |
gethrvtime \ |
getenv \ |
getrlimit \ |
getrusage \ |
gettimeofday \ |
index \ |
localtime \ |
gmtime \ |
memchr \ |
memcpy \ |
memset \ |
mktime \ |
perror \ |
rindex \ |
setlocale \ |
setrlimit \ |
setresuid \ |
sigaction \ |
sigblock \ |
sigprocmask \ |
sigvec \ |
strcasecmp \ |
strchr \ |
strcspn \ |
strerror \ |
strrchr \ |
strtod \ |
strtok \ |
strtol \ |
time \ |
times \ |
vfprintf \ |
vsprintf \ |
vsnprintf \ |
wait3 \ |
wait4 \ |
waitpid \ |
munmap \ |
shl_load \ |
dld_link \ |
dld_get_func \ |
pipe \ |
strdup \ |
kill \ |
alarm \ |
fork1 \ |
flock \ |
lockf \ |
setuid getuid seteuid geteuid \ |
setgid getgid setegid getegid \ |
getpwent getpwnam getpwuid \ |
getgrent getgrnam \ |
initgroups setgroups \ |
socketpair \ |
fpclass \ |
fp_class_d \ |
isinf \ |
isnan \ |
iszero \ |
finite \ |
signbit \ |
nice \ |
__priocntl \ |
sched_setscheduler \ |
setpriority \ |
) |
|
AC_MSG_CHECKING(if the last argument to accept is a size_t *) |
AC_CACHE_VAL(pike_cv_accept_size_t, [ |
AC_TRY_COMPILE([ |
#ifndef _LARGEFILE_SOURCE |
# define _FILE_OFFSET_BITS 64 |
# define _LARGEFILE_SOURCE |
# define _LARGEFILE64_SOURCE 1 |
#endif |
/* HPUX needs these too... */ |
#ifndef __STDC_EXT__ |
# define __STDC_EXT__ |
#endif /* !__STDC_EXT__ */ |
|
#include <sys/types.h> |
#ifdef HAVE_UNISTD_H |
#include <unistd.h> |
#endif |
#ifdef HAVE_SYS_SOCKET_H |
#include <sys/socket.h> |
#endif |
|
/* NT */ |
#ifdef HAVE_WINSOCK_H |
#include <winsock.h> |
#endif |
|
/* Here's the actual test: */ |
int accept(int, struct sockaddr *, size_t *); |
], [ |
/* EMPTY */ |
], pike_cv_accept_size_t=size_t, pike_cv_accept_size_t=int) |
]) |
AC_MSG_RESULT($pike_cv_accept_size_t) |
AC_DEFINE_UNQUOTED(ACCEPT_SIZE_T, $pike_cv_accept_size_t) |
|
if test x$pike_cv_sys_os = xWindows_NT ; then |
AC_DEFINE(HAVE_LOADLIBRARY) |
AC_DEFINE(HAVE_FREELIBRARY) |
AC_DEFINE(HAVE_GETPROCADDRESS) |
AC_DEFINE(DL_EXPORT, _dlspec(export)) |
else |
AC_DEFINE(DL_EXPORT, []) |
fi |
|
if test $ac_cv_func_crypt$ac_cv_func__crypt = nono ; then |
AC_CHECK_LIB(crypt,crypt,[LIBS="${LIBS} -lcrypt" ; AC_DEFINE(HAVE_CRYPT)], |
[ |
if test -f "$srcdir/crypt.c"; then |
AC_MSG_RESULT(Using crypt.c for BSD style crypt()) |
EXTRA_OBJS="${EXTRA_OBJS} crypt.o" |
AC_DEFINE(HAVE_CRYPT) |
else |
: |
fi |
]) |
|
fi |
|
|
############################################################################# |
|
# FreeBSD 3.0 has broken F_SETFD when running with threads. |
|
AC_MSG_CHECKING(whether F_SETFD exists and works) |
|
AC_CACHE_VAL(pike_cv_broken_f_setfd, [ |
AC_TRY_RUN([ |
#ifdef HAVE_SYS_TYPES_H |
#include <sys/types.h> |
#endif /* HAVE_SYS_TYPES_H */ |
#include <sys/stat.h> |
#ifdef HAVE_FCNTL_H |
#include <fcntl.h> |
#endif /* HAVE_FCNTL_H */ |
#include <stdio.h> |
#ifndef FD_CLOEXEC |
#define FD_CLOEXEC 1 |
#endif /* FD_CLOEXEC */ |
int main(int argc, char **argv) |
{ |
int fd = 0; |
if (fcntl(fd, F_SETFD, FD_CLOEXEC) < 0) { |
exit(1); |
} |
if (fcntl(fd, F_GETFD) != FD_CLOEXEC) { |
exit(1); |
} |
exit(0); |
} |
], pike_cv_broken_f_setfd=no, pike_cv_broken_f_setfd=yes, |
pike_cv_broken_f_setfd=no) |
]) |
|
if test "x$pike_cv_broken_f_setfd" = "xyes"; then |
AC_MSG_RESULT(no) |
AC_DEFINE(HAVE_BROKEN_F_SETFD) |
else |
AC_MSG_RESULT(yes) |
fi |
|
############################################################################# |
|
AC_STRUCT_TM |
|
############################################################################# |
|
AC_MSG_CHECKING(extern int timezone) |
|
AC_CACHE_VAL(pike_cv_has_external_timezone,[ |
AC_TRY_LINK([ |
#include <time.h> |
],[ |
int _tz; |
_tz=timezone; |
timezone=_tz; |
],pike_cv_has_external_timezone=yes,pike_cv_has_external_timezone=no) |
]) |
|
if test "$pike_cv_has_external_timezone" = "yes"; then |
AC_DEFINE(HAVE_EXTERNAL_TIMEZONE) |
fi |
|
AC_MSG_RESULT($pike_cv_has_external_timezone) |
|
############################################################################# |
|
# No test for this yet... |
AC_DEFINE(HAVE_STRUCT_TIMEVAL) |
|
############################################################################# |
|
if test "x$ac_cv_func_strtol" = "xyes"; then |
AC_MSG_CHECKING(if strtol works for large hexadecimal constants) |
AC_CACHE_VAL(pike_cv_func_strtol_works, [ |
AC_TRY_RUN([ |
#include <stdlib.h> |
int main(int argc, char **argv) |
{ |
/* On some OS's strtol() rounds this to 0x7fffffff. */ |
return(strtol("0xffffffff", NULL, 0) != 0xffffffff); |
} |
], pike_cv_func_strtol_works=yes, |
pike_cv_func_strtol_works=no, |
pike_cv_func_strtol_works=no) |
]) |
AC_MSG_RESULT($pike_cv_func_strtol_works) |
if test "x$pike_cv_func_strtol_works" = "xyes"; then |
AC_DEFINE(HAVE_WORKING_STRTOL) |
else :; fi |
else :; fi |
|
############################################################################# |
|
AC_MSG_CHECKING(if gettimeofday takes two arguments) |
AC_CACHE_VAL(pike_cv_func_gettimeofday_has_two_args, |
[ |
AC_TRY_RUN([ |
#if TIME_WITH_SYS_TIME |
# include <sys/time.h> |
# include <time.h> |
#else |
# if HAVE_SYS_TIME_H |
# include <sys/time.h> |
# else |
# if HAVE_TIME_H |
# include <time.h> |
# endif |
# endif |
#endif |
|
#ifndef HAVE_STRUCT_TIMEVAL |
struct timeval |
{ |
long tv_sec; |
long tv_usec; |
}; |
#endif |
|
int main() { |
struct timeval tv; |
gettimeofday(&tv,(void *)0); |
exit(0); |
} |
], |
pike_cv_func_gettimeofday_has_two_args=yes, |
pike_cv_func_gettimeofday_has_two_args=no, |
pike_cv_func_gettimeofday_has_two_args=no)]) |
|
if test $pike_cv_func_gettimeofday_has_two_args = yes; then |
AC_DEFINE(GETTIMEOFDAY_TAKES_TWO_ARGS) |
fi |
|
AC_MSG_RESULT($pike_cv_func_gettimeofday_has_two_args) |
|
AC_MSG_CHECKING(if struct tm has tm_gmtoff) |
|
AC_CACHE_VAL(pike_cv_struct_tm_has_gmtoff,[ |
AC_TRY_COMPILE([ |
#ifdef TM_IN_SYS_TIME |
#include <sys/time.h> |
#else |
#include <time.h> |
#endif |
],[ |
int _tz; |
struct tm foo; |
_tz=foo->tm_gmtoff; |
],pike_cv_struct_tm_has_gmtoff=yes,pike_cv_struct_tm_has_gmtoff=no) |
]) |
|
if test "$pike_cv_struct_tm_has_gmtoff" = "yes"; then |
AC_DEFINE(STRUCT_TM_HAS_GMTOFF) |
fi |
|
AC_MSG_RESULT($pike_cv_struct_tm_has_gmtoff) |
|
AC_MSG_CHECKING(for USHRT_MAX definition) |
|
AC_CACHE_VAL(pike_cv_ushrt_max_is_defined,[ |
AC_EGREP_CPP(yes,[ |
#include <limits.h> |
#ifdef USHRT_MAX |
yes |
#endif |
],pike_cv_ushrt_max_is_defined=yes,pike_cv_ushrt_max_is_defined=no) |
]) |
|
if test "$pike_cv_ushrt_max_is_defined" = "no" ; then |
AC_DEFINE(USHRT_MAX,65535) |
fi |
|
AC_MSG_RESULT($pike_cv_ushrt_max_is_defined) |
|
define(MY_CHECK_HEADERS, |
[ |
AC_MSG_CHECKING(for $1 declaration) |
AC_CACHE_VAL(pike_cv_decl_$1, |
[ |
pike_cv_decl_$1=nonexistant |
for a in $2 |
do |
AC_EGREP_HEADER($1,$a,[ pike_cv_decl_$1=existant; break ]) |
done |
]) |
AC_MSG_RESULT($pike_cv_decl_$1) |
if test "$pike_cv_decl_$1" = nonexistant; then |
AC_DEFINE(translit($1,[a-z],[A-Z])[]_DECL_MISSING) |
fi |
]) |
|
MY_CHECK_HEADERS(strchr,string.h unistd.h stdlib.h) |
MY_CHECK_HEADERS(malloc,memory.h unistd.h stdlib.h) |
MY_CHECK_HEADERS(getpeername,sys/socket.h sys/socketvar.h sys/socketio.h winsock.h winsock2.h) |
MY_CHECK_HEADERS(popen,stdio.h unistd.h) |
MY_CHECK_HEADERS(getenv,unistd.h stdlib.h) |
MY_CHECK_HEADERS(gethostname,unistd.h netdb.h winsock.h winsock2.h) |
|
AC_ALLOCA |
|
AC_C_CONST |
AC_C_INLINE |
|
AC_CHECK_FUNCS(ualarm setitimer) |
|
if test "x$ac_cv_func_ualarm" = "xyes"; then |
AC_MSG_CHECKING(no of arguments to ualarm) |
AC_CACHE_VAL(pike_cv_ualarm_takes_two_args, |
[ |
AC_TRY_COMPILE([ |
#ifdef HAVE_UNISTD_H |
#include <unistd.h> |
#endif /* HAVE_UNISTD_H */ |
],[ |
ualarm(0,0); |
],pike_cv_ualarm_takes_two_args=yes,pike_cv_ualarm_takes_two_args=no) |
]) |
if test "$pike_cv_ualarm_takes_two_args" = yes; then |
AC_MSG_RESULT(2) |
AC_DEFINE(UALARM_TAKES_TWO_ARGS) |
else |
AC_MSG_RESULT(1) |
fi |
fi |
|
OLD_LIBOBJS="${LIBOBJS}" |
|
######################################################################## |
AC_MSG_CHECKING(stack direction) |
AC_CACHE_VAL(pike_cv_hardware_stack_direction, |
[ |
AC_TRY_RUN([ |
static int find_stack_direction(void *foo) |
{ |
if(!foo) { |
return find_stack_direction((void *)&foo); |
} |
if (((void *)&foo) > foo) { |
return 1; |
} else { |
return -1; |
} |
} |
|
int main() { exit( find_stack_direction(0) + 1); } |
],pike_cv_hardware_stack_direction=down,pike_cv_hardware_stack_direction=up) |
]) |
|
AC_MSG_RESULT($pike_cv_hardware_stack_direction) |
|
if grep STACK_DIRECTION confdefs.h >/dev/null 2>&1; then |
: |
else |
if test "x$pike_cv_hardware_stack_direction" = "xup" ; then |
AC_DEFINE(STACK_DIRECTION, 1) |
else |
AC_DEFINE(STACK_DIRECTION, -1) |
fi |
fi |
|
######################################################################## |
|
AC_MSG_CHECKING(byteorder) |
AC_CACHE_VAL(pike_cv_hardware_byteorder, |
[ |
AC_TRY_RUN([ |
#include <stdio.h> |
|
int main() |
{ |
#if SIZEOF_INT == 4 |
#define T int |
#else |
#define T long |
#endif |
FILE *f; |
T a; |
int e; |
for(e=0;e<sizeof(T);e++) |
((char *)&a)[e]=(e+1) % 10; |
|
f=fopen("conftest.out.2","w"); |
for(e=0;e<sizeof(T);e++) |
{ |
fprintf(f,"%d",(int)(a & 255)); |
a>>=8; |
} |
fprintf(f,"\n"); |
fclose(f); |
|
return 0; |
}], |
pike_cv_hardware_byteorder=`cat conftest.out.2` |
, |
pike_cv_hardware_byteorder=0 |
, |
pike_cv_hardware_byteorder=0 |
)]) |
|
AC_MSG_RESULT($pike_cv_hardware_byteorder) |
AC_DEFINE_UNQUOTED(PIKE_BYTEORDER,$pike_cv_hardware_byteorder) |
|
dnl##################################################################### |
|
define(MY_CHECK_FUNCTION,[ |
AC_MSG_CHECKING(for working $1) |
AC_CACHE_VAL(pike_cv_func_$1,[ |
AC_TRY_RUN([$2],pike_cv_func_$1=yes,pike_cv_func_$1=no,pike_cv_func_$1=no) |
]) |
AC_MSG_RESULT([$]pike_cv_func_$1) |
if test [$]pike_cv_func_$1 = yes; then |
AC_DEFINE(translit(HAVE_$1,[a-z],[A-Z])) |
fi]) |
|
######################################################################## |
MY_CHECK_FUNCTION(fork, |
[ |
#ifdef HAVE_SYS_TYPES_H |
#include <sys/types.h> |
#endif |
#ifdef HAVE_UNISTD_H |
#include <unistd.h> |
#endif |
|
int main() |
{ |
exit(fork()==-1); |
} |
]); |
######################################################################## |
MY_CHECK_FUNCTION(fpsetmask, |
[ |
#include <math.h> |
#ifdef HAVE_FLOATINGPOINT_H |
#include <floatingpoint.h> |
#endif |
|
#ifdef HAVE_IEEEFP_H |
#include <ieeefp.h> |
#endif |
|
int main() |
{ |
fpsetmask(0); |
exit(0); |
} |
]); |
######################################################################## |
|
MY_CHECK_FUNCTION(dlopen, |
[ |
#include <dlfcn.h> |
int main() |
{ |
dlopen(0, 0); |
exit(0); |
}]) |
|
######################################################################## |
|
MY_CHECK_FUNCTION(ldexp, |
[ |
#include <math.h> |
int main() |
{ |
double x; |
int p; |
|
for(x=0.0;x<2.0;x+=1.0/64.0) |
for(p=-6;p<7;p++) |
if(ldexp(x,p) != x*pow(2.0, (double)p)) |
exit(1); |
exit(0); |
}]) |
|
######################################################################## |
|
MY_CHECK_FUNCTION(frexp, |
[ |
#include <math.h> |
int main() |
{ |
double x,y; |
int p,e; |
|
x=frexp(1.0, &e); |
if(x * pow(2.0,(double)e) != 1.0) exit(3); |
|
p=-7; |
for(x=3.0/4.0*pow(2.0,(double)p);x<50000.0;x*=2.0,p++) |
{ |
if(frexp(x, &e)!=3.0/4.0) exit(1); |
if(e!=p) exit(2); |
} |
exit(0); |
}]) |
|
############################################################################# |
MY_CHECK_FUNCTION(GetSystemTimeAsFileTime, |
[ |
#include <windows.h> |
#include <winbase.h> |
|
int main() |
{ |
FILETIME f; |
GetSystemTimeAsFileTime(&f); |
exit(0); |
} |
]) |
############################################################################# |
MY_CHECK_FUNCTION(gethostname, |
[ |
#ifdef HAVE_UNISTD_H |
#include <unistd.h> |
#endif |
#ifdef HAVE_WINSOCK_H |
#include <winsock.h> |
#endif |
|
int main(int argc, char **argv) |
{ |
char buffer[10000]; |
char *x=gethostname(buffer,sizeof(buffer)); |
exit(0); |
} |
]) |
############################################################################# |
MY_CHECK_FUNCTION(strcoll, |
[ |
#include <string.h> |
#include <locale.h> |
int main() |
{ |
setlocale(LC_CTYPE, "ISO-8859-1"); |
exit(strcoll("abc", "def") >= 0 || |
strcoll("ABC", "DEF") >= 0 || |
strcoll("ABC", "ABCD") >= 0 || |
strcoll("ABCD", "ABC") <= 0 || |
strcoll("*^#", "*^#") != 0 || |
strcoll("123", "456") >= 0); |
} |
]) |
|
######################################################################## |
|
MY_CHECK_FUNCTION(memmem, |
[ |
#include <string.h> |
char *a="foo bar gazonk"; |
char *b="foo"; |
char *c="bar"; |
char *d="gazonk"; |
int main() |
{ |
if(((char *)memmem(b,strlen(b),a,strlen(a)))!=a || |
((char *)memmem(c,strlen(c),a,strlen(a)))!=(a+4) || |
((char *)memmem(d,strlen(d),a,strlen(a)))!=(a+8) || |
((char *)memmem(d,0,a,strlen(a)))!=a || |
memmem(d,strlen(d)+1,a,strlen(a))!=0) |
exit(1); |
exit(0); |
} |
]) |
|
######################################################################## |
|
MY_CHECK_FUNCTION(memmove, |
[ |
#include <string.h> |
char buf[100]; |
int main() |
{ |
strcpy(buf,"foo bar gazonk elefantsnabel."); |
if(strcmp(buf,"foo bar gazonk elefantsnabel.")) exit(1); |
memmove(buf,buf+1,7); |
if(strcmp(buf,"oo bar gazonk elefantsnabel.")) exit(1); |
memmove(buf+1,buf+1,9); |
if(strcmp(buf,"oo bar gazonk elefantsnabel.")) exit(1); |
memmove(buf+1,buf,11); |
if(strcmp(buf,"ooo bar gaznk elefantsnabel.")) exit(1); |
exit(0); |
} |
]) |
|
######################################################################## |
|
MY_CHECK_FUNCTION(isspace, |
[ |
#include <ctype.h> |
int main() |
{ |
if(isspace(' ')) exit(0); |
exit(1); |
} |
]) |
|
############################################################################# |
|
AC_MSG_CHECKING(if we can declare environ) |
AC_CACHE_VAL(pike_cv_declare_environ,[ |
AC_TRY_COMPILE([ |
#include <stdlib.h> |
],[ |
extern char **environ; |
exit(0); |
],pike_cv_declare_environ=yes,pike_cv_declare_environ=no,pike_cv_declare_environ=yes) |
]) |
|
AC_MSG_RESULT($pike_cv_declare_environ) |
if test "x$pike_cv_declare_environ" = xyes ; then |
AC_DEFINE(DECLARE_ENVIRON) |
fi |
|
############################################################################# |
|
AC_MSG_CHECKING([for union wait (old BSD convention)]) |
AC_CACHE_VAL(pike_cv_union_wait, [ AC_TRY_COMPILE([ |
#ifdef HAVE_SYS_WAIT_H |
#include <sys/wait.h> |
#endif /* HAVE_SYS_WAIT_H */ |
], [ |
union wait status; |
exit(0); |
], pike_cv_union_wait=yes, pike_cv_union_wait=no) |
]) |
|
AC_MSG_RESULT($pike_cv_union_wait) |
if test "x$pike_cv_union_wait" = "xyes" ; then |
AC_MSG_CHECKING([whether union wait is really needed]) |
AC_CACHE_VAL(pike_cv_union_wait_needed, [ AC_TRY_COMPILE([ |
#ifdef HAVE_SYS_WAIT_H |
#include <sys/wait.h> |
#endif /* HAVE_SYS_WAIT_H */ |
], [ |
int status; |
return WIFEXITED(status) || 0; |
], pike_cv_union_wait_needed=no, pike_cv_union_wait_needed=yes) |
]) |
AC_MSG_RESULT($pike_cv_union_wait_needed) |
if test "x$pike_cv_union_wait_needed" = "xyes" ; then |
AC_DEFINE(HAVE_UNION_WAIT) |
else :; fi |
else :; fi |
|
############################################################################# |
|
AC_MSG_CHECKING(how to extract an unsigned char) |
AC_CACHE_VAL(pike_cv_method_extract_uchar, |
[ |
AC_TRY_RUN([ |
int main() |
{ |
char i,*p; |
i=-10; |
p=&i; |
if(*(unsigned char *)(p)!= 0x100 - 10) exit(1); |
exit(0); |
} |
],pike_cv_method_extract_uchar=by_cast, |
pike_cv_method_extract_uchar=not_by_cast, |
pike_cv_method_extract_uchar=not_by_cast)]) |
|
if test "$pike_cv_method_extract_uchar" = by_cast; then |
AC_MSG_RESULT(by cast) |
AC_DEFINE(EXTRACT_UCHAR_BY_CAST) |
else |
AC_MSG_RESULT(not by cast) |
fi |
|
######################################################################## |
|
AC_MSG_CHECKING(how to extract a signed char) |
AC_CACHE_VAL(pike_cv_method_extract_char, |
[ |
AC_TRY_RUN([ |
int main() |
{ |
char i,*p; |
i=-10; |
p=&i; |
if(*(signed char *)(p)!= -10) exit(1); |
exit(0); |
} |
],pike_cv_method_extract_char=by_cast, |
pike_cv_method_extract_char=not_by_cast, |
pike_cv_method_extract_char=not_by_cast)]) |
|
if test "$pike_cv_method_extract_char" = by_cast; then |
AC_MSG_RESULT(by cast) |
AC_DEFINE(EXTRACT_CHAR_BY_CAST) |
else |
AC_MSG_RESULT(not by cast) |
fi |
|
############################################################################# |
|
AC_MSG_CHECKING(if float conversion can cause SIGFPE) |
AC_CACHE_VAL(pike_cv_sys_idiot_sigfpe, |
[ |
AC_TRY_RUN([ |
#include <math.h> |
|
#ifdef HAVE_FLOATINGPOINT_H |
#include <floatingpoint.h> |
#endif |
|
#ifdef HAVE_IEEEFP_H |
#include <ieeefp.h> |
#endif |
|
float foo_float = 0.0; |
|
int main(int argc, char **argv) |
{ |
float x=2.0, y=-128.0; |
#ifdef HAVE_FPSETMASK |
fpsetmask(0); |
#endif |
x = pow(2.0, -128.0); |
foo_float = x; |
if (x == 2.0) exit(1); |
x = pow(2.0, 1024.0); |
foo_float = x; |
if(x == 2.0) exit(1); |
exit(0); |
} |
],pike_cv_sys_idiot_sigfpe=no,pike_cv_sys_idiot_sigfpe=yes, |
pike_cv_sys_idiot_sigfpe=yes) |
]) |
|
if test $pike_cv_sys_idiot_sigfpe = yes ; then |
AC_MSG_RESULT(yes) |
|
IEEE_FLAG=no |
if test "x${GCC-}" = xyes ; then |
AC_SYS_COMPILER_FLAG(-mieee, mieee, CFLAGS,[],IEEE_FLAG=yes) |
else |
AC_SYS_COMPILER_FLAG(-ieee, ieee, CFLAGS,[],IEEE_FLAG=yes) |
fi |
TEST_IGNORE_SIGFPE=yes |
|
if test $IEEE_FLAG = yes; then |
AC_MSG_CHECKING(if float conversion is still broken) |
AC_CACHE_VAL(pike_cv_sys_idiot_sigfpe_with_ieee, |
[ |
OLD_CFLAGS="$CFLAGS" |
CFLAGS="$CFLAGS $OPTIMIZE" |
AC_TRY_RUN([ |
#include <math.h> |
|
#ifdef HAVE_FLOATINGPOINT_H |
#include <floatingpoint.h> |
#endif |
|
#ifdef HAVE_IEEEFP_H |
#include <ieeefp.h> |
#endif |
|
float foo_float = 0.0; |
|
int main(int argc, char **argv) |
{ |
float x=2.0, y=-128.0; |
#ifdef HAVE_FPSETMASK |
fpsetmask(0); |
#endif |
x = pow(2.0, -128.0); |
foo_float = x; |
if (x == 2.0) exit(1); |
x = pow(2.0, 1024.0); |
foo_float = x; |
if(x == 2.0) exit(1); |
exit(0); |
} |
],pike_cv_sys_idiot_sigfpe_with_ieee=no,pike_cv_sys_idiot_sigfpe_with_ieee=yes, |
pike_cv_sys_idiot_sigfpe_with_ieee=yes) |
CFLAGS="$OLD_CFLAGS" |
]) |
|
if test $pike_cv_sys_idiot_sigfpe_with_ieee = yes ; then |
AC_MSG_RESULT(yes) |
else |
AC_MSG_RESULT(no) |
TEST_IGNORE_SIGFPE=no |
fi |
fi # IEEE_FLAG |
|
if test $TEST_IGNORE_SIGFPE = yes; then |
AC_MSG_CHECKING(if ignoring SIGFPE helps) |
AC_CACHE_VAL(pike_cv_sys_ignore_sigfpe, |
[ |
OLD_CFLAGS="$CFLAGS" |
CFLAGS="$CFLAGS $OPTIMIZE" |
AC_TRY_RUN([ |
#include <signal.h> |
#include <math.h> |
int counter=0; |
RETSIGTYPE func(void) |
{ |
if(counter++>10) exit(7); |
signal(SIGFPE,func); |
} |
|
float foo_float = 0.0; |
|
int main(int argc, char **argv) |
{ |
float x=2.0, y=-128.0; |
signal(SIGFPE,func); |
x = pow(2.0, -128.0); |
foo_float = x; |
if (x == 2.0) exit(1); |
x = pow(2.0, 1024.0); |
foo_float = x; |
if(x == 2.0) exit(1); |
exit(0); |
} |
],pike_cv_sys_ignore_sigfpe=yes,pike_cv_sys_ignore_sigfpe=no, |
pike_cv_sys_ignore_sigfpe=yes) |
CFLAGS="$OLD_CFLAGS" |
]) |
|
if test "$pike_cv_sys_ignore_sigfpe" = yes; then |
AC_MSG_RESULT(yes) |
AC_DEFINE(IGNORE_SIGFPE) |
else |
AC_MSG_RESULT(no) |
fi |
fi # TEST_IGNORE_SIGFPE |
|
else |
AC_MSG_RESULT(no) |
fi # pike_cv_sys_idiot_sigfpe |
|
############################################################################# |
|
define(float_check, [[ |
#include <math.h> |
#define TY $1 |
#define TEST_$1 |
#define TEST_$2 |
#define EXPECTED_SIZE_float 4 |
#define EXPECTED_SIZE_double 8 |
void check(TY n, char *pf, char *pd) |
{ |
int i; |
char *p, *p2 = (char*)&n; |
#ifdef TEST_float |
p = pf; |
#else |
p = pd; |
#endif |
for(i=0; i<sizeof(TY); i++) |
#ifdef TEST_BIG |
if(p[i] != p2[i]) |
exit(1); |
#else |
if(p[i] != p2[sizeof(TY)-i-1]) |
exit(1); |
#endif |
} |
int main() |
{ |
if(sizeof(TY)!=EXPECTED_SIZE_$1) |
exit(1); |
check((TY)0.0, "\000\000\000\000", "\000\000\000\000\000\000\000\000"); |
check((TY)1.0, "\077\200\000\000", "\077\360\000\000\000\000\000\000"); |
check((TY)-1.0, "\277\200\000\000", "\277\360\000\000\000\000\000\000"); |
check((TY)2.0, "\100\000\000\000", "\100\000\000\000\000\000\000\000"); |
check((TY)1.5, "\077\300\000\000", "\077\370\000\000\000\000\000\000"); |
check((TY)0.032999999821186065673828125, "\075\007\053\002", "\077\240\345\140\100\000\000\000"); |
exit(0); |
} |
]]) |
|
AC_MSG_CHECKING(for type of float) |
AC_CACHE_VAL(pike_cv_float_type, |
[AC_TRY_RUN(float_check(float,BIG),pike_cv_float_type=ieee_big, |
[AC_TRY_RUN(float_check(float,LITTLE),pike_cv_float_type=ieee_little, |
pike_cv_float_type=not_ieee)],pike_cv_float_type=not_ieee)]) |
if test "$pike_cv_float_type" = ieee_big; then |
AC_MSG_RESULT(IEEE big endian) |
AC_DEFINE(FLOAT_IS_IEEE_BIG) |
else |
if test "$pike_cv_float_type" = ieee_little; then |
AC_MSG_RESULT(IEEE little endian) |
AC_DEFINE(FLOAT_IS_IEEE_LITTLE) |
else |
AC_MSG_RESULT(not IEEE) |
fi |
fi |
|
AC_MSG_CHECKING(for type of double) |
AC_CACHE_VAL(pike_cv_double_type, |
[AC_TRY_RUN(float_check(double,BIG),pike_cv_double_type=ieee_big, |
[AC_TRY_RUN(float_check(double,LITTLE),pike_cv_double_type=ieee_little, |
pike_cv_double_type=not_ieee)],pike_cv_double_type=not_ieee)]) |
if test "$pike_cv_double_type" = ieee_big; then |
AC_MSG_RESULT(IEEE big endian) |
AC_DEFINE(DOUBLE_IS_IEEE_BIG) |
else |
if test "$pike_cv_double_type" = ieee_little; then |
AC_MSG_RESULT(IEEE little endian) |
AC_DEFINE(DOUBLE_IS_IEEE_LITTLE) |
else |
AC_MSG_RESULT(not IEEE) |
fi |
fi |
|
############################################################################# |
|
AC_MSG_CHECKING(for volatile) |
AC_CACHE_VAL(pike_cv_volatile, |
[ |
AC_TRY_COMPILE([],[ volatile int foo=1;], pike_cv_volatile=yes,pike_cv_volatile=no) |
]) |
|
if test "$pike_cv_volatile" = yes; then |
AC_MSG_RESULT(yes) |
AC_DEFINE(VOLATILE,volatile) |
else |
AC_MSG_RESULT(no) |
AC_DEFINE(VOLATILE,) |
fi |
|
######################################################################## |
|
AC_MSG_CHECKING(for sig_atomic_t) |
AC_CACHE_VAL(ac_cv_type_sig_atomic_t, |
[ |
AC_EGREP_CPP(sig_atomic_t, [ |
#ifdef HAVE_SIGNAL_H |
#include <signal.h> |
#endif |
#include <sys/types.h> |
#if STDC_HEADERS |
#include <stdlib.h> |
#include <stddef.h> |
#endif], ac_cv_type_sig_atomic_t=yes, ac_cv_type_sig_atomic_t=no)]) |
AC_MSG_RESULT($ac_cv_type_sig_atomic_t) |
if test x"$ac_cv_type_sig_atomic_t" = xno; then |
AC_DEFINE(sig_atomic_t, int) |
else |
: |
fi |
|
AC_MSG_CHECKING(if signal handlers reset automatically) |
AC_CACHE_VAL(pike_cv_sys_signal_oneshot, |
[ |
AC_TRY_RUN([ |
#ifdef HAVE_SIGNAL_H |
#include <signal.h> |
#endif |
#include <sys/types.h> |
#if STDC_HEADERS |
#include <stdlib.h> |
#include <stddef.h> |
#endif |
VOLATILE sig_atomic_t sigrun=0; |
RETSIGTYPE func(int sig) { sigrun=1; } |
|
int main() |
{ |
#define sig SIGSEGV |
|
#ifdef HAVE_SIGACTION |
{ |
struct sigaction action; |
action.sa_handler= func; |
sigfillset(&action.sa_mask); |
#ifdef SA_INTERRUPT |
action.sa_flags=SA_INTERRUPT; |
#endif |
sigaction(sig,&action,0); |
} |
#else |
#ifdef HAVE_SIGVEC |
{ |
struct sigvec action; |
action.sv_handler= func; |
action.sv_mask=-1; |
#ifdef SV_INTERRUPT |
action.sv_flags=SV_INTERRUPT; |
#endif |
sigvec(sig,&action,0); |
} |
#else |
signal(sig, func); |
#endif |
#endif |
|
kill(getpid(), sig); |
while(!sigrun) sleep(1); |
sigrun=0; |
kill(getpid(), sig); |
while(!sigrun) sleep(1); |
sigrun=0; |
exit(0); |
} |
],pike_cv_sys_signal_oneshot=no,pike_cv_sys_signal_oneshot=yes,pike_cv_sys_signal_oneshot=yes)]) |
|
if test "$pike_cv_sys_signal_oneshot" = yes; then |
AC_MSG_RESULT(yes) |
AC_DEFINE(SIGNAL_ONESHOT) |
else |
AC_MSG_RESULT(no) |
fi |
|
######################################################################## |
|
AC_MSG_CHECKING(available file descriptors) |
AC_CACHE_VAL(pike_cv_max_open_fd, |
[ |
AC_TRY_RUN([ |
#include <stdio.h> |
#ifdef HAVE_SYS_TIME_H |
#include <sys/time.h> |
#endif |
#ifdef HAVE_SYS_RESOURCE_H |
#include <sys/resource.h> |
#endif |
|
#ifndef MAX_FD |
#define MAX_FD 256 |
#endif |
|
int main() |
{ |
FILE *f; |
long limit; |
|
#if !defined(RLIMIT_NOFILE) && defined(RLIMIT_OFILE) |
#define RLIMIT_NOFILE RLIMIT_OFILE |
#endif |
|
#if defined(HAVE_SETRLIMIT) && defined(RLIMIT_NOFILE) |
struct rlimit lim; |
|
if(getrlimit(RLIMIT_NOFILE,&lim)) |
{ |
limit = MAX_FD; |
}else{ |
if(lim.rlim_max == RLIM_INFINITY) |
{ |
limit=131072; /* Noone needs more :-) */ |
}else{ |
limit=lim.rlim_max; |
if(limit > 131072) limit=131072; |
} |
} |
#else |
limit = MAX_FD; |
#endif |
|
f=fopen("conftest.out.2","w"); |
fprintf(f,"%ld\n",(long)limit); |
fclose(f); |
|
return 0; |
} |
], |
pike_cv_max_open_fd=`cat conftest.out.2` |
, |
pike_cv_max_open_fd=256 |
, |
pike_cv_max_open_fd=256 |
)]) |
AC_MSG_RESULT($pike_cv_max_open_fd) |
AC_DEFINE_UNQUOTED(MAX_OPEN_FILEDESCRIPTORS,$pike_cv_max_open_fd) |
|
AC_MSG_CHECKING(full availability of struct rusage members) |
AC_CACHE_VAL(pike_cv_func_getrusage_full, |
[ |
AC_TRY_LINK([ |
#include <sys/time.h> |
#ifdef HAVE_SYS_RUSAGE_H |
#include <sys/rusage.h> |
#endif |
#include <sys/resource.h> |
#ifndef RUSAGE_SELF |
#define RUSAGE_SELF 0 |
#endif |
],[ |
struct rusage rus; |
long *v = (long *)main; |
getrusage(RUSAGE_SELF, &rus); |
*v++ = rus.ru_maxrss; |
*v++ = rus.ru_ixrss; |
*v++ = rus.ru_idrss; |
*v++ = rus.ru_isrss; |
*v++ = rus.ru_minflt; |
*v++ = rus.ru_majflt; |
*v++ = rus.ru_nswap; |
*v++ = rus.ru_inblock; |
*v++ = rus.ru_oublock; |
*v++ = rus.ru_msgsnd; |
*v++ = rus.ru_msgrcv; |
*v++ = rus.ru_nsignals; |
*v++ = rus.ru_nvcsw; |
*v++ = rus.ru_nivcsw; |
], |
pike_cv_func_getrusage_full=yes |
, |
pike_cv_func_getrusage_full=no |
)]) |
|
if test "$pike_cv_func_getrusage_full" = yes; then |
AC_MSG_RESULT(all there) |
else |
AC_MSG_RESULT(getrusage is restricted) |
AC_DEFINE(GETRUSAGE_RESTRICTED) |
fi |
|
######################################################################## |
# |
# IRIX also has procfs support, but it it different, a separate test |
# should be made. /Hubbe |
# |
|
if test "$ac_cv_header_sys_procfs_h" = "yes"; then |
AC_MSG_CHECKING(getrusage() through procfs) |
AC_CACHE_VAL(pike_cv_getrusage_procfs, [ |
AC_TRY_COMPILE([ |
#ifndef _LARGEFILE_SOURCE |
# define _FILE_OFFSET_BITS 64 |
# define _LARGEFILE_SOURCE |
# define _LARGEFILE64_SOURCE 1 |
#endif |
#include <sys/procfs.h> |
#include <sys/fcntl.h> |
int proc_fd; |
long tmp; |
char proc_name[20]; |
prusage_t pru; |
prstatus_t prs; |
],[ |
sprintf(proc_name, "/proc/%05d", getpid()); |
proc_fd = open(proc_name, O_RDONLY); |
ioctl(proc_fd, PIOCUSAGE, &pru); |
ioctl(proc_fd, PIOCSTATUS, &prs); |
tmp=pru.pr_utime.tv_sec; |
], |
pike_cv_getrusage_procfs=yes |
, |
pike_cv_getrusage_procfs=no |
) |
]) |
|
if test "$pike_cv_getrusage_procfs" = yes; then |
AC_MSG_RESULT(yes) |
AC_DEFINE(GETRUSAGE_THROUGH_PROCFS) |
else |
AC_MSG_RESULT(no) |
fi |
fi |
|
############################################################################# |
|
AC_MSG_CHECKING(for isgraph) |
AC_CACHE_VAL(pike_cv_func_isgraph, [ AC_TRY_LINK([ |
#include <ctype.h> |
], [ |
return(!isgraph('A')); |
], pike_cv_func_isgraph=yes, pike_cv_func_isgraph=no) |
]) |
AC_MSG_RESULT($pike_cv_func_isgraph) |
if test "x$pike_cv_func_isgraph" = "xyes" ; then |
AC_DEFINE(HAVE_ISGRAPH) |
else :; fi |
|
############################################################################# |
# |
# __func__ is new in ISO C 9x |
# |
# It should expand to the name of the current function, and is |
# useful for debug. |
|
AC_MSG_CHECKING(if __func__ exists and works) |
AC_CACHE_VAL(pike_cv_have_working___func__, |
[ |
AC_TRY_RUN([ |
#ifdef HAVE_STRING_H |
#include <string.h> |
#else /* !HAVE_STRING_H */ |
#ifdef HAVE_STRINGS_H |
#include <strings.h> |
#endif /* HAVE_STRIGNS_H */ |
#endif /* HAVE_STRING_H */ |
int main() |
{ |
exit(strcmp("main", __func__)); |
} |
], pike_cv_have_working___func__=yes, pike_cv_have_working___func__=no, |
pike_cv_have_working___func__=no) |
]) |
AC_MSG_RESULT($pike_cv_have_working___func__) |
if test "$pike_cv_have_working___func__" = yes; then |
AC_DEFINE(HAVE_WORKING___FUNC__) |
else :; fi |
|
# gcc has __FUNCTION__ instead. |
|
AC_MSG_CHECKING(if __FUNCTION__ exists and works) |
AC_CACHE_VAL(pike_cv_have_working___FUNCTION__, |
[ |
AC_TRY_RUN([ |
#ifdef HAVE_STRING_H |
#include <string.h> |
#else /* !HAVE_STRING_H */ |
#ifdef HAVE_STRINGS_H |
#include <strings.h> |
#endif /* HAVE_STRIGNS_H */ |
#endif /* HAVE_STRING_H */ |
int main() |
{ |
exit(strcmp("main", __FUNCTION__)); |
} |
], pike_cv_have_working___FUNCTION__=yes, |
pike_cv_have_working___FUNCTION__=no, |
pike_cv_have_working___FUNCTION__=no) |
]) |
AC_MSG_RESULT($pike_cv_have_working___FUNCTION__) |
if test "$pike_cv_have_working___FUNCTION__" = yes; then |
AC_DEFINE(HAVE_WORKING___FUNCTION__) |
else :; fi |
|
############################################################################# |
|
AC_MSG_CHECKING(for gcc function attributes) |
AC_CACHE_VAL(pike_cv_gcc_attributes, |
[ |
AC_TRY_RUN([ |
#include <stdarg.h> |
void fatal(char *foo,...) __attribute__ ((noreturn,format (printf,1,2))); |
int sqr(int x) __attribute__ ((const)); |
|
int sqr(int x) { return x*x; } |
|
void fatal(char *foo,...) |
{ |
va_list args; |
va_start(foo,args); |
printf(foo,args); |
va_end(args); |
exit(2); |
} |
|
int main() { exit(0); } |
|
], pike_cv_gcc_attributes=yes, pike_cv_gcc_attributes=no, pike_cv_gcc_attributes=no)]) |
|
AC_MSG_RESULT($pike_cv_gcc_attributes) |
if test "$pike_cv_gcc_attributes" = yes; then |
AC_DEFINE(HAVE_FUNCTION_ATTRIBUTES) |
fi |
|
AC_MSG_CHECKING(how to concatenate two symbols) |
AC_CACHE_VAL(pike_cv_cpp_symbol_concat, [ |
AC_TRY_COMPILE([ |
int AABB=0; |
#define CONCAT(X,Y) X##Y |
], [ |
return CONCAT(AA,BB); |
], pike_cv_cpp_symbol_concat=ANSI, [ |
AC_TRY_COMPILE([ |
int AABB=0; |
#define CONCAT(X,Y) X/**/Y |
], [ |
return CONCAT(AA,BB); |
], pike_cv_cpp_symbol_concat=KR, [ |
pike_cv_cpp_symbol_concat=Unknown |
]) |
]) |
]) |
AC_MSG_RESULT($pike_cv_cpp_symbol_concat) |
case "$pike_cv_cpp_symbol_concat" in |
"ANSI") |
AC_DEFINE(HAVE_ANSI_CONCAT) |
;; |
"KR") |
AC_DEFINE(HAVE_KR_CONCAT) |
;; |
esac |
|
############################################################################# |
|
AC_MSG_CHECKING(how to set things nonblocking) |
AC_CACHE_VAL(pike_cv_sys_nonblock, |
[ |
# Kludge needed for AmigaOS |
if test "$pike_cv_sys_os" = "AmigaOS" ; then |
pike_cv_sys_nonblock=USE_FCNTL_O_NONBLOCK |
else |
AC_TRY_RUN([ |
#define TESTING |
#define USE_FCNTL_FNDELAY |
#include "$srcdir/fd_control.c" |
], pike_cv_sys_nonblock=USE_FCNTL_FNDELAY, |
AC_TRY_RUN([ |
#define TESTING |
#define USE_FCNTL_O_NDELAY |
#include "$srcdir/fd_control.c" |
], pike_cv_sys_nonblock=USE_FCNTL_O_NDELAY, |
AC_TRY_RUN([ |
#define TESTING |
#define USE_FCNTL_O_NONBLOCK |
#include "$srcdir/fd_control.c" |
], pike_cv_sys_nonblock=USE_FCNTL_O_NONBLOCK, |
AC_TRY_RUN([ |
#define TESTING |
#define USE_IOCTL_FIONBIO |
#include "$srcdir/fd_control.c" |
], pike_cv_sys_nonblock=USE_IOCTL_FIONBIO, |
AC_TRY_RUN([ |
#define TESTING |
#define USE_IOCTLSOCKET_FIONBIO |
#include "$srcdir/fd_control.c" |
], pike_cv_sys_nonblock=USE_IOCTLSOCKET_FIONBIO, |
unset pike_cv_sys_nonblock, |
unset pike_cv_sys_nonblock), |
unset pike_cv_sys_nonblock), |
unset pike_cv_sys_nonblock), |
unset pike_cv_sys_nonblock), |
unset pike_cv_sys_nonblock) |
fi |
]) |
|
if test "${pike_cv_sys_nonblock}" = ""; then |
AC_MSG_RESULT(none found) |
else |
AC_MSG_RESULT($pike_cv_sys_nonblock) |
AC_DEFINE_UNQUOTED($pike_cv_sys_nonblock) |
fi |
|
rm -f core |
|
########################################################################## |
|
# Set info about shared libraries. |
AC_SUBST(SO) |
AC_SUBST(LDSHARED) |
AC_SUBST(CCSHARED) |
AC_SUBST(LINKFORSHARED) |
|
# SO is the extension of shared libraries |
# -- usually so, sl on HP-UX |
AC_MSG_CHECKING(SO) |
if test -z "$SO" |
then |
case "$pike_cv_sys_os" in |
hp*|HP*) SO=sl;; |
*) SO=so;; |
esac |
fi |
AC_MSG_RESULT($SO) |
# LDSHARED is the ld *command* used to create shared library |
# -- "ld" on SunOS 4.x.x, "ld -G" on SunOS 5.x, "ld -shared" on IRIX 5 |
AC_MSG_CHECKING(LDSHARED) |
if test -z "$LDSHARED" ; then |
case "$pike_cv_sys_os" in |
AIX*) |
if test "$GCC" = yes ; then |
if test "`uname -r`" -ge 2 -a "`uname -v`" -ge 4 ; then |
LDSHARED="ld -G -bexpall" |
else if test "`uname -v`" -gt 4 ; then |
# Extra forward compatibility... |
# AIX 5+ |
LDSHARED="ld -G -bexpall" |
else |
# AIX 4.1 and earlier don't have/have unreliable |
# handling of dlopen et al. |
# |
# Even AIX 4.2.1 has buggy dlopen -- NEVER attempt |
# to dlopen a file that hasn't been linked with -G. |
pike_cv_sys_dynamic_loading=no |
LDSHARED="ld" |
fi |
fi |
else |
# Dynamic linking turned off for AIX-cc |
# |
# In addition, the dynamic loading test seems to |
# cause our RS/6000 to hang, which causes the |
# watchdog-timer to PANIC. |
pike_cv_sys_dynamic_loading=no |
LDSHARED="ld" |
fi |
;; |
IRIX*) |
if test "$GCC" = yes ; then |
# egcs defaults to building -n32 objects |
LDSHARED="ld -shared -n32" |
else |
LDSHARED="ld -shared" |
fi |
# -woff isn't understood by ld on Irix 5. |
if test "`uname -r`" -ge 6 ; then |
LDSHARED="$LDSHARED -woff 84,85,134" |
else :; fi |
;; |
SunOS*) LDSHARED="ld";; |
Solaris) LDSHARED="/usr/ccs/bin/ld -G";; |
hp*|HP*) LDSHARED="ld -b";; |
OSF*) LDSHARED="ld -expect_unresolved '*' -shared -msym -O3";; |
DYNIX/ptx*) LDSHARED="ld -G";; |
next) LDSHARED="$CC $CFLAGS -nostdlib -r";; |
Linux*) LDSHARED="$CC -shared";; |
GNU*) LDSHARED="ld -Bshareable";; |
FreeBSD*) LDSHARED="ld -Bshareable";; |
NetBSD) LDSHARED="ld -Bshareable";; |
OpenBSD*) LDSHARED="ld -Bshareable";; |
BSD/OS*) LDSHARED="shlicc -r";; |
SCO_SV*) LDSHARED="cc -G -KPIC -Wl,-Bexport";; |
UNIX_SV) LDSHARED="ld -G";; |
UnixWare) |
if test "$GCC" = yes ; then |
LDSHARED="ld -G" |
else |
LDSHARED="cc -G -KPIC -Wl,-Bexport" |
fi |
;; |
Windows_NT*) LDSHARED="$CC -shared";; |
*) LDSHARED="ld";; |
esac |
fi |
AC_MSG_RESULT($LDSHARED) |
|
# CCSHARED are the C *flags* used to create objects to go into a shared |
# library -- this is only needed for a few systems |
AC_MSG_CHECKING(CCSHARED) |
if test -z "$CCSHARED" ; then |
if test "$GCC" = yes ; then |
case $pike_cv_sys_os in |
BSD/OS*) CCSHARED="";; |
*) CCSHARED="-fpic";; |
esac |
else |
case $pike_cv_sys_os in |
hp*|HP*) CCSHARED="+z"; ;; |
FreeBSD*) CCSHARED="-fpic";; |
SCO_SV*) CCSHARED="-KPIC -dy -Bdynamic";; |
Solaris*) CCSHARED="-KPIC -Bdynamic";; |
Windows_NT*) CCSHARED="-shared" ;; |
esac |
fi |
fi |
AC_MSG_RESULT($CCSHARED) |
|
AC_MSG_CHECKING(LINKFORSHARED) |
|
AC_CACHE_VAL(pike_cv_sys_linkforshared,[ |
# LINKFORSHARED are the flags passed to the $(CC) command that links |
# the pike executable -- this is only needed for a few systems |
if test -z "$LINKFORSHARED" |
then |
LINKFORSHARED="" |
if test "$GCC" = yes ; then |
case $pike_cv_sys_os in |
AIX*) LINKFORSHARED="-Wl,-bexpall -Wl,-brtl";; |
hp*|HP*) LINKFORSHARED="-Wl,-E";; |
Linux*) LINKFORSHARED="-rdynamic";; |
GNU*) LINKFORSHARED="-rdynamic";; |
next) LINKFORSHARED="-u libsys_s";; |
SCO_SV*) LINKFORSHARED="-fpic -Wl,-Bexport";; |
# What about UNIX_SV? |
UnixWare) LINKFORSHARED="-fpic -Wl,-Bexport";; |
|
FreeBSD) |
AC_TRY_RUN([int main(){exit( |
#ifdef __ELF__ |
0 |
#else |
1 |
#endif |
);} |
],LINKFORSHARED=-rdynamic) |
;; |
esac |
else |
case $pike_cv_sys_os in |
AIX*) LINKFORSHARED="-Wl,-bexpall -Wl,-brtl";; |
hp*|HP*) LINKFORSHARED="-Wl,-E";; |
Linux*) LINKFORSHARED="-rdynamic";; |
GNU*) LINKFORSHARED="-rdynamic";; |
next) LINKFORSHARED="-u libsys_s";; |
SCO_SV*) LINKFORSHARED="-Bdynamic -dy -Wl,-Bexport";; |
# What about UNIX_SV? |
UnixWare) LINKFORSHARED="-Bdynamic -dy -Wl,-Bexport";; |
esac |
fi |
fi |
|
|
OLD_CFLAGS="$CFLAGS" |
CFLAGS="$CFLAGS $LINKFORSHARED" |
AC_TRY_RUN([int main() { exit(0); }], |
pike_cv_sys_linkforshared="$LINKFORSHARED", pike_cv_sys_linkforshared='', pike_cv_sys_linkforshared='') |
CFLAGS="$OLD_CFLAGS" |
]) |
|
LINKFORSHARED="$pike_cv_sys_linkforshared" |
|
AC_MSG_RESULT($LINKFORSHARED) |
|
############################################################################# |
|
cat >conftest.c <<EOF |
#include <stdio.h> |
void testfunc(void) { |
fprintf(stderr,"Calling testfunc2\n"); |
testfunc2(); |
fprintf(stderr,"testfunc2 returned!\n"); |
exit(1); |
} |
EOF |
|
AC_MSG_CHECKING(if dynamic loading works) |
AC_CACHE_VAL(pike_cv_sys_dynamic_loading, |
[ |
echo $CC -c $CFLAGS $CCSHARED conftest.c -o conftest.o 1>&5 |
$CC -c $CFLAGS $CCSHARED conftest.c -o conftest.o 1>&5 2>&5 |
|
echo $BINDIR/smartlink $LDSHARED $LDFLAGS conftest.o -o conftest.$SO 1>&5 |
$BINDIR/smartlink $LDSHARED $LDFLAGS conftest.o -o conftest.$SO 1>&5 2>&5 |
|
if test -f conftest.$SO ; then |
mv conftest.$SO myconftest.so |
|
OLD_CFLAGS="$CFLAGS" |
CFLAGS="$CFLAGS $LINKFORSHARED" |
OLD_CC="$CC" |
case "$LD" in |
*shlicc) |
CC="$BINDIR/smartlink shlicc" |
;; |
esac |
AC_TRY_RUN([ |
#define TESTING |
#include "$srcdir/dynamic_load.c" |
void testfunc2(void) { exit(0); } |
], pike_cv_sys_dynamic_loading=yes, pike_cv_sys_dynamic_loading=no, pike_cv_sys_dynamic_loading=no) |
CFLAGS="$OLD_CFLAGS" |
CC="$OLD_CC" |
else |
pike_cv_sys_dynamic_loading=no |
fi |
rm -f myconftest.so >/dev/null 2>/dev/null |
]) |
AC_MSG_RESULT($pike_cv_sys_dynamic_loading) |
|
if test x$pike_cv_sys_dynamic_loading = xno ; then |
with_dynamic_modules=no |
fi |
|
# |
# Since configure doesn't always know if we will be linking with ld or cc, |
# We use this little code snippet to add flags to ld that would otherwise |
# be given automatically by $(CC) $(CFLAGS) |
# /Hubbe |
# |
|
case "x$LD" in |
$CC*) |
# Options in CFLAGS, no stuff needs to be added |
;; |
*) |
LD="${LD} ${LD_FALLBACK_FLAGS-}" |
;; |
esac |
|
|
|
############################################################################# |
|
echo |
echo "Compiler summary:" |
echo |
echo "C Compiler: $CC" |
echo "Linker: $LD" |
echo "Shared linker: $LDSHARED" |
echo |
echo "Shared object extension: $SO" |
echo |
echo "CPPFLAGS: $CPPFLAGS" |
echo "CFLAGS: $CFLAGS" |
echo "CCSHARED: $CCSHARED" |
echo "LINKFORSHARED: $LINKFORSHARED" |
echo "LIBGCC: $LIBGCC" |
echo "WARN: $WARN" |
echo "OPTIMIZE: $OPTIMIZE" |
echo "LDFLAGS: $LDFLAGS" |
echo "LIBS: $LIBS" |
echo "prefix: $prefix" |
echo |
|
############################################################################# |
|
export LDFLAGS CFLAGS CPPFLAGS LIBS |
|
AC_CONFIG_SUBDIRS(modules) |
|
my_libdir=`echo $prefix | sed "s@^NONE@$ac_default_prefix@g"` |
default_master=$my_libdir/lib/pike/master.pike |
AC_DEFINE_UNQUOTED(DEFAULT_MASTER,"$default_master") |
|
AC_SUBST_FILE(dependencies) |
dependencies=$srcdir/dependencies |
|
AC_SUBST(YACC) |
AC_SUBST(INSTALL) |
AC_SUBST(WARN) |
AC_SUBST(OPTIMIZE) |
AC_SUBST(EXTRA_OBJS) |
AC_SUBST(RANLIB) |
AC_SUBST(DEBUGDEF) |
AC_SUBST(ac_configure_args) |
pike_cv_prog_CC="${CC}" |
|
if test x$ac_cv_func_dlopen$ac_cv_func_dld_link$ac_cv_func_shl_load = xnonono; |
then |
if test x$pike_cv_sys_os != xWindows_NT ; then |
with_dynamic_modules=no |
fi |
fi |
|
if test x$with_dynamic_modules = xyes ; then |
dmmsrc="modules/dynamic_module_makefile.in" |
else |
dmmsrc="modules/static_module_makefile.in" |
fi |
|
AC_SUBST(dmmsrc) |
|
AC_OUTPUT(Makefile modules/static_module_makefile modules/dynamic_module_makefile:$dmmsrc,[echo foo >stamp-h]) |
|
|
|