move cmake modules to a modules/ subdir

cmake/modules/CheckAlwaysInline.cmake

@@ -0,0 +1,44 @@
+# This module checks if the C++ compiler supports
+# __attribute__((always_inline)).
+#
+# If yes, _RESULT is set to __attribute__((always_inline)).
+# If no, _RESULT is set to empty value.
+#
+# Copyright Benoit Jacob 2007 <jacob@math.jussieu.fr>
+#
+# Redistribution and use is allowed according to the terms of the BSD license.
+# For details see the accompanying COPYING-CMAKE-SCRIPTS file in
+# kdelibs/cmake/modules.
+
+INCLUDE(CheckCXXSourceCompiles)
+
+MACRO (CHECK_ALWAYS_INLINE _RESULT)
+
+SET(_CHECK_attribute_always_inline_SRC "
+
+#ifdef __GNUC__
+#  define ALL_IS_WELL
+#endif
+
+#ifdef __INTEL_COMPILER
+#  if (__INTEL_COMPILER == 800) || (__INTEL_COMPILER > 800)
+#    define ALL_IS_WELL
+#  endif
+#endif
+
+#ifndef ALL_IS_WELL
+#  error I guess your compiler doesn't support __attribute__((always_inline))
+#endif
+
+int main(int argc, char *argv[]) { return 0; } 
+")
+
+CHECK_CXX_SOURCE_COMPILES("${_CHECK_attribute_always_inline_SRC}"
+                          HAVE_attribute_always_inline)
+IF(HAVE_attribute_always_inline)
+  SET(${_RESULT} "__attribute__((always_inline))")
+ELSE(HAVE_attribute_always_inline)
+  SET(${_RESULT} ) # attribute always_inline unsupported
+ENDIF(HAVE_attribute_always_inline)
+
+ENDMACRO (CHECK_ALWAYS_INLINE)

cmake/modules/CheckComplex.cmake

@@ -0,0 +1,22 @@
+INCLUDE(CheckCXXSourceCompiles)
+
+MACRO (CHECK_COMPLEX _RESULT)
+
+SET(_CHECK_COMPLEX_SOURCE_CODE "
+
+#include<complex>
+
+using namespace std;
+
+int main(int argc, char *argv[])
+{
+  complex<double> x(1.0, 1.0);
+  complex<float> y(1.0f, 1.0f);
+  return 0;
+}
+
+")
+
+CHECK_CXX_SOURCE_COMPILES("${_CHECK_COMPLEX_SOURCE_CODE}" ${_RESULT})
+
+ENDMACRO (CHECK_COMPLEX)

cmake/modules/CheckComplexMath1.cmake

@@ -0,0 +1,23 @@
+INCLUDE(CheckCXXSourceCompiles)
+
+MACRO (CHECK_COMPLEX_MATH1 _RESULT)
+
+SET(_CHECK_COMPLEX_MATH1_SOURCE_CODE "
+
+#include<complex>
+
+using namespace std;
+
+int main(int argc, char *argv[])
+{
+  complex<double> x(1.0, 1.0), y(1.0, 1.0);
+  cos(x); cosh(x); exp(x); log(x); pow(x,1); pow(x,double(2.0));
+  pow(x, y); pow(double(2.0), x); sin(x); sinh(x); sqrt(x); tan(x); tanh(x);
+  return 0;
+}
+
+")
+
+CHECK_CXX_SOURCE_COMPILES("${_CHECK_COMPLEX_MATH1_SOURCE_CODE}" ${_RESULT})
+
+ENDMACRO (CHECK_COMPLEX_MATH1)

cmake/modules/CheckComplexMath2.cmake

@@ -0,0 +1,22 @@
+INCLUDE(CheckCXXSourceCompiles)
+
+MACRO (CHECK_COMPLEX_MATH2 _RESULT)
+
+SET(_CHECK_COMPLEX_MATH2_SOURCE_CODE "
+
+#include<complex>
+
+using namespace std;
+
+int main(int argc, char *argv[])
+{
+  complex<double> x(1.0, 1.0), y(1.0, 1.0);
+  acos(x); asin(x); atan(x); atan2(x,y); atan2(x, double(3.0));
+  atan2(double(3.0), x); log10(x); return 0;
+}
+
+")
+
+CHECK_CXX_SOURCE_COMPILES("${_CHECK_COMPLEX_MATH2_SOURCE_CODE}" ${_RESULT})
+
+ENDMACRO (CHECK_COMPLEX_MATH2)

cmake/modules/CheckIeeeMath.cmake

@@ -0,0 +1,30 @@
+INCLUDE(CheckCXXSourceCompiles)
+
+MACRO (CHECK_IEEE_MATH _RESULT)
+
+SET(_CHECK_IEEE_MATH_SOURCE_CODE "
+
+#include<cmath>
+
+int main(int argc, char *argv[])
+{
+  double x = 1.0; double y = 1.0;
+  acosh(x); asinh(x); atanh(x);
+  expm1(x);
+  erf(x); erfc(x);
+  // finite(x);
+  isnan(x);
+  j0(x); j1(x);
+  lgamma(x);
+  logb(x); log1p(x);
+  rint(x);
+  // trunc(x);
+  y0(x); y1(x);
+  return 0;
+}
+
+")
+
+CHECK_CXX_SOURCE_COMPILES("${_CHECK_IEEE_MATH_SOURCE_CODE}" ${_RESULT})
+
+ENDMACRO (CHECK_IEEE_MATH)

cmake/modules/CheckLongDouble.cmake

@@ -0,0 +1,17 @@
+INCLUDE(CheckCXXSourceCompiles)
+
+MACRO (CHECK_LONG_DOUBLE _RESULT)
+
+SET(_CHECK_LONG_DOUBLE_SOURCE_CODE "
+
+int main(int argc, char *argv[])
+{
+  long double ld = static_cast<long double>(0);
+  return 0;
+}
+
+")
+
+CHECK_CXX_SOURCE_COMPILES("${_CHECK_LONG_DOUBLE_SOURCE_CODE}" ${_RESULT})
+
+ENDMACRO (CHECK_LONG_DOUBLE)

cmake/modules/CheckLongLong.cmake

@@ -0,0 +1,18 @@
+INCLUDE(CheckCXXSourceCompiles)
+
+MACRO (CHECK_LONG_LONG _RESULT)
+
+SET(_CHECK_LONG_LONG_SOURCE_CODE "
+
+int main(int argc, char *argv[])
+{
+  long long ll = static_cast<long long>(0);
+  long long int lli = static_cast<long long int>(0);
+  return 0;
+}
+
+")
+
+CHECK_CXX_SOURCE_COMPILES("${_CHECK_LONG_LONG_SOURCE_CODE}" ${_RESULT})
+
+ENDMACRO (CHECK_LONG_LONG)

cmake/modules/CheckRestrictKeyword.cmake

@@ -0,0 +1,87 @@
+# This module checks if the C++ compiler supports the restrict keyword or
+# some variant of it. The following variants are checked for in that order:
+# 1. restrict            (The standard C99 keyword, not yet in C++ standard)
+# 2. __restrict          (G++ has it)
+# 3. __restrict__        (G++ has it too)
+# 4. _Restrict           (seems to be used by Sun's compiler)
+# These four cases seem to cover all existing variants; however some C++
+# compilers don't support any variant, in which case the _RESULT variable is
+# set to empty value.
+#
+# Copyright Benoit Jacob 2007 <jacob@math.jussieu.fr>
+#
+# Redistribution and use is allowed according to the terms of the BSD license.
+# For details see the accompanying COPYING-CMAKE-SCRIPTS file in
+# kdelibs/cmake/modules.
+
+INCLUDE(CheckCXXSourceCompiles)
+
+MACRO (CHECK_RESTRICT_KEYWORD _RESULT)
+
+SET(_CHECK_restrict_KEYWORD_SRC "
+
+char f( const char * restrict x )
+{
+  return *x;
+}
+
+int main(int argc, char *argv[]) { return 0; } 
+")
+
+SET(_CHECK___restrict_KEYWORD_SRC "
+
+char f( const char * __restrict x )
+{
+  return *x;
+}
+
+int main(int argc, char *argv[]) { return 0; } 
+")
+
+SET(_CHECK___restrict___KEYWORD_SRC "
+
+char f( const char * __restrict__ x )
+{
+  return *x;
+}
+
+int main(int argc, char *argv[]) { return 0; } 
+")
+
+SET(_CHECK__Restrict_KEYWORD_SRC "
+
+char f( const char * _Restrict x )
+{
+  return *x;
+}
+
+int main(int argc, char *argv[]) { return 0; } 
+")
+
+CHECK_CXX_SOURCE_COMPILES("${_CHECK_restrict_KEYWORD_SRC}"
+                          HAVE_KEYWORD_restrict)
+IF(HAVE_KEYWORD_restrict)
+  SET(${_RESULT} restrict)
+ELSE(HAVE_KEYWORD_restrict)
+  CHECK_CXX_SOURCE_COMPILES("${_CHECK___restrict_KEYWORD_SRC}"
+                          HAVE_KEYWORD___restrict)
+  IF(HAVE_KEYWORD___restrict)
+    SET(${_RESULT} __restrict)
+  ELSE(HAVE_KEYWORD___restrict)
+    CHECK_CXX_SOURCE_COMPILES("${_CHECK___restrict___KEYWORD_SRC}"
+                            HAVE_KEYWORD___restrict__)
+    IF(HAVE_KEYWORD___restrict__)
+      SET(${_RESULT} __restrict__)
+    ELSE(HAVE_KEYWORD___restrict__)
+      CHECK_CXX_SOURCE_COMPILES("${_CHECK__Restrict_KEYWORD_SRC}"
+                            HAVE_KEYWORD__Restrict)
+      IF(HAVE_KEYWORD__Restrict)
+        SET(${_RESULT} _Restrict)
+      ELSE(HAVE_KEYWORD__Restrict)
+        SET(${_RESULT} ) # no variant of restrict keyword supported
+      ENDIF(HAVE_KEYWORD__Restrict)
+    ENDIF(HAVE_KEYWORD___restrict__)
+  ENDIF(HAVE_KEYWORD___restrict)
+ENDIF(HAVE_KEYWORD_restrict)
+
+ENDMACRO (CHECK_RESTRICT_KEYWORD)

cmake/modules/CheckSysvMath.cmake

@@ -0,0 +1,34 @@
+INCLUDE(CheckCXXSourceCompiles)
+
+MACRO (CHECK_SYSV_MATH _RESULT)
+
+SET(_CHECK_SYSV_MATH_SOURCE_CODE "
+
+#include<cmath>
+
+int main(int argc, char *argv[])
+{
+  double x = 1.0; double y = 1.0;
+  _class(x);
+  ilogb(x);
+  itrunc(x);
+  nearest(x);
+  rsqrt(x);
+  uitrunc(x);
+  
+  copysign(x,y);
+  drem(x,y);
+  fmod(x,y);
+  hypot(x,y);
+  nextafter(x,y);
+  remainder(x,y);
+  scalb(x,y);
+  unordered(x,y);
+  return 0;
+}
+
+")
+
+CHECK_CXX_SOURCE_COMPILES("${_CHECK_SYSV_MATH_SOURCE_CODE}" ${_RESULT})
+
+ENDMACRO (CHECK_SYSV_MATH)