dnl OJ_CHECK_SIZEOF(TYPE, HEADER [, CROSS-SIZE]) AC_DEFUN([OJ_CHECK_SIZEOF], [changequote(<<, >>)dnl dnl The name to #define. define(<>, translit(sizeof_$1, [a-z *], [A-Z_P]))dnl dnl The cache variable name. define(<>, translit(ac_cv_sizeof_$1, [ *], [_p]))dnl changequote([, ])dnl AC_MSG_CHECKING(size of $1) AC_CACHE_VAL(AC_CV_NAME, [AC_TRY_RUN([#include #include <$2> main() { FILE *f=fopen("conftestval", "w"); if (!f) exit(1); fprintf(f, "%d\n", sizeof($1)); exit(0); }], AC_CV_NAME=`cat conftestval`, AC_CV_NAME=0, ifelse([$3] , , AC_CV_NAME=$3))])dnl AC_MSG_RESULT($AC_CV_NAME) AC_DEFINE_UNQUOTED(AC_TYPE_NAME, $AC_CV_NAME) undefine([AC_TYPE_NAME])dnl undefine([AC_CV_NAME])dnl ]) dnl @synopsis AC_CXX_PLACEMENT_OPERATOR_DELETE dnl dnl If the compiler supports void delete(size_t,void*), define dnl HAVE_PLACEMENT_OPERATOR_DELETE. dnl dnl @author Matthias Clasen dnl AC_DEFUN([AC_CXX_PLACEMENT_OPERATOR_DELETE], [AC_CACHE_CHECK(whether the compiler supports placement operator delete, ac_cv_cxx_placement_operator_delete, [AC_LANG_SAVE AC_LANG_CPLUSPLUS AC_TRY_COMPILE([#include ], [class Thing { public: Thing() { }; void *operator new(size_t,bool) { }; void operator delete(size_t,void*) { }; };], ac_cv_cxx_placement_operator_delete=yes, ac_cv_cxx_placement_operator_delete=no) AC_LANG_RESTORE ]) if test "$ac_cv_cxx_placement_operator_delete" = yes; then AC_DEFINE(HAVE_PLACEMENT_OPERATOR_DELETE,, [define if the compiler supports placement operator delete]) fi ]) dnl @synopsis AC_CXX_BOOL dnl dnl If the compiler recognizes bool as a separate built-in type, dnl define HAVE_BOOL. Note that a typedef is not a separate dnl type since you cannot overload a function such that it accepts either dnl the basic type or the typedef. dnl dnl @version $Id: acinclude.m4,v 1.9.2.1 2004/06/30 13:16:25 keichwa Exp $ dnl @author Luc Maisonobe dnl AC_DEFUN([AC_CXX_BOOL], [AC_CACHE_CHECK(whether the compiler recognizes bool as a built-in type, ac_cv_cxx_bool, [AC_LANG_SAVE AC_LANG_CPLUSPLUS AC_TRY_COMPILE([ int f(int x){return 1;} int f(char x){return 1;} int f(bool x){return 1;} ],[bool b = true; return f(b);], ac_cv_cxx_bool=yes, ac_cv_cxx_bool=no) AC_LANG_RESTORE ]) if test "$ac_cv_cxx_bool" = yes; then AC_DEFINE(HAVE_BOOL,,[define if bool is a built-in type]) fi ]) dnl @synopsis AC_CXX_TYPENAME dnl dnl If the compiler recognizes the typename keyword, define HAVE_TYPENAME. dnl dnl @version $Id: acinclude.m4,v 1.9.2.1 2004/06/30 13:16:25 keichwa Exp $ dnl @author Luc Maisonobe dnl AC_DEFUN([AC_CXX_TYPENAME], [AC_CACHE_CHECK(whether the compiler recognizes typename, ac_cv_cxx_typename, [AC_LANG_SAVE AC_LANG_CPLUSPLUS AC_TRY_COMPILE([templateclass X {public:X(){}};], [X z; return 0;], ac_cv_cxx_typename=yes, ac_cv_cxx_typename=no) AC_LANG_RESTORE ]) if test "$ac_cv_cxx_typename" = yes; then AC_DEFINE(HAVE_TYPENAME,,[define if the compiler recognizes typename]) fi ]) dnl @synopsis AC_CXX_NEW_FOR_SCOPING dnl dnl If the compiler accepts the new for scoping rules (the scope of a dnl variable declared inside the parentheses is restricted to the dnl for-body), define HAVE_NEW_FOR_SCOPING. dnl dnl @version $Id: acinclude.m4,v 1.9.2.1 2004/06/30 13:16:25 keichwa Exp $ dnl @author Luc Maisonobe dnl AC_DEFUN([AC_CXX_NEW_FOR_SCOPING], [AC_CACHE_CHECK(whether the compiler accepts the new for scoping rules, ac_cv_cxx_new_for_scoping, [AC_LANG_SAVE AC_LANG_CPLUSPLUS AC_TRY_COMPILE(,[ int z = 0; for (int i = 0; i < 10; ++i) z = z + i; for (int i = 0; i < 10; ++i) z = z - i; return z;], ac_cv_cxx_new_for_scoping=yes, ac_cv_cxx_new_for_scoping=no) AC_LANG_RESTORE ]) if test "$ac_cv_cxx_new_for_scoping" = yes; then AC_DEFINE(HAVE_NEW_FOR_SCOPING,,[define if the compiler accepts the new for scoping rules]) fi ]) dnl @synopsis AC_CXX_DYNAMIC_CAST dnl dnl If the compiler supports dynamic_cast<>, define HAVE_DYNAMIC_CAST. dnl dnl @version $Id: acinclude.m4,v 1.9.2.1 2004/06/30 13:16:25 keichwa Exp $ dnl @author Luc Maisonobe dnl AC_DEFUN([AC_CXX_DYNAMIC_CAST], [AC_CACHE_CHECK(whether the compiler supports dynamic_cast<>, ac_cv_cxx_dynamic_cast, [AC_LANG_SAVE AC_LANG_CPLUSPLUS AC_TRY_COMPILE([#include class Base { public : Base () {} virtual void f () = 0;}; class Derived : public Base { public : Derived () {} virtual void f () {} };],[ Derived d; Base& b=d; return dynamic_cast(&b) ? 0 : 1;], ac_cv_cxx_dynamic_cast=yes, ac_cv_cxx_dynamic_cast=no) AC_LANG_RESTORE ]) if test "$ac_cv_cxx_dynamic_cast" = yes; then AC_DEFINE(HAVE_DYNAMIC_CAST,,[define if the compiler supports dynamic_cast<>]) fi ]) dnl @synopsis AC_CXX_NAMESPACES dnl dnl If the compiler can prevent names clashes using namespaces, define dnl HAVE_NAMESPACES. dnl dnl @version $Id: acinclude.m4,v 1.9.2.1 2004/06/30 13:16:25 keichwa Exp $ dnl @author Luc Maisonobe dnl AC_DEFUN([AC_CXX_NAMESPACES], [AC_CACHE_CHECK(whether the compiler implements namespaces, ac_cv_cxx_namespaces, [AC_LANG_SAVE AC_LANG_CPLUSPLUS AC_TRY_COMPILE([namespace Outer { namespace Inner { int i = 0; }}], [using namespace Outer::Inner; return i;], ac_cv_cxx_namespaces=yes, ac_cv_cxx_namespaces=no) AC_LANG_RESTORE ]) if test "$ac_cv_cxx_namespaces" = yes; then AC_DEFINE(HAVE_NAMESPACES,,[define if the compiler implements namespaces]) fi ]) dnl @synopsis ACX_CHECK_PATHNAME_STYLE_DOS dnl dnl Check if host OS uses DOS-style pathnames. This includes the use dnl of drive letters and backslashes. Under DOS, Windows, and OS/2, dnl defines HAVE_PATHNAME_STYLE_DOS and PATH_SEPARATOR to ';'. dnl Otherwise, defines PATH_SEPARATOR to ':'. dnl dnl Use for enabling code to handle drive letters, backslashes in dnl filenames and semicolons in the PATH. dnl dnl @version $Id: acinclude.m4,v 1.9.2.1 2004/06/30 13:16:25 keichwa Exp $ dnl @author Mark Elbrecht dnl AC_DEFUN([ACX_CHECK_PATHNAME_STYLE_DOS], [AC_MSG_CHECKING(for Windows and DOS and OS/2 style pathnames) AC_CACHE_VAL(acx_cv_pathname_style_dos, [AC_REQUIRE([AC_CANONICAL_HOST]) acx_cv_pathname_style_dos="no" case ${host_os} in *djgpp | *mingw32 | *emx*) acx_cv_pathname_style_dos="yes" ;; esac ]) AC_MSG_RESULT($acx_cv_pathname_style_dos) if test $acx_cv_pathname_style_dos = "yes"; then AC_DEFINE(HAVE_PATHNAME_STYLE_DOS) AC_DEFINE(PATH_SEPARATOR, ';') else AC_DEFINE(PATH_SEPARATOR, ':') fi ]) dnl @synopsis AC_CXX_EXPLICIT_INSTANTIATIONS dnl dnl If the C++ compiler supports explicit instanciations syntax, dnl define HAVE_INSTANTIATIONS. dnl dnl @version $Id: acinclude.m4,v 1.9.2.1 2004/06/30 13:16:25 keichwa Exp $ dnl @author Luc Maisonobe dnl AC_DEFUN([AC_CXX_EXPLICIT_INSTANTIATIONS], [AC_CACHE_CHECK(whether the compiler supports explicit instantiations, ac_cv_cxx_explinst, [AC_LANG_SAVE AC_LANG_CPLUSPLUS AC_TRY_COMPILE([template class A { T t; }; template class A;], [], ac_cv_cxx_explinst=yes, ac_cv_cxx_explinst=no) AC_LANG_RESTORE ]) if test "$ac_cv_cxx_explinst" = yes; then AC_DEFINE(HAVE_INSTANTIATIONS,, [define if the compiler supports explicit instantiations]) fi ]) AC_DEFUN([AC_DEFINE_DIR], [ ac_expanded=`( test "x$prefix" = xNONE && prefix="$ac_default_prefix" test "x$exec_prefix" = xNONE && exec_prefix="${prefix}" eval echo \""[$]$2"\" )` ifelse($3, , AC_DEFINE_UNQUOTED($1, "$ac_expanded"), AC_DEFINE_UNQUOTED($1, "$ac_expanded", $3)) ]) dnl @synopsis AC_CXX_MUTABLE dnl dnl If the compiler allows modifying class data members flagged with dnl the mutable keyword even in const objects (for example in the dnl body of a const member function), define HAVE_MUTABLE. dnl dnl @version $Id: acinclude.m4,v 1.9.2.1 2004/06/30 13:16:25 keichwa Exp $ dnl @author Luc Maisonobe dnl AC_DEFUN([AC_CXX_MUTABLE], [AC_CACHE_CHECK(whether the compiler supports the mutable keyword, ac_cv_cxx_mutable, [AC_LANG_SAVE AC_LANG_CPLUSPLUS AC_TRY_COMPILE([ class A { mutable int i; public: int f (int n) const { i = n; return i; } }; ],[A a; return a.f (1);], ac_cv_cxx_mutable=yes, ac_cv_cxx_mutable=no) AC_LANG_RESTORE ]) if test "$ac_cv_cxx_mutable" = yes; then AC_DEFINE(HAVE_MUTABLE,,[define if the compiler supports the mutable keyword]) fi ])