diff options
Diffstat (limited to 'build/cxx.m4')
-rw-r--r-- | build/cxx.m4 | 360 |
1 files changed, 360 insertions, 0 deletions
diff --git a/build/cxx.m4 b/build/cxx.m4 new file mode 100644 index 00000000..37062b75 --- /dev/null +++ b/build/cxx.m4 @@ -0,0 +1,360 @@ + +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 +]) +]) + +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; } +}; +],[ +],[ + ac_cxx_mutable=yes + AC_MSG_RESULT([$ac_cxx_mutable]) + $1 +],[ + ac_cxx_mutable=no + AC_MSG_RESULT([$ac_cxx_mutable]) + $2 +]) +]) + + +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; + } + + 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]) +]) + +## 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. +## +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; + + 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"] + ) + ]) + + 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 +]) + + + +## 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. +## +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 + { + 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.]) + } + fi +]) + + +## 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 +]) + +## 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. +## +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 + + + ],[ + + ], + [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 +]) + + |