Debian Codegraph @

config/cmake_files/medMacros.cmake

raw
1 INCLUDE(CheckIncludeFile)
2 IF(CMAKE_Fortran_COMPILER_WORKS)
3 INCLUDE(FortranCInterface)
4 ENDIF(CMAKE_Fortran_COMPILER_WORKS)
5 INCLUDE(CheckFunctionExists)
6 INCLUDE(CheckTypeSize)
7
8 ###############################################################################
9 ##Define constants
10 ###############################################################################
11
12 SET(PACKAGE_NAME "\"MED Fichier\"")
13 SET(MED_CHECK_23FORMAT 1)
14 SET(MED_HAVE_FORTRAN 1)
15 SET(MESGERR 1)
16 SET(PACKAGE \"${PROJECT_NAME}\")
17 SET(PACKAGE_BUGREPORT \"[email protected]\")
18 SET(PACKAGE_STRING "\"MED Fichier ${MED_STR_VERSION}\"")
19 SET(PACKAGE_TARNAME "${PROJECT_NAME}")
20 SET(PACKAGE_URL \"\")
21 SET(PACKAGE_VERSION \"${MED_STR_VERSION}\")
22 SET(VERSION \"${MED_STR_VERSION}\")
23
24 ###############################################################################
25 ## TEMPORARY HARDCODED FLAGS, BECAUSE CMAKE HAS NO TOOLS TO
26 ## THEIR DETERMINATION.
27 ## !!! SHOULD BE REMOVED AFTER FUTURE IMPROVEMENTS !!!
28 ###############################################################################
29 IF(NOT WINDOWS)
30 SET(HAVE_CC_C99 1)
31 SET(STDC_HEADERS 1)
32 ENDIF(NOT WINDOWS)
33 SET(HAVE__BOOL 1)
34
35 MACRO(MED_CREATE_CONFIG_FILES)
36 SET(f_content_new "")
37 FILE(READ ${PROJECT_SOURCE_DIR}/include/med_config.h.in f_content)
38 STRING(REPLACE "\n" ";" list_f_content ${f_content})
39 FOREACH(ln ${list_f_content})
40 STRING(REGEX MATCH "#undef.*" flag_name "${ln}")
41 STRING(REPLACE "#undef" "" flag_name "${flag_name}")
42 STRING(STRIP "${flag_name}" flag_name)
43 STRING(LENGTH "${flag_name}" len)
44 IF(${len} GREATER 0)
45 STRING(STRIP "${flag_name}" flag_name)
46 IF(flag_name MATCHES "^F77_FUNC.*")
47 SET(ln "#cmakedefine ${flag_name}@${flag_name}@")
48 ELSE()
49 SET(ln "#cmakedefine ${flag_name} @${flag_name}@")
50 ENDIF()
51 ENDIF(${len} GREATER 0)
52 SET(f_content_new "${f_content_new}${ln}\n")
53 ENDFOREACH(ln ${list_f_content})
54
55 FILE(WRITE ${PROJECT_BINARY_DIR}/include/med_config.h.cmake "${f_content_new}")
56 FILE(WRITE ${PROJECT_BINARY_DIR}/include/2.3.6/med_config.h.cmake "${f_content_new}")
57 ENDMACRO(MED_CREATE_CONFIG_FILES)
58
59 ##
60 ## Macro to extract version numbers from Autotools file
61 ##
62 MACRO(MED_EXTRACT_AUTOTOOLS_VERSION filename major minor release)
63 FILE(READ ${filename} _f_content)
64 STRING(REGEX MATCH "MED_NUM_MAJEUR=([0-9]+)" _output_unused ${_f_content})
65 SET(${major} ${CMAKE_MATCH_1})
66
67 STRING(REGEX MATCH "MED_NUM_MINEUR=([0-9]+)" _output_unused ${_f_content})
68 SET(${minor} ${CMAKE_MATCH_1})
69
70 STRING(REGEX MATCH "MED_NUM_RELEASE=([0-9]+)" _output_unused ${_f_content})
71 SET(${release} ${CMAKE_MATCH_1})
72 ENDMACRO(MED_EXTRACT_AUTOTOOLS_VERSION)
73
74 ###############################################################################
75 ## Macro to set compilation flag for target
76 ###############################################################################
77 MACRO(MED_SET_DEFINITIONS lib)
78 STRING(LENGTH "${ARGN}" len)
79 IF(${len})
80 # Doc says:
81 # COMPILE_DEFINITIONS property may be set to a semicolon-separated list
82 # of preprocessor definitions using the syntax VAR or VAR=value.
83 SET_TARGET_PROPERTIES(${lib} PROPERTIES COMPILE_DEFINITIONS "${ARGN}")
84 #MESSAGE("bli ${ARGN}")
85 ENDIF(${len})
86 ENDMACRO(MED_SET_DEFINITIONS)
87
88 ###############################################################################
89 ## Macro to check header files
90 ###############################################################################
91 MACRO(MED_CHECK_HEADERS)
92
93 #Define list of headers
94 SET(H_LIST "H5public;dlfcn;inttypes;malloc;memory;pwd;stdbool;stdint;stdlib")
95 SET(H_LIST "${H_LIST};stdbool;stdint;stdlib;strings;string;sys/stat")
96 SET(H_LIST "${H_LIST};sys/timeb;sys/time;sys/types;unistd;stdio")
97
98 #Check each header
99 FOREACH(H_FILE ${H_LIST})
100 SET(STR_FILE "${H_FILE}")
101 STRING(REPLACE "/" "_" STR_FILE ${STR_FILE})
102 STRING(TOUPPER "${STR_FILE}" STR_FILE)
103 SET(H_FILE_FLAG "HAVE_${STR_FILE}_H")
104 CHECK_INCLUDE_FILE("${H_FILE}.h" ${H_FILE_FLAG})
105 ENDFOREACH(H_FILE ${H_LIST})
106
107 ENDMACRO(MED_CHECK_HEADERS)
108
109 ###############################################################################
110 ## Macro to check methods files
111 ###############################################################################
112 MACRO(MED_CHECK_FUNCTIONS)
113
114 #Define list of functions
115 SET(F_LIST "cuserid;ftime;geteuid;getpwuid;gettimeofday")
116
117 #Check each header
118 FOREACH(F_FUNC ${F_LIST})
119 STRING(TOUPPER "${F_FUNC}" STR_F_FUNC)
120 SET(F_FUNC_FLAG "HAVE_${STR_F_FUNC}")
121 CHECK_FUNCTION_EXISTS("${F_FUNC}" ${F_FUNC_FLAG})
122 ENDFOREACH(F_FUNC ${F_LIST})
123
124 ENDMACRO(MED_CHECK_FUNCTIONS)
125
126 ###############################################################################
127 ## Macro to get sizeof Fortran INTEGER
128 ###############################################################################
129 MACRO(CHECK_FORTRAN_INTEGER_SIZE)
130
131 #EF : La variable MED_MEDINT_TYPE est prioritaire pour définir la taille du med_int à utiliser
132 # TODO: vérifier le comportement pour de la cross-compilation
133 #SET(SIZEOF_FORTRAN_INTEGER 4 CACHE INTERNAL "Size of the default INTEGER type" FORCE)
134
135 #EF TODO: Pourquoi ne pas faire le test en f77 qui fonctionnerait avec f77/f90
136 #EF TODO: Existe t-il en cmake un test compilateur f77 et une gestion simultanée f77+f90 ?
137 IF(CMAKE_Fortran_COMPILER_SUPPORTS_F90)
138 FOREACH(_TEST_SIZE 1 2 4 8 16 32)
139 SET(_TEST_FILE ${PROJECT_BINARY_DIR}/testFortranIntegerSize${_TEST_SIZE}.f90)
140 FILE( WRITE ${_TEST_FILE}
141 "
142 PROGRAM check_size
143 INTEGER*${_TEST_SIZE}, TARGET :: a
144 INTEGER, POINTER :: pa
145 pa => a
146 END PROGRAM
147 ")
148 TRY_COMPILE( SIZEOF_INTEGER ${PROJECT_BINARY_DIR} ${_TEST_FILE} )
149 IF(SIZEOF_INTEGER)
150 MESSAGE(STATUS "Testing default INTEGER*${_TEST_SIZE} - found")
151 #EF: SET(SIZEOF_FORTRAN_INTEGER ${_TEST_SIZE})
152 SET(SIZEOF_FORTRAN_INTEGER ${_TEST_SIZE} CACHE INTERNAL "Size of the default INTEGER type" FORCE)
153 BREAK()
154 ENDIF(SIZEOF_INTEGER)
155 ENDFOREACH(_TEST_SIZE 1 2 4 8 16 32)
156 ENDIF(CMAKE_Fortran_COMPILER_SUPPORTS_F90)
157 ENDMACRO(CHECK_FORTRAN_INTEGER_SIZE)
158
159 ###############################################################################
160 ## Macro to check sizeof
161 ###############################################################################
162 MACRO(MED_CHECK_SIZE)
163 #int
164 CHECK_TYPE_SIZE(int SIZEOF_INT)
165 #long
166 CHECK_TYPE_SIZE(long SIZEOF_LONG)
167 #Verify MED_MEDINT_TYPE user defintion
168 SET(_med_medint_type_is_set "NO")
169 IF( NOT "${MED_MEDINT_TYPE}" STREQUAL "" )
170 CHECK_TYPE_SIZE(${MED_MEDINT_TYPE} SIZEOF_MEDINT_TYPE)
171 IF(${SIZEOF_MEDINT_TYPE})
172 SET(_med_medint_type_is_set "YES")
173 ELSE()
174 MESSAGE(WARNING "The MED_MEDINT_TYPE definition is defined but the attended type is UNKNOWN.")
175 ENDIF()
176 ENDIF()
177
178 IF( (NOT _med_medint_type_is_set) AND (NOT CMAKE_Fortran_COMPILER_SUPPORTS_F90) )
179 MESSAGE(WARNING "The MED_MEDINT_TYPE definition is unset and the fortran is disabled. \
180 The med_int type is supposed to be <int>.")
181 SET(LONG_OR_INT int)
182 ENDIF()
183
184 IF( (NOT _med_medint_type_is_set) AND CMAKE_Fortran_COMPILER_SUPPORTS_F90 )
185 CHECK_FORTRAN_INTEGER_SIZE()
186 MESSAGE(WARNING "The MED_MEDINT_TYPE definition is unset but the fortran is enabled. \
187 The med_int type deduced from the integer fortran size.")
188 IF(${SIZEOF_FORTRAN_INTEGER} EQUAL 8)
189 SET(HAVE_F77INT64 1)
190 IF(${SIZEOF_LONG} EQUAL 8)
191 SET(LONG_OR_INT long)
192 ELSEIF(${SIZEOF_LONG_LONG} EQUAL 8)
193 SET(LONG_OR_INT "long long")
194 ELSE()
195 MESSAGE(FATAL_ERROR "Neither C type long nor C type long long is eight bytes")
196 ENDIF()
197 ELSE(${SIZEOF_FORTRAN_INTEGER} EQUAL 8)
198 IF(${SIZEOF_FORTRAN_INTEGER} EQUAL 4)
199 IF(${SIZEOF_INT} EQUAL 4)
200 SET(LONG_OR_INT int)
201 ELSE(${SIZEOF_INT} EQUAL 4)
202 MESSAGE(FATAL_ERROR "Size of C type int expected to be four bytes")
203 ENDIF(${SIZEOF_INT} EQUAL 4)
204 ENDIF(${SIZEOF_FORTRAN_INTEGER} EQUAL 4)
205 ENDIF(${SIZEOF_FORTRAN_INTEGER} EQUAL 8)
206 ENDIF()
207
208 IF(_med_medint_type_is_set AND (NOT CMAKE_Fortran_COMPILER_SUPPORTS_F90) )
209 IF(${SIZEOF_MEDINT_TYPE} EQUAL 8)
210 SET(HAVE_F77INT64 1) #Le nom est mal choisi car il est utilisé même s'il n'y a pas de fortran
211 ENDIF()
212 SET(LONG_OR_INT ${MED_MEDINT_TYPE})
213 ENDIF()
214
215 IF(_med_medint_type_is_set AND CMAKE_Fortran_COMPILER_SUPPORTS_F90 )
216 CHECK_FORTRAN_INTEGER_SIZE()
217 IF( NOT ${SIZEOF_MEDINT_TYPE} EQUAL ${SIZEOF_FORTRAN_INTEGER} )
218 MESSAGE(FATAL_ERROR "The MED_MEDINT_TYPE definition must be coherent with the default fortran integer. \
219 Please, define the correct option in the fortran compiler FFLAGS flag.")
220 ENDIF()
221 IF(${SIZEOF_FORTRAN_INTEGER} EQUAL 8)
222 SET(HAVE_F77INT64 1)
223 ENDIF()
224 SET(LONG_OR_INT ${MED_MEDINT_TYPE})
225 ENDIF()
226
227
228 STRING(REPLACE "long long" "llong" MED_UTILS_LONG_OR_INT "${LONG_OR_INT}")
229 SET(MED_UTILS_LONG_OR_INT ${MED_UTILS_LONG_OR_INT})
230
231 ##
232 ## The below is a light porting of what the M4 macro config/med_check_typeof_int64.m4 does
233 ##
234
235 # Try to find 64 and 32 bits types on the platform:
236 SET(HAVE_INT64 0)
237 SET(MED_INT64 0)
238 SET(MED_INT32 0)
239 CHECK_TYPE_SIZE(int64_t SIZEOF_INT64T)
240 IF (${SIZEOF_INT64T} EQUAL 8)
241 MESSAGE(STATUS "Type 'int64_t' exists and is 8 bytes")
242 SET(MED_INT64 "int64_t")
243 SET(HAVE_INT64 1)
244 ELSE()
245 MESSAGE(WARNING "Type 'int64_t' has WRONG size or is UNDEFINED (${SIZEOF_INT64T})!! 64bits fields will be unavailable")
246 SET(MED_INT64 "med_int")
247 ENDIF()
248
249 CHECK_TYPE_SIZE(int32_t SIZEOF_INT32T)
250 IF (${SIZEOF_INT32T} EQUAL 4)
251 MESSAGE(STATUS "Type 'int32_t' exists and is 4 bytes")
252 SET(MED_INT32 "int32_t")
253 ELSE()
254 MESSAGE(FATAL_ERROR "Type 'int32_t' has WRONG size or is UNDEFINED (${SIZEOF_INT32T})!! Unable to pursue.")
255 ENDIF()
256
257 # In the HDF5 world we have to come back to native types ('long' or 'long long') since int64_t or int32_t
258 # won't be understood
259 SET(MED_H5T_INT64)
260 CHECK_TYPE_SIZE("long long" SIZEOF_LONGLONG)
261 CHECK_TYPE_SIZE("long" SIZEOF_LONG)
262 IF (${SIZEOF_LONG} EQUAL 8)
263 SET(MED_H5T_INT64 "H5T_NATIVE_LONG")
264 MESSAGE(STATUS "MED_H5T_INT64 will map to H5T_NATIVE_LONG")
265 ELSE()
266 IF (${SIZEOF_LONGLONG} EQUAL 8)
267 SET(MED_H5T_INT64 "H5T_NATIVE_LLONG")
268 MESSAGE(STATUS "MED_H5T_INT64 will map to H5T_NATIVE_LLONG")
269 ELSE()
270 MESSAGE(FATAL_ERROR "Neither 'long' nor 'long long' are 8 bytes long!! Unable to pursue.")
271 ENDIF()
272 ENDIF()
273
274 ENDMACRO(MED_CHECK_SIZE)
275
276 ###############################################################################
277 ## Macro to get C <-> Fortran mangling
278 ###############################################################################
279 MACRO(MED_C_FORTRAN_INTERFACE)
280 IF(CMAKE_Fortran_COMPILER_WORKS)
281 FortranCInterface_HEADER(${PROJECT_BINARY_DIR}/include/FC.h)
282 FILE(READ ${PROJECT_BINARY_DIR}/include/FC.h f_content)
283 STRING(REPLACE "\n" ";" list_f_content ${f_content})
284
285 FOREACH(ln ${list_f_content})
286 IF(${ln} MATCHES "#define FortranCInterface_GLOBAL[^_].*")
287 STRING(REPLACE "#define FortranCInterface_GLOBAL" "" F77_FUNC "${ln}")
288 ENDIF()
289
290 IF("${ln}" MATCHES "#define FortranCInterface_GLOBAL_.*")
291 STRING(REPLACE "#define FortranCInterface_GLOBAL_" "" F77_FUNC_ "${ln}")
292 ENDIF()
293 ENDFOREACH(ln ${list_f_content})
294
295 ELSE(CMAKE_Fortran_COMPILER_WORKS)
296
297 SET(F77_FUNC "(name,NAME) NAME")
298
299 ENDIF(CMAKE_Fortran_COMPILER_WORKS)
300
301 ENDMACRO(MED_C_FORTRAN_INTERFACE)
302
303 ###############################################################################
304 ## Macro to check possibility include time.h and sys/time.h headers together
305 ###############################################################################
306 MACRO(MED_TIME_SYS_TIME)
307
308 SET(_TEST_FILE ${PROJECT_BINARY_DIR}/testTimeSysTime.c)
309 FILE( WRITE ${_TEST_FILE}
310 "
311 #include <sys/types.h>
312 #include <sys/time.h>
313 #include <time.h>
314
315 # ifdef __cplusplus
316 extern \"C\"
317 # endif
318
319 int
320 main ()
321 {
322 if ((struct tm *) 0)
323 return 0;
324 ;
325 return 0;
326 }
327 "
328 )
329
330 TRY_COMPILE( TIME_WITH_SYS_TIME ${PROJECT_BINARY_DIR} ${_TEST_FILE} )
331 IF(${TIME_WITH_SYS_TIME})
332 SET(TIME_WITH_SYS_TIME 1)
333 ELSE(${TIME_WITH_SYS_TIME})
334 SET(TIME_WITH_SYS_TIME 0)
335 ENDIF(${TIME_WITH_SYS_TIME})
336
337 ENDMACRO(MED_TIME_SYS_TIME)
338
339 ###########################
340 # SALOME_CHECK_EQUAL_PATHS(result path1 path2)
341 # Check if two paths are identical, resolving links. If the paths do not exist a simple
342 # text comparison is performed.
343 # result is a boolean.
344 ###########################
345 MACRO(SALOME_CHECK_EQUAL_PATHS varRes path1 path2)
346 SET("${varRes}" OFF)
347 IF(EXISTS "${path1}")
348 GET_FILENAME_COMPONENT(_tmp1 "${path1}" REALPATH)
349 ELSE()
350 SET(_tmp1 "${path1}")
351 ENDIF()
352
353 IF(EXISTS "${path2}")
354 GET_FILENAME_COMPONENT(_tmp2 "${path2}" REALPATH)
355 ELSE()
356 SET(_tmp2 "${path2}")
357 ENDIF()
358
359 IF("${_tmp1}" STREQUAL "${_tmp2}")
360 SET("${varRes}" ON)
361 ENDIF()
362 # MESSAGE(${${varRes}})
363 ENDMACRO()
364
365 ########################################################################
366 # SALOME_FIND_PACKAGE(englobingPackageName standardPackageName modus)
367 # Encapsulate the call to the standard FIND_PACKAGE(standardPackageName) passing all the options
368 # given when calling the command FIND_PACKAGE(customPackageName)
369 # Modus is either MODULE or CONFIG (cf standard FIND_PACKAGE() documentation).
370 # This macro is to be called from within the FindCustomPackage.cmake file.
371 ########################################################################
372 MACRO(SALOME_FIND_PACKAGE englobPkg stdPkg mode)
373 # Only bother if the package was not already found:
374 # Some old packages use the lower case version - standard should be to always use
375 # upper case:
376 STRING(TOUPPER ${stdPkg} stdPkgUC)
377 IF(NOT (${stdPkg}_FOUND OR ${stdPkgUC}_FOUND))
378 IF(${englobPkg}_FIND_QUIETLY)
379 SET(_tmp_quiet "QUIET")
380 ELSE()
381 SET(_tmp_quiet)
382 ENDIF()
383 IF(${englobPkg}_FIND_REQUIRED)
384 SET(_tmp_req "REQUIRED")
385 ELSE()
386 SET(_tmp_req)
387 ENDIF()
388 IF(${englobPkg}_FIND_VERSION_EXACT)
389 SET(_tmp_exact "EXACT")
390 ELSE()
391 SET(_tmp_exact)
392 ENDIF()
393 IF(${englobPkg}_FIND_COMPONENTS)
394 STRING(REPLACE ";" " " _tmp_compo ${${englobPkg}_FIND_COMPONENTS})
395 ELSE()
396 SET(_tmp_compo)
397 ENDIF()
398
399 # Call the root FIND_PACKAGE():
400 IF(_tmp_compo)
401 FIND_PACKAGE(${stdPkg} ${${englobPkg}_FIND_VERSION} ${_tmp_exact} ${mode} ${_tmp_quiet} ${_tmp_req} COMPONENTS ${_tmp_compo})
402 ELSE()
403 FIND_PACKAGE(${stdPkg} ${${englobPkg}_FIND_VERSION} ${_tmp_exact} ${mode} ${_tmp_quiet} ${_tmp_req})
404 ENDIF()
405 ENDIF()
406 ENDMACRO()
407
408 ###############################################################################
409 ## Macro to find MPI and most of all set all relevant flags
410 ###############################################################################
411 MACRO(MED_FIND_MPI)
412 SET (MEDFILE_USE_MPI OFF CACHE BOOL "Use MPI to compile MED-file")
413 IF (MEDFILE_USE_MPI)
414 MESSAGE(STATUS "Check for MPI ...")
415
416 FIND_PACKAGE(MedfileMPI REQUIRED)
417
418 # Library configuration:
419 IF(WIN32)
420 # Win specific stuff
421 FIND_LIBRARY(MPI_LIB_THREAD libboost_thread-vc90-mt-gd-1_35 ${MPI_ROOT_DIR_EXP}/lib)
422 FIND_LIBRARY(MPI_LIB_DATE_TIME libboost_date_time-vc90-mt-gd-1_35 ${MPI_ROOT_DIR_EXP}/lib)
423 ELSE(WIN32)
424 # set flags for both OpenMPI or MPICH:
425 ADD_DEFINITIONS(-DOMPI_IGNORE_CXX_SEEK -DMPICH_IGNORE_CXX_SEEK)
426 ENDIF(WIN32)
427 # Gather all MPI libs in one place:
428 SET(MPI_LIBS ${MPI_CXX_LIBRARIES})
429 LIST(APPEND MPI_LIBS ${MPI_C_LIBRARIES})
430 IF(CMAKE_Fortran_COMPILER_WORKS)
431 LIST(APPEND MPI_LIBS ${MPI_Fortran_LIBRARIES})
432 ENDIF()
433 MESSAGE(STATUS "MPI libs: ${MPI_LIBS}")
434 ELSE(MEDFILE_USE_MPI)
435 MESSAGE(STATUS "Configuring without MPI (set MEDFILE_USE_MPI to True to change this)")
436 ENDIF(MEDFILE_USE_MPI)
437 ENDMACRO(MED_FIND_MPI)
438
439 ###############################################################################
440 ## Macro to find HDF5 and most of all set all relevant flags
441 ###############################################################################
442 MACRO(MED_FIND_HDF5)
443 MESSAGE(STATUS "Check for HDF5 ...")
444
445 FIND_PACKAGE(MedfileHDF5 REQUIRED)
446
447 ##
448 ## Requires 1.10.x version
449 ##
450 IF (NOT HDF_VERSION_MAJOR_REF EQUAL 1 OR NOT HDF_VERSION_MINOR_REF EQUAL 10 OR NOT HDF_VERSION_RELEASE_REF GREATER 1)
451 MESSAGE(FATAL_ERROR "HDF5 version is ${HDF_VERSION_REF}. Only versions >= 1.10.2 are supported.")
452 ENDIF()
453 ##
454 ##
455
456 ADD_DEFINITIONS(-DH5_USE_16_API)
457 IF(WIN32 AND MEDFILE_BUILD_SHARED_LIBS)
458 ADD_DEFINITIONS(-D_HDF5USEDLL_ -DH5_BUILT_AS_DYNAMIC_LIB=1)
459 ENDIF()
460
461 # Take what is exposed by the standard FIND_PACKAGE()
462
463 SET(HDF5_LIBS ${HDF5_LIBRARIES})
464
465 IF(HDF5_IS_PARALLEL OR HDF5_ENABLE_PARALLEL)
466 MESSAGE(STATUS "HDF5 is parallel")
467 ENDIF()
468
469 # Extract some stuff from headers
470 FIND_FILE(_H5PUB_ABS_PATH H5public.h PATHS ${HDF5_INCLUDE_DIRS} NO_DEFAULT_PATH)
471 FIND_FILE(_H5_I_PUB_ABS_PATH H5Ipublic.h PATHS ${HDF5_INCLUDE_DIRS} NO_DEFAULT_PATH)
472 IF(NOT _H5PUB_ABS_PATH OR NOT _H5_I_PUB_ABS_PATH)
473 MESSAGE(FATAL_ERROR "Could not find H5public.h or H5Ipublic.h!")
474 ELSE()
475 FILE(STRINGS "${_H5PUB_ABS_PATH}" _h5pub_contents)
476 FOREACH(_line IN LISTS _h5pub_contents)
477 SET(_match)
478 STRING(REGEX MATCH "^[ \t]*typedef .*herr_t.*" _match "${_line}")
479 IF(_match)
480 SET(HDF5_TYPEDEF_HERR_T "${_match}")
481 ENDIF()
482 STRING(REGEX MATCH "^[ \t]*typedef .*hsize_t.*" _match "${_line}")
483 IF(_match)
484 SET(HDF5_TYPEDEF_HSIZE_T "${_match}")
485 ENDIF()
486 ENDFOREACH()
487
488 FILE(STRINGS "${_H5_I_PUB_ABS_PATH}" _h5_i_pub_contents)
489 FOREACH(_line IN LISTS _h5_i_pub_contents)
490 SET(_match)
491 STRING(REGEX MATCH "^[ \t]*typedef .*hid_t.*" _match "${_line}")
492 IF(_match)
493 SET(HDF5_TYPEDEF_HID_T "${_match}")
494 BREAK()
495 ENDIF()
496 ENDFOREACH()
497 ENDIF()
498 ENDMACRO(MED_FIND_HDF5)
499
500 #
501 # Install and compile a Python file - needs Python!
502 #
503 MACRO(INSTALL_AND_COMPILE_PYTHON_FILE PYFILE2COMPINST PYFILELOC)
504 INSTALL(CODE "SET(PYTHON_FILE ${f})")
505 FOREACH(input ${PYFILE2COMPINST})
506 GET_FILENAME_COMPONENT(inputname ${input} NAME)
507 INSTALL(FILES ${input} DESTINATION ${CMAKE_INSTALL_PREFIX}/${PYFILELOC})
508 INSTALL(CODE "MESSAGE(STATUS \"py compiling \$ENV{DESTDIR}${CMAKE_INSTALL_PREFIX}/${PYFILELOC}/${inputname}\")")
509 INSTALL(CODE "SET(CMD \"import py_compile ; py_compile.compile('\$ENV{DESTDIR}${CMAKE_INSTALL_PREFIX}/${PYFILELOC}/${inputname}')\")")
510 INSTALL(CODE "EXECUTE_PROCESS(COMMAND ${PYTHON_EXECUTABLE} -c \"\${CMD}\")")
511 INSTALL(CODE "EXECUTE_PROCESS(COMMAND ${PYTHON_EXECUTABLE} -O -c \"\${CMD}\")")
512 ENDFOREACH(input ${PYFILE2COMPINST})
513 ENDMACRO(INSTALL_AND_COMPILE_PYTHON_FILE PYFILE2COMPINST PYFILELOC)