dnl Process this file with autoconf to produce a configure script.

dnl General setup.

AC_INIT(src/q.c)
AM_CONFIG_HEADER(config.h)
AM_INIT_AUTOMAKE(q, 6.2)
AM_MAINTAINER_MODE

AC_CANONICAL_HOST
if test -z "${host}"; then
  host=unknown
fi

dnl set this to the libq version (interface:revision:age)
LIBQ_VERSION=6:0:0

dnl set this to the libqint version (interface:revision:age)
LIBQINT_VERSION=2:0:1

dnl set this to the year of the release (used to generate copyright infos)
year=2005

qpath='.:$(pkgdatadir)/lib:$(pkglibdir)'
libtool='$(pkglibdir)/libtool'

AC_SUBST(LIBQ_VERSION)
AC_SUBST(LIBQINT_VERSION)
AC_SUBST(bindir)
AC_SUBST(host)
AC_SUBST(year)
AC_SUBST(qpath)
AC_SUBST(libtool)

dnl Checks for programs.

AC_PROG_AWK
AC_PROG_CC
AC_PROG_CPP
AC_PROG_YACC
if test "${YACC}" != "bison -y"; then
  AC_MSG_ERROR([Sorry, this program requires bison!])
fi
AM_PROG_LEX
if test "${LEX}" != "flex"; then
  AC_MSG_ERROR([Sorry, this program requires flex!])
else
  LEX="flex -I"
fi
AC_PROG_INSTALL
AC_PROG_LN_S
AC_PROG_MAKE_SET
AC_LIBTOOL_DLOPEN
AC_LIBTOOL_WIN32_DLL

ltdl_opt=false
AC_ARG_WITH(installed-ltdl, ,
  [case "${withval}" in
    yes) ltdl_opt=true
         AC_LIBLTDL_INSTALLABLE ;;
    no)  AC_LIBLTDL_CONVENIENCE ;;
    *)   AC_MSG_ERROR([bad --with-installed-ltdl option value: ${withval}]) ;;
  esac],[AC_LIBLTDL_CONVENIENCE])

AC_PROG_LIBTOOL
dnl AM_PATH_LISPDIR

AC_SUBST(INCLTDL)
AC_SUBST(LIBLTDL)

dnl Checks for libraries.

# not necessary to link with libm.a under cygwin
if test "${CYGWIN}" != yes; then
AC_CHECK_LIB(m, sin)
fi

# Solaris needs -lsocket -lnsl
AC_CHECK_LIB(socket, socket)
AC_CHECK_LIB(nsl, gethostbyname)

# pty stuff (Linux, BSD)
AC_CHECK_LIB(util, openpty)

# password encryption
AC_CHECK_LIB(crypt, crypt)

# X libraries
AC_PATH_XTRA

# various stuff (mostly optional)

# gmp (required!)

INCGMP=""
LIBGMP="-lgmp"
AC_ARG_WITH(gmp,
  [  --with-gmp[[=LIBS]]       use the GNU multiprecision library (required!)],
  [case "${withval}" in
    yes) AC_CHECK_LIB(gmp, __gmpz_init, [ true ],
                      [ AC_MSG_ERROR(could not find the GMP library!) ]) ;;
    no)  AC_MSG_ERROR(the GMP library is required!) ;;
    *)   LIBGMP="${withval}"
         ;;
  esac])
AC_SUBST(LIBGMP)

AC_ARG_WITH(gmp-includes,
  [  --with-gmp-includes=INC extra includes for the GMP library],
  [case "${withval}" in
    yes) INCGMP="" ;;
    no)  INCGMP="" ;;
    *) INCGMP="${withval}" ;;
  esac])
AC_SUBST(INCGMP)

# readline

READLINE=""
DEFREADLINE=""
INCREADLINE=""
LIBREADLINE=""
AC_ARG_WITH(rl,
  [  --with-rl[[=LIBS]]        use GNU readline (fancy command line editing)],
  [case "${withval}" in
    yes) rl_opt=true ;;
    no)  rl_opt=false ;;
    *)   rl_opt=false
         LIBREADLINE="${withval}"
         AC_DEFINE(USE_READLINE, 1, [Define when building with readline support.])
         ;;
  esac],[rl_opt=true])
if test x${rl_opt} = xtrue; then
  AC_CHECK_LIB(readline, readline, [ LIBREADLINE="-lreadline" ])
  if test "${LIBREADLINE}" != ""; then
    rl_opt=false
    AC_DEFINE(USE_READLINE, 1)
    AC_MSG_RESULT([defining LIBREADLINE to be ${LIBREADLINE}])
  fi
fi
AM_CONDITIONAL(READLINE, test x${rl_opt} = xtrue)

AC_ARG_WITH(rl-includes,
  [  --with-rl-includes=INC  extra includes for the readline library],
  [case "${withval}" in
    yes) INCREADLINE="" ;;
    no)  INCREADLINE="" ;;
    *) INCREADLINE="${withval}" ;;
  esac])

# pthread

INCPTHREAD=""
LIBPTHREAD="yes"
AC_ARG_WITH(pthread,
  [  --with-pthread[[=LIBS]]   use the POSIX threads library (multithreading)],
  [case "${withval}" in
    no)  LIBPTHREAD="" ;;
    *)   LIBPTHREAD="${withval}" ;;
  esac])
if test "${LIBPTHREAD}" = "yes"; then
  LIBPTHREAD=""
  AC_CHECK_LIB(pthread, pthread_create, [ LIBPTHREAD="-lpthread" ])
  if test "${LIBPTHREAD}" = ""; then
    AC_MSG_WARN([could not find the pthread library, building without multithreading support])
  else
    AC_MSG_RESULT([defining LIBPTHREAD to be ${LIBPTHREAD}])
  fi
fi
if test "${LIBPTHREAD}" != ""; then
  AC_DEFINE(USE_THREADS, 1, [Define when building with POSIX threads support.])
fi
AC_SUBST(LIBPTHREAD)

AC_ARG_WITH(pthread-includes,
  [  --with-pthread-includes=INC extra includes for the pthread library],
  [case "${withval}" in
    no)  INCPTHREAD="" ;;
    *) INCPTHREAD="${withval}" ;;
  esac])
AC_SUBST(INCPTHREAD)

# CURL

CURL_LIBS="yes"
AC_ARG_WITH(curl,
  [  --with-curl[[=LIBS]]      use libcurl (curl module)],
  [case "${withval}" in
    no)  CURL_LIBS="" ;;
    *) CURL_LIBS="${withval}" ;;
  esac])
if test "${CURL_LIBS}" = "yes"; then
  CURL_LIBS=""
  AC_CHECK_LIB(curl, curl_global_init, [ CURL_LIBS="-lcurl" ])
  if test "${CURL_LIBS}" = ""; then
    AC_MSG_WARN([could not find libcurl, skipping the curl module])
  else
    AC_MSG_RESULT([defining CURL_LIBS to be ${CURL_LIBS}])
  fi
fi
AM_CONDITIONAL(CURL, test "${CURL_LIBS}" != "")
AC_SUBST(CURL_LIBS)
if test "${CURL_LIBS}" != ""; then
  CURL_MODULE='-dlopen ../modules/curl/curl.la'
else
  CURL_MODULE=""
fi
AC_SUBST(CURL_MODULE)

CURL_INCLUDES=""
AC_ARG_WITH(curl-includes,
  [  --with-curl-includes=INC extra includes for libcurl],
  [case "${withval}" in
    yes) CURL_INCLUDES="" ;;
    no)  CURL_INCLUDES="" ;;
    *) CURL_INCLUDES="${withval}" ;;
  esac])
AC_SUBST(CURL_INCLUDES)

# GNU dbm

GDBM_LIBS="yes"
AC_ARG_WITH(gdbm,
  [  --with-gdbm[[=LIBS]]      use GNU dbm (gdbm module)],
  [case "${withval}" in
    no)  GDBM_LIBS="" ;;
    *) GDBM_LIBS="${withval}" ;;
  esac])
if test "${GDBM_LIBS}" = "yes"; then
  GDBM_LIBS=""
  AC_CHECK_LIB(gdbm, gdbm_open, [ GDBM_LIBS="-lgdbm" ])
  if test "${GDBM_LIBS}" = ""; then
    AC_MSG_WARN([could not find the gdbm library, skipping the gdbm module])
  else
    AC_MSG_RESULT([defining GDBM_LIBS to be ${GDBM_LIBS}])
  fi
fi
AM_CONDITIONAL(GDBM, test "${GDBM_LIBS}" != "")
AC_SUBST(GDBM_LIBS)
if test "${GDBM_LIBS}" != ""; then
  GDBM_MODULE='-dlopen ../modules/gdbm/gdbm.la'
else
  GDBM_MODULE=""
fi
AC_SUBST(GDBM_MODULE)

GDBM_INCLUDES=""
AC_ARG_WITH(gdbm-includes,
  [  --with-gdbm-includes=INC extra includes for the gdbm library],
  [case "${withval}" in
    yes) GDBM_INCLUDES="" ;;
    no)  GDBM_INCLUDES="" ;;
    *) GDBM_INCLUDES="${withval}" ;;
  esac])
AC_SUBST(GDBM_INCLUDES)

# GGI

GGI_LIBS="yes"
AC_ARG_WITH(ggi,
  [  --with-ggi[[=LIBS]]       use the GGI library (ggi module)],
  [case "${withval}" in
    no)  GGI_LIBS="" ;;
    *) GGI_LIBS="${withval}" ;;
  esac])
if test "${GGI_LIBS}" = "yes"; then
  GGI_LIBS=""
  AC_CHECK_LIB(ggi, ggiInit, [ GGI_LIBS="-lggi -lgii -lgg" ])
  if test "${GGI_LIBS}" = ""; then
    AC_MSG_WARN([could not find the GGI library, skipping the ggi module])
  else
    AC_MSG_RESULT([defining GGI_LIBS to be ${GGI_LIBS}])
  fi
fi
AM_CONDITIONAL(GGI, test "${GGI_LIBS}" != "")
AC_SUBST(GGI_LIBS)
if test "${GGI_LIBS}" != ""; then
  GGI_MODULE='-dlopen ../modules/ggi/ggi.la'
else
  GGI_MODULE=""
fi
AC_SUBST(GGI_MODULE)

GGI_INCLUDES=""
AC_ARG_WITH(ggi-includes,
  [  --with-ggi-includes=INC extra includes for the GGI library],
  [case "${withval}" in
    yes) GGI_INCLUDES="" ;;
    no)  GGI_INCLUDES="" ;;
    *) GGI_INCLUDES="${withval}" ;;
  esac])
AC_SUBST(GGI_INCLUDES)

# FreeType2

FT2_LIBS="yes"
AC_ARG_WITH(ft2,
  [  --with-ft2[[=LIBS]]       use the FreeType2 library (font support for ggi)],
  [case "${withval}" in
    no)  FT2_LIBS="" ;;
    *) FT2_LIBS="${withval}" ;;
  esac])
ftconf=`which freetype-config 2>/dev/null`
if test "${FT2_LIBS}" = "yes"; then
  FT2_LIBS=""
  if test -x "$ftconf"; then
    FT2_LIBS=`$ftconf --libs`
    AC_MSG_RESULT([defining FT2_LIBS to be ${FT2_LIBS}])
  else
    AC_MSG_WARN([could not find the FreeType2 library, building without font support])
  fi
fi
AC_SUBST(FT2_LIBS)

if test -x "$ftconf"; then
  FT2_INCLUDES=`$ftconf --cflags`
else
  FT2_INCLUDES=""
fi
AC_ARG_WITH(ft2-includes,
  [  --with-ft2-includes=INC extra includes for the FreeType2 library],
  [case "${withval}" in
    yes) ;;
    no)  FT2_INCLUDES="" ;;
    *) FT2_INCLUDES="${withval}" ;;
  esac])
AC_SUBST(FT2_INCLUDES)

# ImageMagick

MAGICK_LIBS="yes"
AC_ARG_WITH(magick,
  [  --with-magick[[=LIBS]]    use the ImageMagick library (magick module)],
  [case "${withval}" in
    no)  MAGICK_LIBS="" ;;
    *) MAGICK_LIBS="${withval}" ;;
  esac])
if test "${MAGICK_LIBS}" = "yes"; then
  MAGICK_LIBS=""
  AC_CHECK_LIB(Magick, InitializeMagick, [ MAGICK_LIBS="-lMagick" ])
  if test "${MAGICK_LIBS}" = ""; then
    AC_MSG_WARN([could not find the ImageMagick library, skipping the magick module])
  else
    AC_MSG_RESULT([defining MAGICK_LIBS to be ${MAGICK_LIBS}])
  fi
fi
AM_CONDITIONAL(MAGICK, test "${MAGICK_LIBS}" != "")
AC_SUBST(MAGICK_LIBS)
if test "${MAGICK_LIBS}" != ""; then
  MAGICK_MODULE='-dlopen ../modules/magick/magick.la'
else
  MAGICK_MODULE=""
fi
AC_SUBST(MAGICK_MODULE)

MAGICK_INCLUDES=""
AC_ARG_WITH(magick-includes,
  [  --with-magick-includes=INC extra includes for the ImageMagick library],
  [case "${withval}" in
    yes) MAGICK_INCLUDES="" ;;
    no)  MAGICK_INCLUDES="" ;;
    *) MAGICK_INCLUDES="${withval}" ;;
  esac])
AC_SUBST(MAGICK_INCLUDES)

# ODBC

ODBC_LIBS="yes"
AC_ARG_WITH(odbc,
  [  --with-odbc[[=LIBS]]      use the ODBC library (odbc module)],
  [case "${withval}" in
    no)  ODBC_LIBS="" ;;
    *) ODBC_LIBS="${withval}" ;;
  esac])
if test "${ODBC_LIBS}" = "yes"; then
  ODBC_LIBS=""
  AC_CHECK_LIB(odbc, SQLDriverConnect, [ ODBC_LIBS="-lodbc" ])
  if test "${ODBC_LIBS}" = ""; then
    AC_CHECK_LIB(iodbc, SQLDriverConnect, [ ODBC_LIBS="-liodbc" ])
  fi
  if test "${ODBC_LIBS}" = ""; then
    AC_MSG_WARN([could not find the ODBC library, skipping the odbc module])
  else
    AC_MSG_RESULT([defining ODBC_LIBS to be ${ODBC_LIBS}])
  fi
fi
AM_CONDITIONAL(ODBC, test "${ODBC_LIBS}" != "")
AC_SUBST(ODBC_LIBS)
if test "${ODBC_LIBS}" != ""; then
  ODBC_MODULE='-dlopen ../modules/odbc/odbc.la'
else
  ODBC_MODULE=""
fi
AC_SUBST(ODBC_MODULE)

ODBC_INCLUDES=""
AC_ARG_WITH(odbc-includes,
  [  --with-odbc-includes=INC extra includes for the ODBC library],
  [case "${withval}" in
    yes) ODBC_INCLUDES="" ;;
    no)  ODBC_INCLUDES="" ;;
    *) ODBC_INCLUDES="${withval}" ;;
  esac])
AC_SUBST(ODBC_INCLUDES)

# Tcl/Tk

TK_LIBS="yes"
AC_ARG_WITH(tk,
  [  --with-tk[[=LIBS]]        use Tcl/Tk (tk module)],
  [case "${withval}" in
    no)  TK_LIBS="" ;;
    *) TK_LIBS="${withval}" ;;
  esac])
if test "${TK_LIBS}" = "yes"; then
  TK_LIBS=""
  for version in "" 8.4 8.3 8.2 8.1 8.0; do
    AC_CHECK_LIB(tk${version}, Tk_Init,
                 [TK_LIBS="-ltcl${version} -ltk${version}"])
    if test "${TK_LIBS}" != ""; then
      break
    fi
  done
  if test "${TK_LIBS}" = ""; then
    AC_MSG_WARN([could not find the Tcl/Tk libraries, skipping the tk module])
  else
    AC_MSG_RESULT([defining TK_LIBS to be ${TK_LIBS}])
  fi
fi
AM_CONDITIONAL(TK, test "${TK_LIBS}" != "")
AC_SUBST(TK_LIBS)
TK_INCLUDES=""
if test "${TK_LIBS}" != ""; then
  TK_MODULE='-dlopen ../modules/tk/tk.la'
  if test -a "/usr/include/tcl${version}"; then
    TK_INCLUDES="-I/usr/include/tcl${version}"
  fi
else
  TK_MODULE=""
fi
AC_SUBST(TK_MODULE)

AC_ARG_WITH(tk-includes,
  [  --with-tk-includes=INC  extra includes for the Tcl/Tk libraries],
  [case "${withval}" in
    yes) ;;
    no)  TK_INCLUDES="" ;;
    *) TK_INCLUDES="${withval}" ;;
  esac])
AC_SUBST(TK_INCLUDES)

# libxml2/libxslt

XML_LIBS="yes"
AC_ARG_WITH(xml,
  [  --with-xml[[=LIBS]]       use libxml2/libxslt (xml module)],
  [case "${withval}" in
    no)  XML_LIBS="" ;;
    *) XML_LIBS="${withval}" ;;
  esac])
xmlconf=`which xml2-config 2>/dev/null`
xsltconf=`which xslt-config 2>/dev/null`
if test "${XML_LIBS}" = "yes"; then
  XML_LIBS=""
  if test -x "$xmlconf" -a -x "$xsltconf"; then
    XML_LIBS="`$xmlconf --libs` `$xsltconf --libs`"
    AC_MSG_RESULT([defining XML_LIBS to be ${XML_LIBS}])
  else
    AC_MSG_WARN([could not find libxml2/libxslt, skipping the xml module])
  fi
fi
AM_CONDITIONAL(XML, test "${XML_LIBS}" != "")
AC_SUBST(XML_LIBS)
if test "${XML_LIBS}" != ""; then
  XML_MODULE='-dlopen ../modules/xml/xml.la'
else
  XML_MODULE=""
fi
AC_SUBST(XML_MODULE)

if test -x "$xmlconf" -a -x "$xsltconf"; then
  XML_INCLUDES="`$xmlconf --cflags` `$xsltconf --cflags`"
else
  XML_INCLUDES=""
fi
AC_ARG_WITH(xml-includes,
  [  --with-xml-includes=INC extra includes for libxml2/libxslt],
  [case "${withval}" in
    yes) ;;
    no)  XML_INCLUDES="" ;;
    *) XML_INCLUDES="${withval}" ;;
  esac])
AC_SUBST(XML_INCLUDES)

# DXLink (Data Explorer)

DXL_LIBS="yes"
DXL_INCLUDES=""
AC_ARG_WITH(dxl,
  [  --with-dxl[[=LIBS]]       use DXLink (dxl module)],
  [case "${withval}" in
    no)  DXL_LIBS="" ;;
    *) DXL_LIBS="${withval}" ;;
  esac])
if test "${DXL_LIBS}" = "yes"; then
  DXL_LIBS=""
  Q_CHECK_LIB([-lDXL], DXLStartDX,
              [DXL_LIBS="-lDXL"])
  if test "${DXL_LIBS}" = ""; then
    for dir in /usr/local/dx/lib_* /usr/dx/lib_* /opt/dx/lib_*; do
      Q_CHECK_LIB([-L${dir} -lDXL], DXLStartDX,
                  [DXL_LIBS="-L${dir} -lDXL"
                   DXL_INCLUDES="-I`echo ${dir} | sed -e 's?/lib_.*?/include?'`"])
      if test "${DXL_LIBS}" != ""; then
        break
      fi
    done
  fi
  if test "${DXL_LIBS}" = ""; then
    AC_MSG_WARN([could not find the DXLink library, skipping the dxl module])
  else
    AC_MSG_RESULT([defining DXL_LIBS to be ${DXL_LIBS}])
  fi
fi
AM_CONDITIONAL(DXL, test "${DXL_LIBS}" != "")
AC_SUBST(DXL_LIBS)
if test "${DXL_LIBS}" != ""; then
  DXL_MODULE='-dlopen ../modules/dxl/dxl.la'
else
  DXL_MODULE=""
fi
AC_SUBST(DXL_MODULE)

AC_ARG_WITH(dxl-includes,
  [  --with-dxl-includes=INC extra includes for the DXLink library],
  [case "${withval}" in
    yes) ;;
    no)  DXL_INCLUDES="" ;;
    *) DXL_INCLUDES="${withval}" ;;
  esac])
AC_SUBST(DXL_INCLUDES)

# Additional modules

MODULES=""
AC_ARG_WITH(modules,
  [  --with-modules=LTOPTS   use preloaded modules (-dlopen/-dlpreopen)],
  [case "${withval}" in
    yes) ;;
    no)  MODULES="" ;;
    *) MODULES="${withval}" ;;
  esac])
AC_SUBST(MODULES)

# dmalloc support

INCDMALLOC=""
LIBDMALLOC=""
LIBDMALLOCTH=""
AC_ARG_WITH(dmalloc,
  [  --with-dmalloc[[=LIBS]]   use dmalloc (malloc debugger)],
  [case "${withval}" in
    no)  LIBDMALLOC="" ;;
    *)   LIBDMALLOC="${withval}" ;;
  esac])
if test "${LIBDMALLOC}" = "yes"; then
  LIBDMALLOC=""
  AC_CHECK_LIB(dmalloc, malloc, [ LIBDMALLOC="-ldmalloc" ])
  if test "${LIBDMALLOC}" = ""; then
    AC_MSG_WARN([could not find the dmalloc library, building without dmalloc support])
  else
    AC_MSG_RESULT([defining LIBDMALLOC to be ${LIBDMALLOC}])
  fi
fi
if test "${LIBDMALLOC}" != ""; then
  if test "${LIBPTHREAD}" != ""; then
    LIBDMALLOCTH="${LIBDMALLOC}th"
  else
    LIBDMALLOCTH="${LIBDMALLOC}"
  fi
  AC_MSG_RESULT([defining LIBDMALLOCTH to be ${LIBDMALLOCTH}])
  AC_DEFINE(DMALLOC, 1, [Define when building with dmalloc support.])
fi
AC_SUBST(LIBDMALLOC)
AC_SUBST(LIBDMALLOCTH)

AC_ARG_WITH(dmalloc-includes,
  [  --with-dmalloc-includes=INC extra includes for the dmalloc library],
  [case "${withval}" in
    no)  INCDMALLOC="" ;;
    *) INCDMALLOC="${withval}" ;;
  esac])
AC_SUBST(INCDMALLOC)

dnl Checks for header files.

AC_HEADER_STDC
AC_HEADER_SYS_WAIT
AC_HEADER_DIRENT
AC_CHECK_HEADERS(errno.h execinfo.h fcntl.h limits.h malloc.h pwd.h grp.h netdb.h pty.h sched.h stropts.h termios.h sys/ioctl.h sys/select.h sys/socket.h sys/un.h arpa/inet.h sys/time.h sys/times.h sys/utsname.h unistd.h util.h utime.h)

dnl Checks for typedefs, structures, and compiler characteristics.

AC_C_BIGENDIAN
AC_C_CONST
AC_C_VOLATILE
AC_C_INLINE
AC_TYPE_UID_T
AC_TYPE_PID_T
AC_TYPE_SIZE_T
AC_STRUCT_ST_RDEV
AC_HEADER_TIME
AC_TYPE_MODE_T
AC_TYPE_OFF_T
AC_TYPE_UID_T
AC_TYPE_GETGROUPS
AC_CHECK_TYPES([socklen_t, in_port_t, in_addr_t, struct sockaddr_in6, uint16_t], , ,
[#include <sys/socket.h>
#include <netinet/in.h>
#include <sys/types.h>])
AC_CHECK_DECLS([tzname, daylight], , ,[#include <time.h>])
Q_CHECK_IPV6

AC_CHECK_SIZEOF(char)
AC_CHECK_SIZEOF(short)
AC_CHECK_SIZEOF(int)
AC_CHECK_SIZEOF(long)
AC_CHECK_SIZEOF(long long)
AC_CHECK_SIZEOF(float)
AC_CHECK_SIZEOF(double)

dnl Checks for library functions.

AC_FUNC_ALLOCA
AC_STRUCT_TIMEZONE
AC_TYPE_SIGNAL
Q_SIGNAL_CHECK
Q_REINSTALL_SIGHANDLERS
dnl auxiliary string functions
AC_CHECK_FUNCS(memcpy memmove memset memcmp strdup strsignal strstr)
dnl auxiliary timing functions
AC_CHECK_FUNCS(ftime nanosleep usleep)
dnl various system functions
AC_CHECK_FUNCS(backtrace setlinebuf select sysconf)
AC_CHECK_FUNCS(dup dup2 pipe fstat fchdir fchmod fchown ftruncate fsync fdatasync)
AC_CHECK_FUNCS(ttyname ctermid getpt grantpt openpty forkpty tcgetpgrp)
AC_CHECK_FUNCS(truncate readdir rewinddir link symlink readlink mkfifo access chmod chown lchown nice pause getppid)
AC_CHECK_FUNCS(crypt getpwuid getpwnam getpwent getgrgid getgrnam getgrent getgroups setgroups setuid setgid seteuid setegid setreuid setregid getuid geteuid getgid getegid getlogin)
AC_CHECK_FUNCS(getpgid setpgid getpgrp setpgrp getsid setsid)
AC_FUNC_GETPGRP
AC_FUNC_SETPGRP
AC_FUNC_STRFTIME
AC_CHECK_FUNCS(times)
AC_CHECK_FUNCS(socket socketpair closesocket shutdown bind listen accept connect getsockname getpeername getsockopt setsockopt recv send recvfrom sendto)
AC_CHECK_FUNCS(gethostname gethostbyname gethostbyaddr gethostent getprotobyname getprotobynumber getprotoent getservbyname getservbyport getservent inet_aton)
dnl pthread stuff
OLDLIBS=$LIBS
LIBS="$LIBS $LIBPTHREAD"
AC_CHECK_FUNCS(pthread_atfork)
LIBS=$OLDLIBS
dnl freetype2 support
LIBS="$LIBS ${FT2_LIBS}"
AC_CHECK_FUNCS(FT_Init_FreeType)
LIBS=$OLDLIBS
dnl xml/xslt
LIBS="$LIBS ${XML_LIBS}"
AC_CHECK_FUNCS(xsltSaveResultToString)
LIBS=$OLDLIBS

dnl Configure readline support.

if test x${rl_opt} = xtrue; then
  READLINE=readline-4.2
  DEFREADLINE=-DREADLINE_LIBRARY
  INCREADLINE='-I$(top_srcdir)/readline-4.2'
  LIBREADLINE='$(top_builddir)/readline-4.2/libreadline.la'
  AC_DEFINE(USE_READLINE, 1)
fi
AC_SUBST(READLINE)
AC_SUBST(DEFREADLINE)
AC_SUBST(INCREADLINE)
AC_SUBST(LIBREADLINE)

dnl see whether we got rl_completion_matches (rl 4.2) or completion_matches

if test x${rl_opt} = xtrue; then
  AC_DEFINE(HAVE_RL_COMPLETION_MATCHES, 1, [Define if you have rl_completion_matches (readline 4.2).])
else
  Q_CHECK_LIB([$LIBREADLINE], rl_completion_matches,
              [AC_DEFINE(HAVE_RL_COMPLETION_MATCHES, 1)], )
fi

dnl define VOID_SIGHANDLER for readline

if test x${rl_opt} = xtrue; then
  case "${RETSIGTYPE}" in
    int)
    ;;
    *)
      VOID_SIGHANDLER="-DVOID_SIGHANDLER=1"
      AC_MSG_RESULT([defining VOID_SIGHANDLER to be 1])
    ;;
  esac
fi
AC_SUBST(VOID_SIGHANDLER)

dnl term libs for the readline library

TERMLIBS=""
if test "${LIBREADLINE}" != ""; then
  for termlib in ncurses curses termcap terminfo termlib; do
    AC_CHECK_LIB(${termlib}, tputs, [TERMLIBS="${TERMLIBS} -l${termlib}"])
    case "${TERMLIBS}" in
      *-l${termlib}*)
        AC_MSG_RESULT([defining TERMLIBS to be ${TERMLIBS}])
        break
      ;;
    esac
  done
fi
AC_SUBST(TERMLIBS)

dnl Configure in subdirs.

export CC

AC_CONFIG_SUBDIRS(libltdl readline-4.2 glob regex)

dnl Output.

AC_OUTPUT(Makefile doc/Makefile etc/Makefile examples/Makefile libq/Makefile modules/Makefile modules/clib/Makefile modules/clib/examples/Makefile modules/curl/Makefile modules/curl/examples/Makefile modules/dxl/Makefile modules/dxl/examples/Makefile modules/gdbm/Makefile modules/gdbm/examples/Makefile modules/ggi/Makefile modules/ggi/examples/Makefile modules/magick/Makefile modules/magick/examples/Makefile modules/octave/Makefile modules/odbc/Makefile modules/odbc/examples/Makefile modules/swig/Makefile modules/swig/examples/Makefile modules/tk/Makefile modules/tk/examples/Makefile modules/xml/Makefile modules/xml/examples/Makefile src/Makefile stdlib/Makefile)

dnl Brief summary.

AC_MSG_RESULT([
****************************************************************************

Q is now configured for ${host}.

  Source directory:     ${srcdir}
  Installation prefix:  ${prefix}
  C compiler:           $CC $CFLAGS
])
AC_MSG_RESULT([  Shared libraries:     $enable_shared])
AC_MSG_RESULT([  Static libraries:     $enable_static])
if test x${ltdl_opt} = xtrue; then
AC_MSG_RESULT([  Libltdl:              installed])
else
AC_MSG_RESULT([  Libltdl:              uninstalled])
fi
AC_MSG_RESULT([])
AC_MSG_RESULT([  GMP library:          libraries: ${LIBGMP}])
AC_MSG_RESULT([                        includes : ${INCGMP}])
if test x${rl_opt} = xtrue; then
AC_MSG_RESULT([  GNU readline:         enabled])
else
if test "${LIBREADLINE}" != ""; then
AC_MSG_RESULT([  GNU readline:         libraries: ${LIBREADLINE}])
AC_MSG_RESULT([                        includes : ${INCREADLINE}])
else
AC_MSG_RESULT([  GNU readline:         disabled])
fi
fi
if test "${LIBPTHREAD}" != ""; then
AC_MSG_RESULT([  POSIX threads:        libraries: ${LIBPTHREAD}])
AC_MSG_RESULT([                        includes : ${INCPTHREAD}])
else
AC_MSG_RESULT([  POSIX threads:        disabled])
fi
if test "${GDBM_LIBS}" != ""; then
AC_MSG_RESULT([  GNU dbm:              libraries: ${GDBM_LIBS}])
AC_MSG_RESULT([                        includes : ${GDBM_INCLUDES}])
else
AC_MSG_RESULT([  GNU dbm:              disabled])
fi
if test "${CURL_LIBS}" != ""; then
AC_MSG_RESULT([  CURL:                 libraries: ${CURL_LIBS}])
AC_MSG_RESULT([                        includes : ${CURL_INCLUDES}])
else
AC_MSG_RESULT([  CURL:                 disabled])
fi
if test "${GGI_LIBS}" != ""; then
AC_MSG_RESULT([  GGI:                  libraries: ${GGI_LIBS}])
AC_MSG_RESULT([                        includes : ${GGI_INCLUDES}])
else
AC_MSG_RESULT([  GGI:                  disabled])
fi
if test "${FT2_LIBS}" != ""; then
AC_MSG_RESULT([  FreeType2:            libraries: ${FT2_LIBS}])
AC_MSG_RESULT([                        includes : ${FT2_INCLUDES}])
else
AC_MSG_RESULT([  FreeType2:            disabled])
fi
if test "${MAGICK_LIBS}" != ""; then
AC_MSG_RESULT([  ImageMagick:          libraries: ${MAGICK_LIBS}])
AC_MSG_RESULT([                        includes : ${MAGICK_INCLUDES}])
else
AC_MSG_RESULT([  ImageMagick:          disabled])
fi
if test "${ODBC_LIBS}" != ""; then
AC_MSG_RESULT([  ODBC:                 libraries: ${ODBC_LIBS}])
AC_MSG_RESULT([                        includes : ${ODBC_INCLUDES}])
else
AC_MSG_RESULT([  ODBC:                 disabled])
fi
if test "${TK_LIBS}" != ""; then
AC_MSG_RESULT([  Tcl/Tk:               libraries: ${TK_LIBS}])
AC_MSG_RESULT([                        includes : ${TK_INCLUDES}])
else
AC_MSG_RESULT([  Tcl/Tk:               disabled])
fi
if test "${XML_LIBS}" != ""; then
AC_MSG_RESULT([  XML/XSLT:             libraries: ${XML_LIBS}])
AC_MSG_RESULT([                        includes : ${XML_INCLUDES}])
else
AC_MSG_RESULT([  XML/XSLT:             disabled])
fi
if test "${DXL_LIBS}" != ""; then
AC_MSG_RESULT([  DXLink:               libraries: ${DXL_LIBS}])
AC_MSG_RESULT([                        includes : ${DXL_INCLUDES}])
else
AC_MSG_RESULT([  DXLink:               disabled])
fi
if test "${MODULES}" != ""; then
AC_MSG_RESULT([])
AC_MSG_RESULT([  Preloaded modules:    $MODULES])
fi
if test "${LIBDMALLOC}" != ""; then
AC_MSG_RESULT([  Debug Malloc:         libraries: ${LIBDMALLOC}])
AC_MSG_RESULT([                        includes : ${INCDMALLOC}])
else
AC_MSG_RESULT([  Debug Malloc:         disabled])
fi
AC_MSG_RESULT([
****************************************************************************

Please verify that the above configuration is correct. Then type 'make' to
build everything, and 'make install' to install this software on your
system. To remove the installed software at a later time use the 'make
uninstall' command.
])