source: git/Singular/configure.in @ 5f9072

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

dnl
dnl set the version here
dnl
MAJOR_VERSION=1
MINOR_VERSION=0
SUB_VERSION=0
VERSION_DATE="April 1997"
AC_SUBST(MAJOR_VERSION)
AC_SUBST(MINOR_VERSION)
AC_SUBST(SUB_VERSION)
AC_DEFINE_UNQUOTED(MAJOR_VERSION, ${MAJOR_VERSION})
AC_DEFINE_UNQUOTED(MINOR_VERSION, ${MINOR_VERSION})
AC_DEFINE_UNQUOTED(S_VERSION1, "version: ${MAJOR_VERSION}.${MINOR_VERSION}.${SUB_VERSION}")
AC_DEFINE_UNQUOTED(S_VERSION2, "${VERSION_DATE}")

dnl
dnl paths stuff
dnl
AC_PREFIX_DEFAULT(`pwd`/..)

if test "x$datadir" = 'x${prefix}/share'; then
  if test "x${prefix}" = xNONE; then
    singulardatadir=${ac_default_prefix}/share/Singular;
  else
    singulardatadir=${prefix}/share/Singular;
  fi
else
  singulardatadir=${datadir}/Singular;
fi

AC_DEFINE_UNQUOTED(SINGULAR_DATADIR, "${singulardatadir}")

AC_SUBST(singulardatadir)

dnl
dnl Checks for programs.
dnl

dnl compiler stuff
dnl we do not want to have "-g -O" for CFLAGS  
if test "${CXXFLAGS+set}" != set; then
  CXXFLAGS="-O"
fi
if test "${CFLAGS+set}" != set; then
  CFLAGS="-O"
fi

AC_PROG_CC
AC_PROG_CXX

dnl we prefer using gcc for compiling C++ files
if test ${GXX} = yes; then
  CXX=gcc
fi  

dnl and add to -I to CPPFLAGS and and -Lto LDFLAGS, just to be sure
LDFLAGS="-L${libdir} ${LDFLAGS}"
CPPFLAGS="-I${includedir} ${CPPFLAGS}"

dnl programs to built the grammar/parser
AC_PROG_LEX
AC_CHECK_PROG(BISON, bison, bison)
if test -z ${BISON}; then
  AC_MSG_ERROR(install bison before Singular)
fi

dnl check for info
AC_CHECK_PROG(INFO, info, info)
if test -n "$INFO"; then
  AC_DEFINE(HAVE_INFO)
fi

dnl programs for installation
ac_save_path=${PATH}
PATH="$PATH:.."  
AC_PROG_INSTALL
AC_PATH_PROG(MKINSTALLDIRS, mkinstalldirs, -mkdir)
PATH="$ac_save_path"


dnl
dnl CHECK --without arguments
dnl
AC_ARG_WITH(
  readline,
  [  --without-readline   do not use readline for fancy display])

AC_ARG_WITH(
  gmp,
  [  --without-gmp        do not use gmp library])
    
AC_ARG_WITH(
  MP,
  [  --without-MP         do not use MP (disables MP links)])

AC_ARG_WITH(
  dbm,
  [  --without-dbm        do not use dbm (disables DBM links)])

AC_ARG_WITH(
  dld,
  [  --without-dld        do not use dld (disables dynamic linking)])

AC_ARG_WITH(
  factory,
  [  --without-factory    do not use factory (disables poly factorization)])

AC_ARG_WITH(
  libfac,
  [  --without-libfac     do not use libfac (disables primary decompositions)])

dnl
dnl CHECK VARIOUS LIBRARIES
dnl for gmp, MP, factory and libfac, we built them in, even if the libs
dnl and headers were not found under the condition that the respective
dnl  --enable argument was given
dnl
  
LIBS="-lm $LIBS"

dnl Check -lbsd
AC_CHECK_LIB(
  bsd,
  bzero,
  LIBS="-lbsd $LIBS"
)

dnl Check -lreadline
if test "$with_readline" != no; then
  AC_CHECK_LIB(ncurses,tgetent,,\
   AC_CHECK_LIB(curses,tgetent,,\
   AC_CHECK_LIB(termcap,tgetent)))
   AC_CHECK_LIB(readline, rl_abort)
   if test "$ac_cv_lib_readline_rl_abort" = yes; then
     AC_CHECK_HEADERS(readline/readline.h readline/history.h sys/file.h,ac_readline_ok=yes,ac_readline_ok=no; break)
   fi
   if test "$ac_readline_ok" = yes; then
     AC_DEFINE(HAVE_READLINE)
   else
     AC_MSG_WARN(building without readline: disabling fancy display);
     AC_DEFINE(HAVE_FEREAD)
   fi
 else
   AC_DEFINE(HAVE_FEREAD)
fi
  
dnl Check dbm
if test "$with_dbm" != no; then
  AC_CHECK_LIB(
    dbm,
    dbminit,
    AC_DEFINE(HAVE_DBM) LIBS="-ldbm $LIBS",
    AC_CHECK_LIB(
      gbm,
      dbminit,
      AC_DEFINE(HAVE_DBM) LIBS="-lgdbm $LIBS",
      AC_MSG_WARN(building without dbm: disabling DBM links)))
fi

dnl Check dld
if test "$with_dld" = yes; then
  AC_CHECK_LIB(dld, dld_init,\
   AC_MSG_WARN(building without dld: disabling dynamic linking))
fi

NEED_LIBS=$LIBS

dnl Check gmp
if test "$with_gmp" != no; then
  AC_CHECK_LIB(gmp, mpz_init)
  AC_CHECK_HEADERS(gmp.h)
  if test "$ac_cv_lib_gmp_mpz_init" = yes && \
   test "$ac_cv_header_gmp_h" = yes; then
    AC_DEFINE(HAVE_GMP)
    NEED_LIBS="-lgmp ${NEED_LIBS}"
    ac_gmp_ok=yes
  elif test "$enable_gmp" = yes; then
    AC_DEFINE(HAVE_GMP)
    NEED_LIBS="-lgmp ${NEED_LIBS}"
    ac_gmp_ok=yes
    AC_MSG_WARN(install gmp before making Singular or configure --without-gmp)
  else
    AC_MSG_WARN(building without gmp: using build-in rational arithmetic)
  fi
fi

dnl Check MP
if test "$with_MP" != no; then
  if test "$ac_gmp_ok" != yes; then
    AC_MSG_WARN(building without MP: can not use MP without gmp)
  else
    if test "$ac_cv_lib_gmp_mpz_init"=yes; then
      AC_CHECK_LIB(MPT, MPT_GetTree,,,-lMP)
    fi
    AC_CHECK_HEADERS(MP.h)
    if test "$ac_cv_lib_MPT_MPT_GetTree" = yes && \
     test "$ac_cv_header_MP_h"=yes; then
      AC_DEFINE(HAVE_MPSR)
      NEED_LIBS="-lMPT -lMP ${NEED_LIBS}"
    elif test "$enable_MP" = yes; then
      AC_DEFINE(HAVE_MPSR)
      NEED_LIBS="-lMPT -lMP ${NEED_LIBS}"
      AC_MSG_WARN(install MP before making Singular or configure --without-MP)
    else
      AC_MSG_WARN(building without MP: disabling MP links)
    fi
  fi
fi

dnl Check factory
if test "$with_factory" != no; then
  if test "$ac_gmp_ok" != yes; then
    AC_MSG_WARN(building without factory: can not use factory without gmp) 
  else
    if test "$ac_cv_lib_gmp_mpz_init"=yes;then
      AC_CHECK_LIB(singcf,initCanonicalForm)
    fi
    AC_CHECK_HEADERS(factory.h)
    if test "$ac_cv_lib_singcf_initCanonicalForm" = yes && \
     test "$ac_cv_header_factory_h" = yes; then
      AC_DEFINE(HAVE_FACTORY)
      NEED_LIBS="-lsingcf ${NEED_LIBS}"
      ac_factory_ok=yes
    elif test "$enable_factory" = yes; then
      NEED_LIBS="-lsingcf ${NEED_LIBS}"
      AC_DEFINE(HAVE_FACTORY)
      ac_factory_ok=yes
      AC_MSG_WARN(install factory before making Singular or configure --without-factory)
    else
      AC_MSG_WARN(building without factory: disabling poly factorization)
    fi
  fi
fi

dnl Check libfac
if test "$with_libfac" != no; then
  if test "$ac_factory_ok" != yes; then
    AC_MSG_WARN(building without libfac: can not use libfac without factory) 
  else
    if test "$ac_cv_lib_singcf_initCanonicalForm" = yes; then
      AC_CHECK_LIB(singlibfac,IrrCharSeries)
    fi
    AC_CHECK_HEADERS(factor.h)
    if test "$ac_cv_lib_singlibfac_IrrCharSeries" = yes && \
     test "$ac_cv_header_factor_h" = yes; then
      NEED_LIBS="-lsinglibfac ${NEED_LIBS}"
      AC_DEFINE(HAVE_LIBFAC_P)
    elif test "$enable_libfac" = yes; then
      NEED_LIBS="-lsinglibfac ${NEED_LIBS}"
      AC_DEFINE(HAVE_LIBFAC_P)
      AC_MSG_WARN(install libfac before making Singular or configure --without-libfac)
    else
      AC_MSG_WARN(building without libfac: disabling char series)
    fi
  fi
fi

AC_SUBST(NEED_LIBS)

dnl
dnl CHECKS FOR HEADER FILES.
dnl

AC_HEADER_STDC

AC_CHECK_HEADERS(limits.h unistd.h,,
  AC_MSG_ERROR(Can not compile without limits.h unistd.h))

AC_CHECK_HEADERS(sys/file.h sys/ioctl.h sys/time.h)

dnl
dnl Checks for typedefs, structures, and compiler characteristics.
dnl  
AC_C_CONST
AC_C_INLINE
AC_TYPE_SIZE_T
AC_HEADER_TIME
AC_STRUCT_TM

dnl
dnl Checks for library functions.
dnl
AC_FUNC_ALLOCA
AC_PROG_GCC_TRADITIONAL
AC_FUNC_MMAP
AC_TYPE_SIGNAL
AC_FUNC_VPRINTF
AC_CHECK_FUNCS(gettimeofday strstr strtod strtol atexit)

dnl
dnl System specific tests
dnl

dnl arithmetic shifts
AC_MSG_CHECKING(whether your machine has correct arithmetic shifts)
AC_CACHE_VAL(ac_cv_shift, AC_TRY_RUN(
  [ int main() { if (-2 >> 1 == -1) exit(0); else exit(1); } ],
   ac_cv_shift=yes,
   ac_cv_shift=no,
   1))
if test "$ac_cv_shift" = yes; then   
  AC_MSG_RESULT(yes)
else
  AC_MSG_RESULT(no)
  AC_MSG_ERROR(need  -2 >> 1 == -1)
fi


dnl sizeof(int) == 4
AC_MSG_CHECKING(whether sizeof int is four bytes)
AC_CACHE_VAL(ac_cv_sizeof_int_equals_four, AC_TRY_RUN(
[ int main() {if (sizeof(int) == 4)  exit(0); else exit(1); } ],
  ac_cv_sizeof_int_equals_four=yes,
  ac_cv_sizeof_int_equals_four=no,
  1))

if test "$ac_cv_sizeof_int_equals_four" = yes; then
  AC_MSG_RESULT(yes)
else
  AC_MSG_RESULT(no)
  AC_MSG_ERROR(need int to be four bytes long)
fi

dnl sizeof(long) == sizeof (void *)
AC_MSG_CHECKING(whether sizeof long equals sizeof void*)
AC_CACHE_VAL(ac_cv_sizeof_long_equals_voidp, AC_TRY_RUN(
  [ int main() {if (sizeof(long) == sizeof(void*))  exit(0); else exit(1); }],
    ac_cv_sizeof_long_equals_voidp=yes,
    ac_cv_sizeof_long_equals_voidp=no,
    1))
if test "$ac_cv_sizeof_long_equals_voidp" = yes; then
  AC_MSG_RESULT(yes)
else
  AC_MSG_RESULT(no)
  AC_MSG_ERROR(need equal sizes for long and void*)
fi

dnl sprintf returns number of printed chars
AC_MSG_CHECKING(whether vsprintf returns number of printed chars)
AC_CACHE_VAL(ac_cv_returns_n_of_chars, AC_TRY_RUN( 
 [#include <stdio.h> 
 main() { char str[21]; if (((int) sprintf(str,"123456789")) == 9) exit(0); else exit(1); }],
   ac_cv_returns_n_of_chars=yes,
   ac_cv_returns_n_of_chars=no,
   1))
if test "$ac_cv_returns_n_of_chars" = yes; then
  AC_MSG_RESULT(yes)
else
  AC_MSG_RESULT(no)
  AC_DEFINE(BSD_SPRINTF)
fi

dnl determine ALIGN_8
AC_CHECK_SIZEOF(void*,4)


dnl
dnl Last, but not least, customize CFLAGS
dnl
if test ${GXX} = yes; then
  CXXFLAGS="-O3 -w -fomit-frame-pointer -fstrength-reduce"
  CXXTEMPLFLAGS="-fno-implicit-templates"
else
  CXXTEMPFLAGS=""
fi
AC_SUBST(CXXTEMPLFLAGS)

if test ${GCC} = yes; then
  CFLAGS="-O3 -w -fomit-frame-pointer -fstrength-reduce"
fi

AC_SUBST(ac_configure_args)

AC_OUTPUT(Makefile)