include(CheckCXXSourceCompiles)

function(adddirname prefix lst out_lst)

set(output)

foreach(item ${lst})

list(APPEND output "${prefix}/${item}")

endforeach()

set(${out_lst} ${${out_lst}} ${output} PARENT_SCOPE)

endfunction()

MACRO(set_version_variables prefix value)

string(REPLACE "." ";" VERSION_LIST ${value})

list(GET VERSION_LIST 0 ${prefix}_MAJOR)

list(GET VERSION_LIST 1 ${prefix}_MINOR)

list(GET VERSION_LIST 2 ${prefix}_PATCH)

set(${prefix}_DEFINESTR "")

ENDMACRO(set_version_variables)

MACRO(set_default varname)

if (NOT DEFINED ${varname})

set(${varname} ${ARGN})

endif()

ENDMACRO(set_default)

MACRO(set1_if varname)

IF(${ARGN})

SET(${varname} 1)

ELSE(${ARGN})

SET(${varname} 0)

ENDIF(${ARGN})

ENDMACRO(set1_if)

MACRO(seton_if varname)

IF(${ARGN})

SET(${varname} ON)

ELSE(${ARGN})

SET(${varname} OFF)

ENDIF(${ARGN})

ENDMACRO(seton_if)

FUNCTION(join_arguments outvar)

set (output)

foreach (i ${ARGN})

set(output "${output} ${i}")

endforeach()

set (${outvar} ${output} PARENT_SCOPE)

ENDFUNCTION()

macro(mvar VARNAME)

if (DEFINED ${VARNAME})

message(STATUS " ${VARNAME}=${${VARNAME}}")

else()

message(STATUS " ${VARNAME} not defined")

endif()

endmacro()

MACRO(MafReadDir directory maffile)

# ARGN contains the extra "section-variable" pairs

# If empty, return nothing

set (MAFREAD_TAGS

SOURCES # source files

PUBLIC_HEADERS # installable headers for include

PROTECTED_HEADERS # installable headers used by other headers

PRIVATE_HEADERS # non-installable headers

SOURCES_WIN32_SHARED # windows specific SOURCES

PRIVATE_HEADERS_WIN32_SHARED # windows specific PRIVATE_HEADERS

OPTIONS

)

cmake_parse_arguments(MAFREAD_VAR "" "${MAFREAD_TAGS}" "" ${ARGN})

# Arguments for these tags are variables to be filled

# with the contents of particular section.

# While reading the file, extract the section.

# Section is recognized by either first uppercase character or space.

# @c http://cmake.org/pipermail/cmake/2007-May/014222.html

FILE(READ ${directory}/${maffile} MAFREAD_CONTENTS)

STRING(REGEX REPLACE ";" "\\\\;" MAFREAD_CONTENTS "${MAFREAD_CONTENTS}")

STRING(REGEX REPLACE "\n" ";" MAFREAD_CONTENTS "${MAFREAD_CONTENTS}")

# Once correctly read, declare this file as dependency of the build file.

# Normally you should use cmake_configure_depends(), but this is

# available only since 3.0 version.

configure_file(${directory}/${maffile} dummy_${maffile}.cmake.out)

file(REMOVE ${CMAKE_CURRENT_BINARY_DIR}/dummy_${maffile}.cmake.out)

#message("DEBUG: MAF FILE CONTENTS: ${MAFREAD_CONTENTS}")

#message("DEBUG: PASSED VARIABLES:")

#foreach(DEBUG_VAR ${MAFREAD_TAGS})

# message("DEBUG: ${DEBUG_VAR}=${MAFREAD_VAR_${DEBUG_VAR}}")

#endforeach()

# The unnamed section becomes SOURCES

set (MAFREAD_VARIABLE ${MAFREAD_VAR_SOURCES})

set (MAFREAD_UNASSIGNED "")

# Default section type. Another is 'flags'.

set (MAFREAD_SECTION_TYPE file)

FOREACH(MAFREAD_LINE ${MAFREAD_CONTENTS})

# Test what this line is

string(STRIP ${MAFREAD_LINE} MAFREAD_OLINE)

string(SUBSTRING ${MAFREAD_OLINE} 0 1 MAFREAD_FIRST)

#message("DEBUG: LINE='${MAFREAD_LINE}' FIRST='${MAFREAD_FIRST}'")

# The 'continue' command is cmake 3.2 - very late discovery

if (MAFREAD_FIRST STREQUAL "")

#message("DEBUG: ... skipped: empty")

elseif (MAFREAD_FIRST STREQUAL "#")

#message("DEBUG: ... skipped: comment")

else()

# Will be skipped if the line was a comment/empty

string(REGEX MATCH "[ A-Z-]" MAFREAD_SECMARK ${MAFREAD_FIRST})

if (MAFREAD_SECMARK STREQUAL "")

# This isn't a section, it's a list element.

#message("DEBUG: ITEM: ${MAFREAD_OLINE} --> ${MAFREAD_VARIABLE}")

if (${MAFREAD_SECTION_TYPE} STREQUAL file)

get_filename_component(MAFREAD_OLINE ${directory}/${MAFREAD_OLINE} ABSOLUTE)

endif()

set (MAFREAD_CONDITION_OK 1)

if (DEFINED MAFREAD_CONDITION_LIST)

FOREACH(MFITEM IN ITEMS ${MAFREAD_CONDITION_LIST})

separate_arguments(MFITEM)

FOREACH(MFVAR IN ITEMS ${MFITEM})

STRING(SUBSTRING ${MFVAR} 0 1 MFPREFIX)

if (MFPREFIX STREQUAL "!")

STRING(SUBSTRING ${MFVAR} 1 -1 MFVAR)

if (${MFVAR})

set (MFCONDITION_RESULT 0)

else()

set (MFCONDITION_RESULT 1)

endif()

else()

if (${MFVAR})

set (MFCONDITION_RESULT 1)

else()

set (MFCONDITION_RESULT 0)

endif()

endif()

#message("CONDITION: ${MFPREFIX} ${MFVAR} -> ${MFCONDITION_RESULT}")

MATH(EXPR MAFREAD_CONDITION_OK "${MAFREAD_CONDITION_OK} & (${MFCONDITION_RESULT})")

ENDFOREACH()

ENDFOREACH()

endif()

if (MAFREAD_CONDITION_OK)

LIST(APPEND ${MAFREAD_VARIABLE} ${MAFREAD_OLINE})

else()

#message("... NOT ADDED ITEM: ${MAFREAD_OLINE}")

endif()

else()

# It's a section

# Check for conditionals (clear current conditions first)

unset(MAFREAD_CONDITION_LIST)

STRING(FIND ${MAFREAD_OLINE} " -" MAFREAD_HAVE_CONDITION)

if (NOT MAFREAD_HAVE_CONDITION EQUAL -1)

# Cut off conditional specification, and

# grab the section name and condition list

STRING(REPLACE " -" ";" MAFREAD_CONDITION_LIST ${MAFREAD_OLINE})

#message("CONDITION READ: ${MAFREAD_CONDITION_LIST}")

LIST(GET MAFREAD_CONDITION_LIST 0 MAFREAD_OLINE)

LIST(REMOVE_AT MAFREAD_CONDITION_LIST 0)

#message("EXTRACTING SECTION=${MAFREAD_OLINE} CONDITIONS=${MAFREAD_CONDITION_LIST}")

endif()

# change the running variable

# Make it section name

STRING(REPLACE " " "_" MAFREAD_SECNAME ${MAFREAD_OLINE})

#message("MAF SECTION: ${MAFREAD_SECNAME}")

# The cmake's version of 'if (MAFREAD_SECNAME[0] == '-')' - sigh...

string(SUBSTRING ${MAFREAD_SECNAME} 0 1 MAFREAD_SECNAME0)

if (${MAFREAD_SECNAME0} STREQUAL "-")

set (MAFREAD_SECTION_TYPE option)

string(SUBSTRING ${MAFREAD_SECNAME} 1 -1 MAFREAD_SECNAME)

else()

set (MAFREAD_SECTION_TYPE file)

endif()

set(MAFREAD_VARIABLE ${MAFREAD_VAR_${MAFREAD_SECNAME}})

if (MAFREAD_VARIABLE STREQUAL "")

set(MAFREAD_VARIABLE MAFREAD_UNASSIGNED)

endif()

#message("DEBUG: NEW SECTION: '${MAFREAD_SECNAME}' --> VARIABLE: '${MAFREAD_VARIABLE}'")

endif()

endif()

ENDFOREACH()

# Final debug report

#set (ALL_VARS "")

#message("DEBUG: extracted variables:")

#foreach(DEBUG_VAR ${MAFREAD_TAGS})

# list(APPEND ALL_VARS ${MAFREAD_VAR_${DEBUG_VAR}})

#endforeach()

#list(REMOVE_DUPLICATES ALL_VARS)

#foreach(DEBUG_VAR ${ALL_VARS})

# message("DEBUG: --> ${DEBUG_VAR} = ${${DEBUG_VAR}}")

#endforeach()

ENDMACRO(MafReadDir)

MACRO(GetMafHeaders directory outvar)

EXECUTE_PROCESS(

COMMAND ${CMAKE_MODULE_PATH}/mafread.tcl

${CMAKE_SOURCE_DIR}/${directory}/HEADERS.maf

"PUBLIC HEADERS"

"PROTECTED HEADERS"

OUTPUT_STRIP_TRAILING_WHITESPACE

OUTPUT_VARIABLE ${outvar}

)

SEPARATE_ARGUMENTS(${outvar})

adddirname(${CMAKE_SOURCE_DIR}/${directory} "${${outvar}}" ${outvar})

ENDMACRO(GetMafHeaders)

function (getVarsWith _prefix _varResult)

get_cmake_property(_vars VARIABLES)

string (REGEX MATCHALL "(^|;)${_prefix}[A-Za-z0-9_]*" _matchedVars "${_vars}")

set (${_varResult} ${_matchedVars} PARENT_SCOPE)

endfunction()

function (addDefinitionsFromPrefixed _prefix)

getVarsWith(${_prefix} enforcers)

foreach(ef ${enforcers})

set (val ${${ef}})

if (NOT val STREQUAL "")

set(val =${val})

endif()

string(LENGTH ${_prefix} pflen)

string(LENGTH ${ef} eflen)

math(EXPR alen ${eflen}-${pflen})

string(SUBSTRING ${ef} ${pflen} ${alen} ef)

message(STATUS "FORCED PP VARIABLE: ${ef}${val}")

add_definitions(-D${ef}${val})

endforeach()

endfunction()

function (check_testcode_compiles testcode libraries _successful)

set (save_required_libraries ${CMAKE_REQUIRED_LIBRARIES})

set (CMAKE_REQUIRED_LIBRARIES "${CMAKE_REQUIRED_LIBRARIES} ${libraries}")

check_cxx_source_compiles("${testcode}" ${_successful})

set (${_successful} ${${_successful}} PARENT_SCOPE)

set (CMAKE_REQUIRED_LIBRARIES ${save_required_libraries})

endfunction()

function (test_requires_clock_gettime _enable _linklib)

# This function tests if clock_gettime can be used

# - at all

# - with or without librt

# Result will be:

# - CLOCK_MONOTONIC is available, link with librt:

# _enable = ON; _linklib = "-lrt".

# - CLOCK_MONOTONIC is available, link without librt:

# _enable = ON; _linklib = "".

# - CLOCK_MONOTONIC is not available:

# _enable = OFF; _linklib = "-".

# Default "not found" state.

set (${_enable} OFF PARENT_SCOPE)

set (${_linklib} "-" PARENT_SCOPE)

set (code "

")

check_testcode_compiles(${code} "" HAVE_CLOCK_GETTIME_IN)

if (HAVE_CLOCK_GETTIME_IN)

message(STATUS "CLOCK_MONOTONIC: available, no extra libs needed")

set (${_enable} ON PARENT_SCOPE)

set (${_linklib} "" PARENT_SCOPE)

return()

endif()

check_testcode_compiles(${code} "rt" HAVE_CLOCK_GETTIME_LIBRT)

if (HAVE_CLOCK_GETTIME_LIBRT)

message(STATUS "CLOCK_MONOTONIC: available, requires -lrt")

set (${_enable} ON PARENT_SCOPE)

set (${_linklib} "-lrt" PARENT_SCOPE)

return()

endif()

set (${_enable} OFF PARENT_SCOPE)

set (${_linklib} "-" PARENT_SCOPE)

message(STATUS "CLOCK_MONOTONIC: not available on this system")

endfunction()

function (srt_parse_compiler_type wct _type _suffix)

if (wct STREQUAL "")

set(${_type} "" PARENT_SCOPE)

set(${_suffix} "" PARENT_SCOPE)

else()

string(REPLACE "-" ";" OUTLIST ${wct})

list(LENGTH OUTLIST OUTLEN)

list(GET OUTLIST 0 ITEM)

set(${_type} ${ITEM} PARENT_SCOPE)

if (OUTLEN LESS 2)

set(_suffix "" PARENT_SCOPE)

else()

list(GET OUTLIST 1 ITEM)

set(${_suffix} "-${ITEM}" PARENT_SCOPE)

endif()

endif()

endfunction()

macro (srt_import_parent_options)

getVarsWith(LIBSRT_ extoptions)

foreach(ef ${extoptions})

set (val ${${ef}})

string(LENGTH LIBSRT_ pflen)

string(LENGTH ${ef} eflen)

math(EXPR alen ${eflen}-${pflen})

string(SUBSTRING ${ef} ${pflen} ${alen} ef)

message(STATUS "IMPORTED OPTION: ${ef}='${val}'")

set (${ef} "${val}")

endforeach()

endmacro()

function(srt_map_compiler COMPILER_TYPE OUT_C_COMMAND OUT_CXX_COMMAND)

if (COMPILER_TYPE STREQUAL "gcc")

set (${OUT_C_COMMAND} gcc PARENT_SCOPE)

set (${OUT_CXX_COMMAND} g++ PARENT_SCOPE)

elseif(COMPILER_TYPE STREQUAL "cc")

set (${OUT_C_COMMAND} cc PARENT_SCOPE)

set (${OUT_CXX_COMMAND} c++ PARENT_SCOPE)

elseif(COMPILER_TYPE STREQUAL "icc")

set (${OUT_C_COMMAND} icc PARENT_SCOPE)

set (${OUT_CXX_COMMAND} icpc PARENT_SCOPE)

else()

set (${OUT_C_COMMAND} "${COMPILER_TYPE}" PARENT_SCOPE)

set (${OUT_CXX_COMMAND} "${COMPILER_TYPE}++" PARENT_SCOPE)

endif()

endfunction()

function(srt_configure_compiler I_TYPE I_PREFIX OUT_C_COMMAND OUT_CXX_COMMAND OUT_COMPILER_TYPE)

srt_parse_compiler_type(${I_TYPE} COMPILER_TYPE COMPILER_SUFFIX)

srt_map_compiler(${COMPILER_TYPE} C_COMMAND CXX_COMMAND GNU_COMPAT)

set (${OUT_C_COMMAND} ${I_PREFIX}${C_COMMAND}${COMPILER_SUFFIX} PARENT_SCOPE)

set (${OUT_CXX_COMMAND} ${I_PREFIX}${CXX_COMMAND}${COMPILER_SUFFIX} PARENT_SCOPE)

set (${OUT_COMPILER_TYPE} ${COMPILER_TYPE} PARENT_SCOPE)

endfunction()

function (srt_check_cxxstd stdval OUT_STD OUT_PFX)

set (STDPFX c++)

if (stdval MATCHES "([^+]+\\++)([0-9]*)")

set (STDPFX ${CMAKE_MATCH_1})

set (STDCXX ${CMAKE_MATCH_2})

elseif (stdval MATCHES "[0-9]*")

set (STDCXX ${stdval})

else()

set (STDCXX 0)

endif()

# Handle C++98 < C++11

# Please fix this around 2070 year.

if (${STDCXX} GREATER 80)

set (STDCXX 03)

endif()

# return

set (${OUT_STD} ${STDCXX} PARENT_SCOPE)

set (${OUT_PFX} ${STDPFX} PARENT_SCOPE)

endfunction()