source: trunk/configure.ac @ 2787

## Process this file with autoconf to produce a configure script.
##
## $Id: configure.ac 2787 2012-07-23 03:14:44Z peter $

# Copyright (C) 2003 Daniel Dalevi, Jari Häkkinen
# Copyright (C) 2004 Jari Häkkinen
# Copyright (C) 2005, 2006 Jari Häkkinen, Peter Johansson
# Copyright (C) 2007, 2008 Jari Häkkinen, Peter Johansson, Markus Ringnér
# Copyright (C) 2009 Jari Häkkinen, Peter Johansson
# Copyright (C) 2010, 2011 Peter Johansson
# Copyright (C) 2012 Jari Häkkinen, Peter Johansson
#
# This file is part of the yat library, http://dev.thep.lu.se/yat
#
# The yat library is free software; you can redistribute it
# and/or modify it under the terms of the GNU General Public License as
# published by the Free Software Foundation; either version 3 of the
# License, or (at your option) any later version.
#
# The yat library is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
# General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with yat. If not, see <http://www.gnu.org/licenses/>.
#
# If you grabbed the source from the subversion repository you should,
# at top-level, execute:
#     ./bootstrap
# To push subsequent changes of this file into the build scripts you
# must issue:
#     autoreconf


m4_include([m4/version.m4])
AC_INIT([yat],[my_VERSION],[libyat-users@lists.sourceforge.net],,
        [http://dev.thep.lu.se/yat])
MY_VERSION
AC_PREREQ(2.63)
AC_CONFIG_SRCDIR([yat/utility/Matrix.h])
AC_CONFIG_AUX_DIR([autotools])
dnl arg below should be the same as in Makefile.am
AC_CONFIG_MACRO_DIR([m4])
AC_PREFIX_DEFAULT([/usr/local])

# Set default htmldir to ${docdir}/html
AS_IF([test $htmldir = '${docdir}'], [htmldir='${docdir}/html'])

dnl FIXME remove when we assume autoconf 2.64
m4_ifndef([AC_PACKAGE_URL],
          [AC_DEFINE([PACKAGE_URL], ["http://dev.thep.lu.se/yat"],
                     [Define to home page for this package])
           AC_SUBST([PACKAGE_URL], ["http://dev.thep.lu.se/yat"])])

AC_SUBST([YAT_LT_VERSION], [YAT_LT_VERSION_INFO])
AC_DEFINE([YAT_VERSION], ["my_VERSION"], [version])

AC_CONFIG_HEADERS([config.h])
AM_INIT_AUTOMAKE([1.11 std-options color-tests parallel-tests silent-rules -Werror subdir-objects])

# Set default programming language
AC_LANG(C++)

# propagate selected configure variables to DISTCHECK_CONFIGURE_FLAGS
for var in CPPFLAGS CXX CXXFLAGS CXXCPP LDFLAGS LIBS; do
  eval isset=\${$var+set}
  if test "$isset" = 'set' ; then
    eval val=$`echo $var`
    DISTCHECK_CONFIGURE_FLAGS="${DISTCHECK_CONFIGURE_FLAGS}'${var}=${val}' "
  fi
done
AC_SUBST(DISTCHECK_CONFIGURE_FLAGS)

# Let user overide default CXXFLAGS
if test "${CXXFLAGS+set}" != set; then
  CXXFLAGS=""  # Setting CXXFLAGS here to prevent expansion in AC_PROG_CXX
fi
# Checks for programs.
AC_PROG_CXX
AC_PROG_SED
AC_PROG_LIBTOOL

# find the compiler vendor: gnu, intel, etc
AX_COMPILER_VENDOR

have_doxygen=no
AC_PATH_PROG([DOXYGEN], [doxygen], [no])
if test "$DOXYGEN" = "no"; then
   AC_MSG_WARN([unable to find doxygen application])
else
   doxygen_min_version=1.5
   AC_MSG_CHECKING([if doxygen is at least $doxygen_min_version])
   doxygen_version=`$DOXYGEN --version`
   AX_COMPARE_VERSION([$doxygen_version], [ge], [$doxygen_min_version],
                      [have_doxygen=yes], [have_doxygen=old])
   AC_MSG_RESULT([$doxygen_version])
fi

AC_SUBST(have_doxygen)
AM_CONDITIONAL([DX_ENABLE_HTML], [test x$have_doxygen = xyes])

# check for quiet_NaN support in OS
# Check at run-time, but if we are cross-compiling fall back on a
# compilation test
AC_MSG_CHECKING([if std::numeric_limits<>::has_quiet_NaN is true])
AC_RUN_IFELSE(
  [AC_LANG_PROGRAM(
    [@%:@include <limits>],
    [return !std::numeric_limits<double>::has_quiet_NaN])],
  [quiet_nan=yes
   AC_MSG_RESULT($quiet_nan)],
  [quiet_nan=no
   AC_MSG_RESULT($quiet_nan)],
  # if we are cross-compiling fall back on compilation test
  [AC_MSG_RESULT(cross-compiling)
   AC_MSG_CHECKING([for std::numeric_limits<>::quiet_NaN()])
    AC_COMPILE_IFELSE(
     [AC_LANG_PROGRAM(
        [@%:@include <limits>
         extern void f(double);],
        [f(std::numeric_limits<double>::quiet_NaN())])],
     [quiet_nan=yes],
     [quiet_nan=no])
   AC_MSG_RESULT($quiet_nan)])
# Check for infinity support for doubles in OS
# Check at run-time, but if we are cross-compiling fall back on a
# compilation test
AC_MSG_CHECKING([if std::numeric_limits<>::has_infinity is true])
AC_RUN_IFELSE(
  [AC_LANG_PROGRAM(
    [@%:@include <limits>],
    [return !std::numeric_limits<double>::has_infinity])],
  [has_infinity=yes
   AC_MSG_RESULT($has_infinity)],
  [has_infinity=no
   AC_MSG_RESULT($has_infinity)],
  # if we are cross-compiling fall back on compilation test
  [AC_MSG_RESULT(cross-compiling)
   AC_MSG_CHECKING([for std::numeric_limits<>::infinity()])
    AC_COMPILE_IFELSE(
     [AC_LANG_PROGRAM(
        [@%:@include <limits>
         extern void f(double);],
        [f(std::numeric_limits<double>::infinity())])],
     [has_infinity=yes],
     [has_infinity=no])
   AC_MSG_RESULT($has_infinity)])

AC_MSG_CHECKING([g++ deprecation attribute])
AC_COMPILE_IFELSE(
   [AC_LANG_PROGRAM([[void f() __attribute__ ((deprecated));]],)],
   [AC_DEFINE([YAT_HAVE_GCC_DEPRECATED], [1],
              [Define if compiler supports deprecated attribute, as in g++ 4.0])
    AC_MSG_RESULT([yes])],
   [AC_MSG_RESULT([no])] )

AC_MSG_CHECKING([if std::multiset::iterator is mutable])
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[@%:@include <set>
                                     @%:@include <vector>]],
                                   [[std::set<std::vector<double> > s;
                                     std::vector<double> v;
                                     s.insert(v);
                                     s.begin()->reserve(100);
                                   ]])],
                  [AC_DEFINE([MULTISET_ITERATOR_IS_MUTABLE], [1],
                             [Define if std::multiset::iterator is mutable])
                   AC_MSG_RESULT([yes])
                  ],
                  [AC_MSG_RESULT([no])] )

# Save user-defined environment settings for later restoration
APR_SAVE_THE_ENVIRONMENT(CPPFLAGS)
APR_SAVE_THE_ENVIRONMENT(CXXFLAGS)
APR_SAVE_THE_ENVIRONMENT(LDFLAGS)
APR_SAVE_THE_ENVIRONMENT(LIBS)

# Checks for libraries.
AC_MSG_NOTICE([checking for libraries])
AC_CHECK_LIBM

# find library implementing BLAS C API, or use gslcblas
YAT_LIB_CBLAS([YAT_CBLAS_LIB=$CBLAS_LIB], [YAT_CBLAS_LIB=-lgslcblas])

# GNU Scientific Library, GSL http://www.gnu.org/software/gsl/, checks
# Including AX_PATH_GSL macro from gsl.m4 distributed by GSL
gsl_version="1.8"
AC_SUBST(gsl_version)
gsl_ok=yes
YAT_CHECK_GSL([$gsl_version],[gsl_ok=yes],[gsl_ok=no])

# Boost http://www.boost.org
boost_version=1.35
AC_SUBST(boost_version)
AX_BOOST_BASE(["$boost_version"], [boost_ok=yes], [boost_ok=no])
# skip boost link tests if boost is not wanted (--without-boost)
AS_IF([test x"$want_boost" = x"yes"],[
  AX_BOOST_THREAD
  AX_BOOST_SYSTEM
])
YAT_CPP_ADD_FLAG([CPPFLAGS], [$BOOST_CPPFLAGS])
YAT_LD_ADD_FLAG([LDFLAGS], [$BOOST_LDFLAGS])

# see tickets #648 #687
AC_MSG_CHECKING([whether constructor in boost concept is supported])
AC_COMPILE_IFELSE([
  AC_LANG_PROGRAM(
    [
     @%:@include <boost/concept_check.hpp>
     template <typename T>
     class MyConcept
     {
     public:
       MyConcept(void) {}
       BOOST_CONCEPT_USAGE(MyConcept){}
     };
    ],[
     MyConcept<double> x;
     x = x;
    ])
  ],
  [AC_MSG_RESULT([yes])
   AC_DEFINE([YAT_HAVE_BOOST_CONCEPT_WITH_CONSTRUCTOR],[1],
             [define if compiler supports boost concept with constructor])
  ],
  [AC_MSG_RESULT([no])]
)


#support for large files
AC_SYS_LARGEFILE
if test "$enable_largefile" = "no"; then
  AC_DEFINE([YAT_LFS_DISABLED], 1,
            [defined to 1 if large file support is disabled])
fi

# we use prefix INTERNAL_ for variables that are solely needed for
# building yat, i.e., they are not needed for a user of yat and are
# not propagated to yat-config or yat.m4.
AS_IF([test x"$ax_cv_cxx_compiler_vendor" = x"gnu"], [
  YAT_CXX_ADD_FLAG([INTERNAL_CXXFLAGS], [-Wall -pedantic])
])
YAT_CPP_ADD_FLAG([INTERNAL_CPPFLAGS], [-DHAVE_INLINE=1])
AC_ARG_ENABLE([debug],
  [AS_HELP_STRING([--enable-debug],[turn on debug options and code])])
if test "${enable_debug}" = "yes" ; then
  YAT_CPP_ADD_FLAG([INTERNAL_CPPFLAGS], [-DYAT_DEBUG=1])
  YAT_CXX_ADD_FLAG([INTERNAL_CXXFLAGS], [-g -O])
else
  # avoid defining GSL_RANGE_CHECK_OFF if GSL_RANGE_CHECK is already defined
  AC_CHECK_DECL([GSL_RANGE_CHECK],[],
                [YAT_CPP_ADD_FLAG([INTERNAL_CPPFLAGS],[-DGSL_RANGE_CHECK_OFF])])
  YAT_CPP_ADD_FLAG([INTERNAL_CPPFLAGS], [-DNDEBUG])
  YAT_CXX_ADD_FLAG([INTERNAL_CXXFLAGS], [-O3])
fi

# turn off compiler warning #654 from intel compiler
AS_IF([test x"$ax_cv_cxx_compiler_vendor" = x"intel"], [
  YAT_CXX_ADD_FLAG([CXXFLAGS], ['-diag-disable 654'])
])

# Turns warnings to errors in compilation tests. Only put tests that
# should be warning sensitive below this point. Can't find any
# mechanism to revert AC_LANG_WERROR
AC_LANG_WERROR

# GCC 4.0.1 on OSX complains about -pthread (issue #713)
AS_IF([AS_ECHO(["$CPPFLAGS"]) | $GREP '\-pthread' > /dev/null],
  [AX_CHECK_PREPROC_FLAG([-pthread], [],
     [CPPFLAGS=`AS_ECHO(["$CPPFLAGS"]) | $SED 's%-pthread%%'`],
     [$INTERNAL_CPPFLAGS])
])

# some versions of boost uses long long - turn off compiler warnings
# with -Wno-long-long
yat_save_CXXFLAGS=$CXXFLAGS
AC_MSG_CHECKING([whether boost uses long long])
CXXFLAGS="$INTERNAL_CXXFLAGS $CXXFLAGS"
AC_COMPILE_IFELSE([AC_LANG_PROGRAM(
  [
    @%:@include <boost/iterator/transform_iterator.hpp>
    @%:@include <boost/thread.hpp>
    @%:@include <cmath>
    @%:@include <functional>
    @%:@include <vector>
  ],[
      using namespace boost;
      typedef std::pointer_to_unary_function<double, double> F;
      std::vector<double> vec;
      transform_iterator<F, std::vector<double>::iterator>
        i(vec.begin(), std::ptr_fun(fabs));
      int x = boost::thread::hardware_concurrency();
      ++x;
  ])],
[AC_MSG_RESULT([no])],
[AC_MSG_RESULT([yes])
 YAT_CXX_ADD_FLAG([INTERNAL_CXXFLAGS], [-Wno-long-long])
])
# restore CXXFLAGS
CXXFLAGS=$yat_save_CXXFLAGS

#doxygen stuff
DX_HTML_OUTPUT=html
AC_SUBST(DX_HTML_OUTPUT)

AC_CONFIG_FILES([build_support/gen_yat_pc.sh],
                [chmod +x build_support/gen_yat_pc.sh])
AC_CONFIG_FILES([build_support/tag_and_release.sh],
                [chmod +x-w build_support/tag_and_release.sh])
AC_CONFIG_FILES([Makefile
     doc/doxygen.config
     doc/first_page.doxygen
     test/common_defs.sh
])

AC_CONFIG_HEADERS([yat/utility/config_public.h])
# for the test suite
yat_abs_top_srcdir=`cd $srcdir && pwd`
AC_DEFINE_UNQUOTED([YAT_ABS_TOP_SRCDIR], ["$yat_abs_top_srcdir"],
                   [Define to absolute path to top yat src dir])

# Print failure status information about selected items, and exit if
# fatal errors were encountered. No output will be created if
# configure is halted prematurely.

# used to trigger exit before creation of output
all_reqs_ok="true"

# No support for quiet NAN is fatal -- sub-sequent compilation, or execution
# of created binary, will fail.
if test "${quiet_nan}" = "no" ; then
  all_reqs_ok="false"
  AC_MSG_WARN([
  Support for quiet NAN required.
  yat will not work on this system!])
fi

# No support for infinity is fatal -- sub-sequent compilation, or execution
# of created binary, will fail.
if test "${has_infinity}" = "no" ; then
  all_reqs_ok="false"
  AC_MSG_WARN([
  Support for infinity required.
  yat will not work on this system!])
fi


# Non-existing GSL is fatal -- sub-sequent compilation will fail.
if test "x$gsl_ok" != "xyes" ; then
  all_reqs_ok="false"
  AC_MSG_WARN([
  GSL $gsl_version (or newer) not found. The GNU Scientific Library
  (GSL) library cannot be found. Please make sure GSL is
  installed. Please refer to warnings above for more details])
fi

if test "x$want_boost" = "xyes"; then
# Too old Boost is fatal -- sub-sequent compilation will fail.
AS_IF([test "${boost_ok}" != "yes"],[
  all_reqs_ok="false"
  AC_MSG_WARN([
  Boost ${boost_version} (or newer) not found. Please make sure Boost
  is installed.])
], [
  AS_IF([test x$ax_cv_boost_thread = xno], [
    all_reqs_ok="false"
    AC_MSG_WARN([
  Boost thread library not found. Please make sure library boost-thread is
  is installed.])
  ])
])
fi

if (test "$all_reqs_ok" = "false") ; then
  AC_MSG_FAILURE([
  Some pre-requisites were not fulfilled, aborting configure.
  Please consult the 'README' file for more information about what
  is needed to compile yat and refer to above warning messages.
  Needed files were NOT created.])
fi

# Reset flags
APR_RESTORE_THE_ENVIRONMENT(CPPFLAGS, YAT_)
APR_RESTORE_THE_ENVIRONMENT(CXXFLAGS, YAT_)
APR_RESTORE_THE_ENVIRONMENT(LDFLAGS, YAT_)
APR_RESTORE_THE_ENVIRONMENT(LIBS, YAT_)

YAT_PRIMARY_LIBS="-lgsl $BOOST_THREAD_LIB $BOOST_SYSTEM_LIB"
YAT_LIBS="$YAT_PRIMARY_LIBS $YAT_CBLAS_LIB $LIBM"
AC_SUBST(YAT_PRIMARY_LIBS)
AC_SUBST(YAT_LIBS)
AC_SUBST(YAT_CBLAS_LIB)

# set and AC_SUBST variables that are interpreted by Automake
AM_CPPFLAGS="-I\$(top_srcdir) $INTERNAL_CPPFLAGS $YAT_CPPFLAGS"
AM_CXXFLAGS="$INTERNAL_CXXFLAGS $YAT_CXXFLAGS"
AM_LDFLAGS="$INTERNAL_LDFLAGS $YAT_LDFLAGS"

AC_SUBST(AM_CPPFLAGS)
AC_SUBST(AM_CXXFLAGS)
AC_SUBST(AM_LDFLAGS)
AC_SUBST(enable_static)

YAT_SVN_RELEASE([am/maintainer.am])

# set some variable for final message
AS_CASE([$have_doxygen],
        [yes], [doxygen_message=yes],
        [no], [doxygen_message="no (doxygen not found)"],
        [old], [doxygen_message="no (\`$DOXYGEN' too old)"],
        [AC_MSG_WARN([unexpected value \$have_doxygen: '$have_doxygen'])
         AS_BOX([Report this to ]AC_PACKAGE_BUGREPORT)
        ])

yat_gslcblas_message=
AS_IF([test "x$YAT_CBLAS_LIB" = "x-lgslcblas"], [
yat_gslcblas_message='
  GSL CBLAS found. This is a reference implementation only.
  Consider using hardware optimized BLAS.
  ATLAS (http://math-atlas.sourceforge.net/) provides an
  optimized BLAS library. It is supported by yat!
'
])

AC_MSG_RESULT([----------------------------------------------------------------])
AC_MSG_RESULT([Creating yat configuration])
# Create output.
AC_OUTPUT


# Some more messages.
AC_MSG_RESULT([
yat is configured as follows:

  Build Shared Library: $enable_shared
  Build Static Library: $enable_static
  Build Documentation:  $doxygen_message

Options used to compile and link:
  VERSION     = $VERSION
  CXX         = $CXX
  CPPFLAGS    = $CPPFLAGS
  YAT_CPPFLAGS= $AM_CPPFLAGS
  CXXFLAGS    = $CXXFLAGS
  YAT_CXXFLAGS= $AM_CXXFLAGS
  LD          = $LD
  LDFLAGS     = $LDFLAGS
  YAT_LDFLAGS = $AM_LDFLAGS
  LIBS        = $LIBS
  YAT_LIBS    = $YAT_LIBS
${yat_gslcblas_message}dnl
----------------------------------------------------------------
Now type `make'. dnl
])