AC_REVISION("$Id: configure.in,v 1.39 1997/01/12 00:35:51 grubba Exp $") |
AC_INIT(interpret.c) |
AC_CONFIG_HEADER(machine.h) |
|
if test "x${CFLAGS-}" = x ; then |
cflags_is_set=no |
else |
cflags_is_set=yes |
fi |
|
if test "x${CPPFLAGS-}" = x ; then |
cppflags_is_set=no |
else |
cppflags_is_set=yes |
fi |
|
if test "x${LDFLAGS-}" = x ; then |
ldflags_is_set=no |
else |
ldflags_is_set=yes |
fi |
|
AC_PROG_CC |
AC_C_CROSS |
|
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 |
|
############################################################################# |
|
# 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`" |
|
if test "$pike_cv_sys_os" = "SunOS"; then |
case "`uname -r`" in |
5.*) pike_cv_sys_os="Solaris"; |
esac |
fi |
else |
pike_cv_sys_os="Not Solaris" |
fi |
]) |
AC_MSG_RESULT($pike_cv_sys_os) |
|
############################################################################# |
|
|
WARN="" |
OPTIMIZE="" |
if test $cflags_is_set = no; then |
if test "x${GCC-}" = xyes ; then |
WARN="-W -Wformat" |
else |
OLD_CFLAGS="$CFLAGS" |
OPTIMIZE=""; |
|
AC_MSG_CHECKING(-fast) |
AC_CACHE_VAL(pike_cv_option_fast, |
[ |
CFLAGS="$OLD_CFLAGS -fast" |
AC_TRY_LINK([],[ exit(0); ],pike_cv_option_fast=yes,pike_cv_option_fast=no) |
]) |
|
CFLAGS="$OLD_CFLAGS" |
|
if test "$pike_cv_option_fast" = "yes" ; then |
OPTIMIZE="$OPTIMIZE -fast" |
AC_MSG_RESULT(-fast found) |
else |
AC_MSG_RESULT(-fast not found) |
|
case "${CFLAGS-}" in |
*-O*) ;; |
*) |
AC_MSG_CHECKING(-O) |
AC_CACHE_VAL(pike_cv_option_opt, |
[ |
CFLAGS="$OLD_CFLAGS -O" |
AC_TRY_LINK([],[ exit(0); ],pike_cv_option_opt=yes,pike_cv_option_opt=no) |
]) |
|
if test "$pike_cv_option_opt" = "yes" ; then |
CFLAGS="$OLD_CFLAGS -O" |
OPTIMIZE="$OPTIMIZE -O" |
AC_MSG_RESULT(-O found) |
else |
AC_MSG_RESULT(-O not found) |
fi |
|
CFLAGS="$OLD_CFLAGS" |
;; |
esac |
fi |
fi |
fi |
|
|
|
if test "$GCC" = "yes"; then |
if test $cflags_is_set = no; then |
AC_MSG_CHECKING(-pipe) |
OLD_CFLAGS="$CFLAGS" |
CFLAGS="$CFLAGS -pipe" |
AC_CACHE_VAL(pike_cv_option_pipe, |
[ |
AC_TRY_LINK([],[ exit(0); ],pike_cv_option_pipe=yes,pike_cv_option_pipe=no) |
]) |
|
if test "$pike_cv_option_pipe" = "yes" ; then |
AC_MSG_RESULT(-pipe found) |
else |
AC_MSG_RESULT(-pipe not found) |
CFLAGS="$OLD_CFLAGS" |
fi |
fi |
else |
# |
# Special hack for HP-UX stupid cc |
# |
if test "$pike_cv_sys_os" = "HP-UX"; then |
AC_TRY_LINK([int foo(int bar);],[ exit(0); ],[], |
[ |
OLD_CC="${CC-cc}" |
if test "$CC" = "cc" -a -x /usr/bin/cc ; then |
CC=/usr/bin/cc |
fi |
CC="$CC -Aa -D_HPUX_SOURCE +Olibcalls" |
AC_TRY_LINK([int foo(int bar);],[ exit(0); ],[],[CC="$OLD_CC"]) |
]) |
fi |
fi |
|
AC_MSG_CHECKING(if ld accepts setting the run-time path with -R) |
AC_CACHE_VAL(pike_cv_ld_accepts_r, |
[ |
OLD_CFLAGS="$CFLAGS" |
|
CFLAGS="$CFLAGS -R." |
AC_TRY_LINK([],[ exit(0); ],[ |
pike_cv_ld_accepts_r=yes |
],[ pike_cv_ld_accepts_r=no ]) |
CFLAGS="$OLD_CFLAGS" |
]) |
AC_MSG_RESULT($pike_cv_ld_accepts_r) |
|
if test x$pike_cv_ld_accepts_r = xyes ; then |
SET_RUN_PATH='`cat modules/lib_dirs`' |
else |
: |
fi |
|
# |
# If no cppflags or ldflags where given we try to guess some.. |
# |
# This doesn't work since we have to test if the linker accepts |
# -R first... :( /Hubbe |
# |
# Since I just added a test for -R above, maybe it's time to enable |
# this code again. /grubba |
# |
if test -f modules/master_lib_dirs; then |
rm modules/master_lib_dirs |
else : ; fi |
if test $cppflags_is_set$ldflags_is_set = nono -a x${C_INCLUDE_PATH-} = x ; then |
for d in /usr/gnu /opt/gnu /usr/local /sw/gnu /sw |
do |
if test -d "$d/lib" ; then |
echo Adding $d/lib to the library-path |
LDFLAGS="${LDFLAGS} -L$d/lib" |
echo $d/lib >>modules/master_lib_dirs |
fi |
|
if test -d "$d/include" ; then |
echo Adding $d/include to the include-path |
CPPFLAGS="${CPPFLAGS} -I$d/include" |
fi |
done |
export LDFLAGS CPPFLAGS |
fi |
|
############################################################################# |
|
AC_MSG_CHECKING(ansi prototype capability) |
AC_CACHE_VAL(pike_cv_sys_ansi_prototypes, |
[ |
AC_TRY_LINK([int foo(int bar);],[ exit(0); ], |
[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 |
|
############################################################################# |
|
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 "Get bison if you want to make export" ; 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" |
AC_MSG_RESULT($YACC) |
|
############################################################################# |
|
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 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 dlfcn.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) |
|
if test "${ac_cv_lib_m}" = "no" -a "${pike_cv_sys_os}" = "Linux"; then |
AC_MSG_WARN(I will compensate for this by adding -lc -lm) |
LIBS="${LIBS} -lc -lm" |
fi |
|
######################################################################## |
|
if test x$with_threads = xyes ; then |
|
AC_MSG_CHECKING(posix threads) |
|
OLDLIBS="$LIBS" |
|
case "x$pike_cv_sys_os" in |
xOSF1) |
LIBS="${LIBS} -lpthread -lmach -lexc -lc" |
;; |
|
*) |
LIBS="${LIBS} -lpthread" |
;; |
esac |
|
AC_CACHE_VAL(pike_cv_posix_threads, |
[ |
AC_TRY_RUN([ |
#define _REENTRANT |
#define _THREAD_SAFE |
#define _MIT_POSIX_THREADS |
|
#include <pthread.h> |
|
void *foo(void *bar) { return ; } |
pthread_mutex_t tmp; |
pthread_t gazonk; |
|
int main() |
{ |
void *sune; |
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) |
AC_CHECK_FUNCS(pthread_attr_setstacksize) |
else |
AC_MSG_RESULT(no) |
LIBS="$OLDLIBS" |
fi |
|
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 \ |
getenv \ |
getrlimit \ |
getrusage \ |
gettimeofday \ |
index \ |
localtime \ |
memchr \ |
memcpy \ |
memset \ |
rindex \ |
setlocale \ |
setrlimit \ |
sigaction \ |
sigvec \ |
strcasecmp \ |
strchr \ |
strcspn \ |
strrchr \ |
strtod \ |
strtok \ |
strtol \ |
times \ |
vfprintf \ |
vsprintf \ |
wait3 \ |
wait4 \ |
waitpid \ |
munmap \ |
dlopen \ |
dlsym \ |
) |
|
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_LINK([ |
#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) |
|
|
AC_MSG_CHECKING(return type of free) |
AC_CACHE_VAL(pike_cv_sys_free_return, |
[AC_TRY_LINK([ |
#ifdef HAVE_STDLIB_H |
#include <stdlib.h> |
#endif |
|
#ifdef HAVE_UNISTD_H |
#include <unistd.h> |
#endif |
|
#if !defined(STDC_HEADERS) && defined(HAVE_MEMORY_H) |
#include <memory.h> |
#endif |
char foo; |
|
], |
[ |
foo=free(malloc(2))[0]; |
], |
pike_cv_sys_free_return='char *' |
, |
pike_cv_sys_free_return='void' |
)]) |
|
if test "$pike_cv_sys_free_return" = void; then |
AC_DEFINE(FREE_RETURNS_VOID) |
AC_MSG_RESULT([void]); |
else |
AC_MSG_RESULT([not void]) |
fi |
|
AC_MSG_CHECKING([void* or char* from malloc]) |
AC_CACHE_VAL(pike_cv_sys_malloc_return, |
[ |
AC_TRY_LINK([ |
#include <sys/types.h> |
|
#ifdef HAVE_STDLIB_H |
#include <stdlib.h> |
#endif |
|
#ifdef HAVE_UNISTD_H |
#include <unistd.h> |
#endif |
|
#if !defined(STDC_HEADERS) && defined(HAVE_MEMORY_H) |
#include <memory.h> |
#endif |
|
char foo; |
], |
[ |
foo=malloc(2)[0]; |
], |
pike_cv_sys_malloc_return="char *" |
, |
pike_cv_sys_malloc_return="void *" |
)]) |
|
AC_MSG_RESULT($pike_cv_sys_malloc_return) |
AC_DEFINE_UNQUOTED(POINTER,$pike_cv_sys_malloc_return) |
|
|
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_LINK([ |
#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(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) |
|
######################################################################## |
|
AC_MSG_CHECKING(for working memmem) |
AC_CACHE_VAL(pike_cv_func_memmem, |
[ |
AC_TRY_RUN([ |
#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); |
} |
],pike_cv_func_memmem=yes,pike_cv_func_memmem=no)]) |
|
if test "$pike_cv_func_memmem" = yes; then |
AC_MSG_RESULT(yes) |
AC_DEFINE(HAVE_MEMMEM) |
else |
AC_MSG_RESULT(no) |
fi |
|
AC_MSG_CHECKING(for working memmove) |
AC_CACHE_VAL(pike_cv_func_memmove, |
[ |
AC_TRY_RUN([ |
#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); |
} |
],pike_cv_func_memmove=yes,pike_cv_func_memmove=no)]) |
|
if test "$pike_cv_func_memmove" = yes; then |
AC_MSG_RESULT(yes) |
AC_DEFINE(HAVE_MEMMOVE) |
else |
AC_MSG_RESULT(no) |
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)]) |
|
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 |
|
######################################################################## |
|
AC_MSG_CHECKING(getrusage() through procfs) |
AC_CACHE_VAL(pike_cv_getrusage_procfs, |
[ |
AC_TRY_LINK([ |
#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 |
|
|
AC_MSG_CHECKING(for isspace) |
AC_CACHE_VAL(pike_cv_have_func_isspace, |
[ |
AC_TRY_LINK([ |
#include <ctype.h> |
],[ |
if(isspace(' ')) exit(0); |
], |
pike_cv_have_func_isspace=yes |
, |
pike_cv_have_func_isspace=no |
)]) |
|
if test "$pike_cv_have_func_isspace" = yes; then |
AC_MSG_RESULT(yes) |
AC_DEFINE(HAVE_FUNC_ISSPACE) |
else |
AC_MSG_RESULT(no) |
fi |
|
|
|
AC_MSG_CHECKING(checking for volatile) |
AC_CACHE_VAL(pike_cv_volatile, |
[ |
AC_TRY_LINK([],[ 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 set things nonblocking) |
AC_CACHE_VAL(pike_cv_sys_nonblock, |
[ |
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 |
))))]) |
|
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 |
|
LIBDIR=`(cd $srcdir/../lib ; pwd)` |
BINDIR=`(cd $srcdir/../bin ; pwd)` |
DOCDIR=`(cd $srcdir/../doc ; pwd)` |
BUILDDIR=`pwd` |
|
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(YACC) |
AC_SUBST(INSTALL) |
AC_SUBST(WARN) |
AC_SUBST(OPTIMIZE) |
AC_SUBST(EXTRA_OBJS) |
AC_SUBST(RANLIB) |
AC_SUBST(LIBDIR) |
AC_SUBST(BINDIR) |
AC_SUBST(BUILDDIR) |
AC_SUBST(DOCDIR) |
AC_SUBST(DEBUGDEF) |
AC_SUBST(SET_RUN_PATH) |
|
AC_OUTPUT(Makefile,[echo foo >stamp-h]) |
|
|
|