Clean up C++ compiler test Autoconf macros

* build/cxx.m4: Clean up M4 code and switch to non-deprecated
Autoconf macros.
(AC_CXX_NAMESPACES), (AC_CXX_BOOL), (AC_CXX_MUTABLE): Remove
obsolete feature check macros.
* configure.ac: Remove AC_CXX_NAMESPACES(), AC_CXX_BOOL(),
AC_CXX_MUTABLE() and GLIBMM_CXX_HAS_NAMESPACE_STD checks.

1 files changed, 202 insertions, 324 deletions

diff --git a/build/cxx.m4 b/build/cxx.m4
index 37062b75..a584f5db 100644
--- a/build/cxx.m4
+++ b/build/cxx.m4
@@ -1,360 +1,238 @@
+## Copyright (c) 2009  Openismus GmbH  <http://www.openismus.com/>
+##
+## This file is part of glibmm.
+##
+## glibmm is free software: you can redistribute it and/or modify it
+## under the terms of the GNU Lesser General Public License as published
+## by the Free Software Foundation, either version 2.1 of the License,
+## or (at your option) any later version.
+##
+## glibmm 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 Lesser General Public License for more details.
+##
+## You should have received a copy of the GNU Lesser General Public License
+## along with this library.  If not, see <http://www.gnu.org/licenses/>.
 
-dnl
-dnl AC_CXX_NAMESPACES(ACTION_FOUND,ACTION_NOT_FOUND)
-dnl
-AC_DEFUN([AC_CXX_NAMESPACES],[
-AC_MSG_CHECKING(if C++ compiler supports namespaces)
-AC_TRY_COMPILE(
-[
-namespace Foo { struct A {}; }
-using namespace Foo;
-],[
-A a;
-(void)a;
-],[
- ac_cxx_namespaces=yes
- AC_MSG_RESULT([$ac_cxx_namespaces])
- $1
-],[
- ac_cxx_namespaces=no
- AC_MSG_RESULT([$ac_cxx_namespaces])
- $2
-])
-])
+#serial 20090816
 
-dnl
-dnl AC_CXX_NAMESPACES(ACTION_FOUND,ACTION_NOT_FOUND)
-dnl
-AC_DEFUN([AC_CXX_BOOL],[
-AC_MSG_CHECKING(if C++ compiler supports bool)
-AC_TRY_COMPILE(
-[
-],[
-   bool b=true;
-   bool b1=false;
-   (void)b;
-   (void)b1;
-],[
-  ac_cxx_bool=yes
-  AC_MSG_RESULT([$ac_cxx_bool])
-  $1
-],[
-  ac_cxx_bool=no
-  AC_MSG_RESULT([$ac_cxx_bool])
-  $2
-])
-])
-
-dnl
-dnl AC_CXX_MUTABLE(ACTION_FOUND,ACTION_NOT_FOUND)
-dnl
-AC_DEFUN([AC_CXX_MUTABLE],[
-AC_MSG_CHECKING(if C++ compiler supports mutable)
-AC_TRY_COMPILE(
-[
-class k {   
-  mutable char *c;
-public:
-   void foo() const { c=0; }
+## GLIBMM_CXX_MEMBER_FUNCTIONS_MEMBER_TEMPLATES
+##
+## Test whether the compiler allows member functions to refer to spezialized
+## member function templates.  Some compilers have problems with this.  GCC
+## 2.95.3 aborts with an internal compiler error.
+##
+AC_DEFUN([GLIBMM_CXX_MEMBER_FUNCTIONS_MEMBER_TEMPLATES],
+[dnl
+AC_CACHE_CHECK(
+  [whether C++ member functions may refer to member templates],
+  [glibmm_cv_cxx_member_functions_member_templates],
+  [AC_COMPILE_IFELSE([AC_LANG_PROGRAM(
+[[
+struct foo
+{
+  template <class C> inline void doit();
+  void thebug();
 };
-],[
-],[
-  ac_cxx_mutable=yes
-  AC_MSG_RESULT([$ac_cxx_mutable])
-  $1
-],[
-  ac_cxx_mutable=no
-  AC_MSG_RESULT([$ac_cxx_mutable])
-  $2
-]) 
-])
 
+template <class C>
+inline void foo::doit()
+{}
 
-dnl
-dnl AC_CXX_CONST_CAST(ACTION_FOUND,ACTION_NOT_FOUND)
-dnl
-AC_DEFUN([AC_CXX_CONST_CAST],[
-AC_MSG_CHECKING([if C++ compiler supports const_cast<>])
-AC_TRY_COMPILE(
-[
-   class foo;
-],[
-   const foo *c=0;
-   foo *c1=const_cast<foo*>(c);
-   (void)c1;
-],[
-  ac_cxx_const_cast=yes
-  AC_MSG_RESULT([$ac_cxx_const_cast])
-],[
-  ac_cxx_const_cast=no
-  AC_MSG_RESULT([$ac_cxx_const_cast])
-])
-])
-
-
-dnl
-dnl GLIBMM_CXX_MEMBER_FUNCTIONS_MEMBER_TEMPLATES(ACTION_FOUND,ACTION_NOT_FOUND)
-dnl
-dnl Test whether the compiler allows member functions to refer to spezialized member function templates.
-dnl Some compilers have problems with this. gcc 2.95.3 aborts with an internal compiler error.
-dnl
-AC_DEFUN([GLIBMM_CXX_MEMBER_FUNCTIONS_MEMBER_TEMPLATES],[
-AC_MSG_CHECKING([if C++ compiler allows member functions to refer to member templates])
-AC_TRY_COMPILE(
-[
-  struct foo {
-    template <class C> inline
-    void doit();
-    void thebug();
-  };
-
-  template <class C> inline
-  void foo::doit() {
-  }
-
-  struct bar {
-    void neitherabug();
-  };
-
-  void notabug() {
-    void (foo::*func)();
-    func = &foo::doit<int>;
-    (void)func;
-  }
-
-  void bar::neitherabug() {
-    void (foo::*func)();
-    func = &foo::doit<int>;
-    (void)func;
-  }
+struct bar
+{
+  void neitherabug();
+};
 
-  void foo::thebug() {
-    void (foo::*func)();
-    func = &foo::doit<int>; //Compiler bugs usually show here.
-    (void)func;
-  }
-],[],[glibmm_cxx_member_functions_member_templates=yes
-  AC_DEFINE([GLIBMM_MEMBER_FUNCTIONS_MEMBER_TEMPLATES], [1],
-            [does the C++ compiler allow member functions to refer to member templates])
-], [glibmm_cxx_member_functions_member_templates=no])
-  AC_MSG_RESULT([$glibmm_cxx_member_functions_member_templates])
+void bar::neitherabug()
+{
+  void (foo::*func)();
+  func = &foo::doit<int>;
+  (void)func;
+}
+
+void foo::thebug()
+{
+  void (foo::*func)();
+  func = &foo::doit<int>; // the compiler bugs usually show here
+  (void)func;
+}
+]], [[
+void (foo::*func)();
+func = &foo::doit<int>;
+(void)func;
+]],
+    [glibmm_cv_cxx_member_functions_member_templates=yes],
+    [glibmm_cv_cxx_member_functions_member_templates=no])])])
+
+AS_IF([test "x$glibmm_cv_cxx_member_functions_member_templates" = xyes],
+      [AC_DEFINE([GLIBMM_MEMBER_FUNCTIONS_MEMBER_TEMPLATES], [1],
+                 [Define if C++ member functions may refer to member templates.])])[]dnl
 ])
 
-## GLIBMM_CXX_CAN_DISAMBIGUATE_CONST_TEMPLATE_SPECIALIZATIONS()
+## GLIBMM_CXX_CAN_DISAMBIGUATE_CONST_TEMPLATE_SPECIALIZATIONS
 ##
-## Check whether the compiler finds it ambiguous to have both
-## const and non-const template specializations,
-## The SUN Forte compiler has this problem, though we are
-## not 100% sure that it's a C++ standards violation.
+## Check whether the compiler finds it ambiguous to have both const and
+## non-const template specializations.  The SUN Forte compiler has this
+## problem, though we are not 100% sure that it's a C++ standard violation.
 ##
 AC_DEFUN([GLIBMM_CXX_CAN_DISAMBIGUATE_CONST_TEMPLATE_SPECIALIZATIONS],
-[
-  AC_REQUIRE([GLIBMM_CXX_HAS_NAMESPACE_STD])
-
-  AC_CACHE_CHECK(
-    [whether the compiler finds it ambiguous to have both const and non-const template specializations],
-    [glibmm_cv_cxx_can_disambiguate_const_template_specializations],
-  [
-    AC_TRY_COMPILE(
-    [
-      #include <iostream>
-
-      template <class T> class Foo {};
-
-      template <typename T> class Traits {
-      public:
-          const char* whoami() {
-              return "generic template";
-          }
-      };
-
-      template <typename T> class Traits<Foo<T> > {
-      public:
-          const char* whoami() {
-              return "partial specialization for Foo<T>";
-          }
-      };
-
-      template <typename T> class Traits<Foo<const T> > {
-      public:
-          const char* whoami() {
-              return "partial specialization for Foo<const T>";
-          }
-      };
-      
-    ],[
-          Traits<int> it;
-          Traits<Foo<int> > fit;
-          Traits<Foo<const int> > cfit;
+[dnl
+AC_CACHE_CHECK(
+  [whether the compiler disambiguates template specializations for const and non-const types],
+  [glibmm_cv_cxx_can_disambiguate_const_template_specializations],
+  [AC_COMPILE_IFELSE([AC_LANG_PROGRAM(
+[[
+template <class T> class Foo {};
+
+template <class T> class Traits
+{
+public:
+  const char* whoami() { return "generic template"; }
+};
 
-          std::cout << "Traits<int>             --> "
-                    << it.whoami() << std::endl;
-          std::cout << "Traits<Foo<int>>        --> "
-                    << fit.whoami() << std::endl;
-          std::cout << "Traits<Foo<const int >> --> "
-                    << cfit.whoami() << std::endl;
-    ],
-      [glibmm_cv_cxx_can_disambiguate_const_template_specializations="yes"],
-      [glibmm_cv_cxx_can_disambiguate_const_template_specializations="no"]
-    )
-  ])
+template <class T> class Traits< Foo<T> >
+{
+public:
+  const char* whoami() { return "partial specialization for Foo<T>"; }
+};
 
-  if test "x${glibmm_cv_cxx_can_disambiguate_const_template_specializations}" = "xyes"; then
-  {
-    AC_DEFINE([GLIBMM_HAVE_DISAMBIGUOUS_CONST_TEMPLATE_SPECIALIZATIONS],[1], [Defined if the compiler does not find it ambiguous to have both const and non-const template specializations])
-  }
-  fi
+template <class T> class Traits< Foo<const T> >
+{
+public:
+  const char* whoami() { return "partial specialization for Foo<const T>"; }
+};
+]], [[
+Traits<int> it;
+Traits< Foo<int> > fit;
+Traits< Foo<const int> > cfit;
+
+(void) it.whoami();
+(void) fit.whoami();
+(void) cfit.whoami();
+]],
+    [glibmm_cv_cxx_can_disambiguate_const_template_specializations=yes],
+    [glibmm_cv_cxx_can_disambiguate_const_template_specializations=no])])])
+
+AS_IF([test "x$glibmm_cv_cxx_can_disambiguate_const_template_specializations" = xyes],
+      [AC_DEFINE([GLIBMM_HAVE_DISAMBIGUOUS_CONST_TEMPLATE_SPECIALIZATIONS], [1],
+[Define if the compiler disambiguates template specializations for const and non-const types.])])[]dnl
 ])
 
-
-
-## GLIBMM_CXX_CAN_USE_DYNAMIC_CAST_IN_UNUSED_TEMPLATE_WITHOUT_DEFINITION()
+## GLIBMM_CXX_CAN_USE_DYNAMIC_CAST_IN_UNUSED_TEMPLATE_WITHOUT_DEFINITION
 ##
-## Check whether the compiler allows us to define a template that uses 
-## dynamic_cast<> with an object whose type is not defined, 
-## even if we do not use that template before we have defined the type.
-## This should probably not be allowed anyway.
+## Check whether the compiler allows us to define a template that uses
+## dynamic_cast<> with an object whose type is not defined, even if we do
+## not use that template before we have defined the type.  This should
+## probably not be allowed anyway.
 ##
 AC_DEFUN([GLIBMM_CXX_CAN_USE_DYNAMIC_CAST_IN_UNUSED_TEMPLATE_WITHOUT_DEFINITION],
-[
-  AC_CACHE_CHECK(
-    [whether the compiler allows us to define a template that uses dynamic_cast<> with an object whose type is not yet defined],
-    [glibmm_cv_cxx_can_use_dynamic_cast_in_unused_template_without_definition],
-  [
-    AC_TRY_COMPILE(
-    [
-      class SomeClass;
-
-      SomeClass* some_function();
-
-      template <class T>
-      class SomeTemplate
-      {
-        static bool do_something()
-        {
-          //This does not compile, with the MipsPro (IRIX) compiler
-          //even if we don't use this template at all.
-          //(We would use it later, after we have defined the type).
-          return dynamic_cast<T*>(some_function());
-        }
-      };
-      
-    ],[
-       
-    ],
-      [glibmm_cv_cxx_can_use_dynamic_cast_in_unused_template_without_definition="yes"],
-      [glibmm_cv_cxx_can_use_dynamic_cast_in_unused_template_without_definition="no"]
-    )
-  ])
-
-  if test "x${glibmm_cv_cxx_can_use_dynamic_cast_in_unused_template_without_definition}" = "xyes"; then
+[dnl
+AC_CACHE_CHECK(
+  [whether the compiler allows dynamic_cast<> to undefined types in non-instantiated templates],
+  [glibmm_cv_cxx_can_use_dynamic_cast_in_unused_template_without_definition],
+  [AC_COMPILE_IFELSE([AC_LANG_PROGRAM(
+[[
+class SomeClass;
+
+SomeClass* some_function();
+
+template <class T>
+class SomeTemplate
+{
+  static bool do_something()
   {
-    AC_DEFINE([GLIBMM_CAN_USE_DYNAMIC_CAST_IN_UNUSED_TEMPLATE_WITHOUT_DEFINITION],[1], [Defined if the compiler allows us to define a template that uses dynamic_cast<> with an object whose type is not yet defined.])
+    // This does not compile with the MipsPro (IRIX) compiler
+    // even if we don't use this template at all.
+    return (dynamic_cast<T*>(some_function()) != 0);
   }
-  fi
-])
+};
+]],,
+    [glibmm_cv_cxx_can_use_dynamic_cast_in_unused_template_without_definition=yes],
+    [glibmm_cv_cxx_can_use_dynamic_cast_in_unused_template_without_definition=no])])])
 
+AS_IF([test "x$glibmm_cv_cxx_can_use_dynamic_cast_in_unused_template_without_definition" = xyes],
+      [AC_DEFINE([GLIBMM_CAN_USE_DYNAMIC_CAST_IN_UNUSED_TEMPLATE_WITHOUT_DEFINITION], [1],
+        [Define if non-instantiated templates may dynamic_cast<> to an undefined type.])])[]dnl
+])
 
-## GLIBMM_CXX_CAN_ASSIGN_NON_EXTERN_C_FUNCTIONS_TO_EXTERN_C_CALLBACKS()
+## GLIBMM_CXX_CAN_ASSIGN_NON_EXTERN_C_FUNCTIONS_TO_EXTERN_C_CALLBACKS
 ##
 ## Check whether the compiler allows us to use a non-extern "C" function, 
 ## such as a static member function, to an extern "C" function pointer, 
 ## such as a GTK+ callback.
-## This should not be allowed anyway.
 ##
 AC_DEFUN([GLIBMM_CXX_CAN_ASSIGN_NON_EXTERN_C_FUNCTIONS_TO_EXTERN_C_CALLBACKS],
-[
-  AC_CACHE_CHECK(
-    [whether the the compilerallows us to use a non-extern "C" function for an extern "C" function pointer.],
-    [glibmm_cv_cxx_can_assign_non_extern_c_functions_to_extern_c_callbacks],
-  [
-    AC_TRY_COMPILE(
-    [
-      extern "C"
-      {
-        struct somestruct
-        {
-          void (*callback) (int);
-        };
-        
-      } // extern "C"
-      
-      void somefunction(int)
-      {
-      }
-      
-    ],[ 
-      somestruct something;
-      something.callback = &somefunction;
-    ],
-      [glibmm_cv_cxx_can_assign_non_extern_c_functions_to_extern_c_callbacks="yes"],
-      [glibmm_cv_cxx_can_assign_non_extern_c_functions_to_extern_c_callbacks="no"]
-    )
-  ])
-
-  if test "x${glibmm_cv_cxx_can_assign_non_extern_c_functions_to_extern_c_callbacks}" = "xyes"; then
-  {
-    AC_DEFINE([GLIBMM_CAN_ASSIGN_NON_EXTERN_C_FUNCTIONS_TO_EXTERN_C_CALLBACKS],[1], [Defined if the compiler allows us to use a non-extern "C" function for an extern "C" function pointer.])
-  }
-  fi
+[dnl
+AC_CACHE_CHECK(
+  [whether extern "C" and extern "C++" function pointers are compatible],
+  [glibmm_cv_cxx_can_assign_non_extern_c_functions_to_extern_c_callbacks],
+  [AC_COMPILE_IFELSE([AC_LANG_PROGRAM(
+[[
+extern "C"
+{
+struct somestruct
+{
+  void (*callback) (int);
+};
+} // extern "C"
+
+void somefunction(int) {}
+]], [[
+somestruct something;
+something.callback = &somefunction;
+]],
+    [glibmm_cv_cxx_can_assign_non_extern_c_functions_to_extern_c_callbacks=yes],
+    [glibmm_cv_cxx_can_assign_non_extern_c_functions_to_extern_c_callbacks=no])])])
+
+AS_IF([test "x$glibmm_cv_cxx_can_assign_non_extern_c_functions_to_extern_c_callbacks" = xyes],
+      [AC_DEFINE([GLIBMM_CAN_ASSIGN_NON_EXTERN_C_FUNCTIONS_TO_EXTERN_C_CALLBACKS], [1],
+                 [Define if extern "C" and extern "C++" function pointers are compatible.])])[]dnl
 ])
 
-## GLIBMM_CXX_CAN_USE_NAMESPACES_INSIDE_EXTERNC()
+## GLIBMM_CXX_CAN_USE_NAMESPACES_INSIDE_EXTERNC
 ##
-## Check whether the compiler puts extern "C" functions in the global namespace, 
-## even inside a namespace declaration. The AIX xlC compiler does this, and also 
-## gets confused if we declare the namespace again inside the extern "C" block.
-## This seems like a compiler bug, but not a serious one.
+## Check whether the compiler puts extern "C" functions in the global
+## namespace, even inside a namespace declaration. The AIX xlC compiler does
+## this, and also gets confused if we declare the namespace again inside the
+## extern "C" block.  This seems like a compiler bug, but not a serious one.
+##
+## It is debatable whether it is a bug at all, since the namespace would only
+## exist at the compiler level anyway, but not be a part of the exported
+## symbol name.  (For the functions in question, it was my fault not to add
+## the namespace prefix to the function name.  Sorry. --danielk)
 ##
 AC_DEFUN([GLIBMM_CXX_CAN_USE_NAMESPACES_INSIDE_EXTERNC],
-[
-  AC_CACHE_CHECK(
-    [whether the compiler uses namespace declarations inside extern "C" blocks.],
-    [glibmm_cv_cxx_can_use_namespaces_inside_externc],
-  [
-    AC_TRY_COMPILE(
-    [
-      namespace test
-      {
-      
-      extern "C"
-      {
-      
-      void do_something();
-      
-      } //extern C
-      
-      
-      class Something
-      {
-      protected:
-        int i;
-      
-        friend void do_something();
-      };
-      
-      void do_something()
-      {
-        Something something;
-        something.i = 1;
-      }
-      
-      } //namespace
+[dnl
+AC_CACHE_CHECK(
+  [whether the compiler honors namespaces inside extern "C" blocks],
+  [glibmm_cv_cxx_can_use_namespaces_inside_externc],
+  [AC_COMPILE_IFELSE([AC_LANG_PROGRAM(
+[[
+namespace test
+{
+
+extern "C" { void do_something(); }
+
+class Something
+{
+  int i;
+  friend void do_something();
+};
 
-      
-    ],[ 
-     
-    ],
-      [glibmm_cv_cxx_can_use_namespaces_inside_externc="yes"],
-      [glibmm_cv_cxx_can_use_namespaces_inside_externc="no"]
-    )
-  ])
-
-  if test "x${glibmm_cv_cxx_can_use_namespaces_inside_externc}" = "xyes"; then
-  {
-    AC_DEFINE([GLIBMM_CAN_USE_NAMESPACES_INSIDE_EXTERNC],[1], [Defined if the compiler whether the compiler uses namespace declarations inside extern "C" blocks.])
-  }
-  fi
-])
+void do_something()
+{
+  Something something;
+  something.i = 1;
+}
 
+} // namespace test
+]],,
+    [glibmm_cv_cxx_can_use_namespaces_inside_externc=yes],
+    [glibmm_cv_cxx_can_use_namespaces_inside_externc=no])])])
 
+AS_IF([test "x$glibmm_cv_cxx_can_use_namespaces_inside_externc" = xyes],
+      [AC_DEFINE([GLIBMM_CAN_USE_NAMESPACES_INSIDE_EXTERNC], [1],
+                 [Define if the compiler honors namespaces inside extern "C" blocks.])])[]dnl
+])