File: itkTestTypes.cmake

package info (click to toggle)
insighttoolkit 3.20.1%2Bgit20120521-3
  • links: PTS, VCS
  • area: main
  • in suites: wheezy
  • size: 80,652 kB
  • sloc: cpp: 458,133; ansic: 196,223; fortran: 28,000; python: 3,839; tcl: 1,811; sh: 1,184; java: 583; makefile: 430; csh: 220; perl: 193; xml: 20
file content (137 lines) | stat: -rw-r--r-- 6,955 bytes parent folder | download | duplicates (3)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
# based on VTK/CMake/vtkTestTypes.cmake 11/13/09 -BCL

CHECK_TYPE_SIZE("long long" ITK_SIZEOF_LONG_LONG)
CHECK_TYPE_SIZE("__int64"   ITK_SIZEOF___INT64)

# The only compiler that satisfies the criteria for __int64 specified 
# in this file is Borland, however from some reason the NumericTraits
#  are not funcitoning therefore we had no systems which correctly 
# support __int64 as a fundemental type.
#
# Disable trying to even use __int64
SET( ITK_TRY_TO_USE__INT64 0 )

IF( ITK_TRY_TO_USE__INT64 )
  IF(HAVE_ITK_SIZEOF___INT64)
    # In CMake 2.6 and above the type __int64 may have been found only
    # due to inclusion of a system header.  Further try-compiles using
    # the type should include the header too.
    SET(_HAVE_DEFS)
    FOREACH(def HAVE_SYS_TYPES_H HAVE_STDINT_H HAVE_STDDEF_H)
      IF(${def})
        LIST(APPEND _HAVE_DEFS -D${def})
      ENDIF(${def})
    ENDFOREACH(def)

    IF("ITK_TYPE_SAME_LONG_AND___INT64" MATCHES "^ITK_TYPE_SAME_LONG_AND___INT64$")
      MESSAGE(STATUS "Checking whether long and __int64 are the same type")
      TRY_COMPILE(ITK_TYPE_SAME_LONG_AND___INT64
        ${ITK_BINARY_DIR}/CMakeTmp
        ${ITK_SOURCE_DIR}/CMake/itkTestCompareTypes.cxx
        COMPILE_DEFINITIONS
        -DITK_TEST_COMPARE_TYPE_1=long
        -DITK_TEST_COMPARE_TYPE_2=__int64
        ${_HAVE_DEFS}
        OUTPUT_VARIABLE OUTPUT)
      IF(ITK_TYPE_SAME_LONG_AND___INT64)
        MESSAGE(STATUS "Checking whether long and __int64 are the same type -- yes")
        SET(ITK_TYPE_SAME_LONG_AND___INT64 1 CACHE INTERNAL "Whether long and __int64 are the same type")
        WRITE_FILE(${CMAKE_BINARY_DIR}/CMakeFiles/CMakeOutput.log
          "Determining whether long and __int64 are the same type "
          "passed with the following output:\n"
          "${OUTPUT}\n" APPEND)
      ELSE(ITK_TYPE_SAME_LONG_AND___INT64)
        MESSAGE(STATUS "Checking whether long and __int64 are the same type -- no")
        SET(ITK_TYPE_SAME_LONG_AND___INT64 0 CACHE INTERNAL "Whether long and __int64 are the same type")
        WRITE_FILE(${CMAKE_BINARY_DIR}/CMakeFiles/CMakeError.log
          "Determining whether long and __int64 are the same type "
          "failed with the following output:\n"
          "${OUTPUT}\n" APPEND)
      ENDIF(ITK_TYPE_SAME_LONG_AND___INT64)
    ENDIF("ITK_TYPE_SAME_LONG_AND___INT64" MATCHES "^ITK_TYPE_SAME_LONG_AND___INT64$")

    IF(HAVE_ITK_SIZEOF_LONG_LONG)
      IF("ITK_TYPE_SAME_LONG_LONG_AND___INT64" MATCHES "^ITK_TYPE_SAME_LONG_LONG_AND___INT64$")
        MESSAGE(STATUS "Checking whether long long and __int64 are the same type")
        TRY_COMPILE(ITK_TYPE_SAME_LONG_LONG_AND___INT64
          ${ITK_BINARY_DIR}/CMakeTmp
          ${ITK_SOURCE_DIR}/CMake/itkTestCompareTypes.cxx
          COMPILE_DEFINITIONS
          -DITK_TEST_COMPARE_TYPE_1=TYPE_LONG_LONG
          -DITK_TEST_COMPARE_TYPE_2=__int64
          ${_HAVE_DEFS}
          OUTPUT_VARIABLE OUTPUT)
        IF(ITK_TYPE_SAME_LONG_LONG_AND___INT64)
          MESSAGE(STATUS "Checking whether long long and __int64 are the same type -- yes")
          SET(ITK_TYPE_SAME_LONG_LONG_AND___INT64 1 CACHE INTERNAL "Whether long long and __int64 are the same type")
          WRITE_FILE(${CMAKE_BINARY_DIR}/CMakeFiles/CMakeOutput.log
            "Determining whether long long and __int64 are the same type "
            "passed with the following output:\n"
            "${OUTPUT}\n" APPEND)
        ELSE(ITK_TYPE_SAME_LONG_LONG_AND___INT64)
          MESSAGE(STATUS "Checking whether long long and __int64 are the same type -- no")
          SET(ITK_TYPE_SAME_LONG_LONG_AND___INT64 0 CACHE INTERNAL "Whether long long and __int64 are the same type")
          WRITE_FILE(${CMAKE_BINARY_DIR}/CMakeFiles/CMakeError.log
            "Determining whether long long and __int64 are the same type "
            "failed with the following output:\n"
            "${OUTPUT}\n" APPEND)
        ENDIF(ITK_TYPE_SAME_LONG_LONG_AND___INT64)
      ENDIF("ITK_TYPE_SAME_LONG_LONG_AND___INT64" MATCHES "^ITK_TYPE_SAME_LONG_LONG_AND___INT64$")
    ENDIF(HAVE_ITK_SIZEOF_LONG_LONG)
    IF(NOT ITK_TYPE_SAME_LONG_AND___INT64)
      IF(NOT ITK_TYPE_SAME_LONG_LONG_AND___INT64)
        #  VS 6 cannot convert unsigned __int64 to double unless the
        # "Visual C++ Processor Pack" is installed.
        IF("ITK_TYPE_CONVERT_UI64_TO_DOUBLE" MATCHES "^ITK_TYPE_CONVERT_UI64_TO_DOUBLE$")
          MESSAGE(STATUS "Checking whether unsigned __int64 can convert to double")
          TRY_COMPILE(ITK_TYPE_CONVERT_UI64_TO_DOUBLE
            ${ITK_BINARY_DIR}/CMakeTmp
            ${ITK_SOURCE_DIR}/CMake/itkTestConvertTypes.cxx
            COMPILE_DEFINITIONS
            -DITK_TEST_CONVERT_TYPE_FROM=TYPE_UNSIGNED___INT64
            -DITK_TEST_CONVERT_TYPE_TO=double
            ${_HAVE_DEFS}
            OUTPUT_VARIABLE OUTPUT)
          IF(ITK_TYPE_CONVERT_UI64_TO_DOUBLE)
            MESSAGE(STATUS "Checking whether unsigned __int64 can convert to double -- yes")
            SET(ITK_TYPE_CONVERT_UI64_TO_DOUBLE 1 CACHE INTERNAL "Whether unsigned __int64 can convert to double")
            WRITE_FILE(${CMAKE_BINARY_DIR}/CMakeFiles/CMakeOutput.log
              "Determining whether unsigned __int64 can convert to double "
              "passed with the following output:\n"
              "${OUTPUT}\n" APPEND)
          ELSE(ITK_TYPE_CONVERT_UI64_TO_DOUBLE)
            MESSAGE(STATUS "Checking whether unsigned __int64 can convert to double -- no")
            SET(ITK_TYPE_CONVERT_UI64_TO_DOUBLE 0 CACHE INTERNAL "Whether unsigned __int64 can convert to double")
            WRITE_FILE(${CMAKE_BINARY_DIR}/CMakeFiles/CMakeError.log
              "Determining whether unsigned __int64 can convert to double "
              "failed with the following output:\n"
              "${OUTPUT}\n" APPEND)
          ENDIF(ITK_TYPE_CONVERT_UI64_TO_DOUBLE)
        ENDIF("ITK_TYPE_CONVERT_UI64_TO_DOUBLE" MATCHES "^ITK_TYPE_CONVERT_UI64_TO_DOUBLE$")
      ENDIF(NOT ITK_TYPE_SAME_LONG_LONG_AND___INT64)
    ENDIF(NOT ITK_TYPE_SAME_LONG_AND___INT64)
  ENDIF(HAVE_ITK_SIZEOF___INT64)
ENDIF ( ITK_TRY_TO_USE__INT64 )

# Enable the "long long" type if it is available.  It is standard in
# C99 and C++03 but not in earlier standards.
SET(ITK_TYPE_USE_LONG_LONG)
IF(HAVE_ITK_SIZEOF_LONG_LONG)
  SET(ITK_TYPE_USE_LONG_LONG 1)
ENDIF(HAVE_ITK_SIZEOF_LONG_LONG)

# Enable the "__int64" type if it is available and is a fundemental type.  It is not
# standard. It also must be convertable to double.
SET(ITK_TYPE_USE___INT64)

IF ( ITK_TRY_TO_USE__INT64 )
IF(HAVE_ITK_SIZEOF___INT64)
  IF(NOT ITK_TYPE_SAME_LONG_AND___INT64)
    IF(NOT ITK_TYPE_SAME_LONG_LONG_AND___INT64)
      IF(ITK_TYPE_CONVERT_UI64_TO_DOUBLE)       
        SET(ITK_TYPE_USE___INT64 1)
      ENDIF(ITK_TYPE_CONVERT_UI64_TO_DOUBLE)
    ENDIF(NOT ITK_TYPE_SAME_LONG_LONG_AND___INT64)
  ENDIF(NOT ITK_TYPE_SAME_LONG_AND___INT64)
ENDIF(HAVE_ITK_SIZEOF___INT64)
ENDIF( ITK_TRY_TO_USE__INT64 )