# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
# file Copyright.txt or https://cmake.org/licensing for details.
#.rst:
# FindMatlab
# ----------
#
# Finds Matlab or Matlab Compiler Runtime (MCR) and provides Matlab tools,
# libraries and compilers to CMake.
#
# This package primary purpose is to find the libraries associated with Matlab
# or the MCR in order to be able to build Matlab extensions (mex files). It
# can also be used:
#
# * to run specific commands in Matlab in case Matlab is available
# * for declaring Matlab unit test
# * to retrieve various information from Matlab (mex extensions, versions and
# release queries, ...)
#
# The module supports the following components:
#
# * ``MX_LIBRARY``, ``ENG_LIBRARY`` and ``MAT_LIBRARY``: respectively the ``MX``,
# ``ENG`` and ``MAT`` libraries of Matlab
# * ``ENGINE_LIBRARY``, ``DATAARRAY_LIBRARY``: respectively the ``MatlabEngine``
# and ``MatlabDataArray`` libraries of Matlab (Matlab 2018a and later)
# * ``MAIN_PROGRAM`` the Matlab binary program. Note that this component is not
# available on the MCR version, and will yield an error if the MCR is found
# instead of the regular Matlab installation.
# * ``MEX_COMPILER`` the MEX compiler.
# * ``MCC_COMPILER`` the MCC compiler, included with the Matlab Compiler add-on.
# * ``SIMULINK`` the Simulink environment.
#
# .. note::
#
# The version given to the :command:`find_package` directive is the Matlab
# **version**, which should not be confused with the Matlab *release* name
# (eg. `R2014`).
# The :command:`matlab_get_version_from_release_name` and
# :command:`matlab_get_release_name_from_version` provide a mapping
# between the release name and the version.
#
# The variable :variable:`Matlab_ROOT_DIR` may be specified in order to give
# the path of the desired Matlab version. Otherwise, the behaviour is platform
# specific:
#
# * Windows: The installed versions of Matlab/MCR are retrieved from the
# Windows registry
# * OS X: The installed versions of Matlab/MCR are given by the MATLAB
# default installation paths in ``/Application``. If no such application is
# found, it falls back to the one that might be accessible from the ``PATH``.
# * Unix: The desired Matlab should be accessible from the ``PATH``. This does
# not work for MCR installation and :variable:`Matlab_ROOT_DIR` should be
# specified on this platform.
#
# Additional information is provided when :variable:`MATLAB_FIND_DEBUG` is set.
# When a Matlab/MCR installation is found automatically and the ``MATLAB_VERSION``
# is not given, the version is queried from Matlab directly (on Windows this
# may pop up a Matlab window) or from the MCR installation.
#
# The mapping of the release names and the version of Matlab is performed by
# defining pairs (name, version). The variable
# :variable:`MATLAB_ADDITIONAL_VERSIONS` may be provided before the call to
# the :command:`find_package` in order to handle additional versions.
#
# A Matlab scripts can be added to the set of tests using the
# :command:`matlab_add_unit_test`. By default, the Matlab unit test framework
# will be used (>= 2013a) to run this script, but regular ``.m`` files
# returning an exit code can be used as well (0 indicating a success).
#
# Module Input Variables
# ^^^^^^^^^^^^^^^^^^^^^^
#
# Users or projects may set the following variables to configure the module
# behaviour:
#
# :variable:`Matlab_ROOT_DIR`
# the root of the Matlab installation.
# :variable:`MATLAB_FIND_DEBUG`
# outputs debug information
# :variable:`MATLAB_ADDITIONAL_VERSIONS`
# additional versions of Matlab for the automatic retrieval of the installed
# versions.
#
# Variables defined by the module
# ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
#
# Result variables
# """"""""""""""""
#
# ``Matlab_FOUND``
# ``TRUE`` if the Matlab installation is found, ``FALSE``
# otherwise. All variable below are defined if Matlab is found.
# ``Matlab_ROOT_DIR``
# the final root of the Matlab installation determined by the FindMatlab
# module.
# ``Matlab_MAIN_PROGRAM``
# the Matlab binary program. Available only if the component ``MAIN_PROGRAM``
# is given in the :command:`find_package` directive.
# ``Matlab_INCLUDE_DIRS``
# the path of the Matlab libraries headers
# ``Matlab_MEX_LIBRARY``
# library for mex, always available.
# ``Matlab_MX_LIBRARY``
# mx library of Matlab (arrays). Available only if the component
# ``MX_LIBRARY`` has been requested.
# ``Matlab_ENG_LIBRARY``
# Matlab engine library. Available only if the component ``ENG_LIBRARY``
# is requested.
# ``Matlab_MAT_LIBRARY``
# Matlab matrix library. Available only if the component ``MAT_LIBRARY``
# is requested.
# ``Matlab_ENGINE_LIBRARY``
# Matlab C++ engine library. Available only if the component ``ENGINE_LIBRARY``
# is requested.
# ``Matlab_DATAARRAY_LIBRARY``
# Matlab C++ data array library. Available only if the component ``DATAARRAY_LIBRARY``
# is requested.
# ``Matlab_LIBRARIES``
# the whole set of libraries of Matlab
# ``Matlab_MEX_COMPILER``
# the mex compiler of Matlab. Currently not used.
# Available only if the component ``MEX_COMPILER`` is requested.
# ``Matlab_MCC_COMPILER``
# the mcc compiler of Matlab. Included with the Matlab Compiler add-on.
# Available only if the component ``MCC_COMPILER`` is requested.
#
# Cached variables
# """"""""""""""""
#
# ``Matlab_MEX_EXTENSION``
# the extension of the mex files for the current platform (given by Matlab).
# ``Matlab_ROOT_DIR``
# the location of the root of the Matlab installation found. If this value
# is changed by the user, the result variables are recomputed.
#
# Provided macros
# ^^^^^^^^^^^^^^^
#
# :command:`matlab_get_version_from_release_name`
# returns the version from the release name
# :command:`matlab_get_release_name_from_version`
# returns the release name from the Matlab version
#
# Provided functions
# ^^^^^^^^^^^^^^^^^^
#
# :command:`matlab_add_mex`
# adds a target compiling a MEX file.
# :command:`matlab_add_unit_test`
# adds a Matlab unit test file as a test to the project.
# :command:`matlab_extract_all_installed_versions_from_registry`
# parses the registry for all Matlab versions. Available on Windows only.
# The part of the registry parsed is dependent on the host processor
# :command:`matlab_get_all_valid_matlab_roots_from_registry`
# returns all the possible Matlab or MCR paths, according to a previously
# given list. Only the existing/accessible paths are kept. This is mainly
# useful for the searching all possible Matlab installation.
# :command:`matlab_get_mex_suffix`
# returns the suffix to be used for the mex files
# (platform/architecture dependent)
# :command:`matlab_get_version_from_matlab_run`
# returns the version of Matlab/MCR, given the full directory of the Matlab/MCR
# installation path.
#
#
# Known issues
# ^^^^^^^^^^^^
#
# **Symbol clash in a MEX target**
# By default, every symbols inside a MEX
# file defined with the command :command:`matlab_add_mex` have hidden
# visibility, except for the entry point. This is the default behaviour of
# the MEX compiler, which lowers the risk of symbol collision between the
# libraries shipped with Matlab, and the libraries to which the MEX file is
# linking to. This is also the default on Windows platforms.
#
# However, this is not sufficient in certain case, where for instance your
# MEX file is linking against libraries that are already loaded by Matlab,
# even if those libraries have different SONAMES.
# A possible solution is to hide the symbols of the libraries to which the
# MEX target is linking to. This can be achieved in GNU GCC compilers with
# the linker option ``-Wl,--exclude-libs,ALL``.
#
# **Tests using GPU resources**
# in case your MEX file is using the GPU and
# in order to be able to run unit tests on this MEX file, the GPU resources
# should be properly released by Matlab. A possible solution is to make
# Matlab aware of the use of the GPU resources in the session, which can be
# performed by a command such as ``D = gpuDevice()`` at the beginning of
# the test script (or via a fixture).
#
#
# Reference
# ^^^^^^^^^
#
# .. variable:: Matlab_ROOT_DIR
#
# The root folder of the Matlab installation. If set before the call to
# :command:`find_package`, the module will look for the components in that
# path. If not set, then an automatic search of Matlab
# will be performed. If set, it should point to a valid version of Matlab.
#
# .. variable:: MATLAB_FIND_DEBUG
#
# If set, the lookup of Matlab and the intermediate configuration steps are
# outputted to the console.
#
# .. variable:: MATLAB_ADDITIONAL_VERSIONS
#
# If set, specifies additional versions of Matlab that may be looked for.
# The variable should be a list of strings, organised by pairs of release
# name and versions, such as follows::
#
# set(MATLAB_ADDITIONAL_VERSIONS
# "release_name1=corresponding_version1"
# "release_name2=corresponding_version2"
# ...
# )
#
# Example::
#
# set(MATLAB_ADDITIONAL_VERSIONS
# "R2013b=8.2"
# "R2013a=8.1"
# "R2012b=8.0")
#
# The order of entries in this list matters when several versions of
# Matlab are installed. The priority is set according to the ordering in
# this list.
set ( _FindMatlab_SELF_DIR "${CMAKE_CURRENT_LIST_DIR}" )
include ( ${ CMAKE_CURRENT_LIST_DIR } /FindPackageHandleStandardArgs.cmake )
include ( CheckCXXCompilerFlag )
include ( CheckCCompilerFlag )
# The currently supported versions. Other version can be added by the user by
# providing MATLAB_ADDITIONAL_VERSIONS
if ( NOT MATLAB_ADDITIONAL_VERSIONS )
set ( MATLAB_ADDITIONAL_VERSIONS )
endif ( )
set ( MATLAB_VERSIONS_MAPPING
" R 2 0 1 8 b = 9 . 5 "
" R 2 0 1 8 a = 9 . 4 "
" R 2 0 1 7 b = 9 . 3 "
" R 2 0 1 7 a = 9 . 2 "
" R 2 0 1 6 b = 9 . 1 "
" R 2 0 1 6 a = 9 . 0 "
" R 2 0 1 5 b = 8 . 6 "
" R 2 0 1 5 a = 8 . 5 "
" R 2 0 1 4 b = 8 . 4 "
" R 2 0 1 4 a = 8 . 3 "
" R 2 0 1 3 b = 8 . 2 "
" R 2 0 1 3 a = 8 . 1 "
" R 2 0 1 2 b = 8 . 0 "
" R 2 0 1 2 a = 7 . 1 4 "
" R 2 0 1 1 b = 7 . 1 3 "
" R 2 0 1 1 a = 7 . 1 2 "
" R 2 0 1 0 b = 7 . 1 1 "
$ { M A T L A B _ A D D I T I O N A L _ V E R S I O N S }
)
# temporary folder for all Matlab runs
set ( _matlab_temporary_folder ${ CMAKE_BINARY_DIR } /Matlab )
if ( NOT EXISTS "${_matlab_temporary_folder}" )
file ( MAKE_DIRECTORY "${_matlab_temporary_folder}" )
endif ( )
#.rst:
# .. command:: matlab_get_version_from_release_name
#
# Returns the version of Matlab (17.58) from a release name (R2017k)
macro ( matlab_get_version_from_release_name release_name version_name )
string ( REGEX MATCHALL "${release_name}=([0-9]+\\.?[0-9]*)" _matched ${ MATLAB_VERSIONS_MAPPING } )
set ( ${ version_name } "" )
if ( NOT _matched STREQUAL "" )
set ( ${ version_name } ${ CMAKE_MATCH_1 } )
else ( )
message ( WARNING "[MATLAB] The release name ${release_name} is not registered" )
endif ( )
unset ( _matched )
endmacro ( )
#.rst:
# .. command:: matlab_get_release_name_from_version
#
# Returns the release name (R2017k) from the version of Matlab (17.58)
macro ( matlab_get_release_name_from_version version release_name )
set ( ${ release_name } "" )
foreach ( _var IN LISTS MATLAB_VERSIONS_MAPPING )
string ( REGEX MATCHALL "(.+)=${version}" _matched ${ _var } )
if ( NOT _matched STREQUAL "" )
set ( ${ release_name } ${ CMAKE_MATCH_1 } )
break ( )
endif ( )
endforeach ( _var )
unset ( _var )
unset ( _matched )
if ( ${ release_name } STREQUAL "" )
message ( WARNING "[MATLAB] The version ${version} is not registered" )
endif ( )
endmacro ( )
# extracts all the supported release names (R2017k...) of Matlab
# internal use
macro ( matlab_get_supported_releases list_releases )
set ( ${ list_releases } )
foreach ( _var IN LISTS MATLAB_VERSIONS_MAPPING )
string ( REGEX MATCHALL "(.+)=([0-9]+\\.?[0-9]*)" _matched ${ _var } )
if ( NOT _matched STREQUAL "" )
list ( APPEND ${ list_releases } ${ CMAKE_MATCH_1 } )
endif ( )
unset ( _matched )
unset ( CMAKE_MATCH_1 )
endforeach ( _var )
unset ( _var )
endmacro ( )
# extracts all the supported versions of Matlab
# internal use
macro ( matlab_get_supported_versions list_versions )
set ( ${ list_versions } )
foreach ( _var IN LISTS MATLAB_VERSIONS_MAPPING )
string ( REGEX MATCHALL "(.+)=([0-9]+\\.?[0-9]*)" _matched ${ _var } )
if ( NOT _matched STREQUAL "" )
list ( APPEND ${ list_versions } ${ CMAKE_MATCH_2 } )
endif ( )
unset ( _matched )
unset ( CMAKE_MATCH_1 )
endforeach ( _var )
unset ( _var )
endmacro ( )
#.rst:
# .. command:: matlab_extract_all_installed_versions_from_registry
#
# This function parses the registry and founds the Matlab versions that are
# installed. The found versions are returned in `matlab_versions`.
# Set `win64` to `TRUE` if the 64 bit version of Matlab should be looked for
# The returned list contains all versions under
# ``HKLM\\SOFTWARE\\Mathworks\\MATLAB`` and
# ``HKLM\\SOFTWARE\\Mathworks\\MATLAB Runtime`` or an empty list in case an
# error occurred (or nothing found).
#
# .. note::
#
# Only the versions are provided. No check is made over the existence of the
# installation referenced in the registry,
#
function ( matlab_extract_all_installed_versions_from_registry win64 matlab_versions )
if ( NOT CMAKE_HOST_WIN32 )
message ( FATAL_ERROR "[MATLAB] This macro can only be called by a windows host (call to reg.exe)" )
endif ( )
if ( ${ win64 } AND CMAKE_HOST_SYSTEM_PROCESSOR MATCHES "64" )
set ( APPEND_REG "/reg:64" )
else ( )
set ( APPEND_REG "/reg:32" )
endif ( )
set ( matlabs_from_registry )
foreach ( _installation_type IN ITEMS "MATLAB" "MATLAB Runtime" )
# /reg:64 should be added on 64 bits capable OSs in order to enable the
# redirection of 64 bits applications
execute_process (
C O M M A N D r e g q u e r y H K E Y _ L O C A L _ M A C H I N E \ \ S O F T W A R E \ \ M a t h w o r k s \ \ $ { _ i n s t a l l a t i o n _ t y p e } / f * / k $ { A P P E N D _ R E G }
R E S U L T _ V A R I A B L E r e s u l t M a t l a b
O U T P U T _ V A R I A B L E v a r M a t l a b
E R R O R _ V A R I A B L E e r r M a t l a b
I N P U T _ F I L E N U L
)
if ( ${ resultMatlab } EQUAL 0 )
string (
R E G E X M A T C H A L L " M A T L A B \ \ \ \ ( [ 0 - 9 ] + ( \ \ . [ 0 - 9 ] + ) ? ) "
m a t l a b _ v e r s i o n s _ r e g e x $ { v a r M a t l a b } )
foreach ( match IN LISTS matlab_versions_regex )
string (
R E G E X M A T C H " M A T L A B \ \ \ \ ( ( [ 0 - 9 ] + ) ( \ \ . ( [ 0 - 9 ] + ) ) ? ) "
c u r r e n t _ m a t c h $ { m a t c h } )
set ( _matlab_current_version ${ CMAKE_MATCH_1 } )
set ( current_matlab_version_major ${ CMAKE_MATCH_2 } )
set ( current_matlab_version_minor ${ CMAKE_MATCH_4 } )
if ( NOT current_matlab_version_minor )
set ( current_matlab_version_minor "0" )
endif ( )
list ( APPEND matlabs_from_registry ${ _matlab_current_version } )
unset ( _matlab_current_version )
endforeach ( )
endif ( )
endforeach ( )
if ( matlabs_from_registry )
list ( REMOVE_DUPLICATES matlabs_from_registry )
list ( SORT matlabs_from_registry )
list ( REVERSE matlabs_from_registry )
endif ( )
set ( ${ matlab_versions } ${ matlabs_from_registry } PARENT_SCOPE )
endfunction ( )
# (internal)
macro ( extract_matlab_versions_from_registry_brute_force matlab_versions )
# get the supported versions
set ( matlab_supported_versions )
matlab_get_supported_versions ( matlab_supported_versions )
# this is a manual population of the versions we want to look for
# this can be done as is, but preferably with the call to
# matlab_get_supported_versions and variable
# populating the versions we want to look for
# set(matlab_supported_versions)
# # Matlab 7
# set(matlab_major 7)
# foreach(current_matlab_minor RANGE 4 20)
# list(APPEND matlab_supported_versions "${matlab_major}.${current_matlab_minor}")
# endforeach(current_matlab_minor)
# # Matlab 8
# set(matlab_major 8)
# foreach(current_matlab_minor RANGE 0 5)
# list(APPEND matlab_supported_versions "${matlab_major}.${current_matlab_minor}")
# endforeach(current_matlab_minor)
# # taking into account the possible additional versions provided by the user
# if(DEFINED MATLAB_ADDITIONAL_VERSIONS)
# list(APPEND matlab_supported_versions MATLAB_ADDITIONAL_VERSIONS)
# endif()
# we order from more recent to older
if ( matlab_supported_versions )
list ( REMOVE_DUPLICATES matlab_supported_versions )
list ( SORT matlab_supported_versions )
list ( REVERSE matlab_supported_versions )
endif ( )
set ( ${ matlab_versions } ${ matlab_supported_versions } )
endmacro ( )
#.rst:
# .. command:: matlab_get_all_valid_matlab_roots_from_registry
#
# Populates the Matlab root with valid versions of Matlab or
# Matlab Runtime (MCR).
# The returned matlab_roots is organized in triplets
# ``(type,version_number,matlab_root_path)``, where ``type``
# indicates either ``MATLAB`` or ``MCR``.
#
# ::
#
# matlab_get_all_valid_matlab_roots_from_registry(
# matlab_versions
# matlab_roots)
#
# ``matlab_versions``
# the versions of each of the Matlab or MCR installations
# ``matlab_roots``
# the location of each of the Matlab or MCR installations
function ( matlab_get_all_valid_matlab_roots_from_registry matlab_versions matlab_roots )
# The matlab_versions comes either from
# extract_matlab_versions_from_registry_brute_force or
# matlab_extract_all_installed_versions_from_registry.
set ( _matlab_roots_list )
# check for Matlab installations
foreach ( _matlab_current_version ${ matlab_versions } )
get_filename_component (
c u r r e n t _ M A T L A B _ R O O T
" [ H K E Y _ L O C A L _ M A C H I N E \ \ S O F T W A R E \ \ M a t h W o r k s \ \ M A T L A B \ \ $ { _ m a t l a b _ c u r r e n t _ v e r s i o n } ; M A T L A B R O O T ] "
A B S O L U T E )
if ( EXISTS ${ current_MATLAB_ROOT } )
list ( APPEND _matlab_roots_list "MATLAB" ${ _matlab_current_version } ${ current_MATLAB_ROOT } )
endif ( )
endforeach ( )
# Check for MCR installations
foreach ( _matlab_current_version ${ matlab_versions } )
get_filename_component (
c u r r e n t _ M A T L A B _ R O O T
" [ H K E Y _ L O C A L _ M A C H I N E \ \ S O F T W A R E \ \ M a t h W o r k s \ \ M A T L A B R u n t i m e \ \ $ { _ m a t l a b _ c u r r e n t _ v e r s i o n } ; M A T L A B R O O T ] "
A B S O L U T E )
# remove the dot
string ( REPLACE "." "" _matlab_current_version_without_dot "${_matlab_current_version}" )
if ( EXISTS ${ current_MATLAB_ROOT } )
list ( APPEND _matlab_roots_list "MCR" ${ _matlab_current_version } "${current_MATLAB_ROOT}/v${_matlab_current_version_without_dot}" )
endif ( )
endforeach ( )
set ( ${ matlab_roots } ${ _matlab_roots_list } PARENT_SCOPE )
endfunction ( )
#.rst:
# .. command:: matlab_get_mex_suffix
#
# Returns the extension of the mex files (the suffixes).
# This function should not be called before the appropriate Matlab root has
# been found.
#
# ::
#
# matlab_get_mex_suffix(
# matlab_root
# mex_suffix)
#
# ``matlab_root``
# the root of the Matlab/MCR installation
# ``mex_suffix``
# the variable name in which the suffix will be returned.
function ( matlab_get_mex_suffix matlab_root mex_suffix )
# todo setup the extension properly. Currently I do not know if this is
# sufficient for all win32 distributions.
# there is also CMAKE_EXECUTABLE_SUFFIX that could be tweaked
set ( mexext_suffix "" )
if ( WIN32 )
list ( APPEND mexext_suffix ".bat" )
endif ( )
# we first try without suffix, since cmake does not understand a list with
# one empty string element
find_program (
M a t l a b _ M E X E X T E N S I O N S _ P R O G
N A M E S m e x e x t
P A T H S $ { m a t l a b _ r o o t } / b i n
D O C " M a t l a b M E X e x t e n s i o n p r o v i d e r "
N O _ D E F A U L T _ P A T H
)
foreach ( current_mexext_suffix IN LISTS mexext_suffix )
if ( NOT DEFINED Matlab_MEXEXTENSIONS_PROG OR NOT Matlab_MEXEXTENSIONS_PROG )
# this call should populate the cache automatically
find_program (
M a t l a b _ M E X E X T E N S I O N S _ P R O G
" m e x e x t $ { c u r r e n t _ m e x e x t _ s u f f i x } "
P A T H S $ { m a t l a b _ r o o t } / b i n
D O C " M a t l a b M E X e x t e n s i o n p r o v i d e r "
N O _ D E F A U L T _ P A T H
)
endif ( )
endforeach ( current_mexext_suffix )
if ( MATLAB_FIND_DEBUG )
message ( STATUS "[MATLAB] Determining mex files extensions from '${matlab_root}/bin' with program '${Matlab_MEXEXTENSIONS_PROG}'" )
endif ( )
# the program has been found?
if ( ( NOT Matlab_MEXEXTENSIONS_PROG ) OR ( NOT EXISTS ${ Matlab_MEXEXTENSIONS_PROG } ) )
if ( MATLAB_FIND_DEBUG )
message ( WARNING "[MATLAB] Cannot found mexext program. Matlab root is ${matlab_root}" )
endif ( )
unset ( Matlab_MEXEXTENSIONS_PROG CACHE )
return ( )
endif ( )
set ( _matlab_mex_extension )
set ( devnull )
if ( UNIX )
set ( devnull INPUT_FILE /dev/null )
elseif ( WIN32 )
set ( devnull INPUT_FILE NUL )
endif ( )
# this is the preferred way. If this does not work properly (eg. MCR on Windows), then we use our own knowledge
execute_process (
C O M M A N D $ { M a t l a b _ M E X E X T E N S I O N S _ P R O G }
O U T P U T _ V A R I A B L E _ m a t l a b _ m e x _ e x t e n s i o n
#RESULT_VARIABLE _matlab_mex_extension_call
E R R O R _ V A R I A B L E _ m a t l a b _ m e x _ e x t e n s i o n _ e r r o r
$ { d e v n u l l } )
if ( NOT "${_matlab_mex_extension_error}" STREQUAL "" )
if ( WIN32 )
# this is only for intel architecture
if ( CMAKE_SIZEOF_VOID_P EQUAL 8 )
set ( _matlab_mex_extension "mexw64" )
else ( )
set ( _matlab_mex_extension "mexw32" )
endif ( )
endif ( )
endif ( )
string ( STRIP "${_matlab_mex_extension}" _matlab_mex_extension )
if ( MATLAB_FIND_DEBUG )
message ( STATUS "[MATLAB] '${Matlab_MEXEXTENSIONS_PROG}' : returned '${_matlab_mex_extension_call}', determined extension '${_matlab_mex_extension}' and error string is '${_matlab_mex_extension_error}'" )
endif ( )
unset ( Matlab_MEXEXTENSIONS_PROG CACHE )
set ( ${ mex_suffix } ${ _matlab_mex_extension } PARENT_SCOPE )
endfunction ( )
#.rst:
# .. command:: matlab_get_version_from_matlab_run
#
# This function runs Matlab program specified on arguments and extracts its
# version. If the path provided for the Matlab installation points to an MCR
# installation, the version is extracted from the installed files.
#
# ::
#
# matlab_get_version_from_matlab_run(
# matlab_binary_path
# matlab_list_versions)
#
# ``matlab_binary_path``
# the location of the `matlab` binary executable
# ``matlab_list_versions``
# the version extracted from Matlab
function ( matlab_get_version_from_matlab_run matlab_binary_program matlab_list_versions )
set ( ${ matlab_list_versions } "" PARENT_SCOPE )
if ( MATLAB_FIND_DEBUG )
message ( STATUS "[MATLAB] Determining the version of Matlab from ${matlab_binary_program}" )
endif ( )
if ( EXISTS "${_matlab_temporary_folder}/matlabVersionLog.cmaketmp" )
if ( MATLAB_FIND_DEBUG )
message ( STATUS "[MATLAB] Removing previous ${_matlab_temporary_folder}/matlabVersionLog.cmaketmp file" )
endif ( )
file ( REMOVE "${_matlab_temporary_folder}/matlabVersionLog.cmaketmp" )
endif ( )
# the log file is needed since on windows the command executes in a new
# window and it is not possible to get back the answer of Matlab
# the -wait command is needed on windows, otherwise the call returns
# immediately after the program launches itself.
if ( WIN32 )
set ( _matlab_additional_commands "-wait" )
endif ( )
set ( devnull )
if ( UNIX )
set ( devnull INPUT_FILE /dev/null )
elseif ( WIN32 )
set ( devnull INPUT_FILE NUL )
endif ( )
# timeout set to 120 seconds, in case it does not start
# note as said before OUTPUT_VARIABLE cannot be used in a platform
# independent manner however, not setting it would flush the output of Matlab
# in the current console (unix variant)
execute_process (
C O M M A N D " $ { m a t l a b _ b i n a r y _ p r o g r a m } " - n o s p l a s h - n o j v m $ { _ m a t l a b _ a d d i t i o n a l _ c o m m a n d s } - l o g f i l e " m a t l a b V e r s i o n L o g . c m a k e t m p " - n o d e s k t o p - n o d i s p l a y - r " v e r s i o n , e x i t "
O U T P U T _ V A R I A B L E _ m a t l a b _ v e r s i o n _ f r o m _ c m d _ d u m m y
R E S U L T _ V A R I A B L E _ m a t l a b _ r e s u l t _ v e r s i o n _ c a l l
E R R O R _ V A R I A B L E _ m a t l a b _ r e s u l t _ v e r s i o n _ c a l l _ e r r o r
T I M E O U T 1 2 0
W O R K I N G _ D I R E C T O R Y " $ { _ m a t l a b _ t e m p o r a r y _ f o l d e r } "
$ { d e v n u l l }
)
if ( "${_matlab_result_version_call}" MATCHES "timeout" )
if ( MATLAB_FIND_DEBUG )
message ( WARNING "[MATLAB] Unable to determine the version of Matlab."
" M a t l a b c a l l t i m e d o u t a f t e r 1 2 0 s e c o n d s . " )
endif ( )
return ( )
endif ( )
if ( ${ _matlab_result_version_call } )
if ( MATLAB_FIND_DEBUG )
message ( WARNING "[MATLAB] Unable to determine the version of Matlab. Matlab call returned with error ${_matlab_result_version_call}." )
endif ( )
return ( )
elseif ( NOT EXISTS "${_matlab_temporary_folder}/matlabVersionLog.cmaketmp" )
if ( MATLAB_FIND_DEBUG )
message ( WARNING "[MATLAB] Unable to determine the version of Matlab. The log file does not exist." )
endif ( )
return ( )
endif ( )
# if successful, read back the log
file ( READ "${_matlab_temporary_folder}/matlabVersionLog.cmaketmp" _matlab_version_from_cmd )
file ( REMOVE "${_matlab_temporary_folder}/matlabVersionLog.cmaketmp" )
set ( index -1 )
string ( FIND ${ _matlab_version_from_cmd } "ans" index )
if ( index EQUAL -1 )
if ( MATLAB_FIND_DEBUG )
message ( WARNING "[MATLAB] Cannot find the version of Matlab returned by the run." )
endif ( )
else ( )
set ( matlab_list_of_all_versions_tmp )
string ( SUBSTRING ${ _matlab_version_from_cmd } ${ index } -1 substring_ans )
string (
R E G E X M A T C H A L L " a n s [ \ r \ n \ t ] * = [ \ r \ n \ t ] * ' ? ( [ 0 - 9 ] + ( \ \ . [ 0 - 9 ] + ) ? ) "
m a t l a b _ v e r s i o n s _ r e g e x
$ { s u b s t r i n g _ a n s } )
foreach ( match IN LISTS matlab_versions_regex )
string (
R E G E X M A T C H " a n s [ \ r \ n \ t ] * = [ \ r \ n \ t ] * ' ? ( ( [ 0 - 9 ] + ) ( \ \ . ( [ 0 - 9 ] + ) ) ? ) "
c u r r e n t _ m a t c h $ { m a t c h } )
list ( APPEND matlab_list_of_all_versions_tmp ${ CMAKE_MATCH_1 } )
endforeach ( )
if ( matlab_list_of_all_versions_tmp )
list ( REMOVE_DUPLICATES matlab_list_of_all_versions_tmp )
endif ( )
set ( ${ matlab_list_versions } ${ matlab_list_of_all_versions_tmp } PARENT_SCOPE )
endif ( )
endfunction ( )
#.rst:
# .. command:: matlab_add_unit_test
#
# Adds a Matlab unit test to the test set of cmake/ctest.
# This command requires the component ``MAIN_PROGRAM`` and hence is not
# available for an MCR installation.
#
# The unit test uses the Matlab unittest framework (default, available
# starting Matlab 2013b+) except if the option ``NO_UNITTEST_FRAMEWORK``
# is given.
#
# The function expects one Matlab test script file to be given.
# In the case ``NO_UNITTEST_FRAMEWORK`` is given, the unittest script file
# should contain the script to be run, plus an exit command with the exit
# value. This exit value will be passed to the ctest framework (0 success,
# non 0 failure). Additional arguments accepted by :command:`add_test` can be
# passed through ``TEST_ARGS`` (eg. ``CONFIGURATION <config> ...``).
#
# ::
#
# matlab_add_unit_test(
# NAME <name>
# UNITTEST_FILE matlab_file_containing_unittest.m
# [CUSTOM_TEST_COMMAND matlab_command_to_run_as_test]
# [UNITTEST_PRECOMMAND matlab_command_to_run]
# [TIMEOUT timeout]
# [ADDITIONAL_PATH path1 [path2 ...]]
# [MATLAB_ADDITIONAL_STARTUP_OPTIONS option1 [option2 ...]]
# [TEST_ARGS arg1 [arg2 ...]]
# [NO_UNITTEST_FRAMEWORK]
# )
#
# The function arguments are:
#
# ``NAME``
# name of the unittest in ctest.
# ``UNITTEST_FILE``
# the matlab unittest file. Its path will be automatically
# added to the Matlab path.
# ``CUSTOM_TEST_COMMAND``
# Matlab script command to run as the test.
# If this is not set, then the following is run:
# ``runtests('matlab_file_name'), exit(max([ans(1,:).Failed]))``
# where ``matlab_file_name`` is the ``UNITTEST_FILE`` without the extension.
# ``UNITTEST_PRECOMMAND``
# Matlab script command to be ran before the file
# containing the test (eg. GPU device initialisation based on CMake
# variables).
# ``TIMEOUT``
# the test timeout in seconds. Defaults to 180 seconds as the
# Matlab unit test may hang.
# ``ADDITIONAL_PATH``
# a list of paths to add to the Matlab path prior to
# running the unit test.
# ``MATLAB_ADDITIONAL_STARTUP_OPTIONS``
# a list of additional option in order
# to run Matlab from the command line.
# ``-nosplash -nodesktop -nodisplay`` are always added.
# ``TEST_ARGS``
# Additional options provided to the add_test command. These
# options are added to the default options (eg. "CONFIGURATIONS Release")
# ``NO_UNITTEST_FRAMEWORK``
# when set, indicates that the test should not
# use the unittest framework of Matlab (available for versions >= R2013a).
# ``WORKING_DIRECTORY``
# This will be the working directory for the test. If specified it will
# also be the output directory used for the log file of the test run.
# If not specified the temporary directory ``${CMAKE_BINARY_DIR}/Matlab`` will
# be used as the working directory and the log location.
#
function ( matlab_add_unit_test )
if ( NOT Matlab_MAIN_PROGRAM )
message ( FATAL_ERROR "[MATLAB] This functionality needs the MAIN_PROGRAM component (not default)" )
endif ( )
set ( options NO_UNITTEST_FRAMEWORK )
set ( oneValueArgs NAME UNITTEST_FILE TIMEOUT WORKING_DIRECTORY
U N I T T E S T _ P R E C O M M A N D C U S T O M _ T E S T _ C O M M A N D )
set ( multiValueArgs ADDITIONAL_PATH MATLAB_ADDITIONAL_STARTUP_OPTIONS TEST_ARGS )
set ( prefix _matlab_unittest_prefix )
cmake_parse_arguments ( PARSE_ARGV 0 ${ prefix } "${options}" "${oneValueArgs}" "${multiValueArgs}" )
if ( NOT ${ prefix } _NAME )
message ( FATAL_ERROR "[MATLAB] The Matlab test name cannot be empty" )
endif ( )
add_test ( NAME ${ ${prefix } _NAME}
C O M M A N D $ { C M A K E _ C O M M A N D }
" - D t e s t _ n a m e = $ { $ { p r e f i x } _ N A M E } "
" - D a d d i t i o n a l _ p a t h s = $ { $ { p r e f i x } _ A D D I T I O N A L _ P A T H } "
" - D t e s t _ t i m e o u t = $ { $ { p r e f i x } _ T I M E O U T } "
" - D o u t p u t _ d i r e c t o r y = $ { _ m a t l a b _ t e m p o r a r y _ f o l d e r } "
" - D w o r k i n g _ d i r e c t o r y = $ { $ { p r e f i x } _ W O R K I N G _ D I R E C T O R Y } "
" - D M a t l a b _ P R O G R A M = $ { M a t l a b _ M A I N _ P R O G R A M } "
" - D n o _ u n i t t e s t _ f r a m e w o r k = $ { $ { p r e f i x } _ N O _ U N I T T E S T _ F R A M E W O R K } "
" - D M a t l a b _ A D D I T I O N A L _ S T A R T U P _ O P T I O N S = $ { $ { p r e f i x } _ M A T L A B _ A D D I T I O N A L _ S T A R T U P _ O P T I O N S } "
" - D u n i t t e s t _ f i l e _ t o _ r u n = $ { $ { p r e f i x } _ U N I T T E S T _ F I L E } "
" - D c u s t o m _ M a t l a b _ t e s t _ c o m m a n d = $ { $ { p r e f i x } _ C U S T O M _ T E S T _ C O M M A N D } "
" - D c m d _ t o _ r u n _ b e f o r e _ t e s t = $ { $ { p r e f i x } _ U N I T T E S T _ P R E C O M M A N D } "
- P $ { _ F i n d M a t l a b _ S E L F _ D I R } / M a t l a b T e s t s R e d i r e c t . c m a k e
$ { $ { p r e f i x } _ T E S T _ A R G S }
$ { $ { p r e f i x } _ U N P A R S E D _ A R G U M E N T S }
)
endfunction ( )
#.rst:
# .. command:: matlab_add_mex
#
# Adds a Matlab MEX target.
# This commands compiles the given sources with the current tool-chain in
# order to produce a MEX file. The final name of the produced output may be
# specified, as well as additional link libraries, and a documentation entry
# for the MEX file. Remaining arguments of the call are passed to the
# :command:`add_library` or :command:`add_executable` command.
#
# ::
#
# matlab_add_mex(
# NAME <name>
# [EXECUTABLE | MODULE | SHARED]
# SRC src1 [src2 ...]
# [OUTPUT_NAME output_name]
# [DOCUMENTATION file.txt]
# [LINK_TO target1 target2 ...]
# [...]
# )
#
# ``NAME``
# name of the target.
# ``SRC``
# list of source files.
# ``LINK_TO``
# a list of additional link dependencies. The target links to ``libmex``
# by default. If ``Matlab_MX_LIBRARY`` is defined, it also
# links to ``libmx``.
# ``OUTPUT_NAME``
# if given, overrides the default name. The default name is
# the name of the target without any prefix and
# with ``Matlab_MEX_EXTENSION`` suffix.
# ``DOCUMENTATION``
# if given, the file ``file.txt`` will be considered as
# being the documentation file for the MEX file. This file is copied into
# the same folder without any processing, with the same name as the final
# mex file, and with extension `.m`. In that case, typing ``help <name>``
# in Matlab prints the documentation contained in this file.
# ``MODULE`` or ``SHARED`` may be given to specify the type of library to be
# created. ``EXECUTABLE`` may be given to create an executable instead of
# a library. If no type is given explicitly, the type is ``SHARED``.
#
# The documentation file is not processed and should be in the following
# format:
#
# ::
#
# % This is the documentation
# function ret = mex_target_output_name(input1)
#
function ( matlab_add_mex )
if ( NOT WIN32 )
# we do not need all this on Windows
# pthread options
if ( CMAKE_CXX_COMPILER_LOADED )
check_cxx_compiler_flag ( -pthread HAS_MINUS_PTHREAD )
elseif ( CMAKE_C_COMPILER_LOADED )
check_c_compiler_flag ( -pthread HAS_MINUS_PTHREAD )
endif ( )
# we should use try_compile instead, the link flags are discarded from
# this compiler_flag function.
#check_cxx_compiler_flag(-Wl,--exclude-libs,ALL HAS_SYMBOL_HIDING_CAPABILITY)
endif ( )
set ( options EXECUTABLE MODULE SHARED )
set ( oneValueArgs NAME DOCUMENTATION OUTPUT_NAME )
set ( multiValueArgs LINK_TO SRC )
set ( prefix _matlab_addmex_prefix )
cmake_parse_arguments ( ${ prefix } "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ ARGN } )
if ( NOT ${ prefix } _NAME )
message ( FATAL_ERROR "[MATLAB] The MEX target name cannot be empty" )
endif ( )
if ( NOT ${ prefix } _OUTPUT_NAME )
set ( ${ prefix } _OUTPUT_NAME ${ ${prefix } _NAME} )
endif ( )
if ( ${ prefix } _EXECUTABLE )
add_executable ( ${ ${prefix } _NAME}
$ { $ { p r e f i x } _ S R C }
$ { $ { p r e f i x } _ D O C U M E N T A T I O N }
$ { $ { p r e f i x } _ U N P A R S E D _ A R G U M E N T S } )
else ( )
if ( ${ prefix } _MODULE )
set ( type MODULE )
else ( )
set ( type SHARED )
endif ( )
add_library ( ${ ${prefix } _NAME}
$ { t y p e }
$ { $ { p r e f i x } _ S R C }
$ { $ { p r e f i x } _ D O C U M E N T A T I O N }
$ { $ { p r e f i x } _ U N P A R S E D _ A R G U M E N T S } )
endif ( )
target_include_directories ( ${ ${prefix } _NAME} PRIVATE ${ Matlab_INCLUDE_DIRS } )
if ( DEFINED Matlab_MX_LIBRARY )
target_link_libraries ( ${ ${prefix } _NAME} ${ Matlab_MX_LIBRARY } )
endif ( )
if ( DEFINED Matlab_ENGINE_LIBRARY )
target_link_libraries ( ${ ${prefix } _NAME} ${ Matlab_ENGINE_LIBRARY } )
endif ( )
if ( DEFINED Matlab_DATAARRAY_LIBRARY )
target_link_libraries ( ${ ${prefix } _NAME} ${ Matlab_DATAARRAY_LIBRARY } )
endif ( )
target_link_libraries ( ${ ${prefix } _NAME} ${ Matlab_MEX_LIBRARY } ${ ${prefix } _LINK_TO} )
set_target_properties ( ${ ${prefix } _NAME}
P R O P E R T I E S
P R E F I X " "
O U T P U T _ N A M E $ { $ { p r e f i x } _ O U T P U T _ N A M E }
S U F F I X " . $ { M a t l a b _ M E X _ E X T E N S I O N } " )
# documentation
if ( NOT ${ ${prefix } _DOCUMENTATION} STREQUAL "" )
get_target_property ( output_name ${ ${prefix } _NAME} OUTPUT_NAME )
add_custom_command (
T A R G E T $ { $ { p r e f i x } _ N A M E }
P R E _ B U I L D
C O M M A N D $ { C M A K E _ C O M M A N D } - E c o p y _ i f _ d i f f e r e n t $ { $ { p r e f i x } _ D O C U M E N T A T I O N } $ < T A R G E T _ F I L E _ D I R : $ { $ { p r e f i x } _ N A M E } > / $ { o u t p u t _ n a m e } . m
C O M M E N T " [ M A T L A B ] C o p y $ { $ { p r e f i x } _ N A M E } d o c u m e n t a t i o n f i l e i n t o t h e o u t p u t f o l d e r "
)
endif ( ) # documentation
# entry point in the mex file + taking care of visibility and symbol clashes.
if ( MSVC )
get_target_property (
_ p r e v i o u s _ l i n k _ f l a g s
$ { $ { p r e f i x } _ N A M E }
L I N K _ F L A G S )
if ( NOT _previous_link_flags )
set ( _previous_link_flags )
endif ( )
set_target_properties ( ${ ${prefix } _NAME}
P R O P E R T I E S
L I N K _ F L A G S " $ { _ p r e v i o u s _ l i n k _ f l a g s } / E X P O R T : m e x F u n c t i o n " )
endif ( )
if ( WIN32 )
set_target_properties ( ${ ${prefix } _NAME}
P R O P E R T I E S
D E F I N E _ S Y M B O L " D L L _ E X P O R T _ S Y M = __declspec ( dllexport ) " )
else ( )
if ( HAS_MINUS_PTHREAD AND NOT APPLE )
# Apparently, compiling with -pthread generated the proper link flags
# and some defines at compilation
target_compile_options ( ${ ${prefix } _NAME} PRIVATE "-pthread" )
endif ( )
# if we do not do that, the symbols linked from eg. boost remain weak and
# then clash with the ones defined in the matlab process. So by default
# the symbols are hidden.
# This also means that for shared libraries (like MEX), the entry point
# should be explicitly declared with default visibility, otherwise Matlab
# cannot find the entry point.
# Note that this is particularly meaningful if the MEX wrapper itself
# contains symbols that are clashing with Matlab (that are compiled in the
# MEX file). In order to propagate the visibility options to the libraries
# to which the MEX file is linked against, the -Wl,--exclude-libs,ALL
# option should also be specified.
set_target_properties ( ${ ${prefix } _NAME}
P R O P E R T I E S
C X X _ V I S I B I L I T Y _ P R E S E T " h i d d e n "
C _ V I S I B I L I T Y _ P R E S E T " h i d d e n "
V I S I B I L I T Y _ I N L I N E S _ H I D D E N O N
)
# get_target_property(
# _previous_link_flags
# ${${prefix}_NAME}
# LINK_FLAGS)
# if(NOT _previous_link_flags)
# set(_previous_link_flags)
# endif()
# if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
# set_target_properties(${${prefix}_NAME}
# PROPERTIES
# LINK_FLAGS "${_previous_link_flags} -Wl,--exclude-libs,ALL"
# # -Wl,--version-script=${_FindMatlab_SELF_DIR}/MatlabLinuxVisibility.map"
# )
# elseif("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
# # in this case, all other symbols become hidden.
# set_target_properties(${${prefix}_NAME}
# PROPERTIES
# LINK_FLAGS "${_previous_link_flags} -Wl,-exported_symbol,_mexFunction"
# #-Wl,-exported_symbols_list,${_FindMatlab_SELF_DIR}/MatlabOSXVisilibity.map"
# )
# endif()
set_target_properties ( ${ ${prefix } _NAME}
P R O P E R T I E S
D E F I N E _ S Y M B O L " D L L _ E X P O R T _ S Y M = __attribute__ ( ( visibility ( \"default\")))"
)
endif ( )
endfunction ( )
# (internal)
# Used to get the version of matlab, using caching. This basically transforms the
# output of the root list, with possible unknown version, to a version
# This can possibly run Matlab for extracting the version.
function ( _Matlab_get_version_from_root matlab_root matlab_or_mcr matlab_known_version matlab_final_version )
# if the version is not trivial, we query matlab (if not MCR) for that
# we keep track of the location of matlab that induced this version
#if(NOT DEFINED Matlab_PROG_VERSION_STRING_AUTO_DETECT)
# set(Matlab_PROG_VERSION_STRING_AUTO_DETECT "" CACHE INTERNAL "internal matlab location for the discovered version")
#endif()
if ( NOT ${ matlab_known_version } STREQUAL "NOTFOUND" )
# the version is known, we just return it
set ( ${ matlab_final_version } ${ matlab_known_version } PARENT_SCOPE )
set ( Matlab_VERSION_STRING_INTERNAL ${ matlab_known_version } CACHE INTERNAL "Matlab version (automatically determined)" FORCE )
return ( )
endif ( )
if ( "${matlab_or_mcr}" STREQUAL "UNKNOWN" )
if ( MATLAB_FIND_DEBUG )
message ( WARNING "[MATLAB] Determining Matlab or MCR" )
endif ( )
if ( EXISTS "${matlab_root}/appdata/version.xml" )
# we inspect the application version.xml file that contains the product information
file ( STRINGS "${matlab_root}/appdata/version.xml" productinfo_string NEWLINE_CONSUME )
string ( REGEX MATCH "<installedProductData.*displayedString=\" ( [a-zA-Z ]+ ) \".*/>"
p r o d u c t _ r e g _ m a t c h
$ { p r o d u c t i n f o _ s t r i n g }
)
# default fallback to Matlab
set ( matlab_or_mcr "MATLAB" )
if ( NOT "${CMAKE_MATCH_1}" STREQUAL "" )
string ( TOLOWER "${CMAKE_MATCH_1}" product_reg_match )
if ( "${product_reg_match}" STREQUAL "matlab runtime" )
set ( matlab_or_mcr "MCR" )
endif ( )
endif ( )
endif ( )
if ( MATLAB_FIND_DEBUG )
message ( WARNING "[MATLAB] '${matlab_root}' contains the '${matlab_or_mcr}'" )
endif ( )
endif ( )
# UNKNOWN is the default behaviour in case we
# - have an erroneous matlab_root
# - have an initial 'UNKNOWN'
if ( "${matlab_or_mcr}" STREQUAL "MATLAB" OR "${matlab_or_mcr}" STREQUAL "UNKNOWN" )
# MATLAB versions
set ( _matlab_current_program ${ Matlab_MAIN_PROGRAM } )
# do we already have a matlab program?
if ( NOT _matlab_current_program )
set ( _find_matlab_options )
if ( matlab_root AND EXISTS ${ matlab_root } )
set ( _find_matlab_options PATHS ${ matlab_root } ${ matlab_root } /bin NO_DEFAULT_PATH )
endif ( )
find_program (
_ m a t l a b _ c u r r e n t _ p r o g r a m
m a t l a b
$ { _ f i n d _ m a t l a b _ o p t i o n s }
D O C " M a t l a b m a i n p r o g r a m "
)
endif ( )
if ( NOT _matlab_current_program OR NOT EXISTS ${ _matlab_current_program } )
# if not found, clear the dependent variables
if ( MATLAB_FIND_DEBUG )
message ( WARNING "[MATLAB] Cannot find the main matlab program under ${matlab_root}" )
endif ( )
set ( Matlab_PROG_VERSION_STRING_AUTO_DETECT "" CACHE INTERNAL "internal matlab location for the discovered version" FORCE )
set ( Matlab_VERSION_STRING_INTERNAL "" CACHE INTERNAL "internal matlab location for the discovered version" FORCE )
unset ( _matlab_current_program )
unset ( _matlab_current_program CACHE )
return ( )
endif ( )
# full real path for path comparison
get_filename_component ( _matlab_main_real_path_tmp "${_matlab_current_program}" REALPATH )
unset ( _matlab_current_program )
unset ( _matlab_current_program CACHE )
# is it the same as the previous one?
if ( _matlab_main_real_path_tmp STREQUAL Matlab_PROG_VERSION_STRING_AUTO_DETECT )
set ( ${ matlab_final_version } ${ Matlab_VERSION_STRING_INTERNAL } PARENT_SCOPE )
return ( )
endif ( )
# update the location of the program
set ( Matlab_PROG_VERSION_STRING_AUTO_DETECT
$ { _ m a t l a b _ m a i n _ r e a l _ p a t h _ t m p }
C A C H E I N T E R N A L " i n t e r n a l m a t l a b l o c a t i o n f o r t h e d i s c o v e r e d v e r s i o n " F O R C E )
set ( matlab_list_of_all_versions )
matlab_get_version_from_matlab_run ( "${Matlab_PROG_VERSION_STRING_AUTO_DETECT}" matlab_list_of_all_versions )
list ( LENGTH matlab_list_of_all_versions list_of_all_versions_length )
if ( ${ list_of_all_versions_length } GREATER 0 )
list ( GET matlab_list_of_all_versions 0 _matlab_version_tmp )
else ( )
set ( _matlab_version_tmp "unknown" )
endif ( )
# set the version into the cache
set ( Matlab_VERSION_STRING_INTERNAL ${ _matlab_version_tmp } CACHE INTERNAL "Matlab version (automatically determined)" FORCE )
# warning, just in case several versions found (should not happen)
if ( ( ${ list_of_all_versions_length } GREATER 1 ) AND MATLAB_FIND_DEBUG )
message ( WARNING "[MATLAB] Found several versions, taking the first one (versions found ${matlab_list_of_all_versions})" )
endif ( )
# return the updated value
set ( ${ matlab_final_version } ${ Matlab_VERSION_STRING_INTERNAL } PARENT_SCOPE )
elseif ( EXISTS "${matlab_root}/VersionInfo.xml" )
# MCR
# we cannot run anything in order to extract the version. We assume that the file
# VersionInfo.xml exists under the MatlabRoot, we look for it and extract the version from there
set ( _matlab_version_tmp "unknown" )
file ( STRINGS "${matlab_root}/VersionInfo.xml" versioninfo_string NEWLINE_CONSUME )
if ( versioninfo_string )
# parses "<version>9.2.0.538062</version>"
string ( REGEX MATCH "<version>(.*)</version>"
v e r s i o n _ r e g _ m a t c h
$ { v e r s i o n i n f o _ s t r i n g }
)
if ( NOT "${version_reg_match}" STREQUAL "" )
if ( "${CMAKE_MATCH_1}" MATCHES "(([0-9])\\.([0-9]))[\\.0-9]*" )
set ( _matlab_version_tmp "${CMAKE_MATCH_1}" )
endif ( )
endif ( )
endif ( )
set ( ${ matlab_final_version } "${_matlab_version_tmp}" PARENT_SCOPE )
set ( Matlab_VERSION_STRING_INTERNAL
" $ { _ m a t l a b _ v e r s i o n _ t m p } "
C A C H E I N T E R N A L " Matlab ( MCR ) version ( automatically determined ) "
F O R C E )
endif ( ) # Matlab or MCR
endfunction ( )
# Utility function for finding Matlab or MCR on Win32
function ( _Matlab_find_instances_win32 matlab_roots )
# On WIN32, we look for Matlab installation in the registry
# if unsuccessful, we look for all known revision and filter the existing
# ones.
# testing if we are able to extract the needed information from the registry
set ( _matlab_versions_from_registry )
if ( CMAKE_SIZEOF_VOID_P EQUAL 8 )
set ( _matlab_win64 ON )
else ( )
set ( _matlab_win64 OFF )
endif ( )
matlab_extract_all_installed_versions_from_registry ( _matlab_win64 _matlab_versions_from_registry )
# the returned list is empty, doing the search on all known versions
if ( NOT _matlab_versions_from_registry )
if ( MATLAB_FIND_DEBUG )
message ( STATUS "[MATLAB] Search for Matlab from the registry unsuccessful, testing all supported versions" )
endif ( )
extract_matlab_versions_from_registry_brute_force ( _matlab_versions_from_registry )
endif ( )
# filtering the results with the registry keys
matlab_get_all_valid_matlab_roots_from_registry ( "${_matlab_versions_from_registry}" _matlab_possible_roots )
set ( ${ matlab_roots } ${ _matlab_possible_roots } PARENT_SCOPE )
endfunction ( )
# Utility function for finding Matlab or MCR on OSX
function ( _Matlab_find_instances_osx matlab_roots )
set ( _matlab_possible_roots )
# on mac, we look for the /Application paths
# this corresponds to the behaviour on Windows. On Linux, we do not have
# any other guess.
matlab_get_supported_releases ( _matlab_releases )
if ( MATLAB_FIND_DEBUG )
message ( STATUS "[MATLAB] Matlab supported versions ${_matlab_releases}. If more version should be supported "
" t h e v a r i a b l e M A T L A B _ A D D I T I O N A L _ V E R S I O N S c a n b e s e t a c c o r d i n g t o t h e d o c u m e n t a t i o n " )
endif ( )
foreach ( _matlab_current_release IN LISTS _matlab_releases )
matlab_get_version_from_release_name ( "${_matlab_current_release}" _matlab_current_version )
string ( REPLACE "." "" _matlab_current_version_without_dot "${_matlab_current_version}" )
set ( _matlab_base_path "/Applications/MATLAB_${_matlab_current_release}.app" )
# Check Matlab, has precedence over MCR
if ( EXISTS ${ _matlab_base_path } )
if ( MATLAB_FIND_DEBUG )
message ( STATUS "[MATLAB] Found version ${_matlab_current_release} (${_matlab_current_version}) in ${_matlab_base_path}" )
endif ( )
list ( APPEND _matlab_possible_roots "MATLAB" ${ _matlab_current_version } ${ _matlab_base_path } )
endif ( )
# Checks MCR
set ( _mcr_path "/Applications/MATLAB/MATLAB_Runtime/v${_matlab_current_version_without_dot}" )
if ( EXISTS "${_mcr_path}" )
if ( MATLAB_FIND_DEBUG )
message ( STATUS "[MATLAB] Found MCR version ${_matlab_current_release} (${_matlab_current_version}) in ${_mcr_path}" )
endif ( )
list ( APPEND _matlab_possible_roots "MCR" ${ _matlab_current_version } ${ _mcr_path } )
endif ( )
endforeach ( )
set ( ${ matlab_roots } ${ _matlab_possible_roots } PARENT_SCOPE )
endfunction ( )
# Utility function for finding Matlab or MCR from the PATH
function ( _Matlab_find_instances_from_path matlab_roots )
set ( _matlab_possible_roots )
# At this point, we have no other choice than trying to find it from PATH.
# If set by the user, this wont change
find_program (
_ m a t l a b _ m a i n _ t m p
N A M E S m a t l a b )
if ( _matlab_main_tmp )
# we then populate the list of roots, with empty version
if ( MATLAB_FIND_DEBUG )
message ( STATUS "[MATLAB] matlab found from PATH: ${_matlab_main_tmp}" )
endif ( )
# resolve symlinks
get_filename_component ( _matlab_current_location "${_matlab_main_tmp}" REALPATH )
# get the directory (the command below has to be run twice)
# this will be the matlab root
get_filename_component ( _matlab_current_location "${_matlab_current_location}" DIRECTORY )
get_filename_component ( _matlab_current_location "${_matlab_current_location}" DIRECTORY ) # Matlab should be in bin
# We found the Matlab program
list ( APPEND _matlab_possible_roots "MATLAB" "NOTFOUND" ${ _matlab_current_location } )
# we remove this from the CACHE
unset ( _matlab_main_tmp CACHE )
else ( )
find_program (
_ m a t l a b _ m e x _ t m p
N A M E S m e x )
if ( _matlab_mex_tmp )
# we then populate the list of roots, with empty version
if ( MATLAB_FIND_DEBUG )
message ( STATUS "[MATLAB] mex compiler found from PATH: ${_matlab_mex_tmp}" )
endif ( )
# resolve symlinks
get_filename_component ( _mex_current_location "${_matlab_mex_tmp}" REALPATH )
# get the directory (the command below has to be run twice)
# this will be the matlab root
get_filename_component ( _mex_current_location "${_mex_current_location}" DIRECTORY )
get_filename_component ( _mex_current_location "${_mex_current_location}" DIRECTORY ) # Matlab Runtime mex compiler should be in bin
# We found the Matlab program
list ( APPEND _matlab_possible_roots "MCR" "NOTFOUND" ${ _mex_current_location } )
unset ( _matlab_mex_tmp CACHE )
else ( )
if ( MATLAB_FIND_DEBUG )
message ( STATUS "[MATLAB] mex compiler not found" )
endif ( )
endif ( )
endif ( )
set ( ${ matlab_roots } ${ _matlab_possible_roots } PARENT_SCOPE )
endfunction ( )
# ###################################
# Exploring the possible Matlab_ROOTS
# this variable will get all Matlab installations found in the current system.
set ( _matlab_possible_roots )
if ( Matlab_ROOT_DIR )
# if the user specifies a possible root, we keep this one
if ( NOT EXISTS "${Matlab_ROOT_DIR}" )
# if Matlab_ROOT_DIR specified but erroneous
if ( MATLAB_FIND_DEBUG )
message ( WARNING "[MATLAB] the specified path for Matlab_ROOT_DIR does not exist (${Matlab_ROOT_DIR})" )
endif ( )
else ( )
# NOTFOUND indicates the code below to search for the version automatically
if ( "${Matlab_VERSION_STRING_INTERNAL}" STREQUAL "" )
list ( APPEND _matlab_possible_roots "UNKNOWN" "NOTFOUND" ${ Matlab_ROOT_DIR } ) # empty version, empty MCR/Matlab indication
else ( )
list ( APPEND _matlab_possible_roots "UNKNOWN" ${ Matlab_VERSION_STRING_INTERNAL } ${ Matlab_ROOT_DIR } ) # cached version
endif ( )
endif ( )
else ( )
# if the user does not specify the possible installation root, we look for
# one installation using the appropriate heuristics.
# There is apparently no standard way on Linux.
if ( CMAKE_HOST_WIN32 )
_Matlab_find_instances_win32 ( _matlab_possible_roots_win32 )
list ( APPEND _matlab_possible_roots ${ _matlab_possible_roots_win32 } )
elseif ( APPLE )
_Matlab_find_instances_osx ( _matlab_possible_roots_osx )
list ( APPEND _matlab_possible_roots ${ _matlab_possible_roots_osx } )
endif ( )
endif ( )
list ( LENGTH _matlab_possible_roots _numbers_of_matlab_roots )
if ( _numbers_of_matlab_roots EQUAL 0 )
# if we have not found anything, we fall back on the PATH
_Matlab_find_instances_from_path ( _matlab_possible_roots )
endif ( )
if ( MATLAB_FIND_DEBUG )
message ( STATUS "[MATLAB] Matlab root folders are ${_matlab_possible_roots}" )
endif ( )
# take the first possible Matlab root
list ( LENGTH _matlab_possible_roots _numbers_of_matlab_roots )
set ( Matlab_VERSION_STRING "NOTFOUND" )
set ( Matlab_Or_MCR "UNKNOWN" )
if ( _numbers_of_matlab_roots GREATER 0 )
list ( GET _matlab_possible_roots 0 Matlab_Or_MCR )
list ( GET _matlab_possible_roots 1 Matlab_VERSION_STRING )
list ( GET _matlab_possible_roots 2 Matlab_ROOT_DIR )
# adding a warning in case of ambiguity
if ( _numbers_of_matlab_roots GREATER 3 AND MATLAB_FIND_DEBUG )
message ( WARNING "[MATLAB] Found several distributions of Matlab. Setting the current version to ${Matlab_VERSION_STRING} (located ${Matlab_ROOT_DIR})."
" I f t h i s i s n o t t h e d e s i r e d b e h a v i o u r , p r o v i d e t h e - D M a t l a b _ R O O T _ D I R = . . . o n t h e c o m m a n d l i n e " )
endif ( )
endif ( )
# check if the root changed wrt. the previous defined one, if so
# clear all the cached variables for being able to reconfigure properly
if ( DEFINED Matlab_ROOT_DIR_LAST_CACHED )
if ( NOT Matlab_ROOT_DIR_LAST_CACHED STREQUAL Matlab_ROOT_DIR )
set ( _Matlab_cached_vars
M a t l a b _ I N C L U D E _ D I R S
M a t l a b _ M E X _ L I B R A R Y
M a t l a b _ M E X _ C O M P I L E R
M a t l a b _ M C C _ C O M P I L E R
M a t l a b _ M A I N _ P R O G R A M
M a t l a b _ M X _ L I B R A R Y
M a t l a b _ E N G _ L I B R A R Y
M a t l a b _ M A T _ L I B R A R Y
M a t l a b _ E N G I N E _ L I B R A R Y
M a t l a b _ D A T A A R R A Y _ L I B R A R Y
M a t l a b _ M E X _ E X T E N S I O N
M a t l a b _ S I M U L I N K _ I N C L U D E _ D I R
# internal
M a t l a b _ M E X E X T E N S I O N S _ P R O G
M a t l a b _ R O O T _ D I R _ L A S T _ C A C H E D
#Matlab_PROG_VERSION_STRING_AUTO_DETECT
M a t l a b _ V E R S I O N _ S T R I N G _ I N T E R N A L
)
foreach ( _var IN LISTS _Matlab_cached_vars )
if ( DEFINED ${ _var } )
unset ( ${ _var } CACHE )
endif ( )
endforeach ( )
endif ( )
endif ( )
set ( Matlab_ROOT_DIR_LAST_CACHED ${ Matlab_ROOT_DIR } CACHE INTERNAL "last Matlab root dir location" )
set ( Matlab_ROOT_DIR ${ Matlab_ROOT_DIR } CACHE PATH "Matlab installation root path" FORCE )
# Fix the version, in case this one is NOTFOUND
_Matlab_get_version_from_root (
" $ { M a t l a b _ R O O T _ D I R } "
" $ { M a t l a b _ O r _ M C R } "
$ { M a t l a b _ V E R S I O N _ S T R I N G }
M a t l a b _ V E R S I O N _ S T R I N G
)
if ( MATLAB_FIND_DEBUG )
message ( STATUS "[MATLAB] Current version is ${Matlab_VERSION_STRING} located ${Matlab_ROOT_DIR}" )
endif ( )
if ( Matlab_ROOT_DIR )
file ( TO_CMAKE_PATH ${ Matlab_ROOT_DIR } Matlab_ROOT_DIR )
endif ( )
if ( CMAKE_SIZEOF_VOID_P EQUAL 4 )
set ( _matlab_64Build FALSE )
else ( )
set ( _matlab_64Build TRUE )
endif ( )
if ( APPLE )
set ( _matlab_bin_prefix "mac" ) # i should be for intel
set ( _matlab_bin_suffix_32bits "i" )
set ( _matlab_bin_suffix_64bits "i64" )
elseif ( UNIX )
set ( _matlab_bin_prefix "gln" )
set ( _matlab_bin_suffix_32bits "x86" )
set ( _matlab_bin_suffix_64bits "xa64" )
else ( )
set ( _matlab_bin_prefix "win" )
set ( _matlab_bin_suffix_32bits "32" )
set ( _matlab_bin_suffix_64bits "64" )
endif ( )
set ( MATLAB_INCLUDE_DIR_TO_LOOK ${ Matlab_ROOT_DIR } /extern/include )
if ( _matlab_64Build )
set ( _matlab_current_suffix ${ _matlab_bin_suffix_64bits } )
else ( )
set ( _matlab_current_suffix ${ _matlab_bin_suffix_32bits } )
endif ( )
set ( Matlab_BINARIES_DIR
$ { M a t l a b _ R O O T _ D I R } / b i n / $ { _ m a t l a b _ b i n _ p r e f i x } $ { _ m a t l a b _ c u r r e n t _ s u f f i x } )
set ( Matlab_EXTERN_LIBRARY_DIR
$ { M a t l a b _ R O O T _ D I R } / e x t e r n / l i b / $ { _ m a t l a b _ b i n _ p r e f i x } $ { _ m a t l a b _ c u r r e n t _ s u f f i x } )
if ( WIN32 )
if ( MINGW )
set ( _matlab_lib_dir_for_search ${ Matlab_EXTERN_LIBRARY_DIR } /mingw64 )
else ( )
set ( _matlab_lib_dir_for_search ${ Matlab_EXTERN_LIBRARY_DIR } /microsoft )
endif ( )
set ( _matlab_lib_prefix_for_search "lib" )
else ( )
set ( _matlab_lib_dir_for_search ${ Matlab_BINARIES_DIR } )
set ( _matlab_lib_prefix_for_search "lib" )
endif ( )
unset ( _matlab_64Build )
if ( NOT DEFINED Matlab_MEX_EXTENSION )
set ( _matlab_mex_extension "" )
matlab_get_mex_suffix ( "${Matlab_ROOT_DIR}" _matlab_mex_extension )
# This variable goes to the cache.
set ( Matlab_MEX_EXTENSION ${ _matlab_mex_extension } CACHE STRING "Extensions for the mex targets (automatically given by Matlab)" )
unset ( _matlab_mex_extension )
endif ( )
if ( MATLAB_FIND_DEBUG )
message ( STATUS "[MATLAB] [DEBUG]_matlab_lib_prefix_for_search = ${_matlab_lib_prefix_for_search} | _matlab_lib_dir_for_search = ${_matlab_lib_dir_for_search}" )
endif ( )
# internal
# This small stub around find_library is to prevent any pollution of CMAKE_FIND_LIBRARY_PREFIXES in the global scope.
# This is the function to be used below instead of the find_library directives.
function ( _Matlab_find_library _matlab_library_prefix )
set ( CMAKE_FIND_LIBRARY_PREFIXES ${ CMAKE_FIND_LIBRARY_PREFIXES } ${ _matlab_library_prefix } )
find_library ( ${ ARGN } )
endfunction ( )
set ( _matlab_required_variables )
# the MEX library/header are required
find_path (
M a t l a b _ I N C L U D E _ D I R S
m e x . h
P A T H S $ { M A T L A B _ I N C L U D E _ D I R _ T O _ L O O K }
N O _ D E F A U L T _ P A T H
)
list ( APPEND _matlab_required_variables Matlab_INCLUDE_DIRS )
_Matlab_find_library (
$ { _ m a t l a b _ l i b _ p r e f i x _ f o r _ s e a r c h }
M a t l a b _ M E X _ L I B R A R Y
m e x
P A T H S $ { _ m a t l a b _ l i b _ d i r _ f o r _ s e a r c h }
N O _ D E F A U L T _ P A T H
)
list ( APPEND _matlab_required_variables Matlab_MEX_LIBRARY )
# the MEX extension is required
list ( APPEND _matlab_required_variables Matlab_MEX_EXTENSION )
# the matlab root is required
list ( APPEND _matlab_required_variables Matlab_ROOT_DIR )
# component Mex Compiler
list ( FIND Matlab_FIND_COMPONENTS MEX_COMPILER _matlab_find_mex_compiler )
if ( _matlab_find_mex_compiler GREATER -1 )
find_program (
M a t l a b _ M E X _ C O M P I L E R
" m e x "
P A T H S $ { M a t l a b _ B I N A R I E S _ D I R }
D O C " M a t l a b M E X c o m p i l e r "
N O _ D E F A U L T _ P A T H
)
if ( Matlab_MEX_COMPILER )
set ( Matlab_MEX_COMPILER_FOUND TRUE )
endif ( )
endif ( )
unset ( _matlab_find_mex_compiler )
# component Matlab program
list ( FIND Matlab_FIND_COMPONENTS MAIN_PROGRAM _matlab_find_matlab_program )
if ( _matlab_find_matlab_program GREATER -1 )
find_program (
M a t l a b _ M A I N _ P R O G R A M
m a t l a b
P A T H S $ { M a t l a b _ R O O T _ D I R } $ { M a t l a b _ R O O T _ D I R } / b i n
D O C " M a t l a b m a i n p r o g r a m "
N O _ D E F A U L T _ P A T H
)
if ( Matlab_MAIN_PROGRAM )
set ( Matlab_MAIN_PROGRAM_FOUND TRUE )
endif ( )
endif ( )
unset ( _matlab_find_matlab_program )
# Component MX library
list ( FIND Matlab_FIND_COMPONENTS MX_LIBRARY _matlab_find_mx )
if ( _matlab_find_mx GREATER -1 )
_Matlab_find_library (
$ { _ m a t l a b _ l i b _ p r e f i x _ f o r _ s e a r c h }
M a t l a b _ M X _ L I B R A R Y
m x
P A T H S $ { _ m a t l a b _ l i b _ d i r _ f o r _ s e a r c h }
N O _ D E F A U L T _ P A T H
)
if ( Matlab_MX_LIBRARY )
set ( Matlab_MX_LIBRARY_FOUND TRUE )
endif ( )
endif ( )
unset ( _matlab_find_mx )
# Component ENG library
list ( FIND Matlab_FIND_COMPONENTS ENG_LIBRARY _matlab_find_eng )
if ( _matlab_find_eng GREATER -1 )
_Matlab_find_library (
$ { _ m a t l a b _ l i b _ p r e f i x _ f o r _ s e a r c h }
M a t l a b _ E N G _ L I B R A R Y
e n g
P A T H S $ { _ m a t l a b _ l i b _ d i r _ f o r _ s e a r c h }
N O _ D E F A U L T _ P A T H
)
if ( Matlab_ENG_LIBRARY )
set ( Matlab_ENG_LIBRARY_FOUND TRUE )
endif ( )
endif ( )
unset ( _matlab_find_eng )
# Component MAT library
list ( FIND Matlab_FIND_COMPONENTS MAT_LIBRARY _matlab_find_mat )
if ( _matlab_find_mat GREATER -1 )
_Matlab_find_library (
$ { _ m a t l a b _ l i b _ p r e f i x _ f o r _ s e a r c h }
M a t l a b _ M A T _ L I B R A R Y
m a t
P A T H S $ { _ m a t l a b _ l i b _ d i r _ f o r _ s e a r c h }
N O _ D E F A U L T _ P A T H
)
if ( Matlab_MAT_LIBRARY )
set ( Matlab_MAT_LIBRARY_FOUND TRUE )
endif ( )
endif ( )
unset ( _matlab_find_mat )
# Component Simulink
list ( FIND Matlab_FIND_COMPONENTS SIMULINK _matlab_find_simulink )
if ( _matlab_find_simulink GREATER -1 )
find_path (
M a t l a b _ S I M U L I N K _ I N C L U D E _ D I R
s i m s t r u c . h
P A T H S " $ { M a t l a b _ R O O T _ D I R } / s i m u l i n k / i n c l u d e "
N O _ D E F A U L T _ P A T H
)
if ( Matlab_SIMULINK_INCLUDE_DIR )
set ( Matlab_SIMULINK_FOUND TRUE )
list ( APPEND Matlab_INCLUDE_DIRS "${Matlab_SIMULINK_INCLUDE_DIR}" )
endif ( )
endif ( )
unset ( _matlab_find_simulink )
# component MCC Compiler
list ( FIND Matlab_FIND_COMPONENTS MCC_COMPILER _matlab_find_mcc_compiler )
if ( _matlab_find_mcc_compiler GREATER -1 )
find_program (
M a t l a b _ M C C _ C O M P I L E R
" m c c "
P A T H S $ { M a t l a b _ B I N A R I E S _ D I R }
D O C " M a t l a b M C C c o m p i l e r "
N O _ D E F A U L T _ P A T H
)
if ( Matlab_MCC_COMPILER )
set ( Matlab_MCC_COMPILER_FOUND TRUE )
endif ( )
endif ( )
unset ( _matlab_find_mcc_compiler )
# component MatlabEngine
list ( FIND Matlab_FIND_COMPONENTS ENGINE_LIBRARY _matlab_find_matlab_engine )
if ( _matlab_find_matlab_engine GREATER -1 )
_Matlab_find_library (
$ { _ m a t l a b _ l i b _ p r e f i x _ f o r _ s e a r c h }
M a t l a b _ E N G I N E _ L I B R A R Y
M a t l a b E n g i n e
P A T H S $ { _ m a t l a b _ l i b _ d i r _ f o r _ s e a r c h }
D O C " M a t l a b E n g i n e L i b r a r y "
N O _ D E F A U L T _ P A T H
)
if ( Matlab_ENGINE_LIBRARY )
set ( Matlab_ENGINE_LIBRARY_FOUND TRUE )
endif ( )
endif ( )
unset ( _matlab_find_matlab_engine )
# component MatlabDataArray
list ( FIND Matlab_FIND_COMPONENTS DATAARRAY_LIBRARY _matlab_find_matlab_dataarray )
if ( _matlab_find_matlab_dataarray GREATER -1 )
_Matlab_find_library (
$ { _ m a t l a b _ l i b _ p r e f i x _ f o r _ s e a r c h }
M a t l a b _ D A T A A R R A Y _ L I B R A R Y
M a t l a b D a t a A r r a y
P A T H S $ { _ m a t l a b _ l i b _ d i r _ f o r _ s e a r c h }
D O C " M a t l a b D a t a A r r a y L i b r a r y "
N O _ D E F A U L T _ P A T H
)
if ( Matlab_DATAARRAY_LIBRARY )
set ( Matlab_DATAARRAY_LIBRARY_FOUND TRUE )
endif ( )
endif ( )
unset ( _matlab_find_matlab_dataarray )
unset ( _matlab_lib_dir_for_search )
set ( Matlab_LIBRARIES ${ Matlab_MEX_LIBRARY } ${ Matlab_MX_LIBRARY } ${ Matlab_ENG_LIBRARY } ${ Matlab_MAT_LIBRARY } )
if ( Matlab_DATAARRAY_LIBRARY_FOUND )
set ( Matlab_LIBRARIES ${ Matlab_LIBRARIES } ${ Matlab_DATAARRAY_LIBRARY } )
endif ( )
if ( Matlab_ENGINE_LIBRARY_FOUND )
set ( Matlab_LIBRARIES ${ Matlab_LIBRARIES } ${ Matlab_ENGINE_LIBRARY } )
endif ( )
find_package_handle_standard_args (
M a t l a b
F O U N D _ V A R M a t l a b _ F O U N D
R E Q U I R E D _ V A R S $ { _ m a t l a b _ r e q u i r e d _ v a r i a b l e s }
V E R S I O N _ V A R M a t l a b _ V E R S I O N _ S T R I N G
H A N D L E _ C O M P O N E N T S )
unset ( _matlab_required_variables )
unset ( _matlab_bin_prefix )
unset ( _matlab_bin_suffix_32bits )
unset ( _matlab_bin_suffix_64bits )
unset ( _matlab_current_suffix )
unset ( _matlab_lib_dir_for_search )
unset ( _matlab_lib_prefix_for_search )
if ( Matlab_INCLUDE_DIRS AND Matlab_LIBRARIES )
mark_as_advanced (
M a t l a b _ M E X _ L I B R A R Y
M a t l a b _ M X _ L I B R A R Y
M a t l a b _ E N G _ L I B R A R Y
M a t l a b _ E N G I N E _ L I B R A R Y
M a t l a b _ D A T A A R R A Y _ L I B R A R Y
M a t l a b _ M A T _ L I B R A R Y
M a t l a b _ I N C L U D E _ D I R S
M a t l a b _ F O U N D
M a t l a b _ M A I N _ P R O G R A M
M a t l a b _ M E X E X T E N S I O N S _ P R O G
M a t l a b _ M E X _ E X T E N S I O N
)
endif ( )
