[occt.git] / adm / cmake / occt_macros.cmake

#
macro (OCCT_CHECK_AND_UNSET VARNAME)
  if (DEFINED ${VARNAME})
    unset (${VARNAME} CACHE)
  endif()
endmacro()

macro (OCCT_CHECK_AND_UNSET_GROUP VARNAME)
  OCCT_CHECK_AND_UNSET ("${VARNAME}_DIR")

  OCCT_CHECK_AND_UNSET ("${VARNAME}_INCLUDE_DIR")

  OCCT_CHECK_AND_UNSET ("${VARNAME}_LIBRARY")
  OCCT_CHECK_AND_UNSET ("${VARNAME}_LIBRARY_DIR")

  if (WIN32)
    OCCT_CHECK_AND_UNSET ("${VARNAME}_DLL")
    OCCT_CHECK_AND_UNSET ("${VARNAME}_DLL_DIR")
  endif()
endmacro()

# COMPILER_BITNESS variable
macro (OCCT_MAKE_COMPILER_BITNESS)
  math (EXPR COMPILER_BITNESS "32 + 32*(${CMAKE_SIZEOF_VOID_P}/8)")
endmacro()

# OS_WITH_BIT
macro (OCCT_MAKE_OS_WITH_BITNESS)

  OCCT_MAKE_COMPILER_BITNESS()

  if (WIN32)
    set (OS_WITH_BIT "win${COMPILER_BITNESS}")
  elseif(APPLE)
    set (OS_WITH_BIT "mac${COMPILER_BITNESS}")
  else()
    set (OS_WITH_BIT "lin${COMPILER_BITNESS}")
  endif()
endmacro()

# COMPILER variable
macro (OCCT_MAKE_COMPILER_SHORT_NAME)
  if (MSVC)
    if (MSVC70)
      set (COMPILER vc7)
    elseif (MSVC80)
      set (COMPILER vc8)
    elseif (MSVC90)
      set (COMPILER vc9)
    elseif (MSVC10)
      set (COMPILER vc10)
    elseif (MSVC11)
      set (COMPILER vc11)
    elseif (MSVC12)
      set (COMPILER vc12)
    endif()
  elseif (DEFINED CMAKE_COMPILER_IS_GNUCC)
    set (COMPILER gcc)
  elseif (DEFINED CMAKE_COMPILER_IS_GNUCXX)
    set (COMPILER gxx)
  elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
    set (COMPILER clang)
  elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Intel")
    set (COMPILER icc)
  else()
    set (COMPILER ${CMAKE_GENERATOR})
    string (REGEX REPLACE " " "" COMPILER ${COMPILER})
  endif()
endmacro()

function (SUBDIRECTORY_NAMES MAIN_DIRECTORY RESULT)
  file (GLOB SUB_ITEMS "${MAIN_DIRECTORY}/*")

  foreach (ITEM ${SUB_ITEMS})
    if (IS_DIRECTORY "${ITEM}")
      get_filename_component (ITEM_NAME "${ITEM}" NAME)
      list (APPEND LOCAL_RESULT "${ITEM_NAME}")
    endif()
  endforeach()
  set (${RESULT} ${LOCAL_RESULT} PARENT_SCOPE)
endfunction()

function (FIND_PRODUCT_DIR ROOT_DIR PRODUCT_NAME RESULT)
  OCCT_MAKE_COMPILER_SHORT_NAME()
  OCCT_MAKE_COMPILER_BITNESS()

  string (TOLOWER "${PRODUCT_NAME}" lower_PRODUCT_NAME)

  list (APPEND SEARCH_TEMPLATES "${lower_PRODUCT_NAME}.*${COMPILER}.*${COMPILER_BITNESS}")
  list (APPEND SEARCH_TEMPLATES "${lower_PRODUCT_NAME}.*[0-9.]+.*${COMPILER}.*${COMPILER_BITNESS}")
  list (APPEND SEARCH_TEMPLATES "${lower_PRODUCT_NAME}.*[0-9.]+.*${COMPILER_BITNESS}")
  list (APPEND SEARCH_TEMPLATES "${lower_PRODUCT_NAME}.*[0-9.]+")
  list (APPEND SEARCH_TEMPLATES "${lower_PRODUCT_NAME}")

  SUBDIRECTORY_NAMES ("${ROOT_DIR}" SUBDIR_NAME_LIST)

  foreach (SEARCH_TEMPLATE ${SEARCH_TEMPLATES})
    if (LOCAL_RESULT)
      BREAK()
    endif()

    foreach (SUBDIR_NAME ${SUBDIR_NAME_LIST})
      string (TOLOWER "${SUBDIR_NAME}" lower_SUBDIR_NAME)

      string (REGEX MATCH "${SEARCH_TEMPLATE}" DUMMY_VAR "${lower_SUBDIR_NAME}")
      if (DUMMY_VAR)
        list (APPEND LOCAL_RESULT ${SUBDIR_NAME})
      endif()
    endforeach()
  endforeach()

  if (LOCAL_RESULT)
    list (LENGTH "${LOCAL_RESULT}" LOC_LEN)
    math (EXPR LAST_ELEMENT_INDEX "${LOC_LEN}-1")
    list (GET LOCAL_RESULT ${LAST_ELEMENT_INDEX} DUMMY)
    set (${RESULT} ${DUMMY} PARENT_SCOPE)
  endif()
endfunction()

macro (OCCT_INSTALL_FILE_OR_DIR BEING_INSTALLED_OBJECT DESTINATION_PATH)
  if (APPLY_OCCT_PATCH_DIR AND EXISTS "${APPLY_OCCT_PATCH_DIR}/${BEING_INSTALLED_OBJECT}")
    if (IS_DIRECTORY "${APPLY_OCCT_PATCH_DIR}/${BEING_INSTALLED_OBJECT}")
      # first of all, install original files
      install (DIRECTORY "${CMAKE_SOURCE_DIR}/${BEING_INSTALLED_OBJECT}" DESTINATION  "${DESTINATION_PATH}")

      # secondly, rewrite original files with patched ones
      install (DIRECTORY "${APPLY_OCCT_PATCH_DIR}/${BEING_INSTALLED_OBJECT}" DESTINATION  "${DESTINATION_PATH}")
    else()
      install (FILES     "${APPLY_OCCT_PATCH_DIR}/${BEING_INSTALLED_OBJECT}" DESTINATION  "${DESTINATION_PATH}")
    endif()
  else()
    if (IS_DIRECTORY "${CMAKE_SOURCE_DIR}/${BEING_INSTALLED_OBJECT}")
      install (DIRECTORY "${CMAKE_SOURCE_DIR}/${BEING_INSTALLED_OBJECT}" DESTINATION  "${DESTINATION_PATH}")
    else()
      install (FILES     "${CMAKE_SOURCE_DIR}/${BEING_INSTALLED_OBJECT}" DESTINATION  "${DESTINATION_PATH}")
    endif()
  endif()
endmacro()

macro (OCCT_CONFIGURE_AND_INSTALL BEING_CONGIRUGED_FILE BUILD_NAME INSTALL_NAME DESTINATION_PATH)
  if (APPLY_OCCT_PATCH_DIR AND EXISTS "${APPLY_OCCT_PATCH_DIR}/${BEING_CONGIRUGED_FILE}")
    configure_file("${APPLY_OCCT_PATCH_DIR}/${BEING_CONGIRUGED_FILE}" "${BUILD_NAME}" @ONLY)
  else()
    configure_file("${CMAKE_SOURCE_DIR}/${BEING_CONGIRUGED_FILE}" "${BUILD_NAME}" @ONLY)
  endif()

  install(FILES "${OCCT_BINARY_DIR}/${BUILD_NAME}" DESTINATION  "${DESTINATION_PATH}" RENAME ${INSTALL_NAME})
endmacro()

macro (COLLECT_AND_INSTALL_OCCT_HEADER_FILES ROOT_OCCT_DIR TEMPLATE_HEADER_PATH ROOT_TARGET_OCCT_DIR OCCT_BUILD_TOOLKITS)
  set (OCCT_SOURCE_DIRS)

  foreach (OCCT_USED_TOOLKIT ${OCCT_BUILD_TOOLKITS})
    # append parent folder
    list (APPEND OCCT_SOURCE_DIRS ${OCCT_USED_TOOLKIT})

    # append all required package folders
    set (OCCT_USED_TOOLKIT_DEPS)
    if (EXISTS "${ROOT_OCCT_DIR}/src/${OCCT_USED_TOOLKIT}/PACKAGES")
      file (STRINGS "${ROOT_OCCT_DIR}/src/${OCCT_USED_TOOLKIT}/PACKAGES" OCCT_USED_TOOLKIT_DEPS)
    endif()

    foreach (OCCT_USED_TOOLKIT_DEP ${OCCT_USED_TOOLKIT_DEPS})
      list (APPEND OCCT_SOURCE_DIRS ${OCCT_USED_TOOLKIT_DEP})
    endforeach()
  endforeach()

  foreach (OCCT_SOURCE_DIR ${OCCT_SOURCE_DIRS})
    # get all header files from each src folder 
    file (GLOB OCCT_HEADER_FILES "${ROOT_OCCT_DIR}/src/${OCCT_SOURCE_DIR}/*.[hgl]xx" "${ROOT_OCCT_DIR}/src/${OCCT_SOURCE_DIR}/*.h")

    install (FILES ${OCCT_HEADER_FILES} DESTINATION "${INSTALL_DIR}/inc")

    # create new file including found header
    foreach (OCCT_HEADER_FILE ${OCCT_HEADER_FILES})
      get_filename_component (HEADER_FILE_NAME ${OCCT_HEADER_FILE} NAME)
      configure_file ("${TEMPLATE_HEADER_PATH}" "${ROOT_TARGET_OCCT_DIR}/inc/${HEADER_FILE_NAME}" @ONLY)
    endforeach()
  endforeach()
endmacro()

macro (OCCT_COPY_FILE_OR_DIR BEING_COPIED_OBJECT DESTINATION_PATH)
  # first of all, copy original files
  file (COPY "${CMAKE_SOURCE_DIR}/${BEING_COPIED_OBJECT}" DESTINATION  "${DESTINATION_PATH}")

  if (APPLY_OCCT_PATCH_DIR AND EXISTS "${APPLY_OCCT_PATCH_DIR}/${BEING_COPIED_OBJECT}")
    # secondly, rewrite original files with patched ones
    file (COPY "${APPLY_OCCT_PATCH_DIR}/${BEING_COPIED_OBJECT}" DESTINATION  "${DESTINATION_PATH}")
  endif()
endmacro()

macro (OCCT_CONFIGURE BEING_CONGIRUGED_FILE FINAL_NAME)
  if (APPLY_OCCT_PATCH_DIR AND EXISTS "${APPLY_OCCT_PATCH_DIR}/${BEING_CONGIRUGED_FILE}")
    configure_file("${APPLY_OCCT_PATCH_DIR}/${BEING_CONGIRUGED_FILE}" "${FINAL_NAME}" @ONLY)
  else()
    configure_file("${CMAKE_SOURCE_DIR}/${BEING_CONGIRUGED_FILE}" "${FINAL_NAME}" @ONLY)
  endif()
endmacro()

function (OCCT_IS_PRODUCT_REQUIRED CSF_VAR_NAME USE_PRODUCT)
  set (${USE_PRODUCT} OFF PARENT_SCOPE)

  if (NOT BUILD_TOOLKITS)
    message(STATUS "Warning: the list of being used toolkits is empty")
  else()
    foreach (USED_TOOLKIT ${BUILD_TOOLKITS})
      if (APPLY_OCCT_PATCH_DIR AND EXISTS "${APPLY_OCCT_PATCH_DIR}/src/${USED_TOOLKIT}/EXTERNLIB")
        file (READ "${APPLY_OCCT_PATCH_DIR}/src/${USED_TOOLKIT}/EXTERNLIB" FILE_CONTENT)
      elseif (EXISTS "${CMAKE_SOURCE_DIR}/src/${USED_TOOLKIT}/EXTERNLIB")
        file (READ "${CMAKE_SOURCE_DIR}/src/${USED_TOOLKIT}/EXTERNLIB" FILE_CONTENT)
      endif()

      string (REGEX MATCH "${CSF_VAR_NAME}" DOES_FILE_CONTAIN "${FILE_CONTENT}")

      if (DOES_FILE_CONTAIN)
        set (${USE_PRODUCT} ON PARENT_SCOPE)
        break()
      endif()
    endforeach()
  endif()
endfunction()

function (FILE_TO_LIST FILE_NAME FILE_CONTENT)
  set (LOCAL_FILE_CONTENT)
  if (APPLY_OCCT_PATCH_DIR AND EXISTS "${APPLY_OCCT_PATCH_DIR}/${FILE_NAME}")
    file (STRINGS "${APPLY_OCCT_PATCH_DIR}/${FILE_NAME}" LOCAL_FILE_CONTENT)
  elseif (EXISTS "${CMAKE_SOURCE_DIR}/${FILE_NAME}")
    file (STRINGS "${CMAKE_SOURCE_DIR}/${FILE_NAME}" LOCAL_FILE_CONTENT)
  endif()

  set (${FILE_CONTENT} ${LOCAL_FILE_CONTENT} PARENT_SCOPE)
endfunction()

# Function to determine if TOOLKIT is OCCT toolkit
function (IS_OCCT_TOOLKIT TOOLKIT_NAME MODULES IS_TOOLKIT_FOUND)
  set (${IS_TOOLKIT_FOUND} OFF PARENT_SCOPE)
  foreach (MODULE ${${MODULES}})
    set (TOOLKITS ${${MODULE}_TOOLKITS})
    list (FIND TOOLKITS ${TOOLKIT_NAME} FOUND)

    if (NOT ${FOUND} EQUAL -1)
      set (${IS_TOOLKIT_FOUND} ON PARENT_SCOPE)
    endif()
  endforeach(MODULE)
endfunction()

# TOOLKIT_DEPS is defined with dependencies from file src/TOOLKIT_NAME/EXTERNLIB.
# CSF_ variables are ignored
function (OCCT_TOOLKIT_DEP TOOLKIT_NAME TOOLKIT_DEPS)
  FILE_TO_LIST ("src/${TOOLKIT_NAME}/EXTERNLIB" FILE_CONTENT)

  #list (APPEND LOCAL_TOOLKIT_DEPS ${TOOLKIT_NAME})
  set (LOCAL_TOOLKIT_DEPS)
  foreach (FILE_CONTENT_LINE ${FILE_CONTENT})
    string (REGEX MATCH "^TK" TK_FOUND ${FILE_CONTENT_LINE})
    if ("${FILE_CONTENT_LINE}" STREQUAL "DRAWEXE" OR NOT "${TK_FOUND}" STREQUAL "")
      list (APPEND LOCAL_TOOLKIT_DEPS ${FILE_CONTENT_LINE})
    endif()
  endforeach()

  set (${TOOLKIT_DEPS} ${LOCAL_TOOLKIT_DEPS} PARENT_SCOPE)
endfunction()

# TOOLKIT_FULL_DEPS is defined with complete dependencies (all levels)
function (OCCT_TOOLKIT_FULL_DEP TOOLKIT_NAME TOOLKIT_FULL_DEPS)
  # first level dependencies are stored in LOCAL_TOOLKIT_FULL_DEPS
  OCCT_TOOLKIT_DEP (${TOOLKIT_NAME} LOCAL_TOOLKIT_FULL_DEPS)

  list (LENGTH LOCAL_TOOLKIT_FULL_DEPS LIST_LENGTH)
  set (LIST_INDEX 0)
  while (LIST_INDEX LESS LIST_LENGTH)
    list (GET LOCAL_TOOLKIT_FULL_DEPS ${LIST_INDEX} CURRENT_TOOLKIT)
    OCCT_TOOLKIT_DEP (${CURRENT_TOOLKIT} CURRENT_TOOLKIT_DEPS)

    # append toolkits are not contained
    foreach (CURRENT_TOOLKIT_DEP ${CURRENT_TOOLKIT_DEPS})
      set (CURRENT_TOOLKIT_DEP_FOUND OFF)
      foreach (LOCAL_TOOLKIT_FULL_DEP ${LOCAL_TOOLKIT_FULL_DEPS})
        if ("${CURRENT_TOOLKIT_DEP}" STREQUAL "${LOCAL_TOOLKIT_FULL_DEP}")
          set (CURRENT_TOOLKIT_DEP_FOUND ON)
          break()
        endif()
      endforeach()
      if ("${CURRENT_TOOLKIT_DEP_FOUND}" STREQUAL "OFF")
        list (APPEND LOCAL_TOOLKIT_FULL_DEPS ${CURRENT_TOOLKIT_DEP})
      endif()
    endforeach()

    # increment the list index
    MATH(EXPR LIST_INDEX "${LIST_INDEX}+1")

    # calculate new length
    list (LENGTH LOCAL_TOOLKIT_FULL_DEPS LIST_LENGTH)
  endwhile()

  set (${TOOLKIT_FULL_DEPS} ${LOCAL_TOOLKIT_FULL_DEPS} PARENT_SCOPE)
endfunction()

# Function to get list of modules and toolkits from file adm/MODULES.
# Creates list <$MODULE_LIST> to store list of MODULES and
# <NAME_OF_MODULE>_TOOLKITS foreach module to store its toolkits.
function (OCCT_MODULES_AND_TOOLKITS MODULE_LIST)
  FILE_TO_LIST ("adm/MODULES" FILE_CONTENT)

  foreach (CONTENT_LINE ${FILE_CONTENT})
    string (REPLACE " " ";" CONTENT_LINE ${CONTENT_LINE})
    list (GET CONTENT_LINE 0 MODULE_NAME)
    list (REMOVE_AT CONTENT_LINE 0)
    list (APPEND ${MODULE_LIST} ${MODULE_NAME})
    # (!) REMOVE THE LINE BELOW (implicit variables)
    set (${MODULE_NAME}_TOOLKITS ${CONTENT_LINE} PARENT_SCOPE)
  endforeach()

  set (${MODULE_LIST} ${${MODULE_LIST}} PARENT_SCOPE)
endfunction()

# Returns OCCT version string from file Standard_Version.hxx (if available)
function (OCCT_VERSION OCCT_VERSION_VAR)
  set (OCC_VERSION_COMPLETE "7.1.0")
  set (OCC_VERSION_DEVELOPMENT "")
  
  set (OCCT_VERSION_LOCALVAR "${OCC_VERSION_COMPLETE}.${OCC_VERSION_DEVELOPMENT}")

  set (STANDARD_VERSION_FILE "${CMAKE_SOURCE_DIR}/src/Standard/Standard_Version.hxx")
  if (EXISTS "${STANDARD_VERSION_FILE}")
    foreach (SOUGHT_VERSION OCC_VERSION_COMPLETE OCC_VERSION_DEVELOPMENT)
      file (STRINGS "${STANDARD_VERSION_FILE}" ${SOUGHT_VERSION} REGEX "^#define ${SOUGHT_VERSION} .*")
      string (REGEX REPLACE ".*${SOUGHT_VERSION} .*\"([^ ]+)\".*" "\\1" ${SOUGHT_VERSION} "${${SOUGHT_VERSION}}" )
    endforeach()
    
    if (NOT "${OCC_VERSION_DEVELOPMENT}" STREQUAL "")
      set (OCCT_VERSION_LOCALVAR "${OCC_VERSION_COMPLETE}.${OCC_VERSION_DEVELOPMENT}")
    else()
      set (OCCT_VERSION_LOCALVAR "${OCC_VERSION_COMPLETE}")
    endif()
  endif()

  set (${OCCT_VERSION_VAR} "${OCCT_VERSION_LOCALVAR}" PARENT_SCOPE)
endfunction()
Commit	Line	Data
9f33b387	1	#
9f33b387	2	macro (OCCT_CHECK_AND_UNSET VARNAME)
	3	if (DEFINED ${VARNAME})
	4	unset (${VARNAME} CACHE)
	5	endif()
	6	endmacro()
	7
	8	macro (OCCT_CHECK_AND_UNSET_GROUP VARNAME)
	9	OCCT_CHECK_AND_UNSET ("${VARNAME}_DIR")
	10
	11	OCCT_CHECK_AND_UNSET ("${VARNAME}_INCLUDE_DIR")
	12
	13	OCCT_CHECK_AND_UNSET ("${VARNAME}_LIBRARY")
	14	OCCT_CHECK_AND_UNSET ("${VARNAME}_LIBRARY_DIR")
	15
19286d7c	16	if (WIN32)
	17	OCCT_CHECK_AND_UNSET ("${VARNAME}_DLL")
	18	OCCT_CHECK_AND_UNSET ("${VARNAME}_DLL_DIR")
	19	endif()
9f33b387	20	endmacro()
9f33b387	21
9f33b387	22	# COMPILER_BITNESS variable
	23	macro (OCCT_MAKE_COMPILER_BITNESS)
	24	math (EXPR COMPILER_BITNESS "32 + 32*(${CMAKE_SIZEOF_VOID_P}/8)")
	25	endmacro()
	26
	27	# OS_WITH_BIT
	28	macro (OCCT_MAKE_OS_WITH_BITNESS)
	29
	30	OCCT_MAKE_COMPILER_BITNESS()
	31
	32	if (WIN32)
	33	set (OS_WITH_BIT "win${COMPILER_BITNESS}")
	34	elseif(APPLE)
	35	set (OS_WITH_BIT "mac${COMPILER_BITNESS}")
	36	else()
	37	set (OS_WITH_BIT "lin${COMPILER_BITNESS}")
	38	endif()
	39	endmacro()
	40
	41	# COMPILER variable
	42	macro (OCCT_MAKE_COMPILER_SHORT_NAME)
	43	if (MSVC)
	44	if (MSVC70)
	45	set (COMPILER vc7)
	46	elseif (MSVC80)
	47	set (COMPILER vc8)
	48	elseif (MSVC90)
	49	set (COMPILER vc9)
	50	elseif (MSVC10)
	51	set (COMPILER vc10)
	52	elseif (MSVC11)
	53	set (COMPILER vc11)
	54	elseif (MSVC12)
	55	set (COMPILER vc12)
	56	endif()
	57	elseif (DEFINED CMAKE_COMPILER_IS_GNUCC)
	58	set (COMPILER gcc)
	59	elseif (DEFINED CMAKE_COMPILER_IS_GNUCXX)
	60	set (COMPILER gxx)
	61	elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
	62	set (COMPILER clang)
	63	elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Intel")
	64	set (COMPILER icc)
	65	else()
	66	set (COMPILER ${CMAKE_GENERATOR})
	67	string (REGEX REPLACE " " "" COMPILER ${COMPILER})
	68	endif()
	69	endmacro()
	70
	71	function (SUBDIRECTORY_NAMES MAIN_DIRECTORY RESULT)
	72	file (GLOB SUB_ITEMS "${MAIN_DIRECTORY}/*")
	73
	74	foreach (ITEM ${SUB_ITEMS})
	75	if (IS_DIRECTORY "${ITEM}")
	76	get_filename_component (ITEM_NAME "${ITEM}" NAME)
	77	list (APPEND LOCAL_RESULT "${ITEM_NAME}")
	78	endif()
	79	endforeach()
	80	set (${RESULT} ${LOCAL_RESULT} PARENT_SCOPE)
	81	endfunction()
	82
	83	function (FIND_PRODUCT_DIR ROOT_DIR PRODUCT_NAME RESULT)
	84	OCCT_MAKE_COMPILER_SHORT_NAME()
	85	OCCT_MAKE_COMPILER_BITNESS()
86
87	string (TOLOWER "${PRODUCT_NAME}" lower_PRODUCT_NAME)
88
89	list (APPEND SEARCH_TEMPLATES "${lower_PRODUCT_NAME}.${COMPILER}.${COMPILER_BITNESS}")
90	list (APPEND SEARCH_TEMPLATES "${lower_PRODUCT_NAME}.[0-9.]+.${COMPILER}.*${COMPILER_BITNESS}")
91	list (APPEND SEARCH_TEMPLATES "${lower_PRODUCT_NAME}.[0-9.]+.${COMPILER_BITNESS}")
92	list (APPEND SEARCH_TEMPLATES "${lower_PRODUCT_NAME}.*[0-9.]+")
93	list (APPEND SEARCH_TEMPLATES "${lower_PRODUCT_NAME}")
94
95	SUBDIRECTORY_NAMES ("${ROOT_DIR}" SUBDIR_NAME_LIST)
96
97	foreach (SEARCH_TEMPLATE ${SEARCH_TEMPLATES})
98	if (LOCAL_RESULT)
99	BREAK()
100	endif()
101
102	foreach (SUBDIR_NAME ${SUBDIR_NAME_LIST})
103	string (TOLOWER "${SUBDIR_NAME}" lower_SUBDIR_NAME)
104
105	string (REGEX MATCH "${SEARCH_TEMPLATE}" DUMMY_VAR "${lower_SUBDIR_NAME}")
106	if (DUMMY_VAR)
107	list (APPEND LOCAL_RESULT ${SUBDIR_NAME})
108	endif()
109	endforeach()
110	endforeach()
111
112	if (LOCAL_RESULT)
113	list (LENGTH "${LOCAL_RESULT}" LOC_LEN)
114	math (EXPR LAST_ELEMENT_INDEX "${LOC_LEN}-1")
115	list (GET LOCAL_RESULT ${LAST_ELEMENT_INDEX} DUMMY)
116	set (${RESULT} ${DUMMY} PARENT_SCOPE)
117	endif()
118	endfunction()
119
120	macro (OCCT_INSTALL_FILE_OR_DIR BEING_INSTALLED_OBJECT DESTINATION_PATH)
316d77d9	121	if (APPLY_OCCT_PATCH_DIR AND EXISTS "${APPLY_OCCT_PATCH_DIR}/${BEING_INSTALLED_OBJECT}")
316d77d9	122	if (IS_DIRECTORY "${APPLY_OCCT_PATCH_DIR}/${BEING_INSTALLED_OBJECT}")
9f33b387	123	# first of all, install original files
	124	install (DIRECTORY "${CMAKE_SOURCE_DIR}/${BEING_INSTALLED_OBJECT}" DESTINATION "${DESTINATION_PATH}")
	125
	126	# secondly, rewrite original files with patched ones
316d77d9	127	install (DIRECTORY "${APPLY_OCCT_PATCH_DIR}/${BEING_INSTALLED_OBJECT}" DESTINATION "${DESTINATION_PATH}")
9f33b387	128	else()
316d77d9	129	install (FILES "${APPLY_OCCT_PATCH_DIR}/${BEING_INSTALLED_OBJECT}" DESTINATION "${DESTINATION_PATH}")
9f33b387	130	endif()
	131	else()
	132	if (IS_DIRECTORY "${CMAKE_SOURCE_DIR}/${BEING_INSTALLED_OBJECT}")
	133	install (DIRECTORY "${CMAKE_SOURCE_DIR}/${BEING_INSTALLED_OBJECT}" DESTINATION "${DESTINATION_PATH}")
	134	else()
	135	install (FILES "${CMAKE_SOURCE_DIR}/${BEING_INSTALLED_OBJECT}" DESTINATION "${DESTINATION_PATH}")
	136	endif()
	137	endif()
	138	endmacro()
	139
316d77d9	140	macro (OCCT_CONFIGURE_AND_INSTALL BEING_CONGIRUGED_FILE BUILD_NAME INSTALL_NAME DESTINATION_PATH)
	141	if (APPLY_OCCT_PATCH_DIR AND EXISTS "${APPLY_OCCT_PATCH_DIR}/${BEING_CONGIRUGED_FILE}")
	142	configure_file("${APPLY_OCCT_PATCH_DIR}/${BEING_CONGIRUGED_FILE}" "${BUILD_NAME}" @ONLY)
9f33b387	143	else()
316d77d9	144	configure_file("${CMAKE_SOURCE_DIR}/${BEING_CONGIRUGED_FILE}" "${BUILD_NAME}" @ONLY)
9f33b387	145	endif()
9f33b387	146
316d77d9	147	install(FILES "${OCCT_BINARY_DIR}/${BUILD_NAME}" DESTINATION "${DESTINATION_PATH}" RENAME ${INSTALL_NAME})
9f33b387	148	endmacro()
9f33b387	149
316d77d9	150	macro (COLLECT_AND_INSTALL_OCCT_HEADER_FILES ROOT_OCCT_DIR TEMPLATE_HEADER_PATH ROOT_TARGET_OCCT_DIR OCCT_BUILD_TOOLKITS)
94829f84	151	set (OCCT_SOURCE_DIRS)
94829f84	152
316d77d9	153	foreach (OCCT_USED_TOOLKIT ${OCCT_BUILD_TOOLKITS})
94829f84	154	# append parent folder
	155	list (APPEND OCCT_SOURCE_DIRS ${OCCT_USED_TOOLKIT})
	156
	157	# append all required package folders
	158	set (OCCT_USED_TOOLKIT_DEPS)
	159	if (EXISTS "${ROOT_OCCT_DIR}/src/${OCCT_USED_TOOLKIT}/PACKAGES")
	160	file (STRINGS "${ROOT_OCCT_DIR}/src/${OCCT_USED_TOOLKIT}/PACKAGES" OCCT_USED_TOOLKIT_DEPS)
	161	endif()
	162
	163	foreach (OCCT_USED_TOOLKIT_DEP ${OCCT_USED_TOOLKIT_DEPS})
	164	list (APPEND OCCT_SOURCE_DIRS ${OCCT_USED_TOOLKIT_DEP})
	165	endforeach()
	166	endforeach()
	167
	168	foreach (OCCT_SOURCE_DIR ${OCCT_SOURCE_DIRS})
	169	# get all header files from each src folder
	170	file (GLOB OCCT_HEADER_FILES "${ROOT_OCCT_DIR}/src/${OCCT_SOURCE_DIR}/.[hgl]xx" "${ROOT_OCCT_DIR}/src/${OCCT_SOURCE_DIR}/.h")
	171
	172	install (FILES ${OCCT_HEADER_FILES} DESTINATION "${INSTALL_DIR}/inc")
	173
	174	# create new file including found header
	175	foreach (OCCT_HEADER_FILE ${OCCT_HEADER_FILES})
	176	get_filename_component (HEADER_FILE_NAME ${OCCT_HEADER_FILE} NAME)
	177	configure_file ("${TEMPLATE_HEADER_PATH}" "${ROOT_TARGET_OCCT_DIR}/inc/${HEADER_FILE_NAME}" @ONLY)
	178	endforeach()
	179	endforeach()
	180	endmacro()
	181
19286d7c	182	macro (OCCT_COPY_FILE_OR_DIR BEING_COPIED_OBJECT DESTINATION_PATH)
	183	# first of all, copy original files
	184	file (COPY "${CMAKE_SOURCE_DIR}/${BEING_COPIED_OBJECT}" DESTINATION "${DESTINATION_PATH}")
	185
316d77d9	186	if (APPLY_OCCT_PATCH_DIR AND EXISTS "${APPLY_OCCT_PATCH_DIR}/${BEING_COPIED_OBJECT}")
19286d7c	187	# secondly, rewrite original files with patched ones
316d77d9	188	file (COPY "${APPLY_OCCT_PATCH_DIR}/${BEING_COPIED_OBJECT}" DESTINATION "${DESTINATION_PATH}")
19286d7c	189	endif()
	190	endmacro()
	191
	192	macro (OCCT_CONFIGURE BEING_CONGIRUGED_FILE FINAL_NAME)
316d77d9	193	if (APPLY_OCCT_PATCH_DIR AND EXISTS "${APPLY_OCCT_PATCH_DIR}/${BEING_CONGIRUGED_FILE}")
316d77d9	194	configure_file("${APPLY_OCCT_PATCH_DIR}/${BEING_CONGIRUGED_FILE}" "${FINAL_NAME}" @ONLY)
19286d7c	195	else()
	196	configure_file("${CMAKE_SOURCE_DIR}/${BEING_CONGIRUGED_FILE}" "${FINAL_NAME}" @ONLY)
	197	endif()
	198	endmacro()
	199
9f33b387	200	function (OCCT_IS_PRODUCT_REQUIRED CSF_VAR_NAME USE_PRODUCT)
9f33b387	201	set (${USE_PRODUCT} OFF PARENT_SCOPE)
19286d7c	202
316d77d9	203	if (NOT BUILD_TOOLKITS)
9f33b387	204	message(STATUS "Warning: the list of being used toolkits is empty")
9f33b387	205	else()
316d77d9	206	foreach (USED_TOOLKIT ${BUILD_TOOLKITS})
	207	if (APPLY_OCCT_PATCH_DIR AND EXISTS "${APPLY_OCCT_PATCH_DIR}/src/${USED_TOOLKIT}/EXTERNLIB")
	208	file (READ "${APPLY_OCCT_PATCH_DIR}/src/${USED_TOOLKIT}/EXTERNLIB" FILE_CONTENT)
9f33b387	209	elseif (EXISTS "${CMAKE_SOURCE_DIR}/src/${USED_TOOLKIT}/EXTERNLIB")
	210	file (READ "${CMAKE_SOURCE_DIR}/src/${USED_TOOLKIT}/EXTERNLIB" FILE_CONTENT)
	211	endif()
	212
	213	string (REGEX MATCH "${CSF_VAR_NAME}" DOES_FILE_CONTAIN "${FILE_CONTENT}")
	214
	215	if (DOES_FILE_CONTAIN)
	216	set (${USE_PRODUCT} ON PARENT_SCOPE)
	217	break()
	218	endif()
	219	endforeach()
	220	endif()
	221	endfunction()
	222
19286d7c	223	function (FILE_TO_LIST FILE_NAME FILE_CONTENT)
19286d7c	224	set (LOCAL_FILE_CONTENT)
316d77d9	225	if (APPLY_OCCT_PATCH_DIR AND EXISTS "${APPLY_OCCT_PATCH_DIR}/${FILE_NAME}")
316d77d9	226	file (STRINGS "${APPLY_OCCT_PATCH_DIR}/${FILE_NAME}" LOCAL_FILE_CONTENT)
19286d7c	227	elseif (EXISTS "${CMAKE_SOURCE_DIR}/${FILE_NAME}")
	228	file (STRINGS "${CMAKE_SOURCE_DIR}/${FILE_NAME}" LOCAL_FILE_CONTENT)
	229	endif()
9f33b387	230
19286d7c	231	set (${FILE_CONTENT} ${LOCAL_FILE_CONTENT} PARENT_SCOPE)
19286d7c	232	endfunction()
9f33b387	233
19286d7c	234	# Function to determine if TOOLKIT is OCCT toolkit
	235	function (IS_OCCT_TOOLKIT TOOLKIT_NAME MODULES IS_TOOLKIT_FOUND)
	236	set (${IS_TOOLKIT_FOUND} OFF PARENT_SCOPE)
	237	foreach (MODULE ${${MODULES}})
	238	set (TOOLKITS ${${MODULE}_TOOLKITS})
	239	list (FIND TOOLKITS ${TOOLKIT_NAME} FOUND)
9f33b387	240
19286d7c	241	if (NOT ${FOUND} EQUAL -1)
	242	set (${IS_TOOLKIT_FOUND} ON PARENT_SCOPE)
	243	endif()
	244	endforeach(MODULE)
	245	endfunction()
9f33b387	246
19286d7c	247	# TOOLKIT_DEPS is defined with dependencies from file src/TOOLKIT_NAME/EXTERNLIB.
	248	# CSF_ variables are ignored
	249	function (OCCT_TOOLKIT_DEP TOOLKIT_NAME TOOLKIT_DEPS)
	250	FILE_TO_LIST ("src/${TOOLKIT_NAME}/EXTERNLIB" FILE_CONTENT)
	251
	252	#list (APPEND LOCAL_TOOLKIT_DEPS ${TOOLKIT_NAME})
	253	set (LOCAL_TOOLKIT_DEPS)
	254	foreach (FILE_CONTENT_LINE ${FILE_CONTENT})
	255	string (REGEX MATCH "^TK" TK_FOUND ${FILE_CONTENT_LINE})
	256	if ("${FILE_CONTENT_LINE}" STREQUAL "DRAWEXE" OR NOT "${TK_FOUND}" STREQUAL "")
	257	list (APPEND LOCAL_TOOLKIT_DEPS ${FILE_CONTENT_LINE})
	258	endif()
	259	endforeach()
9f33b387	260
19286d7c	261	set (${TOOLKIT_DEPS} ${LOCAL_TOOLKIT_DEPS} PARENT_SCOPE)
19286d7c	262	endfunction()
9f33b387	263
19286d7c	264	# TOOLKIT_FULL_DEPS is defined with complete dependencies (all levels)
	265	function (OCCT_TOOLKIT_FULL_DEP TOOLKIT_NAME TOOLKIT_FULL_DEPS)
	266	# first level dependencies are stored in LOCAL_TOOLKIT_FULL_DEPS
	267	OCCT_TOOLKIT_DEP (${TOOLKIT_NAME} LOCAL_TOOLKIT_FULL_DEPS)
	268
	269	list (LENGTH LOCAL_TOOLKIT_FULL_DEPS LIST_LENGTH)
	270	set (LIST_INDEX 0)
	271	while (LIST_INDEX LESS LIST_LENGTH)
	272	list (GET LOCAL_TOOLKIT_FULL_DEPS ${LIST_INDEX} CURRENT_TOOLKIT)
	273	OCCT_TOOLKIT_DEP (${CURRENT_TOOLKIT} CURRENT_TOOLKIT_DEPS)
	274
	275	# append toolkits are not contained
	276	foreach (CURRENT_TOOLKIT_DEP ${CURRENT_TOOLKIT_DEPS})
	277	set (CURRENT_TOOLKIT_DEP_FOUND OFF)
	278	foreach (LOCAL_TOOLKIT_FULL_DEP ${LOCAL_TOOLKIT_FULL_DEPS})
	279	if ("${CURRENT_TOOLKIT_DEP}" STREQUAL "${LOCAL_TOOLKIT_FULL_DEP}")
	280	set (CURRENT_TOOLKIT_DEP_FOUND ON)
	281	break()
	282	endif()
	283	endforeach()
	284	if ("${CURRENT_TOOLKIT_DEP_FOUND}" STREQUAL "OFF")
	285	list (APPEND LOCAL_TOOLKIT_FULL_DEPS ${CURRENT_TOOLKIT_DEP})
	286	endif()
	287	endforeach()
9f33b387	288
19286d7c	289	# increment the list index
19286d7c	290	MATH(EXPR LIST_INDEX "${LIST_INDEX}+1")
9f33b387	291
19286d7c	292	# calculate new length
	293	list (LENGTH LOCAL_TOOLKIT_FULL_DEPS LIST_LENGTH)
	294	endwhile()
9f33b387	295
19286d7c	296	set (${TOOLKIT_FULL_DEPS} ${LOCAL_TOOLKIT_FULL_DEPS} PARENT_SCOPE)
19286d7c	297	endfunction()
9f33b387	298
19286d7c	299	# Function to get list of modules and toolkits from file adm/MODULES.
	300	# Creates list <$MODULE_LIST> to store list of MODULES and
	301	# <NAME_OF_MODULE>_TOOLKITS foreach module to store its toolkits.
	302	function (OCCT_MODULES_AND_TOOLKITS MODULE_LIST)
	303	FILE_TO_LIST ("adm/MODULES" FILE_CONTENT)
	304
	305	foreach (CONTENT_LINE ${FILE_CONTENT})
	306	string (REPLACE " " ";" CONTENT_LINE ${CONTENT_LINE})
	307	list (GET CONTENT_LINE 0 MODULE_NAME)
	308	list (REMOVE_AT CONTENT_LINE 0)
	309	list (APPEND ${MODULE_LIST} ${MODULE_NAME})
	310	# (!) REMOVE THE LINE BELOW (implicit variables)
	311	set (${MODULE_NAME}_TOOLKITS ${CONTENT_LINE} PARENT_SCOPE)
	312	endforeach()
9f33b387	313
19286d7c	314	set (${MODULE_LIST} ${${MODULE_LIST}} PARENT_SCOPE)
19286d7c	315	endfunction()
9f33b387	316
adc33035	317	# Returns OCCT version string from file Standard_Version.hxx (if available)
	318	function (OCCT_VERSION OCCT_VERSION_VAR)
	319	set (OCC_VERSION_COMPLETE "7.1.0")
	320	set (OCC_VERSION_DEVELOPMENT "")
	321
	322	set (OCCT_VERSION_LOCALVAR "${OCC_VERSION_COMPLETE}.${OCC_VERSION_DEVELOPMENT}")
	323
	324	set (STANDARD_VERSION_FILE "${CMAKE_SOURCE_DIR}/src/Standard/Standard_Version.hxx")
	325	if (EXISTS "${STANDARD_VERSION_FILE}")
	326	foreach (SOUGHT_VERSION OCC_VERSION_COMPLETE OCC_VERSION_DEVELOPMENT)
	327	file (STRINGS "${STANDARD_VERSION_FILE}" ${SOUGHT_VERSION} REGEX "^#define ${SOUGHT_VERSION} .*")
	328	string (REGEX REPLACE ".${SOUGHT_VERSION} .\"([^ ]+)\".*" "\\1" ${SOUGHT_VERSION} "${${SOUGHT_VERSION}}" )
	329	endforeach()
	330
	331	if (NOT "${OCC_VERSION_DEVELOPMENT}" STREQUAL "")
	332	set (OCCT_VERSION_LOCALVAR "${OCC_VERSION_COMPLETE}.${OCC_VERSION_DEVELOPMENT}")
	333	else()
	334	set (OCCT_VERSION_LOCALVAR "${OCC_VERSION_COMPLETE}")
	335	endif()
	336	endif()
	337
	338	set (${OCCT_VERSION_VAR} "${OCCT_VERSION_LOCALVAR}" PARENT_SCOPE)
	339	endfunction()
	340