README.md is also added. These commands show a way to use it. $ git clone https://github.com/tensorflow/tensorflow.git tensorflow_src $ mkdir tflite_build && cd tflite_build $ cmake ../tensorflow_src/tensorflow/lite $ cmake --build . -j PiperOrigin-RevId: 327736060 Change-Id: I35acf01b0b33156db5537c146c35de7dc534bb7e
584 lines
20 KiB
CMake
584 lines
20 KiB
CMake
#
|
|
# Copyright 2020 The TensorFlow Authors. All Rights Reserved.
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License");
|
|
# you may not use this file except in compliance with the License.
|
|
# You may obtain a copy of the License at
|
|
#
|
|
# https://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
# See the License for the specific language governing permissions and
|
|
# limitations under the License.
|
|
|
|
include(FetchContent)
|
|
|
|
# Pairs of regex --> replacement strings that map Git repositories to archive
|
|
# URLs. GIT_COMMIT is replaced with the hash of the commit.
|
|
set(OVERRIDABLE_FETCH_CONTENT_GITHUB_MATCH
|
|
"^https?://github.com/([^/]+)/([^/.]+)(\\.git)?\$"
|
|
)
|
|
set(OVERRIDABLE_FETCH_CONTENT_GITHUB_REPLACE
|
|
"https://github.com/\\1/\\2/archive/GIT_COMMIT.zip"
|
|
)
|
|
set(OVERRIDABLE_FETCH_CONTENT_GITLAB_MATCH
|
|
"^https?://gitlab.com/([^/]+)/([^/.]+)(\\.git)?"
|
|
)
|
|
set(OVERRIDABLE_FETCH_CONTENT_GITLAB_REPLACE
|
|
"https://gitlab.com/\\1/\\2/-/archive/GIT_COMMIT/\\2-GIT_COMMIT.tar.gz"
|
|
)
|
|
set(OVERRIDABLE_FETCH_CONTENT_GOOGLESOURCE_MATCH
|
|
"^(https?://[^.]+\\.googlesource\\.com/.*)"
|
|
)
|
|
set(OVERRIDABLE_FETCH_CONTENT_GOOGLESOURCE_REPLACE
|
|
"\\1/+archive/GIT_COMMIT.tar.gz"
|
|
)
|
|
# List of prefixes for regex match and replacement variables that map Git
|
|
# repositories to archive URLs.
|
|
list(APPEND OVERRIDABLE_FETCH_CONTENT_GIT_TRANSFORMS
|
|
OVERRIDABLE_FETCH_CONTENT_GITHUB
|
|
OVERRIDABLE_FETCH_CONTENT_GITLAB
|
|
OVERRIDABLE_FETCH_CONTENT_GOOGLESOURCE
|
|
)
|
|
|
|
# Pairs of regex --> replacement strings that map Git repositories to raw file
|
|
# URLs.
|
|
set(OVERRIDABLE_FETCH_CONTENT_GITHUB_FILE_MATCH
|
|
"${OVERRIDABLE_FETCH_CONTENT_GITHUB_MATCH}"
|
|
)
|
|
set(OVERRIDABLE_FETCH_CONTENT_GITHUB_FILE_REPLACE
|
|
"https://raw.githubusercontent.com/\\1/\\2/GIT_COMMIT/FILE_PATH"
|
|
)
|
|
set(OVERRIDABLE_FETCH_CONTENT_GITLAB_FILE_MATCH
|
|
"${OVERRIDABLE_FETCH_CONTENT_GITLAB_MATCH}"
|
|
)
|
|
set(OVERRIDABLE_FETCH_CONTENT_GITLAB_FILE_REPLACE
|
|
"https://gitlab.com/\\1/\\2/-/raw/GIT_COMMIT/FILE_PATH"
|
|
)
|
|
set(OVERRIDABLE_FETCH_CONTENT_GOOGLESOURCE_FILE_MATCH
|
|
"${OVERRIDABLE_FETCH_CONTENT_GOOGLESOURCE_MATCH}"
|
|
)
|
|
# This isn't the raw file, gitiles doesn't support raw file download without
|
|
# decoding the file from base64.
|
|
set(OVERRIDABLE_FETCH_CONTENT_GOOGLESOURCE_FILE_REPLACE
|
|
"\\1/+/GIT_COMMIT/FILE_PATH"
|
|
)
|
|
|
|
# List of prefixes for regex match and replacement variables that map Git
|
|
# repositories to archive URLs.
|
|
list(APPEND OVERRIDABLE_FETCH_CONTENT_GIT_FILE_TRANSFORMS
|
|
OVERRIDABLE_FETCH_CONTENT_GITHUB_FILE
|
|
OVERRIDABLE_FETCH_CONTENT_GITLAB_FILE
|
|
OVERRIDABLE_FETCH_CONTENT_GOOGLESOURCE_FILE
|
|
)
|
|
|
|
# Try applying replacements to string.
|
|
#
|
|
# TRANSFORMS: List which contains prefixes for _MATCH / _REPLACE replacements
|
|
# to try. For example, given the list "FOO" this will try to apply a regex
|
|
# replacement with the value of FOO_MATCH and FOO_REPLACE.
|
|
# TO_REPLACE: String to apply replacements to.
|
|
# OUTPUT_VAR: Name of the variable to store the URL if successful. If
|
|
# conversion fails this variable will be empty.
|
|
function(_ApplyReplacements TRANSFORMS TO_REPLACE OUTPUT_VAR)
|
|
foreach(PREFIX ${TRANSFORMS})
|
|
message(VERBOSE "Try converting ${GIT_REPOSITORY} with ${${PREFIX}_MATCH}")
|
|
set(MATCH "${${PREFIX}_MATCH}")
|
|
set(REPLACE "${${PREFIX}_REPLACE}")
|
|
if(MATCH AND REPLACE)
|
|
string(REGEX REPLACE
|
|
"${MATCH}"
|
|
"${REPLACE}"
|
|
REPLACED
|
|
"${TO_REPLACE}"
|
|
)
|
|
if(NOT "${REPLACED}" STREQUAL "${TO_REPLACE}")
|
|
set(${OUTPUT_VAR} "${REPLACED}" PARENT_SCOPE)
|
|
endif()
|
|
endif()
|
|
endforeach()
|
|
endfunction()
|
|
|
|
|
|
# Try to convert a Git repository to an archive URL.
|
|
#
|
|
# GIT_REPOSITORY: Repository URL to convert.
|
|
# GIT_COMMIT: Commit hash or tag to convert.
|
|
# REPORT_WARNING: Whether to report a warning if conversion fails.
|
|
# OUTPUT_VAR: Name of the variable to store the URL if successful. If
|
|
# conversion fails this variable will be empty.
|
|
function(_GitRepoArchiveUrl GIT_REPOSITORY GIT_COMMIT REPORT_WARNING OUTPUT_VAR)
|
|
list(REMOVE_DUPLICATES OVERRIDABLE_FETCH_CONTENT_GIT_TRANSFORMS)
|
|
_ApplyReplacements(
|
|
"${OVERRIDABLE_FETCH_CONTENT_GIT_TRANSFORMS}"
|
|
"${GIT_REPOSITORY}"
|
|
REPLACED
|
|
)
|
|
if(REPLACED)
|
|
string(REPLACE "GIT_COMMIT" "${GIT_COMMIT}" WITH_COMMIT "${REPLACED}")
|
|
message(VERBOSE "${GIT_REPOSITORY} / ${GIT_COMMIT} --> ${WITH_COMMIT}")
|
|
set(${OUTPUT_VAR} "${WITH_COMMIT}" PARENT_SCOPE)
|
|
elseif(REPORT_WARNING)
|
|
message(WARNING
|
|
"Unable to map ${GIT_REPOSITORY} / ${GIT_COMMIT} to an archive URL"
|
|
)
|
|
endif()
|
|
endfunction()
|
|
|
|
|
|
# Try to convert a Git repository, commit and relative path to a link to the
|
|
# file.
|
|
#
|
|
# GIT_REPOSITORY: Repository URL to convert.
|
|
# GIT_COMMIT: Commit hash or tag to convert.
|
|
# FILE_PATH: Path to the file.
|
|
# OUTPUT_VAR: Name of the variable to store the URL if successful. If
|
|
# conversion fails this variable will be empty.
|
|
function(_GitRepoFileUrl GIT_REPOSITORY GIT_COMMIT FILE_PATH OUTPUT_VAR)
|
|
list(REMOVE_DUPLICATES OVERRIDABLE_FETCH_CONTENT_GIT_FILE_TRANSFORMS)
|
|
_ApplyReplacements(
|
|
"${OVERRIDABLE_FETCH_CONTENT_GIT_FILE_TRANSFORMS}"
|
|
"${GIT_REPOSITORY}"
|
|
REPLACED
|
|
)
|
|
if(REPLACED)
|
|
string(REPLACE "GIT_COMMIT" "${GIT_COMMIT}" WITH_COMMIT "${REPLACED}")
|
|
string(REPLACE "FILE_PATH" "${FILE_PATH}" WITH_FILE "${WITH_COMMIT}")
|
|
message(VERBOSE
|
|
"${GIT_REPOSITORY} / ${GIT_COMMIT} / ${FILE_PATH} --> ${WITH_FILE}"
|
|
)
|
|
set(${OUTPUT_VAR} "${WITH_FILE}" PARENT_SCOPE)
|
|
else()
|
|
message(WARNING
|
|
"Unable to map ${GIT_REPOSITORY} / ${GIT_COMMIT} / ${FILE_PATH} to a URL"
|
|
)
|
|
endif()
|
|
endfunction()
|
|
|
|
|
|
# Try to determine the license URL from a path within the content and
|
|
# cache LICENSE_FILE and LICENSE_URL properties.
|
|
#
|
|
# CONTENT_NAME: Name of the content that hosts the license.
|
|
# LICENSE_FILE: Relative path in the archive.
|
|
# OUTPUT_VAR: Name of variable to store / retrieve the license URL.
|
|
function(_LicenseFileToUrl CONTENT_NAME LICENSE_FILE OUTPUT_VAR)
|
|
foreach(PROPERTY GIT_REPOSITORY GIT_COMMIT LICENSE_URL)
|
|
_OverridableFetchContent_GetProperty(
|
|
"${CONTENT_NAME}"
|
|
"${PROPERTY}"
|
|
"${PROPERTY}"
|
|
)
|
|
endforeach()
|
|
_OverridableFetchContent_SetProperty(
|
|
"${CONTENT_NAME}"
|
|
LICENSE_FILE
|
|
"License for ${CONTENT_NAME}"
|
|
"${LICENSE_FILE}"
|
|
)
|
|
if(NOT LICENSE_URL)
|
|
if(GIT_REPOSITORY AND GIT_COMMIT)
|
|
# Try to synthesize the license URL from the repo path.
|
|
_GitRepoFileUrl(
|
|
"${GIT_REPOSITORY}"
|
|
"${GIT_COMMIT}"
|
|
"${LICENSE_FILE}"
|
|
LICENSE_URL
|
|
)
|
|
if(LICENSE_URL)
|
|
_OverridableFetchContent_SetProperty(
|
|
"${CONTENT_NAME}"
|
|
LICENSE_URL
|
|
"License URL for ${CONTENT_NAME}"
|
|
"${LICENSE_URL}"
|
|
)
|
|
set(${OUTPUT_VAR} "${LICENSE_URL}" PARENT_SCOPE)
|
|
endif()
|
|
endif()
|
|
endif()
|
|
endfunction()
|
|
|
|
|
|
# Replacement for FetchContent_Declare() that allows the user to override the
|
|
# download URL for Git and URL sources and also favor fetching via URL vs.
|
|
# a Git repo using variables external to this method.
|
|
#
|
|
# See FetchContent_Declare() and ExternalProject_Add() for the arguments
|
|
# supported by this method.
|
|
#
|
|
# In addition to FetchContent_Declare() and ExternalProject_Add() arguments,
|
|
# this method supports LICENSE_FILE that enables the caller to specify the
|
|
# relative path of the license in the downloaded archive which disables the
|
|
# search for a license in OverridableFetchContent_Populate().
|
|
# LICENSE_URL can be specified to override the URL of the LICENSE_FILE if
|
|
# a direct link to the URL can't be formed from the download path.
|
|
#
|
|
# It's possible to override, GIT_REPOSITORY, GIT_TAG, URL and URL_HASH for
|
|
# a target by setting
|
|
# OVERRIDABLE_FETCH_CONTENT_<contentName>_<variable> where <contentName> is the
|
|
# CONTENT_NAME argument content provided to this method and <variable> is the
|
|
# argument of this method to override. For example, given CONTENT_NAME = foo
|
|
# the GIT_REPOSITORY can be overridden by setting foo_GIT_REPOSITORY to the
|
|
# value to use instead.
|
|
#
|
|
# To convert a GIT_REPOSITORY / GIT_TAG reference to a URL,
|
|
# set OVERRIDABLE_FETCH_CONTENT_GIT_REPOSITORY_AND_TAG_TO_URL_<contentName>
|
|
# to ON for one repository or
|
|
# OVERRIDABLE_FETCH_CONTENT_GIT_REPOSITORY_AND_TAG_TO_URL to ON for all
|
|
# repositories. This will, where possible, convert a GIT_REPOSITORY / GIT_TAG
|
|
# reference to a URL to download instead which is much faster to copy than
|
|
# cloning a git repo.
|
|
#
|
|
# If OVERRIDABLE_FETCH_CONTENT_USE_GIT is ON, when a GIT_REPOSITORY and a
|
|
# download URL are specified this method will clone the GIT_REPOSITORY. When
|
|
# OVERRIDABLE_FETCH_CONTENT_USE_GIT is OFF or not set and both GIT_REPOSITORY
|
|
# and download URL are specified the download URL is used instead.
|
|
#
|
|
# To override the archive URL before it's passed to FetchContent_Declare()
|
|
# set OVERRIDABLE_FETCH_CONTENT_<contentName>_MATCH to a regular expression
|
|
# to match the archive URL and OVERRIDABLE_FETCH_CONTENT_<contentName>_REPLACE
|
|
# with the string to replace the archive URL.
|
|
#
|
|
# All content names passed to this method are added to the global property
|
|
# OVERRIDABLE_FETCH_CONTENT_LIST.
|
|
function(OverridableFetchContent_Declare CONTENT_NAME)
|
|
set(OVERRIDABLE_ARGS
|
|
GIT_REPOSITORY
|
|
GIT_TAG
|
|
URL
|
|
URL_HASH
|
|
URL_MD5
|
|
)
|
|
set(ALL_VALUE_ARGS LICENSE_FILE LICENSE_URL ${OVERRIDABLE_ARGS})
|
|
cmake_parse_arguments(ARGS
|
|
""
|
|
"${ALL_VALUE_ARGS}"
|
|
""
|
|
${ARGN}
|
|
)
|
|
# Optionally override parsed arguments with values from variables in the form
|
|
# ${CONTENT_NAME}_${OVERRIDABLE_ARG}.
|
|
foreach(OVERRIDABLE_ARG in ${OVERRIDABLE_ARGS})
|
|
set(OVERRIDE_VALUE
|
|
${OVERRIDABLE_FETCH_CONTENT_${CONTENT_NAME}_${OVERRIDABLE_ARG}}
|
|
)
|
|
if(NOT "${OVERRIDE_VALUE}" STREQUAL "")
|
|
set(ARGS_${OVERRIDABLE_ARG} "${OVERRIDE_VALUE}")
|
|
message(VERBOSE "Overriding ${OVERRIDABLE_ARG} of content "
|
|
"${CONTENT_NAME} with '${OVERRIDE_VALUE}'"
|
|
)
|
|
endif()
|
|
endforeach()
|
|
|
|
# If specified, save the source URL so it's possible to synthesize a link to
|
|
# the license when the content is populated.
|
|
if(ARGS_GIT_REPOSITORY AND ARGS_GIT_TAG)
|
|
_OverridableFetchContent_SetProperty(
|
|
"${CONTENT_NAME}"
|
|
GIT_REPOSITORY
|
|
"Git repo for ${CONTENT_NAME}"
|
|
"${ARGS_GIT_REPOSITORY}"
|
|
)
|
|
_OverridableFetchContent_SetProperty(
|
|
"${CONTENT_NAME}"
|
|
GIT_COMMIT
|
|
"Git commit for ${CONTENT_NAME}"
|
|
"${ARGS_GIT_TAG}"
|
|
)
|
|
endif()
|
|
|
|
# Set the license file and URL properties.
|
|
if(ARGS_LICENSE_URL)
|
|
_OverridableFetchContent_SetProperty(
|
|
"${CONTENT_NAME}"
|
|
LICENSE_URL
|
|
"License URL for ${CONTENT_NAME}"
|
|
"${ARGS_LICENSE_URL}"
|
|
)
|
|
endif()
|
|
if(ARGS_LICENSE_FILE)
|
|
_LicenseFileToUrl(
|
|
"${CONTENT_NAME}"
|
|
"${ARGS_LICENSE_FILE}"
|
|
ARGS_LICENSE_URL
|
|
)
|
|
endif()
|
|
|
|
# Try mapping to an archive URL.
|
|
set(ARCHIVE_URL "")
|
|
if(ARGS_GIT_REPOSITORY AND ARGS_GIT_TAG)
|
|
_GitRepoArchiveUrl(
|
|
"${ARGS_GIT_REPOSITORY}"
|
|
"${ARGS_GIT_TAG}"
|
|
OFF
|
|
ARCHIVE_URL
|
|
)
|
|
# If conversion from git repository to archive URL is enabled.
|
|
if(OVERRIDABLE_FETCH_CONTENT_GIT_REPOSITORY_AND_TAG_TO_URL_${CONTENT_NAME}
|
|
OR OVERRIDABLE_FETCH_CONTENT_GIT_REPOSITORY_AND_TAG_TO_URL)
|
|
# Try converting to an archive URL.
|
|
if(NOT ARGS_URL)
|
|
_GitRepoArchiveUrl(
|
|
"${ARGS_GIT_REPOSITORY}"
|
|
"${ARGS_GIT_TAG}"
|
|
ON
|
|
ARGS_URL
|
|
)
|
|
set(ARCHIVE_URL "${ARGS_URL}")
|
|
endif()
|
|
endif()
|
|
endif()
|
|
|
|
# If a download URL and git repository with tag are specified either use
|
|
# the git repo or the download URL.
|
|
if(ARGS_URL AND ARGS_GIT_REPOSITORY)
|
|
if(OVERRIDABLE_FETCH_CONTENT_USE_GIT)
|
|
unset(ARGS_URL)
|
|
unset(ARGS_URL_HASH)
|
|
unset(ARGS_URL_MD5)
|
|
else()
|
|
unset(ARGS_GIT_REPOSITORY)
|
|
unset(ARGS_GIT_TAG)
|
|
endif()
|
|
endif()
|
|
|
|
# Optionally map the archive URL to a mirror.
|
|
if(ARGS_URL)
|
|
_ApplyReplacements(
|
|
"OVERRIDABLE_FETCH_CONTENT_${CONTENT_NAME}"
|
|
"${ARGS_URL}"
|
|
REPLACED
|
|
)
|
|
if(REPLACED)
|
|
set(ARGS_URL "${REPLACED}")
|
|
endif()
|
|
endif()
|
|
|
|
# Save the archive URL.
|
|
if(ARGS_URL)
|
|
set(ARCHIVE_URL "${ARGS_URL}")
|
|
endif()
|
|
if(ARCHIVE_URL)
|
|
_OverridableFetchContent_SetProperty(
|
|
"${CONTENT_NAME}"
|
|
ARCHIVE_URL
|
|
"Archive URL for ${CONTENT_NAME}"
|
|
"${ARCHIVE_URL}"
|
|
)
|
|
endif()
|
|
|
|
# Build the list of arguments to pass to FetchContent_Declare() starting with
|
|
# the overridable arguments.
|
|
set(OUTPUT_ARGS "")
|
|
foreach(OVERRIDABLE_ARG ${OVERRIDABLE_ARGS})
|
|
set(OVERRIDABLE_ARG_VALUE "${ARGS_${OVERRIDABLE_ARG}}")
|
|
if(OVERRIDABLE_ARG_VALUE)
|
|
list(APPEND OUTPUT_ARGS ${OVERRIDABLE_ARG} "${OVERRIDABLE_ARG_VALUE}")
|
|
endif()
|
|
endforeach()
|
|
list(APPEND OUTPUT_ARGS ${ARGS_UNPARSED_ARGUMENTS})
|
|
|
|
# Add all defined packages to a global property.
|
|
get_property(OVERRIDABLE_FETCH_CONTENT_LIST GLOBAL PROPERTY
|
|
OVERRIDABLE_FETCH_CONTENT_LIST
|
|
)
|
|
set(DOCUMENTATION "List of all fetched content")
|
|
define_property(GLOBAL PROPERTY OVERRIDABLE_FETCH_CONTENT_LIST
|
|
BRIEF_DOCS "${DOCUMENTATION}"
|
|
FULL_DOCS "${DOCUMENTATION}"
|
|
)
|
|
list(APPEND OVERRIDABLE_FETCH_CONTENT_LIST "${CONTENT_NAME}")
|
|
set_property(GLOBAL PROPERTY OVERRIDABLE_FETCH_CONTENT_LIST
|
|
"${OVERRIDABLE_FETCH_CONTENT_LIST}"
|
|
)
|
|
|
|
message(VERBOSE "FetchContent_Declare(${CONTENT_NAME} ${OUTPUT_ARGS}")
|
|
FetchContent_Declare("${CONTENT_NAME}" ${OUTPUT_ARGS})
|
|
endfunction()
|
|
|
|
|
|
# Get a property name for this module.
|
|
# CONTENT_NAME: Name of the content associated with the FetchContent function.
|
|
# PROPERTY_NAME: Name of the property.
|
|
# OUTPUT_VAR: Variable to store the name in.
|
|
function(_OverridableFetchContent_GetPropertyName CONTENT_NAME PROPERTY_NAME
|
|
OUTPUT_VAR)
|
|
# The implementation of FetchContent_GetProperties() uses the lower case
|
|
# content name to prefix property names so follow the same pattern here.
|
|
string(TOLOWER "${CONTENT_NAME}" CONTENT_NAME_LOWER)
|
|
set(${OUTPUT_VAR}
|
|
"_OverridableFetchContent_${CONTENT_NAME_LOWER}_${PROPERTY_NAME}"
|
|
PARENT_SCOPE
|
|
)
|
|
endfunction()
|
|
|
|
|
|
# Set a global property for this module.
|
|
# CONTENT_NAME: Name of the content associated with the FetchContent function.
|
|
# PROPERTY_NAME: Name of the property to set.
|
|
# DOCUMENTATION: Documentation string for the property.
|
|
# PROPERTY_VALUE: Value to set the property to.
|
|
function(_OverridableFetchContent_SetProperty CONTENT_NAME PROPERTY_NAME
|
|
DOCUMENTATION PROPERTY_VALUE)
|
|
_OverridableFetchContent_GetPropertyName(
|
|
"${CONTENT_NAME}"
|
|
"${PROPERTY_NAME}"
|
|
GLOBAL_PROPERTY_NAME
|
|
)
|
|
define_property(GLOBAL PROPERTY "${GLOBAL_PROPERTY_NAME}"
|
|
BRIEF_DOCS "${DOCUMENTATION}"
|
|
FULL_DOCS "${DOCUMENTATION}"
|
|
)
|
|
set_property(GLOBAL PROPERTY "${GLOBAL_PROPERTY_NAME}" "${PROPERTY_VALUE}")
|
|
endfunction()
|
|
|
|
|
|
# Get a global property for this module.
|
|
# CONTENT_NAME: Name of the content associated with the FetchContent function.
|
|
# PROPERTY_NAME: Name of the property to get.
|
|
# OUTPUT_VAR: Variable to store the value in.
|
|
function(_OverridableFetchContent_GetProperty CONTENT_NAME PROPERTY_NAME
|
|
OUTPUT_VAR)
|
|
_OverridableFetchContent_GetPropertyName(
|
|
"${CONTENT_NAME}"
|
|
"${PROPERTY_NAME}"
|
|
GLOBAL_PROPERTY_NAME
|
|
)
|
|
get_property(VALUE GLOBAL PROPERTY "${GLOBAL_PROPERTY_NAME}")
|
|
if(VALUE)
|
|
set(${OUTPUT_VAR} "${VALUE}" PARENT_SCOPE)
|
|
endif()
|
|
endfunction()
|
|
|
|
|
|
# Export a list of variables to the parent scope of the caller function.
|
|
macro(_OverridableFetchContent_ExportToParentScope)
|
|
# Export requested variables to the parent scope.
|
|
foreach(VARIABLE_NAME ${ARGN})
|
|
if(${VARIABLE_NAME})
|
|
message(DEBUG "Export ${VARIABLE_NAME} ${${VARIABLE_NAME}}")
|
|
set(${VARIABLE_NAME} "${${VARIABLE_NAME}}" PARENT_SCOPE)
|
|
endif()
|
|
endforeach()
|
|
endmacro()
|
|
|
|
|
|
# Wrapper around FetchContent_GetProperties().
|
|
#
|
|
# Sets the same variables as FetchContent_GetProperties() in addition to:
|
|
# * <contentName>_LICENSE_FILE: License file relative to
|
|
# <contentName>_SOURCE_DIR if found.
|
|
# * <contentName>_LICENSE_URL: License URL if the file is found.
|
|
# * <contentName_ARCHIVE_URL: URL to the source package.
|
|
function(OverridableFetchContent_GetProperties CONTENT_NAME)
|
|
set(EXPORT_VARIABLE_ARGS SOURCE_DIR BINARY_DIR POPULATED)
|
|
cmake_parse_arguments(ARGS
|
|
""
|
|
"${EXPORT_VARIABLE_ARGS}"
|
|
""
|
|
${ARGN}
|
|
)
|
|
|
|
# The implementation of FetchContent_Populate() uses the lower case
|
|
# content name to prefix returned variable names.
|
|
string(TOLOWER "${CONTENT_NAME}" CONTENT_NAME_LOWER)
|
|
# Get the names of the variables to export to the parent scope.
|
|
set(EXPORT_VARIABLES "")
|
|
set(OUTPUT_ARGS "")
|
|
foreach(ARG_NAME ${EXPORT_VARIABLE_ARGS})
|
|
set(ARG_VARIABLE_NAME "ARGS_${ARG_NAME}")
|
|
set(ARG_VARIABLE_VALUE "${${ARG_VARIABLE_NAME}}")
|
|
list(APPEND EXPORT_VARIABLES "${CONTENT_NAME_LOWER}_${ARG_NAME}")
|
|
if(ARG_VARIABLE_VALUE)
|
|
list(APPEND EXPORT_VARIABLES "${ARG_VARIABLE_VALUE}")
|
|
list(APPEND OUTPUT_ARGS "${ARG_NAME}" "${ARG_VARIABLE_VALUE}")
|
|
endif()
|
|
endforeach()
|
|
list(APPEND OUTPUT_ARGS ${ARGS_UNPARSED_ARGUMENTS})
|
|
|
|
foreach(EXPORT_PROPERTY LICENSE_FILE LICENSE_URL ARCHIVE_URL)
|
|
_OverridableFetchContent_GetProperty("${CONTENT_NAME}"
|
|
"${EXPORT_PROPERTY}"
|
|
"${EXPORT_PROPERTY}"
|
|
)
|
|
set(PROPERTY_VALUE "${${EXPORT_PROPERTY}}")
|
|
if(PROPERTY_VALUE)
|
|
set(${CONTENT_NAME}_${EXPORT_PROPERTY} "${PROPERTY_VALUE}" PARENT_SCOPE)
|
|
endif()
|
|
endforeach()
|
|
FetchContent_GetProperties("${CONTENT_NAME}" ${OUTPUT_ARGS})
|
|
_OverridableFetchContent_ExportToParentScope(${EXPORT_VARIABLES})
|
|
endfunction()
|
|
|
|
|
|
# Replacement for FetchContent_Populate() that searches a newly cloned
|
|
# repository for a top level license file and provides it to the caller
|
|
# via the <contentName>_LICENSE_FILE and <contentName>_LICENSE_URL variables
|
|
# where <contentName> is the value passed as the CONTENT_NAME argument of this
|
|
# method.
|
|
#
|
|
# To ensure a fetched repo has a license file and URL
|
|
# OVERRIDABLE_FETCH_CONTENT_LICENSE_CHECK_<contentName> to ON for one
|
|
# repository or OVERRIDABLE_FETCH_CONTENT_LICENSE_CHECK to ON for all
|
|
# repositories.
|
|
function(OverridableFetchContent_Populate CONTENT_NAME)
|
|
# The implementation of FetchContent_Populate() uses the lower case
|
|
# content name to prefix returned variable names.
|
|
string(TOLOWER "${CONTENT_NAME}" CONTENT_NAME_LOWER)
|
|
|
|
FetchContent_Populate("${CONTENT_NAME}")
|
|
OverridableFetchContent_GetProperties("${CONTENT_NAME}")
|
|
|
|
# If a license file isn't cached try finding it in the repo.
|
|
set(LICENSE_FILE "${${CONTENT_NAME_LOWER}_LICENSE_FILE}")
|
|
set(LICENSE_URL "${${CONTENT_NAME_LOWER}_LICENSE_URL}")
|
|
if(${CONTENT_NAME}_POPULATED AND NOT LICENSE_FILE)
|
|
set(SOURCE_DIR "${${CONTENT_NAME_LOWER}_SOURCE_DIR}")
|
|
find_file(_${CONTENT_NAME_LOWER}_LICENSE_FILE
|
|
NAMES LICENSE LICENSE.md LICENSE.txt NOTICE COPYING
|
|
PATHS "${SOURCE_DIR}"
|
|
DOC "${CONTENT_NAME} license file"
|
|
NO_DEFAULT_PATH
|
|
NO_CMAKE_FIND_ROOT_PATH
|
|
)
|
|
set(LICENSE_FILE "${_${CONTENT_NAME_LOWER}_LICENSE_FILE}")
|
|
if(LICENSE_FILE)
|
|
file(RELATIVE_PATH LICENSE_FILE "${SOURCE_DIR}" "${LICENSE_FILE}")
|
|
file(TO_CMAKE_PATH "${LICENSE_FILE}" LICENSE_FILE)
|
|
endif()
|
|
endif()
|
|
# If a LICENSE_FILE was found populate the URL.
|
|
if(LICENSE_FILE AND NOT LICENSE_URL)
|
|
_LicenseFileToUrl(
|
|
"${CONTENT_NAME}"
|
|
"${LICENSE_FILE}"
|
|
LICENSE_URL
|
|
)
|
|
endif()
|
|
|
|
# If enabled, check for source licenses.
|
|
if(OVERRIDABLE_FETCH_CONTENT_LICENSE_CHECK OR
|
|
OVERRIDABLE_FETCH_CONTENT_LICENSE_CHECK_${CONTENT_NAME})
|
|
message(DEBUG "LICENSE_FILE: ${LICENSE_FILE}, LICENSE_URL: ${LICENSE_URL}")
|
|
if(NOT LICENSE_FILE)
|
|
message(FATAL_ERROR
|
|
"Required license file not found for ${CONTENT_NAME}"
|
|
)
|
|
endif()
|
|
if(NOT LICENSE_URL)
|
|
message(FATAL_ERROR
|
|
"Required license URL not found for ${CONTENT_NAME}"
|
|
)
|
|
endif()
|
|
endif()
|
|
|
|
# Export return values to the parent scope.
|
|
set(EXPORT_VARIABLES "")
|
|
foreach(VARIABLE_POSTFIX SOURCE_DIR BINARY_DIR POPULATED)
|
|
list(APPEND EXPORT_VARIABLES "${CONTENT_NAME_LOWER}_${VARIABLE_POSTFIX}")
|
|
endforeach()
|
|
_OverridableFetchContent_ExportToParentScope(${EXPORT_VARIABLES})
|
|
endfunction()
|