Vamp Plugin SDK

# From autoconf archive:

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

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

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

#

# SYNOPSIS

#

#   AX_CXX_COMPILE_STDCXX_11([ext|noext],[mandatory|optional])

#

# DESCRIPTION

#

#   Check for baseline language coverage in the compiler for the C++11

#   standard; if necessary, add switches to CXXFLAGS to enable support.

#

#   The first 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 second argument, if specified 'mandatory' or if left unspecified,

#   indicates that baseline C++11 support 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_CXX11 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 Alexey Sokolov <sokolov@google.com>

#

#   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.

m4_define([_AX_CXX_COMPILE_STDCXX_11_testbody], [[

  template <typename T>

    struct check

    {

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

    };

    struct Base {

    virtual void f() {}

    };

    struct Child : public Base {

    virtual void f() override {}

    };

    typedef check<check<bool>> right_angle_brackets;

    int a;

    decltype(a) b;

    typedef check<int> check_type;

    check_type c;

    check_type&& cr = static_cast<check_type&&>(c);

    auto d = a;

    auto l = [](){};

]])

AC_DEFUN([AX_CXX_COMPILE_STDCXX_11], [dnl

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

        [$1], [ext], [],

        [$1], [noext], [],

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

  m4_if([$2], [], [ax_cxx_compile_cxx11_required=true],

        [$2], [mandatory], [ax_cxx_compile_cxx11_required=true],

        [$2], [optional], [ax_cxx_compile_cxx11_required=false],

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

  AC_LANG_PUSH([C++])dnl

  ac_success=no

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

  ax_cv_cxx_compile_cxx11,

  [AC_COMPILE_IFELSE([AC_LANG_SOURCE([_AX_CXX_COMPILE_STDCXX_11_testbody])],

    [ax_cv_cxx_compile_cxx11=yes],

    [ax_cv_cxx_compile_cxx11=no])])

  if test x$ax_cv_cxx_compile_cxx11 = xyes; then

    ac_success=yes

  fi

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

  if test x$ac_success = xno; then

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

      cachevar=AS_TR_SH([ax_cv_cxx_compile_cxx11_$switch])

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

                     $cachevar,

        [ac_save_CXXFLAGS="$CXXFLAGS"

         CXXFLAGS="$CXXFLAGS $switch"

         AC_COMPILE_IFELSE([AC_LANG_SOURCE([_AX_CXX_COMPILE_STDCXX_11_testbody])],

          [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([$1], [ext], [], [dnl

  if test x$ac_success = xno; then

    for switch in -std=c++11 -std=c++0x; do

      cachevar=AS_TR_SH([ax_cv_cxx_compile_cxx11_$switch])

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

                     $cachevar,

        [ac_save_CXXFLAGS="$CXXFLAGS"

         CXXFLAGS="$CXXFLAGS $switch"

         AC_COMPILE_IFELSE([AC_LANG_SOURCE([_AX_CXX_COMPILE_STDCXX_11_testbody])],

          [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_cxx11_required = xtrue; then

    if test x$ac_success = xno; then

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

    fi

  else

    if test x$ac_success = xno; then

      HAVE_CXX11=0

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

    else

      HAVE_CXX11=1

      AC_DEFINE(HAVE_CXX11,1,

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

    fi

    AC_SUBST(HAVE_CXX11)

  fi

])

HAVE_CXX11

# We now require C++11

    ax_cxx_compile_cxx11_required=true

  ac_ext=cpp

ac_cpp='$CXXCPP $CPPFLAGS'

ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'

ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'

ac_compiler_gnu=$ac_cv_cxx_compiler_gnu

  ac_success=no

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CXX supports C++11 features by default" >&5

$as_echo_n "checking whether $CXX supports C++11 features by default... " >&6; }

if ${ax_cv_cxx_compile_cxx11+:} false; then :

  $as_echo_n "(cached) " >&6

else

  cat confdefs.h - <<_ACEOF >conftest.$ac_ext

/* end confdefs.h.  */

  template <typename T>

    struct check

    {

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

    };

    struct Base {

    virtual void f() {}

    };

    struct Child : public Base {

    virtual void f() override {}

    };

    typedef check<check<bool>> right_angle_brackets;

    int a;

    decltype(a) b;

    typedef check<int> check_type;

    check_type c;

    check_type&& cr = static_cast<check_type&&>(c);

    auto d = a;

    auto l = [](){};

_ACEOF

if ac_fn_cxx_try_compile "$LINENO"; then :

  ax_cv_cxx_compile_cxx11=yes

else

  ax_cv_cxx_compile_cxx11=no

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext

fi

{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ax_cv_cxx_compile_cxx11" >&5

$as_echo "$ax_cv_cxx_compile_cxx11" >&6; }

  if test x$ax_cv_cxx_compile_cxx11 = xyes; then

    ac_success=yes

  fi

    if test x$ac_success = xno; then

    for switch in -std=c++11 -std=c++0x; do

      cachevar=`$as_echo "ax_cv_cxx_compile_cxx11_$switch" | $as_tr_sh`

      { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CXX supports C++11 features with $switch" >&5

$as_echo_n "checking whether $CXX supports C++11 features with $switch... " >&6; }

if eval \${$cachevar+:} false; then :

  $as_echo_n "(cached) " >&6

else

  ac_save_CXXFLAGS="$CXXFLAGS"

         CXXFLAGS="$CXXFLAGS $switch"

         cat confdefs.h - <<_ACEOF >conftest.$ac_ext

/* end confdefs.h.  */

  template <typename T>

    struct check

    {

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

    };

    struct Base {

    virtual void f() {}

    };

    struct Child : public Base {

    virtual void f() override {}

    };

    typedef check<check<bool>> right_angle_brackets;

    int a;

    decltype(a) b;

    typedef check<int> check_type;

    check_type c;

    check_type&& cr = static_cast<check_type&&>(c);

    auto d = a;

    auto l = [](){};

_ACEOF

if ac_fn_cxx_try_compile "$LINENO"; then :

  eval $cachevar=yes

else

  eval $cachevar=no

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext

         CXXFLAGS="$ac_save_CXXFLAGS"

fi

eval ac_res=\$$cachevar

	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5

$as_echo "$ac_res" >&6; }

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

        CXXFLAGS="$CXXFLAGS $switch"

        ac_success=yes

        break

      fi

    done

  fi

  ac_ext=c

ac_cpp='$CPP $CPPFLAGS'

ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'

ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'

ac_compiler_gnu=$ac_cv_c_compiler_gnu

  if test x$ax_cxx_compile_cxx11_required = xtrue; then

    if test x$ac_success = xno; then

      as_fn_error $? "*** A compiler with support for C++11 language features is required." "$LINENO" 5

    fi

  else

    if test x$ac_success = xno; then

      HAVE_CXX11=0

      { $as_echo "$as_me:${as_lineno-$LINENO}: No compiler with C++11 support was found" >&5

$as_echo "$as_me: No compiler with C++11 support was found" >&6;}

    else

      HAVE_CXX11=1

$as_echo "#define HAVE_CXX11 1" >>confdefs.h

    fi

  fi

  CXXFLAGS="$CXXFLAGS -std=c++11"

# We now require C++11

AX_CXX_COMPILE_STDCXX_11(noext)

  CXXFLAGS="$CXXFLAGS -std=c++11"