AC_REVISION("$Id: configure.in,v 1.123 1997/09/26 01:27:44 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" -a ! -z "$CC" -a "$CC" != "$pike_cv_prog_CC" |
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="$CC" |
|
AC_PROG_CC |
AC_ISC_POSIX |
AC_MINIX |
|
############################################################################# |
|
LIBDIR=`(cd $srcdir/../lib ; pwd)` |
BINDIR=`(cd $srcdir/../bin ; pwd)` |
DOCDIR=`(cd $srcdir/../doc ; pwd)` |
BUILDDIR=`pwd` |
AC_SUBST(LIBDIR) |
AC_SUBST(BINDIR) |
AC_SUBST(BUILDDIR) |
AC_SUBST(DOCDIR) |
|
case $CC in |
*smartlink*) ;; |
*) |
CC="$BINDIR/smartlink $CC" |
ac_cv_prog_CC="$CC" |
;; |
esac |
|
############################################################################# |
|
|
|
AC_ARG_WITH(dynamic_modules, [ --without-dynamic-modules link modules statically],[],[with_dynamic_modules=yes]) |
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 time self tests],[],[with_debug=yes]) |
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]) |
|
if test x$with_debug = xyes ; then |
AC_DEFINE(DEBUG) |
fi |
|
############################################################################# |
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) |
|
case "$pike_cv_sys_os" in |
SCO*) |
case "$CC" in |
*-belf*) ;; |
*) |
CC="$CC -belf" |
;; |
esac |
;; |
esac |
|
############################################################################# |
|
|
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) |
]) |
|
CFLAGS="[$]OLD_CFLAGS" |
|
if test x"[$]pike_cv_option_$2" = "xyes" ; then |
OPTIMIZE="[$]OPTIMIZE $1" |
AC_MSG_RESULT(yes) |
else |
AC_MSG_RESULT(no) |
fi |
]) |
|
AC_DEFUN(AC_SYS_CPU_COMPILER_FLAG, |
[ |
if test "`uname -m 2>/dev/null`" = "$1" ; then |
AC_SYS_COMPILER_FLAG($2,$3) |
fi |
]) |
|
AC_DEFUN(AC_SYS_OS_COMPILER_FLAG, |
[ |
if test "x$pike_cv_sys_os" = "x$1" ; then |
AC_SYS_COMPILER_FLAG($2,$3) |
fi |
]) |
|
WARN="" |
OPTIMIZE="" |
|
if test $cflags_is_set = no; then |
if test "x${GCC-}" = xyes ; then |
WARN="-W -Wall -Wpointer-arith -Wno-unused" |
### Optimize for different SUN machines. If there is no working 'uname' |
### no extra optimization will be done, but nothing should break either. |
AC_SYS_CPU_COMPILER_FLAG(sun4c,-msparclite,sparclite) |
AC_SYS_CPU_COMPILER_FLAG(sun4m,-mv8,microsparc) |
AC_SYS_CPU_COMPILER_FLAG(sun4d,-msupersparc,supersparc) |
AC_SYS_CPU_COMPILER_FLAG(sun4u,-msupersparc,ultrasparc) |
else |
|
### Non-gcc thingies. This should probably be enhanced... |
|
# HP-UX |
AC_SYS_OS_COMPILER_FLAG(HP-UX,+Odataprefetch,plus_Odataprefetch) |
AC_SYS_OS_COMPILER_FLAG(HP-UX,+Ofailsafe,plus_Ofailsafe) |
AC_SYS_OS_COMPILER_FLAG(HP-UX,+O3,plus_O3) |
# Ignore warnings 530 and 414 if you turn this on. |
# AC_SYS_OS_COMPILER_FLAG(HP-UX,+w1,plus_w1) |
|
# OSF/1 |
AC_SYS_OS_COMPILER_FLAG(OSF1,-fast,fast) |
AC_SYS_OS_COMPILER_FLAG(OSF1,-g3,g3) |
AC_SYS_OS_COMPILER_FLAG(OSF1,-std1,std1) |
AC_SYS_OS_COMPILER_FLAG(OSF1,-host,host) |
AC_SYS_OS_COMPILER_FLAG(OSF1,-warnprotos,warnprotos) |
|
# IRIX |
# sopt disabled since it takes too long time on interpret.c (>45min on an O²) |
# AC_SYS_OS_COMPILER_FLAG(IRIX,-sopt,sopt) |
|
# -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_OS_COMPILER_FLAG(IRIX,-n32,n32) |
AC_SYS_OS_COMPILER_FLAG(IRIX,-g3,g3) |
AC_SYS_OS_COMPILER_FLAG(IRIX,-fullwarn,fullwarn) |
if test x$with_debug = xyes ; then |
AC_SYS_OS_COMPILER_FLAG(IRIX,-trapuw,trapuw) |
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) |
dnl |
|
dnl ### Ok. This is for apcc... |
case "$CC" in |
*apcc) |
AC_SYS_COMPILER_FLAG(-XO=5,apcc_opt) |
AC_SYS_COMPILER_FLAG(-Xcallmod=2,apcc_opt_2) |
;; |
esac |
|
|
AC_SYS_CPU_COMPILER_FLAG(sun4m,-Xpipe=micro,microsparc) |
AC_SYS_CPU_COMPILER_FLAG(sun4d,-Xpipe=super,supersparc) |
AC_SYS_CPU_COMPILER_FLAG(sun4u,-Xpipe=super,ultrasparc) |
|
case "${CFLAGS-} $OPTIMIZE" in |
*-O*) ;; |
*+O*) ;; |
*-fast*) ;; |
*) |
AC_SYS_COMPILER_FLAG(-O2,O2) |
if test "x$pike_cv_option_O2" != "xyes"; then |
AC_SYS_COMPILER_FLAG(-O,O) |
fi |
;; |
esac |
fi |
fi |
|
|
|
if test "$GCC" = "yes"; then |
if test $cflags_is_set = no; then |
AC_SYS_COMPILER_FLAG(-pipe, pipe) |
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="$BINDIR/smartlink /usr/bin/cc" |
fi |
CFLAGS="-Aa -D_HPUX_SOURCE +Olibcalls $CFLAGS" |
AC_TRY_COMPILE([int foo(int bar);],[],[],[ |
CC="$OLD_CC" |
CFLAGS="$OLD_CFLAGS" |
]) |
]) |
fi |
fi |
|
if test "$pike_cv_sys_os" = "Solaris" ; then |
AC_DEFINE(SOLARIS) |
fi |
|
if test ! -d modules/. ; then |
mkdir modules |
fi |
if test $cppflags_is_set$ldflags_is_set = nono -a x${C_INCLUDE_PATH-} = x ; then |
for d in /usr/local /usr/gnu /opt/gnu /sw/gnu /home/GNU /sw /usr/freeware |
do |
if test -d "$d/lib" ; then |
echo Adding $d/lib to the library-path |
LDFLAGS="${LDFLAGS} -R$d/lib -L$d/lib" |
else |
: |
fi |
|
if test -d "$d/include" ; then |
echo Adding $d/include to the include-path |
CPPFLAGS="${CPPFLAGS} -I$d/include" |
else |
: |
fi |
done |
else |
: |
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 |
|
|
############################################################################# |
|
AC_PROG_INSTALL |
AC_PROG_CPP |
AC_PROG_RANLIB |
AC_SET_MAKE |
|
############################################################################# |
|
# 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 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) |
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_TRY_COMPILE([ |
const int foo(int bar) { return bar; } |
], [ |
return bar(0); |
], [], [ |
ac_cv_c_const=no |
AC_DEFINE(const, []) |
]) |
AC_MSG_RESULT($ac_cv_c_const) |
fi |
|
############################################################################# |
|
AC_MSG_CHECKING(first yacc define) |
AC_CACHE_VAL(pike_cv_yacc_first, |
[ |
cat >conftest.y <<\EOF |
%token GURKA |
%% |
all: GURKA |
%% |
EOF |
pike_cv_yacc_first=257; |
if $YACC -d conftest.y 1>&5 2>&5; then |
if test -f y.tab.h; then |
pike_cv_yacc_first=`egrep GURKA y.tab.h | sed 's/^#[^0-9]*\([0-9]*\)[^0-9]*$/\1/'` |
echo $pike_cv_yacc_first >conftest.out |
if egrep '^(0|1|2|3|4|5|6|7|8|9)+$' conftest.out >/dev/null 2>&1; then |
echo >/dev/null |
else |
pike_cv_yacc_first=257 |
fi |
fi |
fi |
]) |
AC_MSG_RESULT($pike_cv_yacc_first) |
AC_DEFINE_UNQUOTED(F_OFFSET,$pike_cv_yacc_first) |
|
rm -rf conftest.y y.tab.c y.tab.h conftest.out |
|
############################################################################# |
|
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 sys/times.h sched.h sys/procfs.h) |
|
AC_SIZEOF_TYPE(char *) |
AC_SIZEOF_TYPE(long) |
AC_SIZEOF_TYPE(int) |
AC_SIZEOF_TYPE(short) |
AC_SIZEOF_TYPE(float) |
AC_SIZEOF_TYPE(double) |
|
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(dl, dlopen) |
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" |
|
AC_MSG_CHECKING(unix threads) |
case "x$pike_cv_sys_os" in |
*) |
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> |
|
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) |
]) |
|
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) |
|
# Test for POSIX threads instead |
|
AC_MSG_CHECKING(posix threads) |
|
case "x$pike_cv_sys_os" in |
xOSF1) |
LIBS="${OLDLIBS} -lpthread -lmach -lexc -lc" |
;; |
|
*) |
LIBS="${OLDLIBS} -lpthread" |
;; |
esac |
|
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; |
pthread_mutexattr_init(&attr); |
pthread_mutex_init(&tmp, &attr); |
pthread_mutex_lock(&tmp); |
pthread_create(&gazonk,0,foo,0); |
pthread_join(gazonk,&sune); |
exit(0); |
} |
],pike_cv_posix_threads=yes,pike_cv_posix_threads=no) |
]) |
|
if test $pike_cv_posix_threads = yes ; then |
AC_MSG_RESULT(yes) |
AC_DEFINE(_REENTRANT) |
AC_DEFINE(_THREAD_SAFE) |
AC_DEFINE(_MIT_POSIX_THREADS,1) |
|
AC_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 |
else |
AC_MSG_RESULT(no) |
LIBS="$OLDLIBS" |
|
# 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 |
fi |
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 \ |
bcopy \ |
bzero \ |
clock \ |
crypt \ |
fchmod \ |
gethrtime \ |
gethrvtime \ |
getenv \ |
getrlimit \ |
getrusage \ |
gettimeofday \ |
index \ |
localtime \ |
memchr \ |
memcpy \ |
memset \ |
mktime \ |
rindex \ |
setlocale \ |
setrlimit \ |
sigaction \ |
sigvec \ |
strcasecmp \ |
strchr \ |
strcspn \ |
strerror \ |
strrchr \ |
strtod \ |
strtok \ |
strtol \ |
times \ |
vfprintf \ |
vsprintf \ |
wait3 \ |
wait4 \ |
waitpid \ |
munmap \ |
dld_link \ |
dld_get_func \ |
pipe \ |
) |
|
if test $ac_cv_func_crypt$ac_cv_func__crypt = nono ; then |
AC_CHECK_LIB(crypt,crypt,[LIBS="${LIBS} -lcrypt" ; AC_DEFINE(HAVE_CRYPT)]) |
fi |
|
|
AC_STRUCT_TM |
|
############################################################################# |
AC_MSG_CHECKING(working strcoll) |
AC_CACHE_VAL(pike_cv_func_strcoll, |
[ |
AC_TRY_RUN([ |
#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); |
} |
],pike_cv_func_strcoll=yes,pike_cv_func_strcoll=no) |
]) |
|
if test $pike_cv_func_strcoll = yes; then |
AC_DEFINE(HAVE_STRCOLL) |
fi |
|
AC_MSG_RESULT($pike_cv_func_strcoll) |
############################################################################# |
|
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) |
|
############################################################################# |
|
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)]) |
|
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> |
#endif |
#include <time.h> |
#else |
],[ |
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) |
MY_CHECK_HEADERS(popen,stdio.h unistd.h) |
MY_CHECK_HEADERS(getenv,unistd.h stdlib.h) |
MY_CHECK_HEADERS(gethostname,unistd.h netdb.h) |
|
AC_ALLOCA |
|
AC_C_CONST |
AC_C_INLINE |
|
AC_REPLACE_FUNCS(ualarm) |
|
case "$LIBOBJS" in |
*ualarm.o*) ;; |
*) |
AC_DEFINE(HAVE_UALARM) |
AC_MSG_CHECKING(no of arguments to ualarm) |
AC_CACHE_VAL(pike_cv_ualarm_takes_two_args, |
[ |
AC_TRY_COMPILE([ |
#include <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 |
;; |
esac |
|
OLD_LIBOBJS="${LIBOBJS}" |
|
######################################################################## |
AC_MSG_CHECKING(stack direction) |
AC_CACHE_VAL(pike_cv_hardware_stack_direction, |
[ |
AC_TRY_RUN([ |
static int find_stack_direction () |
{ |
static char *addr = NULL; |
char dummy; |
if (addr == NULL) |
{ |
addr = &dummy; |
return find_stack_direction(); |
} |
else |
{ |
if (&dummy > addr) return 1; else return -1; |
} |
} |
|
int main() { exit( find_stack_direction() < 0); } |
],pike_cv_hardware_stack_direction=up,pike_cv_hardware_stack_direction=down) |
]) |
|
AC_MSG_RESULT($pike_cv_hardware_stack_direction) |
if test x$pike_cv_hardware_stack_direction = up ; then |
AC_DEFINE(STACK_DIRECTION, 1) |
else |
AC_DEFINE(STACK_DIRECTION, -1) |
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 |
)]) |
|
AC_MSG_RESULT($pike_cv_hardware_byteorder) |
AC_DEFINE_UNQUOTED(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) |
]) |
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(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(memmem, |
[ |
#include <string.h> |
char *a="foo bar gazonk"; |
char *b="foo"; |
char *c="bar"; |
char *d="gazonk"; |
int main() |
{ |
if(memmem(b,strlen(b),a,strlen(a))!=a || |
memmem(c,strlen(c),a,strlen(a))!=(a+4) || |
memmem(d,strlen(d),a,strlen(a))!=(a+8) || |
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(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)]) |
|
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)]) |
|
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 signal handlers reset automatically) |
AC_CACHE_VAL(pike_cv_sys_signal_oneshot, |
[ |
AC_TRY_RUN([ |
#include <signal.h> |
char 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)]) |
|
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=16384; /* noone needs more */ |
}else{ |
limit=lim.rlim_max; |
if(limit > 16384) limit=16384; |
} |
} |
#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 |
)]) |
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 |
|
######################################################################## |
|
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([ |
#include <sys/procfs.h> |
#include <sys/fcntl.h> |
int proc_fd; |
char proc_name[20]; |
],[ |
sprintf(proc_name, "/proc/%05d", getpid()); |
proc_fd = open(proc_name, O_RDONLY); |
ioctl(proc_fd, PIOCUSAGE, &pru); |
ioctl(proc_fd, PIOCSTATUS, &prs); |
], |
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 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 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); |
} |
main() { exit(0); } |
|
], pike_cv_gcc_attributes=yes, 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([ |
#define AABB 0 |
#define CONCAT(X,Y) X##Y |
], [ |
return CONCAT(AA,BB); |
], pike_cv_cpp_symbol_concat=ANSI, [ |
AC_TRY_COMPILE([ |
#define 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, |
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*) |
# LDSHARED="ld_so_aix \$(CC)" |
LDSHARED="ld -G -bnogc -bnox" |
;; |
IRIX*) LDSHARED="ld -shared";; |
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="gcc -shared";; |
GNU*) LDSHARED="ld -Bshareable";; |
FreeBSD*) LDSHARED="ld -Bshareable";; |
NetBSD) LDSHARED="ld -Bshareable";; |
OpenBSD*) LDSHARED="ld -Bshareable";; |
SCO_SV*) LDSHARED="cc -G -KPIC -Wl,-Bexport";; |
UNIX_SV) LDSHARED="ld -G";; |
*) 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 |
CCSHARED="-fpic" |
else |
case $pike_cv_sys_os in |
hp*|HP*) CCSHARED="+z"; ;; |
FreeBSD*) CCSHARED="-fpic";; |
SCO_SV*) CCSHARED="-KPIC -dy -Bdynamic";; |
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 |
if test "$GCC" = yes ; then |
case $pike_cv_sys_os in |
# AIX*) LINKFORSHARED="-Wl,-bE:pike.exp";; |
hp*|HP*) LINKFORSHARED="-Wl,-E";; |
Linux*) LINKFORSHARED="-rdynamic";; |
GNU*) LINKFORSHARED="-rdynamic";; |
next) LINKFORSHARED="-u libsys_s";; |
SCO_SV*) LINKFORSHARED="-fpic -Wl,-Bexport";; |
esac |
else |
case $pike_cv_sys_os in |
# AIX*) LINKFORSHARED="-Wl,-bE:pike.exp ";; |
hp*|HP*) LINKFORSHARED="-Wl,-E";; |
Linux*) LINKFORSHARED="-rdynamic";; |
GNU*) LINKFORSHARED="-rdynamic";; |
next) LINKFORSHARED="-u libsys_s";; |
SCO_SV*) 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='') |
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" |
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) |
CFLAGS="$OLD_CFLAGS" |
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 |
|
|
############################################################################# |
|
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) |
|
if test x$ac_cv_func_dlopen$ac_cv_func_dld_link = xnono ; then |
with_dynamic_modules=no |
fi |
|
if test x$with_dynamic_modules = xyes ; then |
dmmsrc="modules/dynamic_module_makefile.in" |
else |
dmmsrc="modules/static_module_makefile.in" |
fi |
|
AC_OUTPUT(Makefile modules/static_module_makefile modules/dynamic_module_makefile:$dmmsrc,[echo foo >stamp-h]) |
|
|
|