# generated automatically by aclocal 1.15 -*- Autoconf -*-

# Copyright (C) 1996-2014 Free Software Foundation, Inc.

# This file is free software; the Free Software Foundation

# gives unlimited permission to copy and/or distribute it,

# with or without modifications, as long as this notice is preserved.

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY, to the extent permitted by law; without

# even the implied warranty of MERCHANTABILITY or FITNESS FOR A

# PARTICULAR PURPOSE.

m4_ifndef([AC_CONFIG_MACRO_DIRS], [m4_defun([_AM_CONFIG_MACRO_DIRS], [])m4_defun([AC_CONFIG_MACRO_DIRS], [_AM_CONFIG_MACRO_DIRS($@)])])

m4_ifndef([AC_AUTOCONF_VERSION],

  [m4_copy([m4_PACKAGE_VERSION], [AC_AUTOCONF_VERSION])])dnl

m4_if(m4_defn([AC_AUTOCONF_VERSION]), [2.69],,

[m4_warning([this file was generated for autoconf 2.69.

You have another version of autoconf.  It may work, but is not guaranteed to.

If you have problems, you may need to regenerate the build system entirely.

To do so, use the procedure documented by the package, typically 'autoreconf'.])])

dnl pkg.m4 - Macros to locate and utilise pkg-config.   -*- Autoconf -*-

dnl serial 11 (pkg-config-0.29.1)

dnl

dnl Copyright © 2004 Scott James Remnant <scott@netsplit.com>.

dnl Copyright © 2012-2015 Dan Nicholson <dbn.lists@gmail.com>

dnl

dnl This program is free software; you can redistribute it and/or modify

dnl it under the terms of the GNU General Public License as published by

dnl the Free Software Foundation; either version 2 of the License, or

dnl (at your option) any later version.

dnl

dnl This program is distributed in the hope that it will be useful, but

dnl WITHOUT ANY WARRANTY; without even the implied warranty of

dnl MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

dnl General Public License for more details.

dnl

dnl You should have received a copy of the GNU General Public License

dnl along with this program; if not, write to the Free Software

dnl Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA

dnl 02111-1307, USA.

dnl

dnl As a special exception to the GNU General Public License, if you

dnl distribute this file as part of a program that contains a

dnl configuration script generated by Autoconf, you may include it under

dnl the same distribution terms that you use for the rest of that

dnl program.

dnl PKG_PREREQ(MIN-VERSION)

dnl -----------------------

dnl Since: 0.29

dnl

dnl Verify that the version of the pkg-config macros are at least

dnl MIN-VERSION. Unlike PKG_PROG_PKG_CONFIG, which checks the user's

dnl installed version of pkg-config, this checks the developer's version

dnl of pkg.m4 when generating configure.

dnl

dnl To ensure that this macro is defined, also add:

dnl m4_ifndef([PKG_PREREQ],

dnl     [m4_fatal([must install pkg-config 0.29 or later before running autoconf/autogen])])

dnl

dnl See the "Since" comment for each macro you use to see what version

dnl of the macros you require.

m4_defun([PKG_PREREQ],

[m4_define([PKG_MACROS_VERSION], [0.29.1])

m4_if(m4_version_compare(PKG_MACROS_VERSION, [$1]), -1,

    [m4_fatal([pkg.m4 version $1 or higher is required but ]PKG_MACROS_VERSION[ found])])

])dnl PKG_PREREQ

dnl PKG_PROG_PKG_CONFIG([MIN-VERSION])

dnl ----------------------------------

dnl Since: 0.16

dnl

dnl Search for the pkg-config tool and set the PKG_CONFIG variable to

dnl first found in the path. Checks that the version of pkg-config found

dnl is at least MIN-VERSION. If MIN-VERSION is not specified, 0.9.0 is

dnl used since that's the first version where most current features of

dnl pkg-config existed.

AC_DEFUN([PKG_PROG_PKG_CONFIG],

[m4_pattern_forbid([^_?PKG_[A-Z_]+$])

m4_pattern_allow([^PKG_CONFIG(_(PATH|LIBDIR|SYSROOT_DIR|ALLOW_SYSTEM_(CFLAGS|LIBS)))?$])

m4_pattern_allow([^PKG_CONFIG_(DISABLE_UNINSTALLED|TOP_BUILD_DIR|DEBUG_SPEW)$])

AC_ARG_VAR([PKG_CONFIG], [path to pkg-config utility])

AC_ARG_VAR([PKG_CONFIG_PATH], [directories to add to pkg-config's search path])

AC_ARG_VAR([PKG_CONFIG_LIBDIR], [path overriding pkg-config's built-in search path])

if test "x$ac_cv_env_PKG_CONFIG_set" != "xset"; then

	AC_PATH_TOOL([PKG_CONFIG], [pkg-config])

fi

if test -n "$PKG_CONFIG"; then

	_pkg_min_version=m4_default([$1], [0.9.0])

	AC_MSG_CHECKING([pkg-config is at least version $_pkg_min_version])

	if $PKG_CONFIG --atleast-pkgconfig-version $_pkg_min_version; then

		AC_MSG_RESULT([yes])

	else

		AC_MSG_RESULT([no])

		PKG_CONFIG=""

	fi

fi[]dnl

])dnl PKG_PROG_PKG_CONFIG

dnl PKG_CHECK_EXISTS(MODULES, [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND])

dnl -------------------------------------------------------------------

dnl Since: 0.18

dnl

dnl Check to see whether a particular set of modules exists. Similar to

dnl PKG_CHECK_MODULES(), but does not set variables or print errors.

dnl

dnl Please remember that m4 expands AC_REQUIRE([PKG_PROG_PKG_CONFIG])

dnl only at the first occurence in configure.ac, so if the first place

dnl it's called might be skipped (such as if it is within an "if", you

dnl have to call PKG_CHECK_EXISTS manually

AC_DEFUN([PKG_CHECK_EXISTS],

[AC_REQUIRE([PKG_PROG_PKG_CONFIG])dnl

if test -n "$PKG_CONFIG" && \

    AC_RUN_LOG([$PKG_CONFIG --exists --print-errors "$1"]); then

  m4_default([$2], [:])

m4_ifvaln([$3], [else

  $3])dnl

fi])

dnl _PKG_CONFIG([VARIABLE], [COMMAND], [MODULES])

dnl ---------------------------------------------

dnl Internal wrapper calling pkg-config via PKG_CONFIG and setting

dnl pkg_failed based on the result.

m4_define([_PKG_CONFIG],

[if test -n "$$1"; then

    pkg_cv_[]$1="$$1"

 elif test -n "$PKG_CONFIG"; then

    PKG_CHECK_EXISTS([$3],

                     [pkg_cv_[]$1=`$PKG_CONFIG --[]$2 "$3" 2>/dev/null`

		      test "x$?" != "x0" && pkg_failed=yes ],

		     [pkg_failed=yes])

 else

    pkg_failed=untried

fi[]dnl

])dnl _PKG_CONFIG

dnl _PKG_SHORT_ERRORS_SUPPORTED

dnl ---------------------------

dnl Internal check to see if pkg-config supports short errors.

AC_DEFUN([_PKG_SHORT_ERRORS_SUPPORTED],

[AC_REQUIRE([PKG_PROG_PKG_CONFIG])

if $PKG_CONFIG --atleast-pkgconfig-version 0.20; then

        _pkg_short_errors_supported=yes

else

        _pkg_short_errors_supported=no

fi[]dnl

])dnl _PKG_SHORT_ERRORS_SUPPORTED

dnl PKG_CHECK_MODULES(VARIABLE-PREFIX, MODULES, [ACTION-IF-FOUND],

dnl   [ACTION-IF-NOT-FOUND])

dnl --------------------------------------------------------------

dnl Since: 0.4.0

dnl

dnl Note that if there is a possibility the first call to

dnl PKG_CHECK_MODULES might not happen, you should be sure to include an

dnl explicit call to PKG_PROG_PKG_CONFIG in your configure.ac

AC_DEFUN([PKG_CHECK_MODULES],

[AC_REQUIRE([PKG_PROG_PKG_CONFIG])dnl

AC_ARG_VAR([$1][_CFLAGS], [C compiler flags for $1, overriding pkg-config])dnl

AC_ARG_VAR([$1][_LIBS], [linker flags for $1, overriding pkg-config])dnl

pkg_failed=no

AC_MSG_CHECKING([for $1])

_PKG_CONFIG([$1][_CFLAGS], [cflags], [$2])

_PKG_CONFIG([$1][_LIBS], [libs], [$2])

m4_define([_PKG_TEXT], [Alternatively, you may set the environment variables $1[]_CFLAGS

and $1[]_LIBS to avoid the need to call pkg-config.

See the pkg-config man page for more details.])

if test $pkg_failed = yes; then

   	AC_MSG_RESULT([no])

        _PKG_SHORT_ERRORS_SUPPORTED

        if test $_pkg_short_errors_supported = yes; then

	        $1[]_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors --cflags --libs "$2" 2>&1`

        else 

	        $1[]_PKG_ERRORS=`$PKG_CONFIG --print-errors --cflags --libs "$2" 2>&1`

        fi

	# Put the nasty error message in config.log where it belongs

	echo "$$1[]_PKG_ERRORS" >&AS_MESSAGE_LOG_FD

	m4_default([$4], [AC_MSG_ERROR(

[Package requirements ($2) were not met:

$$1_PKG_ERRORS

Consider adjusting the PKG_CONFIG_PATH environment variable if you

installed software in a non-standard prefix.

_PKG_TEXT])[]dnl

        ])

elif test $pkg_failed = untried; then

     	AC_MSG_RESULT([no])

	m4_default([$4], [AC_MSG_FAILURE(

[The pkg-config script could not be found or is too old.  Make sure it

is in your PATH or set the PKG_CONFIG environment variable to the full

path to pkg-config.

_PKG_TEXT

To get pkg-config, see <http://pkg-config.freedesktop.org/>.])[]dnl

        ])

else

	$1[]_CFLAGS=$pkg_cv_[]$1[]_CFLAGS

	$1[]_LIBS=$pkg_cv_[]$1[]_LIBS

        AC_MSG_RESULT([yes])

	$3

fi[]dnl

])dnl PKG_CHECK_MODULES

dnl PKG_CHECK_MODULES_STATIC(VARIABLE-PREFIX, MODULES, [ACTION-IF-FOUND],

dnl   [ACTION-IF-NOT-FOUND])

dnl ---------------------------------------------------------------------

dnl Since: 0.29

dnl

dnl Checks for existence of MODULES and gathers its build flags with

dnl static libraries enabled. Sets VARIABLE-PREFIX_CFLAGS from --cflags

dnl and VARIABLE-PREFIX_LIBS from --libs.

dnl

dnl Note that if there is a possibility the first call to

dnl PKG_CHECK_MODULES_STATIC might not happen, you should be sure to

dnl include an explicit call to PKG_PROG_PKG_CONFIG in your

dnl configure.ac.

AC_DEFUN([PKG_CHECK_MODULES_STATIC],

[AC_REQUIRE([PKG_PROG_PKG_CONFIG])dnl

_save_PKG_CONFIG=$PKG_CONFIG

PKG_CONFIG="$PKG_CONFIG --static"

PKG_CHECK_MODULES($@)

PKG_CONFIG=$_save_PKG_CONFIG[]dnl

])dnl PKG_CHECK_MODULES_STATIC

dnl PKG_INSTALLDIR([DIRECTORY])

dnl -------------------------

dnl Since: 0.27

dnl

dnl Substitutes the variable pkgconfigdir as the location where a module

dnl should install pkg-config .pc files. By default the directory is

dnl $libdir/pkgconfig, but the default can be changed by passing

dnl DIRECTORY. The user can override through the --with-pkgconfigdir

dnl parameter.

AC_DEFUN([PKG_INSTALLDIR],

[m4_pushdef([pkg_default], [m4_default([$1], ['${libdir}/pkgconfig'])])

m4_pushdef([pkg_description],

    [pkg-config installation directory @<:@]pkg_default[@:>@])

AC_ARG_WITH([pkgconfigdir],

    [AS_HELP_STRING([--with-pkgconfigdir], pkg_description)],,

    [with_pkgconfigdir=]pkg_default)

AC_SUBST([pkgconfigdir], [$with_pkgconfigdir])

m4_popdef([pkg_default])

m4_popdef([pkg_description])

])dnl PKG_INSTALLDIR

dnl PKG_NOARCH_INSTALLDIR([DIRECTORY])

dnl --------------------------------

dnl Since: 0.27

dnl

dnl Substitutes the variable noarch_pkgconfigdir as the location where a

dnl module should install arch-independent pkg-config .pc files. By

dnl default the directory is $datadir/pkgconfig, but the default can be

dnl changed by passing DIRECTORY. The user can override through the

dnl --with-noarch-pkgconfigdir parameter.

AC_DEFUN([PKG_NOARCH_INSTALLDIR],

[m4_pushdef([pkg_default], [m4_default([$1], ['${datadir}/pkgconfig'])])

m4_pushdef([pkg_description],

    [pkg-config arch-independent installation directory @<:@]pkg_default[@:>@])

AC_ARG_WITH([noarch-pkgconfigdir],

    [AS_HELP_STRING([--with-noarch-pkgconfigdir], pkg_description)],,

    [with_noarch_pkgconfigdir=]pkg_default)

AC_SUBST([noarch_pkgconfigdir], [$with_noarch_pkgconfigdir])

m4_popdef([pkg_default])

m4_popdef([pkg_description])

])dnl PKG_NOARCH_INSTALLDIR

dnl PKG_CHECK_VAR(VARIABLE, MODULE, CONFIG-VARIABLE,

dnl [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND])

dnl -------------------------------------------

dnl Since: 0.28

dnl

dnl Retrieves the value of the pkg-config variable for the given module.

AC_DEFUN([PKG_CHECK_VAR],

[AC_REQUIRE([PKG_PROG_PKG_CONFIG])dnl

AC_ARG_VAR([$1], [value of $3 for $2, overriding pkg-config])dnl

_PKG_CONFIG([$1], [variable="][$3]["], [$2])

AS_VAR_COPY([$1], [pkg_cv_][$1])

AS_VAR_IF([$1], [""], [$5], [$4])dnl

])dnl PKG_CHECK_VAR

# ===========================================================================

#   http://www.gnu.org/software/autoconf-archive/ax_cxx_compile_stdcxx.html

# ===========================================================================

#

# SYNOPSIS

#

#   MM_AX_CXX_COMPILE_STDCXX(VERSION, [ext|noext], [mandatory|optional])

#

# DESCRIPTION

#

#   Check for baseline language coverage in the compiler for the specified

#   version of the C++ standard.  If necessary, add switches to CXXFLAGS to

#   enable support.  VERSION may be '11' (for the C++11 standard) or '14'

#   (for the C++14 standard).

#

#   The second argument, if specified, indicates whether you insist on an

#   extended mode (e.g. -std=gnu++11) or a strict conformance mode (e.g.

#   -std=c++11).  If neither is specified, you get whatever works, with

#   preference for an extended mode.

#

#   The third argument, if specified 'mandatory' or if left unspecified,

#   indicates that baseline support for the specified C++ standard is

#   required and that the macro should error out if no mode with that

#   support is found.  If specified 'optional', then configuration proceeds

#   regardless, after defining HAVE_CXX${VERSION} if and only if a

#   supporting mode is found.

#

# LICENSE

#

#   Copyright (c) 2008 Benjamin Kosnik <bkoz@redhat.com>

#   Copyright (c) 2012 Zack Weinberg <zackw@panix.com>

#   Copyright (c) 2013 Roy Stogner <roystgnr@ices.utexas.edu>

#   Copyright (c) 2014, 2015 Google Inc.; contributed by Alexey Sokolov <sokolov@google.com>

#   Copyright (c) 2015 Paul Norman <penorman@mac.com>

#   Copyright (c) 2015 Moritz Klammler <moritz@klammler.eu>

#

#   Copying and distribution of this file, with or without modification, are

#   permitted in any medium without royalty provided the copyright notice

#   and this notice are preserved.  This file is offered as-is, without any

#   warranty.

# Copied from ax_cxx_compile_stdcxx.m4 and added MM_ prefix to avoid

# possible conflict with AX_CXX_COMPILE_STDCXX in other modules.

#serial 1

dnl  This macro is based on the code from the MM_AX_CXX_COMPILE_STDCXX_11 macro

dnl  (serial version number 13).

AC_DEFUN([MM_AX_CXX_COMPILE_STDCXX], [dnl

  m4_if([$1], [11], [],

        [$1], [14], [],

        [$1], [17], [m4_fatal([support for C++17 not yet implemented in MM_AX_CXX_COMPILE_STDCXX])],

        [m4_fatal([invalid first argument `$1' to MM_AX_CXX_COMPILE_STDCXX])])dnl

  m4_if([$2], [], [],

        [$2], [ext], [],

        [$2], [noext], [],

        [m4_fatal([invalid second argument `$2' to MM_AX_CXX_COMPILE_STDCXX])])dnl

  m4_if([$3], [], [ax_cxx_compile_cxx$1_required=true],

        [$3], [mandatory], [ax_cxx_compile_cxx$1_required=true],

        [$3], [optional], [ax_cxx_compile_cxx$1_required=false],

        [m4_fatal([invalid third argument `$3' to MM_AX_CXX_COMPILE_STDCXX])])

  AC_LANG_PUSH([C++])dnl

  ac_success=no

  AC_CACHE_CHECK(whether $CXX supports C++$1 features by default,

  ax_cv_cxx_compile_cxx$1,

  [AC_COMPILE_IFELSE([AC_LANG_SOURCE([_MM_AX_CXX_COMPILE_STDCXX_testbody_$1])],

    [ax_cv_cxx_compile_cxx$1=yes],

    [ax_cv_cxx_compile_cxx$1=no])])

  if test x$ax_cv_cxx_compile_cxx$1 = xyes; then

    ac_success=yes

  fi

  m4_if([$2], [noext], [], [dnl

  if test x$ac_success = xno; then

    for switch in -std=gnu++$1 -std=gnu++0x; do

      cachevar=AS_TR_SH([ax_cv_cxx_compile_cxx$1_$switch])

      AC_CACHE_CHECK(whether $CXX supports C++$1 features with $switch,

                     $cachevar,

        [ac_save_CXXFLAGS="$CXXFLAGS"

         CXXFLAGS="$CXXFLAGS $switch"

         AC_COMPILE_IFELSE([AC_LANG_SOURCE([_MM_AX_CXX_COMPILE_STDCXX_testbody_$1])],

          [eval $cachevar=yes],

          [eval $cachevar=no])

         CXXFLAGS="$ac_save_CXXFLAGS"])

      if eval test x\$$cachevar = xyes; then

        CXXFLAGS="$CXXFLAGS $switch"

        ac_success=yes

        break

      fi

    done

  fi])

  m4_if([$2], [ext], [], [dnl

  if test x$ac_success = xno; then

    dnl HP's aCC needs +std=c++11 according to:

    dnl http://h21007.www2.hp.com/portal/download/files/unprot/aCxx/PDF_Release_Notes/769149-001.pdf

    dnl Cray's crayCC needs "-h std=c++11"

    for switch in -std=c++$1 -std=c++0x +std=c++$1 "-h std=c++$1"; do

      cachevar=AS_TR_SH([ax_cv_cxx_compile_cxx$1_$switch])

      AC_CACHE_CHECK(whether $CXX supports C++$1 features with $switch,

                     $cachevar,

        [ac_save_CXXFLAGS="$CXXFLAGS"

         CXXFLAGS="$CXXFLAGS $switch"

         AC_COMPILE_IFELSE([AC_LANG_SOURCE([_MM_AX_CXX_COMPILE_STDCXX_testbody_$1])],

          [eval $cachevar=yes],

          [eval $cachevar=no])

         CXXFLAGS="$ac_save_CXXFLAGS"])

      if eval test x\$$cachevar = xyes; then

        CXXFLAGS="$CXXFLAGS $switch"

        ac_success=yes

        break

      fi

    done

  fi])

  AC_LANG_POP([C++])

  if test x$ax_cxx_compile_cxx$1_required = xtrue; then

    if test x$ac_success = xno; then

      AC_MSG_ERROR([*** A compiler with support for C++$1 language features is required.])

    fi

  else

    if test x$ac_success = xno; then

      HAVE_CXX$1=0

      AC_MSG_NOTICE([No compiler with C++$1 support was found])

    else

      HAVE_CXX$1=1

      AC_DEFINE(HAVE_CXX$1,1,

                [define if the compiler supports basic C++$1 syntax])

    fi

    AC_SUBST(HAVE_CXX$1)

  fi

])

dnl  Test body for checking C++11 support

m4_define([_MM_AX_CXX_COMPILE_STDCXX_testbody_11],

  _MM_AX_CXX_COMPILE_STDCXX_testbody_new_in_11

)

dnl  Test body for checking C++14 support

m4_define([_MM_AX_CXX_COMPILE_STDCXX_testbody_14],

  _MM_AX_CXX_COMPILE_STDCXX_testbody_new_in_11

  _MM_AX_CXX_COMPILE_STDCXX_testbody_new_in_14

)

dnl  Tests for new features in C++11

m4_define([_MM_AX_CXX_COMPILE_STDCXX_testbody_new_in_11], [[

// If the compiler admits that it is not ready for C++11, why torture it?

// Hopefully, this will speed up the test.

#ifndef __cplusplus

#error "This is not a C++ compiler"

#elif __cplusplus < 201103L

#error "This is not a C++11 compiler"

#else

namespace cxx11

{

  namespace test_static_assert

  {

    template <typename T>

    struct check

    {

      static_assert(sizeof(int) <= sizeof(T), "not big enough");

    };

  }

  namespace test_final_override

  {

    struct Base

    {

      virtual void f() {}

    };

    struct Derived : public Base

    {

      virtual void f() override {}

    };

  }

  namespace test_double_right_angle_brackets

  {

    template < typename T >

    struct check {};

    typedef check<void> single_type;

    typedef check<check<void>> double_type;

    typedef check<check<check<void>>> triple_type;

    typedef check<check<check<check<void>>>> quadruple_type;

  }

  namespace test_decltype

  {

    int

    f()

    {

      int a = 1;

      decltype(a) b = 2;

      return a + b;

    }

  }

  namespace test_type_deduction

  {

    template < typename T1, typename T2 >

    struct is_same

    {

      static const bool value = false;

    };

    template < typename T >

    struct is_same<T, T>

    {

      static const bool value = true;

    };

    template < typename T1, typename T2 >

    auto

    add(T1 a1, T2 a2) -> decltype(a1 + a2)

    {

      return a1 + a2;

    }

    int

    test(const int c, volatile int v)

    {

      static_assert(is_same<int, decltype(0)>::value == true, "");

      static_assert(is_same<int, decltype(c)>::value == false, "");

      static_assert(is_same<int, decltype(v)>::value == false, "");

      auto ac = c;

      auto av = v;

      auto sumi = ac + av + 'x';

      auto sumf = ac + av + 1.0;

      static_assert(is_same<int, decltype(ac)>::value == true, "");

      static_assert(is_same<int, decltype(av)>::value == true, "");

      static_assert(is_same<int, decltype(sumi)>::value == true, "");

      static_assert(is_same<int, decltype(sumf)>::value == false, "");

      static_assert(is_same<int, decltype(add(c, v))>::value == true, "");

      return (sumf > 0.0) ? sumi : add(c, v);

    }

  }

  namespace test_noexcept

  {

    int f() { return 0; }

    int g() noexcept { return 0; }

    static_assert(noexcept(f()) == false, "");

    static_assert(noexcept(g()) == true, "");

  }

  namespace test_constexpr

  {

    template < typename CharT >

    unsigned long constexpr

    strlen_c_r(const CharT *const s, const unsigned long acc) noexcept

    {

      return *s ? strlen_c_r(s + 1, acc + 1) : acc;

    }

    template < typename CharT >

    unsigned long constexpr

    strlen_c(const CharT *const s) noexcept

    {

      return strlen_c_r(s, 0UL);

    }

    static_assert(strlen_c("") == 0UL, "");

    static_assert(strlen_c("1") == 1UL, "");

    static_assert(strlen_c("example") == 7UL, "");

    static_assert(strlen_c("another\0example") == 7UL, "");

  }

  namespace test_rvalue_references

  {

    template < int N >

    struct answer

    {

      static constexpr int value = N;

    };

    answer<1> f(int&)       { return answer<1>(); }

    answer<2> f(const int&) { return answer<2>(); }

    answer<3> f(int&&)      { return answer<3>(); }

    void

    test()

    {

      int i = 0;

      const int c = 0;

      static_assert(decltype(f(i))::value == 1, "");

      static_assert(decltype(f(c))::value == 2, "");

      static_assert(decltype(f(0))::value == 3, "");

    }

  }

  namespace test_uniform_initialization

  {

    struct test

    {

      static const int zero {};

      static const int one {1};

    };

    static_assert(test::zero == 0, "");

    static_assert(test::one == 1, "");

  }

  namespace test_lambdas

  {

    void

    test1()

    {

      auto lambda1 = [](){};

      auto lambda2 = lambda1;

      lambda1();

      lambda2();

    }

    int

    test2()

    {

      auto a = [](int i, int j){ return i + j; }(1, 2);

      auto b = []() -> int { return '0'; }();

      auto c = [=](){ return a + b; }();

      auto d = [&](){ return c; }();

      auto e = [a, &b](int x) mutable {

        const auto identity = [](int y){ return y; };

        for (auto i = 0; i < a; ++i)

          a += b--;

        return x + identity(a + b);

      }(0);

      return a + b + c + d + e;

    }

    int

    test3()

    {

      const auto nullary = [](){ return 0; };

      const auto unary = [](int x){ return x; };

      using nullary_t = decltype(nullary);

      using unary_t = decltype(unary);

      const auto higher1st = [](nullary_t f){ return f(); };

      const auto higher2nd = [unary](nullary_t f1){

        return [unary, f1](unary_t f2){ return f2(unary(f1())); };

      };

      return higher1st(nullary) + higher2nd(nullary)(unary);

    }

  }

  namespace test_variadic_templates

  {

    template <int...>

    struct sum;

    template <int N0, int... N1toN>

    struct sum<N0, N1toN...>

    {

      static constexpr auto value = N0 + sum<N1toN...>::value;

    };

    template <>

    struct sum<>

    {

      static constexpr auto value = 0;

    };

    static_assert(sum<>::value == 0, "");

    static_assert(sum<1>::value == 1, "");

    static_assert(sum<23>::value == 23, "");

    static_assert(sum<1, 2>::value == 3, "");

    static_assert(sum<5, 5, 11>::value == 21, "");

    static_assert(sum<2, 3, 5, 7, 11, 13>::value == 41, "");

  }

  // http://stackoverflow.com/questions/13728184/template-aliases-and-sfinae

  // Clang 3.1 fails with headers of libstd++ 4.8.3 when using std::function

  // because of this.

  namespace test_template_alias_sfinae

  {

    struct foo {};

    template<typename T>

    using member = typename T::member_type;

    template<typename T>

    void func(...) {}

    template<typename T>

    void func(member<T>*) {}

    void test();

    void test() { func<foo>(0); }

  }

}  // namespace cxx11

#endif  // __cplusplus >= 201103L

]])

dnl  Tests for new features in C++14

m4_define([_MM_AX_CXX_COMPILE_STDCXX_testbody_new_in_14], [[

// If the compiler admits that it is not ready for C++14, why torture it?

// Hopefully, this will speed up the test.

#ifndef __cplusplus

#error "This is not a C++ compiler"

#elif __cplusplus < 201402L

#error "This is not a C++14 compiler"

#else

namespace cxx14

{

  namespace test_polymorphic_lambdas

  {

    int

    test()

    {

      const auto lambda = [](auto&&... args){

        const auto istiny = [](auto x){

          return (sizeof(x) == 1UL) ? 1 : 0;

        };

        const int aretiny[] = { istiny(args)... };

        return aretiny[0];

      };

      return lambda(1, 1L, 1.0f, '1');

    }

  }

  namespace test_binary_literals

  {

    constexpr auto ivii = 0b0000000000101010;

    static_assert(ivii == 42, "wrong value");

  }

  namespace test_generalized_constexpr

  {

    template < typename CharT >

    constexpr unsigned long

    strlen_c(const CharT *const s) noexcept

    {

      auto length = 0UL;

      for (auto p = s; *p; ++p)

        ++length;

      return length;

    }

    static_assert(strlen_c("") == 0UL, "");

    static_assert(strlen_c("x") == 1UL, "");

    static_assert(strlen_c("test") == 4UL, "");

    static_assert(strlen_c("another\0test") == 7UL, "");

  }

  namespace test_lambda_init_capture

  {

    int

    test()

    {

      auto x = 0;

      const auto lambda1 = [a = x](int b){ return a + b; };

      const auto lambda2 = [a = lambda1(x)](){ return a; };

      return lambda2();

    }

  }

  namespace test_digit_seperators

  {

    constexpr auto ten_million = 100'000'000;

    static_assert(ten_million == 100000000, "");

  }

  namespace test_return_type_deduction

  {

    auto f(int& x) { return x; }

    decltype(auto) g(int& x) { return x; }

    template < typename T1, typename T2 >

    struct is_same

    {

      static constexpr auto value = false;

    };

    template < typename T >

    struct is_same<T, T>

    {

      static constexpr auto value = true;

    };

    int

    test()

    {

      auto x = 0;

      static_assert(is_same<int, decltype(f(x))>::value, "");

      static_assert(is_same<int&, decltype(g(x))>::value, "");

      return x;

    }

  }

}  // namespace cxx14

#endif  // __cplusplus >= 201402L

]])

#serial 20090814

AC_DEFUN([_MM_PRE_INIT], [m4_pattern_forbid([^_?MM_])])

m4_define([_MM_PREREQ],

[dnl

m4_if(m4_quote(m4_version_compare([$2], [$3])), [-1],

      [m4_fatal([$4 requires $1 $3 (version $2 is installed)])])[]dnl

])

AC_DEFUN([MM_PREREQ],

[dnl

m4_assert([$# >= 1])[]dnl

AC_REQUIRE([_MM_PRE_INIT])[]dnl

_MM_PREREQ([mm-common], [0.9.10], [$1], m4_defn([AC_PACKAGE_NAME]))[]dnl

])

#serial 20091224