AC_REVISION("$Id: configure.in,v 1.140 1997/12/11 23:55:50 grubba 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])
AC_ARG_WITH(profiling, [  --with-profiling       add code used to profile pike code ],[AC_DEFINE(PROFILING)],[])

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 "$CFLAGS" in
       *-belf*) ;;
       *)
	  echo "Adding -belf option."
          CFLAGS="$CFLAGS -belf"
       ;;
     esac
     case "$LDFLAGS" in
       *-belf*) ;;
       *)
	  echo "Adding -belf option."
          LDFLAGS="$LDFLAGS -belf"
       ;;
     esac
  ;;
esac

#############################################################################


# 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)
  ])
  
  CFLAGS="[$]OLD_CFLAGS"
  
  if test x"[$]pike_cv_option_$2" = "xyes" ; then
    $3="[$]$3 $1"
    AC_MSG_RESULT(yes)
  else
    AC_MSG_RESULT(no)
  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)
 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)
 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,OPTIMIZE)
  AC_SYS_CPU_COMPILER_FLAG(sun4m,-mv8,microsparc,OPTIMIZE)
  AC_SYS_CPU_COMPILER_FLAG(sun4d,-msupersparc,supersparc,OPTIMIZE)
  AC_SYS_CPU_COMPILER_FLAG(sun4u,-msupersparc,ultrasparc,OPTIMIZE)
 else

### Non-gcc thingies. This should probably be enhanced...

  # Solaris
  AC_SYS_OS_COMPILER_FLAG(Solaris,-fast,fast,OPTIMIZE)
  AC_SYS_OS_COMPILER_FLAG(Solaris,-xdepend,xdepend,OPTIMIZE)
  AC_SYS_OS_COMPILER_FLAG(Solaris,-xs,xs,CFLAGS)
  # Causes __STDC__ to be 1 which causes several headerfiles to behave
  # differently.
  # AC_SYS_OS_COMPILER_FLAG(Solaris,-Xc,Xc,WARN)

  # HP-UX
  AC_SYS_OS_COMPILER_FLAG(HP-UX,+Odataprefetch,plus_Odataprefetch,OPTIMIZE)
  AC_SYS_OS_COMPILER_FLAG(HP-UX,+Ofailsafe,plus_Ofailsafe,OPTIMIZE)
  AC_SYS_OS_COMPILER_FLAG(HP-UX,+O3,plus_O3,OPTIMIZE)
  # Ignore warnings 530 and 414 if you turn this on.
  # AC_SYS_OS_COMPILER_FLAG(HP-UX,+w1,plus_w1,WARN)

  # OSF/1
  AC_SYS_OS_COMPILER_FLAG(OSF1,-fast,fast,OPTIMIZE)
  AC_SYS_OS_COMPILER_FLAG(OSF1,-g3,g3,OPTIMIZE)
  AC_SYS_OS_COMPILER_FLAG(OSF1,-host,host,OPTIMIZE)
  AC_SYS_OS_COMPILER_FLAG(OSF1,-std1,std1,WARN)
  AC_SYS_OS_COMPILER_FLAG(OSF1,-warnprotos,warnprotos,WARN)

  # IRIX
  # sopt disabled since it takes too long time on interpret.c (>45min on an OČ)
  # AC_SYS_OS_COMPILER_FLAG(IRIX,-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_OS_COMPILER_FLAG(IRIX,-n32,n32,CFLAGS)
  AC_SYS_OS_COMPILER_FLAG(IRIX,-g3,g3,OPTIMIZE)
  AC_SYS_OS_COMPILER_FLAG(IRIX,-fullwarn,fullwarn,WARN)
  if test x$with_debug = xyes ; then
    AC_SYS_OS_COMPILER_FLAG(IRIX,-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="$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

#############################################################################

## Search for some popular places where libraries may be hidden.

#############################################################################

echo Searching for include-file directories...
if test $cppflags_is_set = no -a x${C_INCLUDE_PATH-} = x ; then
  for d in /usr/local /sw/local /usr/gnu /opt/gnu /sw/gnu /sw /usr/freeware
  do
    AC_MSG_CHECKING($d/include)
    if test -d "$d/include/." ; then
      AC_MSG_RESULT(added)
      CPPFLAGS="${CPPFLAGS} -I$d/include"
    else
      AC_MSG_RESULT(no)
    fi
  done
else
  :
fi

echo Searching for library directories...
if test $ldflags_is_set = no ; then
  for d in /usr/local /sw/local /usr/gnu /opt/gnu /sw/gnu /sw /usr/freeware
  do
    AC_MSG_CHECKING($d/lib)
    if test -d "$d/lib/." ; then
      AC_MSG_RESULT(added)
      LDFLAGS="${LDFLAGS} -R$d/lib -L$d/lib"
    else
      AC_MSG_RESULT(no)
    fi
  done
else
  :
fi

echo Searching for binary directories...
for d in "" /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

#############################################################################

## 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

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 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(socket, socket)
AC_CHECK_LIB(nsl, gethostbyname)

AC_CHECK_LIB(dl, dlopen)
AC_CHECK_LIB(dld, dld_link)

AC_HAVE_FUNCS(strdup)


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

    case "x$pike_cv_sys_os" in
      xOSF1)
        LIBS="${OLDLIBS} -lpthread -lmach -lexc -lc"
      ;;
 
      *)
        LIBS="${OLDLIBS} -lpthread"
      ;;
    esac

    AC_CHECK_FUNCS(pthread_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 */
  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*)
         if test "$GCC" = yes ; then
           LDSHARED="ld -G -bexpall"
         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
	;;
	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";;
	Solaris*) CCSHARED="-KPIC -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,-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";;
    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";;
    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_SUBST(dmmsrc)

AC_OUTPUT(Makefile modules/static_module_makefile modules/dynamic_module_makefile:$dmmsrc,[echo foo >stamp-h])


