dnl Process this file with autoconf to produce a configure script.
AC_INIT(mudconf.h)
AC_CONFIG_HEADER(autoconf.h)

AC_MSG_CHECKING(whether to enable Reality Levels)
AC_ARG_ENABLE(
  [realitylvls],
  AC_HELP_STRING([--enable-realitylvls], [enable Reality  Levels (default is NO)]),
  [
    if test "x$enableval" = "xno"; then
      AC_MSG_RESULT(no)
    else
      REALITY_LVLS="-DREALITY_LVLS"
      LIBS="-lstdc++"
      REALITY_SRC="levels.cpp"
      REALITY_OBJ="levels.o"
      AC_MSG_RESULT(yes)
    fi
  ],
  [
    AC_MSG_RESULT(no)
  ])
AC_SUBST(REALITY_LVLS)
AC_SUBST(LIBS)
AC_SUBST(REALITY_SRC)
AC_SUBST(REALITY_OBJ)

AC_MSG_CHECKING(whether to enable WOD Realms)
AC_ARG_ENABLE(
  [wodrealms],
  AC_HELP_STRING([--enable-wodrealms], [enable WOD Realms (default is NO)]),
  [
    if test "x$enableval" = "xno"; then
      AC_MSG_RESULT(no)
    else
      WOD_REALMS="-DWOD_REALMS"
      AC_MSG_RESULT(yes)
    fi
  ],
  [
    AC_MSG_RESULT(no)
  ])
AC_SUBST(WOD_REALMS)

AC_MSG_CHECKING(whether to enable Memory-Based Database)
AC_ARG_ENABLE(
  [memorybased],
  AC_HELP_STRING([--enable-memorybased], [enable Memory-Based Database (default is NO)]),
  [
    if test "x$enableval" = "xno"; then
      AC_MSG_RESULT(no)
    else
      MEMORY_BASED="-DMEMORY_BASED"
      AC_MSG_RESULT(yes)
    fi
  ],
  [
    AC_MSG_RESULT(no)
  ])
AC_SUBST(MEMORY_BASED)

AC_MSG_CHECKING(whether to enable Query Slave)
AC_ARG_ENABLE(
  [queryslave],
  AC_HELP_STRING([--enable-queryslave], [enable Query Slave (default is NO)]),
  [
    if test "x$enableval" = "xno"; then
      AC_MSG_RESULT(no)
    else
      QUERY_SLAVE="-DQUERY_SLAVE"
      SQLSLAVE="sqlslave"
      AC_MSG_RESULT(yes)
    fi
  ],
  [
    AC_MSG_RESULT(no)
  ])
AC_SUBST(QUERY_SLAVE)
AC_SUBST(SQLSLAVE)

AC_MSG_CHECKING(whether to enable deprecated features)
AC_ARG_ENABLE(
  [deprecated],
  AC_HELP_STRING([--enable-deprecated], [enable deprecated features (default is NO)]),
  [
    if test "x$enableval" = "xno"; then
      AC_MSG_RESULT(no)
    else
      DEPRECATED="-DDEPRECATED"
      AC_MSG_RESULT(yes)
    fi
  ],
  [
    AC_MSG_RESULT(no)
  ])
AC_SUBST(DEPRECATED)

AC_CANONICAL_HOST
AC_PROG_CC
AC_PROG_CXX
AC_PROG_CXXCPP
AC_PROG_CPP
case "$host" in
*irix*) LIBS="-lm" ;;
esac
AC_ISC_POSIX
AC_AIX
AC_MINIX
AC_HEADER_DIRENT
AC_HEADER_STDC
AC_HEADER_TIME
AC_CHECK_HEADERS(unistd.h memory.h string.h errno.h malloc.h sys/select.h)
AC_CHECK_HEADERS(fcntl.h limits.h sys/file.h sys/ioctl.h sys/time.h sys/stat.h)
AC_CHECK_HEADERS(fpu_control.h ieeefp.h fenv.h)
AC_CHECK_HEADERS([netinet/in.h])
AC_CHECKING(for sys_errlist decl)
if test $ac_cv_header_errno_h = no; then
	AC_DEFINE(NEED_SYS_ERRLIST_DCL)
else
	AC_EGREP_HEADER(sys_errlist,errno.h, ,AC_EGREP_HEADER(sys_errlist,stdio.h,,AC_DEFINE(NEED_SYS_ERRLIST_DCL)))
fi
AC_CHECK_LIB(crypt, main)
AC_FUNC_STRFTIME
AC_FUNC_VPRINTF
AC_CHECK_FUNCS(setrlimit getrusage srandom)
AC_CHECK_FUNCS(getdtablesize socket gethostbyaddr)
AC_CHECK_FUNCS(gettimeofday select socket localtime_r)
AC_CHECK_FUNCS(getpagesize usleep nanosleep setitimer crypt)
AC_EGREP_HEADER(getpagesize,unistd.h,,AC_DEFINE(NEED_GETPAGESIZE_DCL))
if test $ac_cv_header_ieeefp_h = yes; then
    AC_TRY_COMPILE([
    #include <ieeefp.h>
    ],[
    int main(int argc, char *argv[])
    {
        fp_prec_t a = fpgetprec();
        fpsetprec(FP_PD);
        return 0;
    }
    ],AC_DEFINE(IEEEFP_H_USEABLE))
fi
if test $ac_cv_header_fenv_h = yes; then
	AC_EGREP_HEADER(fesetprec,fenv.h,AC_DEFINE(HAVE_FESETPREC))
	AC_EGREP_HEADER(fegetprec,fenv.h,AC_DEFINE(HAVE_FEGETPREC))
fi
AC_TYPE_OFF_T
AC_TYPE_PID_T
AC_TYPE_SIGNAL
AC_TRY_COMPILE([#include <signal.h>],[struct sigcontext scp;],AC_DEFINE(HAVE_STRUCT_SIGCONTEXT))
AC_HEADER_SYS_WAIT
AC_STRUCT_TM
AC_STRUCT_TIMEZONE
AC_CHECKING(for extended string dcls)
AC_EGREP_HEADER(rindex,string.h, ,AC_DEFINE(NEED_INDEX_DCL))
AC_CHECKING(for malloc dcl)
querymalloc=no
AC_EGREP_HEADER(realloc,stdlib.h,AC_DEFINE(MALLOC_IN_STDLIB_H),querymalloc=yes)
if test $ac_cv_header_malloc_h = no && test $querymalloc = yes; then
    AC_DEFINE(NEED_MALLOC_DCL)
else
    AC_EGREP_HEADER(realloc,malloc.h, ,AC_DEFINE(NEED_MALLOC_DCL))
fi
AC_CHECKING(for vsprintf dcl)
AC_EGREP_HEADER(vsprintf,stdio.h, ,AC_DEFINE(NEED_VSPRINTF_DCL))
AC_CHECKING(for sprintf dcl)
AC_EGREP_HEADER(\<sprintf|\<*sprintf,stdio.h, ,AC_DEFINE(NEED_SPRINTF_DCL))
AC_CHECKING(for extended stdio dcls)
AC_EGREP_HEADER(fread,stdio.h,AC_DEFINE(EXTENDED_STDIO_DCLS))
AC_CHECKING(for extended socket dcls)
AC_EGREP_HEADER(setsockopt,sys/socket.h,AC_DEFINE(EXTENDED_SOCKET_DCLS))
AC_CHECKING(for socklen_t dcls)
AC_EGREP_HEADER(socklen_t,sys/socket.h,AC_DEFINE(SOCKLEN_T_DCL))

AC_CHECKING(for gettimeofday dcl)
if test $ac_cv_header_time = yes && test $ac_cv_header_sys_time_h = yes ; then
AC_EGREP_HEADER(gettimeofday,[time.h>
#include <sys/time.h], ,AC_DEFINE(NEED_GETTIMEOFDAY_DCL))
elif test $ac_cv_header_sys_time_h = yes ; then
AC_EGREP_HEADER(gettimeofday,sys/time.h, ,AC_DEFINE(NEED_GETTIMEOFDAY_DCL))
else
AC_EGREP_HEADER(gettimeofday,time.h, ,AC_DEFINE(NEED_GETTIMEOFDAY_DCL))
fi

AC_CHECKING(for signal SIGCHLD braindamage)
AC_TRY_RUN([
#include <signal.h>

#ifndef SIGCHLD
#define SIGCHLD SIGCLD
#endif

int rlev;

RETSIGTYPE sighand(int sig, int code)
{
  int stat;

  if (rlev++ > 2)
    exit(1);
  signal(SIGCHLD, sighand);
  wait(&stat);
  return;
}

int main(int argc, char *argv[])
{
  rlev = 0;
  signal(SIGCHLD, sighand);
  if (fork()) {
    sleep(10);
  } else {
    sleep(2);
    exit(1);
  }
  exit(0);
}
], ,AC_DEFINE(SIGNAL_SIGCHLD_BRAINDAMAGE),AC_DEFINE(SIGNAL_SIGCHLD_BRAINDAMAGE))

AC_DECL_SYS_SIGLIST
AC_MSG_CHECKING(for sys_signame decl)
AC_EGREP_HEADER(sys_signame,signal.h,AC_DEFINE(HAVE_SYS_SIGNAME) AC_MSG_RESULT(yes),AC_MSG_RESULT(no))
AC_CHECKING(for IEEE floating-point format)
AC_TRY_RUN([
double rZero = 0.0;
int main(int argc, char *argv[])
{
   double r = -1e-125;
   long long i64;
   *(double *)&i64 = r;
   if (i64 == 0xA5FB13AC9AAF4C0Full)
   {
      return 0;
   }
   return 1;
}
],AC_DEFINE(HAVE_IEEE_FP_FORMAT),AC_DEFINE(NO_IEEE_FP_FORMAT),AC_DEFINE(NO_IEEE_FP_FORMAT))
AC_CHECKING(for IEEE floating-point exception handling)
AC_TRY_RUN([
#include <signal.h>
double rZero = 0.0;
int main(int argc, char *argv[])
{
   double r;
   long long i64;
   signal(SIGFPE, SIG_IGN);
   r = 1.0/rZero;
   *(double *)&i64 = r;
   if (i64 == 0x7FF0000000000000ull)
   {
      return 0;
   }
   return 1;
}
],AC_DEFINE(HAVE_IEEE_FP_SNAN),AC_DEFINE(NO_IEEE_FP_SNAN),AC_DEFINE(NO_IEEE_FP_SNAN))
AC_CHECKING(for how division/moduli of negative quotients are handled)
AC_TRY_RUN([
int main(int argc, char *argv[])
{
   int top = -9;
   int bot = 5;
   int quotient = top/bot;
   if (quotient == -1)
   {
       return 0;
   }
   return 1;
}
],AC_DEFINE(SMALLEST_INT_GTE_NEG_QUOTIENT),AC_DEFINE(LARGEST_INT_LTE_NEG_QUOTIENT),AC_DEFINE(LARGEST_INT_LTE_NEG_QUOTIENT))
AC_CHECKING(for getrusage dcl)
AC_EGREP_HEADER(getrusage,sys/resource.h, ,AC_DEFINE(NEED_GETRUSAGE_DCL))
AC_CHECKING(for getrlimit dcl)
AC_EGREP_HEADER(getrlimit,sys/resource.h, ,AC_DEFINE(NEED_GETRLIMIT_DCL))
AC_C_CONST
AC_C_INLINE
AC_C_BIGENDIAN(AC_DEFINE(WORDS_BIGENDIAN),AC_DEFINE(WORDS_LITTLEENDIAN),AC_DEFINE(WORDS_UNKNOWN))
AC_CHECK_SIZEOF(short,2)
AC_CHECK_SIZEOF(unsigned short,2)
AC_CHECK_SIZEOF(int,4)
AC_CHECK_SIZEOF(unsigned int,4)
AC_CHECK_SIZEOF(long,4)
AC_CHECK_SIZEOF(unsigned long,4)
AC_CHECKING(whether unaligned 'short' access is permitted)
AC_TRY_RUN([
int main(int argc, char *argv[])
{
   char foo[sizeof(short)+1];
   short  *ps = (short *)(foo+1);
   *ps = 0;
   return 0;
}
],AC_DEFINE(CAN_UNALIGN_SHORT))
AC_CHECKING(whether unaligned 'int' access is permitted)
AC_TRY_RUN([
int main(int argc, char *argv[])
{
   char foo[sizeof(int)+1];
   int  *pi = (int *)(foo+1);
   *pi = 0;
   return 0;
}
],AC_DEFINE(CAN_UNALIGN_INT))
AC_CHECKING(whether unaligned 'long' access is permitted)
AC_TRY_RUN([
int main(int argc, char *argv[])
{
   char foo[sizeof(long)+1];
   long *pl = (long *)(foo+1);
   *pl = 0;
   return 0;
}
],AC_DEFINE(CAN_UNALIGN_LONG))
AC_CHECKING(whether unaligned 'long long' access is permitted)
AC_TRY_RUN([
int main(int argc, char *argv[])
{
   char foo[sizeof(long long)+1];
   long long *pll = (long long *)(foo+1);
   *pll = 0;
   return 0;
}
],AC_DEFINE(CAN_UNALIGN_LONGLONG))

AC_CHECKING(for pread and pwrite)
AC_TRY_RUN([
#include <sys/types.h>
#include <sys/uio.h>
#include <unistd.h>
main() { pwrite(0, "abc", 3, 0); exit(0); }],
pwrite_works=yes, 
pwrite_works=no,)

if test $pwrite_works = yes; then
  AC_DEFINE(HAVE_PREAD)
  AC_DEFINE(HAVE_PWRITE)
fi

AC_TRY_COMPILE([#include <sys/types.h>
#include <sys/socket.h>],
[struct linger ling; ling.l_onoff = 1;],
AC_DEFINE(HAVE_LINGER))
AC_CHECK_LIB(resolv, main)
AC_CHECK_LIB(sun, getpwnam)
AC_CHECK_LIB(seq, main)
AC_CHECK_LIB(intl, main)
AC_CHECK_LIB(nsl, main)
if test $ac_cv_func_gethostbyaddr = no; then
	AC_CHECK_LIB(inet, main)
fi
if test $ac_cv_func_socket = no; then
	AC_CHECK_LIB(socket, main)
fi
AC_CHECK_LIB(m, main)
AC_CHECKING(for /dev/urandom)
if test -c /dev/urandom; then
  AC_DEFINE(HAVE_DEV_URANDOM)
fi
AC_MSG_CHECKING([for in_addr_t])
AC_TRY_COMPILE([#include <sys/types.h>
#if STDC_HEADERS
#include <stdlib.h>
#include <stddef.h>
#endif
#if HAVE_NETINET_IN_H
#include <netinet/in.h>
#endif], [in_addr_t foo;],
  [AC_DEFINE([HAVE_IN_ADDR_T])
   AC_MSG_RESULT(yes)],
  [AC_MSG_RESULT(no)])
AC_SUBST(def_force_c_compiler)
AC_OUTPUT(Makefile)