mirror of
https://github.com/Kitware/CMake.git
synced 2025-05-08 22:37:04 +08:00
1bdb0ee1b8
This deprecates the protobuf_generate_cpp() and protobuf_generate_python() commands because the protobuf_generate() can work for both of these cases and provides more options. Also, upstream Protobuf CMake-based build system has marked these two commands as legacy and requires setting a separate protobuf_MODULE_COMPATIBLE variable to boolean true before calling the find_package(Protobuf). Changes: - Reworded and synced module documentation with other similar find modules. - Imported targets moved to top. - Moved examples to a separate section. - Extended examples with basic usage and some quick hints how to upgrade deprecated commands to protobuf_generate(). - Used lowercase style of commands. - Used "commands" instead of "functions" or "macros". - Documented the DESCRIPTORS argument for protobuf_generate() command and added a note that this option is not available when Protobuf is found in config mode. - Added a note about the Protobuf CMake-based build system and that probuf_generate*() commands might come from the upstream CMake config files. Mentioned also the protobuf_MODULE_COMPATIBLE variable from upstream CMake build system. See #21228. This fixes this issue in favor of #24321 which tracks further progress about Protobuf. - Documented the missing `PROTOBUF_GENERATE_CPP_APPEND_PATH` variable. See #19968. Issue: #24321 Fixes: #21228 Fixes: #19968
1170 lines
37 KiB
CMake
1170 lines
37 KiB
CMake
# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
|
|
# file LICENSE.rst or https://cmake.org/licensing for details.
|
|
|
|
#[=======================================================================[.rst:
|
|
FindProtobuf
|
|
------------
|
|
|
|
.. note::
|
|
|
|
If the Protobuf library is built and installed using its CMake-based
|
|
build system, it provides a :ref:`package configuration file
|
|
<Config File Packages>` for use with the :command:`find_package` command
|
|
in *config mode*:
|
|
|
|
.. code-block:: cmake
|
|
|
|
find_package(Protobuf CONFIG)
|
|
|
|
In this case, imported targets and CMake commands such as
|
|
:command:`protobuf_generate` are provided by the upstream package rather
|
|
than this module. Additionally, some variables documented here are not
|
|
available in *config mode*, as imported targets are preferred. For usage
|
|
details, refer to the upstream documentation, which is the recommended
|
|
way to use Protobuf with CMake.
|
|
|
|
This module works only in *module mode*.
|
|
|
|
This module finds the Protocol Buffers library (Protobuf) in *module mode*:
|
|
|
|
.. code-block:: cmake
|
|
|
|
find_package(Protobuf [<version>] [...])
|
|
|
|
Protobuf is an open-source, language-neutral, and platform-neutral mechanism
|
|
for serializing structured data, developed by Google. It is commonly used
|
|
for data exchange between programs or across networks.
|
|
|
|
.. versionadded:: 3.6
|
|
Support for the ``<version>`` argument in
|
|
:command:`find_package(Protobuf \<version\>)`.
|
|
|
|
.. versionchanged:: 3.6
|
|
All input and output variables use the ``Protobuf_`` prefix. Variables
|
|
with ``PROTOBUF_`` prefix are supported for backward compatibility.
|
|
|
|
Imported Targets
|
|
^^^^^^^^^^^^^^^^
|
|
|
|
This module provides the following :ref:`Imported Targets`:
|
|
|
|
``protobuf::libprotobuf``
|
|
.. versionadded:: 3.9
|
|
|
|
Target encapsulating the Protobuf library usage requirements, available if
|
|
Protobuf library is found.
|
|
|
|
``protobuf::libprotobuf-lite``
|
|
.. versionadded:: 3.9
|
|
|
|
Target encapsulating the ``protobuf-lite`` library usage requirements,
|
|
available if Protobuf and its lite library are found.
|
|
|
|
``protobuf::libprotoc``
|
|
.. versionadded:: 3.9
|
|
|
|
Target encapsulating the ``protoc`` library usage requirements, available
|
|
if Protobuf and its ``protoc`` library are found.
|
|
|
|
``protobuf::protoc``
|
|
.. versionadded:: 3.10
|
|
|
|
Imported executable target encapsulating the ``protoc`` compiler usage
|
|
requirements, available if Protobuf and ``protoc`` are found.
|
|
|
|
Result Variables
|
|
^^^^^^^^^^^^^^^^
|
|
|
|
This module defines the following variables:
|
|
|
|
``Protobuf_FOUND``
|
|
Boolean indicating whether (the requested version of) Protobuf library is
|
|
found.
|
|
``Protobuf_VERSION``
|
|
.. versionadded:: 3.6
|
|
|
|
The version of Protobuf found.
|
|
``Protobuf_INCLUDE_DIRS``
|
|
Include directories needed to use Protobuf.
|
|
``Protobuf_LIBRARIES``
|
|
Libraries needed to link against to use Protobuf.
|
|
``Protobuf_PROTOC_LIBRARIES``
|
|
Libraries needed to link against to use the ``protoc`` library.
|
|
``Protobuf_LITE_LIBRARIES``
|
|
Libraries needed to link against to use the ``protobuf-lite`` library.
|
|
|
|
Cache Variables
|
|
^^^^^^^^^^^^^^^
|
|
|
|
The following cache variables may also be set:
|
|
|
|
``Protobuf_INCLUDE_DIR``
|
|
The include directory containing Protobuf headers.
|
|
``Protobuf_LIBRARY``
|
|
The path to the ``protobuf`` library.
|
|
``Protobuf_PROTOC_LIBRARY``
|
|
The path to the ``protoc`` library.
|
|
``Protobuf_PROTOC_EXECUTABLE``
|
|
The path to the ``protoc`` compiler.
|
|
``Protobuf_LIBRARY_DEBUG``
|
|
The path to the ``protobuf`` debug library.
|
|
``Protobuf_PROTOC_LIBRARY_DEBUG``
|
|
The path to the ``protoc`` debug library.
|
|
``Protobuf_LITE_LIBRARY``
|
|
The path to the ``protobuf-lite`` library.
|
|
``Protobuf_LITE_LIBRARY_DEBUG``
|
|
The path to the ``protobuf-lite`` debug library.
|
|
``Protobuf_SRC_ROOT_FOLDER``
|
|
When compiling with MSVC, if this cache variable is set, the
|
|
protobuf-default Visual Studio project build locations will be searched for
|
|
libraries and binaries:
|
|
|
|
* ``<Protobuf_SRC_ROOT_FOLDER>/vsprojects/{Debug,Release}``, or
|
|
* ``<Protobuf_SRC_ROOT_FOLDER>/vsprojects/x64/{Debug,Release}``
|
|
|
|
Hints
|
|
^^^^^
|
|
|
|
This module accepts the following optional variables before calling the
|
|
``find_package(Protobuf)``:
|
|
|
|
``Protobuf_DEBUG``
|
|
.. versionadded:: 3.6
|
|
|
|
Boolean variable that enables debug messages of this module to be printed
|
|
for debugging purposes.
|
|
|
|
``Protobuf_USE_STATIC_LIBS``
|
|
.. versionadded:: 3.9
|
|
|
|
Set to ON to force the use of the static libraries. Default is OFF.
|
|
|
|
Commands
|
|
^^^^^^^^
|
|
|
|
This module provides the following commands if Protobuf is found:
|
|
|
|
Generating Source Files
|
|
"""""""""""""""""""""""
|
|
|
|
.. command:: protobuf_generate
|
|
|
|
.. versionadded:: 3.13
|
|
|
|
Automatically generates source files from ``.proto`` schema files at build
|
|
time:
|
|
|
|
.. code-block:: cmake
|
|
|
|
protobuf_generate(
|
|
[TARGET <target>]
|
|
[LANGUAGE <lang>]
|
|
[OUT_VAR <variable>]
|
|
[EXPORT_MACRO <macro>]
|
|
[PROTOC_OUT_DIR <out-dir>]
|
|
[PLUGIN <plugin>]
|
|
[PLUGIN_OPTIONS <plugin-options>]
|
|
[DEPENDENCIES <dependencies>...]
|
|
[PROTOS <proto-files>...]
|
|
[IMPORT_DIRS <dirs>...]
|
|
[APPEND_PATH]
|
|
[GENERATE_EXTENSIONS <extensions>...]
|
|
[PROTOC_OPTIONS <options>...]
|
|
[PROTOC_EXE <executable>]
|
|
[DESCRIPTORS]
|
|
)
|
|
|
|
``TARGET <target>``
|
|
The CMake target to which the generated files are added as sources. This
|
|
option is required when ``OUT_VAR <variable>`` is not used.
|
|
|
|
``LANGUAGE <lang>``
|
|
A single value: ``cpp`` or ``python``. Determines the kind of source
|
|
files to generate. Defaults to ``cpp``. For other languages, use the
|
|
``GENERATE_EXTENSIONS`` option.
|
|
|
|
``OUT_VAR <variable>``
|
|
The name of a CMake variable that will be populated with the paths to
|
|
the generated source files.
|
|
|
|
``EXPORT_MACRO <macro>``
|
|
The name of a preprocessor macro applied to all generated Protobuf message
|
|
classes and extern variables. This can be used, for example, to declare
|
|
DLL exports. The macro should expand to ``__declspec(dllexport)`` or
|
|
``__declspec(dllimport)``, depending on what is being compiled.
|
|
|
|
This option is only used when ``LANGUAGE`` is ``cpp``.
|
|
|
|
``PROTOC_OUT_DIR <out-dir>``
|
|
The output directory for generated source files. Defaults to:
|
|
:variable:`CMAKE_CURRENT_BINARY_DIR`.
|
|
|
|
``PLUGIN <plugin>``
|
|
.. versionadded:: 3.21
|
|
|
|
An optional plugin executable. This could be, for example, the path to
|
|
``grpc_cpp_plugin``.
|
|
|
|
``PLUGIN_OPTIONS <plugin-options>``
|
|
.. versionadded:: 3.28
|
|
|
|
Additional options passed to the plugin, such as ``generate_mock_code=true``
|
|
for the gRPC C++ plugin.
|
|
|
|
``DEPENDENCIES <dependencies>...``
|
|
.. versionadded:: 3.28
|
|
|
|
Dependencies on which the generation of files depends on. These are
|
|
forwarded to the underlying :command:`add_custom_command(DEPENDS)`
|
|
invocation.
|
|
|
|
.. versionchanged:: 4.1
|
|
This argument now accepts multiple values (``DEPENDENCIES a b c...``).
|
|
Previously, only a single value could be specified
|
|
(``DEPENDENCIES "a;b;c;..."``).
|
|
|
|
``PROTOS <proto-files>...``
|
|
A list of ``.proto`` schema files to process. If ``<target>`` is also
|
|
specified, these will be combined with all ``.proto`` source files from
|
|
that target.
|
|
|
|
``IMPORT_DIRS <dirs>...``
|
|
A list of one or more common parent directories for the schema files.
|
|
For example, if the schema file is ``proto/helloworld/helloworld.proto``
|
|
and the import directory is ``proto/``, then the generated files will be
|
|
``<out-dir>/helloworld/helloworld.pb.h`` and
|
|
``<out-dir>/helloworld/helloworld.pb.cc``.
|
|
|
|
``APPEND_PATH``
|
|
If specified, the base paths of all proto schema files are appended to
|
|
``IMPORT_DIRS`` (it causes ``protoc`` to be invoked with ``-I`` argument
|
|
for each directory containing a ``.proto`` file).
|
|
|
|
``GENERATE_EXTENSIONS <extensions>...``
|
|
If ``LANGUAGE`` is omitted, this must be set to specify the extensions
|
|
generated by ``protoc``.
|
|
|
|
``PROTOC_OPTIONS <options>...``
|
|
.. versionadded:: 3.28
|
|
|
|
A list of additional command-line options passed directly to the
|
|
``protoc`` compiler.
|
|
|
|
``PROTOC_EXE <executable>``
|
|
.. versionadded:: 4.0
|
|
|
|
The command-line program, path, or CMake executable used to generate
|
|
Protobuf bindings. If omitted, ``protobuf::protoc`` imported target is
|
|
used by default.
|
|
|
|
``DESCRIPTORS``
|
|
If specified, a command-line option ``--descriptor_set_out=<proto-file>``
|
|
is appended to ``protoc`` compiler for each ``.proto`` source file,
|
|
enabling the creation of self-describing messages. This option can only
|
|
be used when ``<lang>`` is ``cpp`` and Protobuf is found in *module mode*.
|
|
|
|
.. note::
|
|
|
|
This option is not available when Protobuf is found in *config mode*.
|
|
|
|
Deprecated Commands
|
|
"""""""""""""""""""
|
|
|
|
The following commands are provided for backward compatibility.
|
|
|
|
.. note::
|
|
|
|
The ``protobuf_generate_cpp()`` and ``protobuf_generate_python()``
|
|
commands work correctly only within the same directory scope, where
|
|
``find_package(Protobuf ...)`` is called.
|
|
|
|
.. note::
|
|
|
|
If Protobuf is found in *config mode*, the ``protobuf_generate_cpp()`` and
|
|
``protobuf_generate_python()`` commands are **not available** as of
|
|
Protobuf version 3.0.0, unless the upstream package configuration hint
|
|
variable ``protobuf_MODULE_COMPATIBLE`` is set to boolean true before
|
|
calling ``find_package(Protobuf ...)``.
|
|
|
|
.. command:: protobuf_generate_cpp
|
|
|
|
.. deprecated:: 4.1
|
|
Use :command:`protobuf_generate`.
|
|
|
|
Automatically generates C++ source files from ``.proto`` schema files at
|
|
build time:
|
|
|
|
.. code-block:: cmake
|
|
|
|
protobuf_generate_cpp(
|
|
<sources-variable>
|
|
<headers-variable>
|
|
[DESCRIPTORS <variable>]
|
|
[EXPORT_MACRO <macro>]
|
|
<proto-files>...
|
|
)
|
|
|
|
``<sources-variable>``
|
|
Name of the variable to define, which will contain a list of generated
|
|
C++ source files.
|
|
|
|
``<headers-variable>``
|
|
Name of the variable to define, which will contain a list of generated
|
|
header files.
|
|
|
|
``DESCRIPTORS <variable>``
|
|
.. versionadded:: 3.10
|
|
|
|
Name of the variable to define, which will contain a list of generated
|
|
descriptor files if requested.
|
|
|
|
.. note::
|
|
This option is not available when Protobuf is found in *config mode*.
|
|
|
|
``EXPORT_MACRO <macro>``
|
|
Name of a macro that should expand to ``__declspec(dllexport)`` or
|
|
``__declspec(dllimport)``, depending on what is being compiled.
|
|
|
|
``<proto-files>...``
|
|
One of more ``.proto`` files to be processed.
|
|
|
|
.. command:: protobuf_generate_python
|
|
|
|
.. deprecated:: 4.1
|
|
Use :command:`protobuf_generate`.
|
|
|
|
.. versionadded:: 3.4
|
|
|
|
Automatically generates Python source files from ``.proto`` schema files at
|
|
build time:
|
|
|
|
.. code-block:: cmake
|
|
|
|
protobuf_generate_python(<python-sources-variable> <proto-files>...)
|
|
|
|
``<python-sources-variable>``
|
|
Name of the variable to define, which will contain a list of generated
|
|
Python source files.
|
|
|
|
``<proto-files>...``
|
|
One or more ``.proto`` files to be processed.
|
|
|
|
---------------------------------------------------------------------
|
|
|
|
The ``protobuf_generate_cpp()`` and ``protobuf_generate_python()`` commands
|
|
accept the following optional variables before being invoked:
|
|
|
|
``Protobuf_IMPORT_DIRS``
|
|
.. deprecated:: 4.1
|
|
|
|
A list of additional directories to search for imported ``.proto`` files.
|
|
|
|
``PROTOBUF_GENERATE_CPP_APPEND_PATH``
|
|
.. deprecated:: 4.1
|
|
Use :command:`protobuf_generate(APPEND_PATH)` command option.
|
|
|
|
A boolean variable that, if set to boolean true, causes ``protoc`` to be
|
|
invoked with ``-I`` argument for each directory containing a ``.proto``
|
|
file. By default, it is set to boolean true.
|
|
|
|
Examples
|
|
^^^^^^^^
|
|
|
|
Examples: Finding Protobuf
|
|
""""""""""""""""""""""""""
|
|
|
|
Finding Protobuf library:
|
|
|
|
.. code-block:: cmake
|
|
|
|
find_package(Protobuf)
|
|
|
|
Or, finding Protobuf and specifying a minimum required version:
|
|
|
|
.. code-block:: cmake
|
|
|
|
find_package(Protobuf 30)
|
|
|
|
Or, finding Protobuf and making it required (if not found, processing stops
|
|
with an error message):
|
|
|
|
.. code-block:: cmake
|
|
|
|
find_package(Protobuf REQUIRED)
|
|
|
|
Example: Finding Protobuf in Config Mode
|
|
""""""""""""""""""""""""""""""""""""""""
|
|
|
|
When Protobuf library is built and installed using its CMake-based build
|
|
system, it can be found in *config mode*:
|
|
|
|
.. code-block:: cmake
|
|
|
|
find_package(Protobuf CONFIG)
|
|
|
|
However, some Protobuf installations might still not provide package
|
|
configuration file. The following example shows, how to use the
|
|
:variable:`CMAKE_FIND_PACKAGE_PREFER_CONFIG` variable to find Protobuf in
|
|
*config mode* and falling back to *module mode* if config file is not found:
|
|
|
|
.. code-block:: cmake
|
|
|
|
set(CMAKE_FIND_PACKAGE_PREFER_CONFIG TRUE)
|
|
find_package(Protobuf)
|
|
unset(CMAKE_FIND_PACKAGE_PREFER_CONFIG)
|
|
|
|
Example: Using Protobuf
|
|
"""""""""""""""""""""""
|
|
|
|
Finding Protobuf and linking its imported library target to a project target:
|
|
|
|
.. code-block:: cmake
|
|
|
|
find_package(Protobuf)
|
|
target_link_libraries(example PRIVATE protobuf::libprotobuf)
|
|
|
|
Example: Processing Proto Schema Files
|
|
""""""""""""""""""""""""""""""""""""""
|
|
|
|
The following example demonstrates how to process all ``*.proto`` schema
|
|
source files added to a target into C++ source files:
|
|
|
|
.. code-block:: cmake
|
|
:caption: ``CMakeLists.txt``
|
|
|
|
cmake_minimum_required(VERSION 3.24)
|
|
project(ProtobufExample)
|
|
|
|
add_executable(example main.cxx person.proto)
|
|
|
|
find_package(Protobuf)
|
|
|
|
if(Protobuf_FOUND)
|
|
protobuf_generate(TARGET example)
|
|
endif()
|
|
|
|
target_link_libraries(example PRIVATE protobuf::libprotobuf)
|
|
target_include_directories(example PRIVATE ${CMAKE_CURRENT_BINARY_DIR})
|
|
|
|
.. code-block:: proto
|
|
:caption: ``person.proto``
|
|
|
|
syntax = "proto3";
|
|
|
|
message Person {
|
|
string name = 1;
|
|
int32 id = 2;
|
|
}
|
|
|
|
.. code-block:: c++
|
|
:caption: ``main.cxx``
|
|
|
|
#include <iostream>
|
|
#include "person.pb.h"
|
|
|
|
int main()
|
|
{
|
|
Person person;
|
|
person.set_name("Alice");
|
|
person.set_id(123);
|
|
|
|
std::cout << "Name: " << person.name() << "\n";
|
|
std::cout << "ID: " << person.id() << "\n";
|
|
|
|
return 0;
|
|
}
|
|
|
|
Example: Using Protobuf and gRPC
|
|
""""""""""""""""""""""""""""""""
|
|
|
|
The following example shows how to use Protobuf and gRPC:
|
|
|
|
.. code-block:: cmake
|
|
:caption: ``CMakeLists.txt``
|
|
|
|
find_package(Protobuf REQUIRED)
|
|
find_package(gRPC CONFIG REQUIRED)
|
|
|
|
add_library(ProtoExample Example.proto)
|
|
target_link_libraries(ProtoExample PUBLIC gRPC::grpc++)
|
|
|
|
protobuf_generate(TARGET ProtoExample)
|
|
protobuf_generate(
|
|
TARGET ProtoExample
|
|
LANGUAGE grpc
|
|
PLUGIN protoc-gen-grpc=$<TARGET_FILE:gRPC::grpc_cpp_plugin>
|
|
PLUGIN_OPTIONS generate_mock_code=true
|
|
GENERATE_EXTENSIONS .grpc.pb.h .grpc.pb.cc
|
|
)
|
|
|
|
Examples: Upgrading Deprecated Commands
|
|
"""""""""""""""""""""""""""""""""""""""
|
|
|
|
The following example shows how to process ``.proto`` files to C++ code,
|
|
using a deprecated command and its modern replacement:
|
|
|
|
.. code-block:: cmake
|
|
:caption: ``CMakeLists.txt`` with deprecated command
|
|
|
|
find_package(Protobuf)
|
|
|
|
if(Protobuf_FOUND)
|
|
protobuf_generate_cpp(
|
|
proto_sources
|
|
proto_headers
|
|
EXPORT_MACRO DLL_EXPORT
|
|
DESCRIPTORS proto_descriptors
|
|
src/protocol/Proto1.proto
|
|
src/protocol/Proto2.proto
|
|
)
|
|
endif()
|
|
|
|
target_sources(
|
|
example
|
|
PRIVATE ${proto_sources} ${proto_headers} ${proto_descriptors}
|
|
)
|
|
target_link_libraries(example PRIVATE protobuf::libprotobuf)
|
|
|
|
.. code-block:: cmake
|
|
:caption: ``CMakeLists.txt`` with upgraded code
|
|
|
|
find_package(Protobuf)
|
|
|
|
if(Protobuf_FOUND)
|
|
protobuf_generate(
|
|
TARGET example
|
|
EXPORT_MACRO DLL_EXPORT
|
|
IMPORT_DIRS src/protocol
|
|
DESCRIPTORS
|
|
PROTOS
|
|
src/protocol/Proto1.proto
|
|
src/protocol/Proto2.proto
|
|
)
|
|
endif()
|
|
|
|
target_link_libraries(example PRIVATE protobuf::libprotobuf)
|
|
|
|
The following example shows how to process ``.proto`` files to Python code,
|
|
using a deprecated command and its modern replacement:
|
|
|
|
.. code-block:: cmake
|
|
:caption: ``CMakeLists.txt`` with deprecated command
|
|
|
|
find_package(Protobuf)
|
|
|
|
if(Protobuf_FOUND)
|
|
protobuf_generate_python(python_sources foo.proto)
|
|
endif()
|
|
|
|
add_custom_target(proto_files DEPENDS ${python_sources})
|
|
|
|
.. code-block:: cmake
|
|
:caption: ``CMakeLists.txt`` with upgraded code
|
|
|
|
find_package(Protobuf)
|
|
|
|
if(Protobuf_FOUND)
|
|
protobuf_generate(
|
|
LANGUAGE python
|
|
PROTOS foo.proto
|
|
OUT_VAR python_sources
|
|
)
|
|
endif()
|
|
|
|
add_custom_target(proto_files DEPENDS ${python_sources})
|
|
#]=======================================================================]
|
|
|
|
cmake_policy(PUSH)
|
|
cmake_policy(SET CMP0159 NEW) # file(STRINGS) with REGEX updates CMAKE_MATCH_<n>
|
|
|
|
function(protobuf_generate)
|
|
set(_options APPEND_PATH DESCRIPTORS)
|
|
set(_singleargs LANGUAGE OUT_VAR EXPORT_MACRO PROTOC_OUT_DIR PLUGIN PLUGIN_OPTIONS PROTOC_EXE)
|
|
if(COMMAND target_sources)
|
|
list(APPEND _singleargs TARGET)
|
|
endif()
|
|
set(_multiargs PROTOS IMPORT_DIRS GENERATE_EXTENSIONS PROTOC_OPTIONS DEPENDENCIES)
|
|
|
|
cmake_parse_arguments(protobuf_generate "${_options}" "${_singleargs}" "${_multiargs}" "${ARGN}")
|
|
|
|
if(NOT protobuf_generate_PROTOS AND NOT protobuf_generate_TARGET)
|
|
message(SEND_ERROR "Error: protobuf_generate called without any targets or source files")
|
|
return()
|
|
endif()
|
|
|
|
if(NOT protobuf_generate_OUT_VAR AND NOT protobuf_generate_TARGET)
|
|
message(SEND_ERROR "Error: protobuf_generate called without a target or output variable")
|
|
return()
|
|
endif()
|
|
|
|
if(NOT protobuf_generate_LANGUAGE)
|
|
set(protobuf_generate_LANGUAGE cpp)
|
|
endif()
|
|
string(TOLOWER ${protobuf_generate_LANGUAGE} protobuf_generate_LANGUAGE)
|
|
|
|
if(NOT protobuf_generate_PROTOC_OUT_DIR)
|
|
set(protobuf_generate_PROTOC_OUT_DIR ${CMAKE_CURRENT_BINARY_DIR})
|
|
endif()
|
|
|
|
if(protobuf_generate_EXPORT_MACRO AND protobuf_generate_LANGUAGE STREQUAL cpp)
|
|
set(_dll_export_decl "dllexport_decl=${protobuf_generate_EXPORT_MACRO}")
|
|
endif()
|
|
|
|
foreach(_option ${_dll_export_decl} ${protobuf_generate_PLUGIN_OPTIONS})
|
|
# append comma - not using CMake lists and string replacement as users
|
|
# might have semicolons in options
|
|
if(_plugin_options)
|
|
set( _plugin_options "${_plugin_options},")
|
|
endif()
|
|
set(_plugin_options "${_plugin_options}${_option}")
|
|
endforeach()
|
|
|
|
if(protobuf_generate_PLUGIN)
|
|
set(_plugin "--plugin=${protobuf_generate_PLUGIN}")
|
|
endif()
|
|
|
|
if(NOT protobuf_generate_GENERATE_EXTENSIONS)
|
|
if(protobuf_generate_LANGUAGE STREQUAL cpp)
|
|
set(protobuf_generate_GENERATE_EXTENSIONS .pb.h .pb.cc)
|
|
elseif(protobuf_generate_LANGUAGE STREQUAL python)
|
|
set(protobuf_generate_GENERATE_EXTENSIONS _pb2.py)
|
|
else()
|
|
message(SEND_ERROR "Error: protobuf_generate given unknown Language ${LANGUAGE}, please provide a value for GENERATE_EXTENSIONS")
|
|
return()
|
|
endif()
|
|
endif()
|
|
|
|
if(protobuf_generate_TARGET)
|
|
get_target_property(_source_list ${protobuf_generate_TARGET} SOURCES)
|
|
foreach(_file ${_source_list})
|
|
if(_file MATCHES "proto$")
|
|
list(APPEND protobuf_generate_PROTOS ${_file})
|
|
endif()
|
|
endforeach()
|
|
endif()
|
|
|
|
if(NOT protobuf_generate_PROTOS)
|
|
message(SEND_ERROR "Error: protobuf_generate could not find any .proto files")
|
|
return()
|
|
endif()
|
|
|
|
if(NOT protobuf_generate_PROTOC_EXE)
|
|
if(NOT TARGET protobuf::protoc)
|
|
message(SEND_ERROR "protoc executable not found. "
|
|
"Please define the Protobuf_PROTOC_EXECUTABLE variable, or pass PROTOC_EXE to protobuf_generate, or ensure that protoc is in CMake's search path.")
|
|
return()
|
|
endif()
|
|
# Default to using the CMake executable
|
|
set(protobuf_generate_PROTOC_EXE protobuf::protoc)
|
|
endif()
|
|
|
|
if(protobuf_generate_APPEND_PATH)
|
|
# Create an include path for each file specified
|
|
foreach(_file ${protobuf_generate_PROTOS})
|
|
get_filename_component(_abs_file ${_file} ABSOLUTE)
|
|
get_filename_component(_abs_dir ${_abs_file} DIRECTORY)
|
|
list(FIND _protobuf_include_path ${_abs_dir} _contains_already)
|
|
if(${_contains_already} EQUAL -1)
|
|
list(APPEND _protobuf_include_path -I ${_abs_dir})
|
|
endif()
|
|
endforeach()
|
|
endif()
|
|
|
|
foreach(DIR ${protobuf_generate_IMPORT_DIRS})
|
|
get_filename_component(ABS_PATH ${DIR} ABSOLUTE)
|
|
list(FIND _protobuf_include_path ${ABS_PATH} _contains_already)
|
|
if(${_contains_already} EQUAL -1)
|
|
list(APPEND _protobuf_include_path -I ${ABS_PATH})
|
|
endif()
|
|
endforeach()
|
|
|
|
if(NOT protobuf_generate_APPEND_PATH)
|
|
list(APPEND _protobuf_include_path -I ${CMAKE_CURRENT_SOURCE_DIR})
|
|
endif()
|
|
|
|
set(_generated_srcs_all)
|
|
foreach(_proto ${protobuf_generate_PROTOS})
|
|
get_filename_component(_abs_file ${_proto} ABSOLUTE)
|
|
get_filename_component(_abs_dir ${_abs_file} DIRECTORY)
|
|
get_filename_component(_basename ${_proto} NAME_WLE)
|
|
file(RELATIVE_PATH _rel_dir ${CMAKE_CURRENT_SOURCE_DIR} ${_abs_dir})
|
|
|
|
set(_possible_rel_dir)
|
|
if (NOT protobuf_generate_APPEND_PATH)
|
|
foreach(DIR ${_protobuf_include_path})
|
|
if(NOT DIR STREQUAL "-I")
|
|
file(RELATIVE_PATH _rel_dir ${DIR} ${_abs_dir})
|
|
if(_rel_dir STREQUAL _abs_dir)
|
|
continue()
|
|
endif()
|
|
string(FIND "${_rel_dir}" "../" _is_in_parent_folder)
|
|
if (NOT ${_is_in_parent_folder} EQUAL 0)
|
|
break()
|
|
endif()
|
|
endif()
|
|
endforeach()
|
|
set(_possible_rel_dir ${_rel_dir}/)
|
|
endif()
|
|
|
|
set(_generated_srcs)
|
|
foreach(_ext ${protobuf_generate_GENERATE_EXTENSIONS})
|
|
list(APPEND _generated_srcs "${protobuf_generate_PROTOC_OUT_DIR}/${_possible_rel_dir}${_basename}${_ext}")
|
|
endforeach()
|
|
|
|
if(protobuf_generate_DESCRIPTORS AND protobuf_generate_LANGUAGE STREQUAL cpp)
|
|
set(_descriptor_file "${CMAKE_CURRENT_BINARY_DIR}/${_basename}.desc")
|
|
set(_dll_desc_out "--descriptor_set_out=${_descriptor_file}")
|
|
list(APPEND _generated_srcs ${_descriptor_file})
|
|
endif()
|
|
list(APPEND _generated_srcs_all ${_generated_srcs})
|
|
|
|
set(_comment "Running ${protobuf_generate_LANGUAGE} protocol buffer compiler on ${_proto}")
|
|
if(protobuf_generate_PROTOC_OPTIONS)
|
|
set(_comment "${_comment}, protoc-options: ${protobuf_generate_PROTOC_OPTIONS}")
|
|
endif()
|
|
if(_plugin_options)
|
|
set(_comment "${_comment}, plugin-options: ${_plugin_options}")
|
|
endif()
|
|
|
|
add_custom_command(
|
|
OUTPUT ${_generated_srcs}
|
|
COMMAND ${protobuf_generate_PROTOC_EXE}
|
|
ARGS ${protobuf_generate_PROTOC_OPTIONS} --${protobuf_generate_LANGUAGE}_out ${_plugin_options}:${protobuf_generate_PROTOC_OUT_DIR} ${_plugin} ${_dll_desc_out} ${_protobuf_include_path} ${_abs_file}
|
|
DEPENDS ${_abs_file} protobuf::protoc ${protobuf_generate_DEPENDENCIES}
|
|
COMMENT ${_comment}
|
|
VERBATIM )
|
|
endforeach()
|
|
|
|
set_source_files_properties(${_generated_srcs_all} PROPERTIES GENERATED TRUE)
|
|
if(protobuf_generate_OUT_VAR)
|
|
set(${protobuf_generate_OUT_VAR} ${_generated_srcs_all} PARENT_SCOPE)
|
|
endif()
|
|
if(protobuf_generate_TARGET)
|
|
target_sources(${protobuf_generate_TARGET} PRIVATE ${_generated_srcs_all})
|
|
endif()
|
|
endfunction()
|
|
|
|
function(PROTOBUF_GENERATE_CPP SRCS HDRS)
|
|
cmake_parse_arguments(protobuf_generate_cpp "" "EXPORT_MACRO;DESCRIPTORS" "" ${ARGN})
|
|
|
|
set(_proto_files "${protobuf_generate_cpp_UNPARSED_ARGUMENTS}")
|
|
if(NOT _proto_files)
|
|
message(SEND_ERROR "Error: PROTOBUF_GENERATE_CPP() called without any proto files")
|
|
return()
|
|
endif()
|
|
|
|
if(PROTOBUF_GENERATE_CPP_APPEND_PATH)
|
|
set(_append_arg APPEND_PATH)
|
|
endif()
|
|
|
|
if(protobuf_generate_cpp_DESCRIPTORS)
|
|
set(_descriptors DESCRIPTORS)
|
|
endif()
|
|
|
|
if(DEFINED PROTOBUF_IMPORT_DIRS AND NOT DEFINED Protobuf_IMPORT_DIRS)
|
|
set(Protobuf_IMPORT_DIRS "${PROTOBUF_IMPORT_DIRS}")
|
|
endif()
|
|
|
|
if(DEFINED Protobuf_IMPORT_DIRS)
|
|
set(_import_arg IMPORT_DIRS ${Protobuf_IMPORT_DIRS})
|
|
endif()
|
|
|
|
set(_outvar)
|
|
protobuf_generate(${_append_arg} ${_descriptors} LANGUAGE cpp EXPORT_MACRO ${protobuf_generate_cpp_EXPORT_MACRO} OUT_VAR _outvar ${_import_arg} PROTOS ${_proto_files})
|
|
|
|
set(${SRCS})
|
|
set(${HDRS})
|
|
if(protobuf_generate_cpp_DESCRIPTORS)
|
|
set(${protobuf_generate_cpp_DESCRIPTORS})
|
|
endif()
|
|
|
|
foreach(_file ${_outvar})
|
|
if(_file MATCHES "cc$")
|
|
list(APPEND ${SRCS} ${_file})
|
|
elseif(_file MATCHES "desc$")
|
|
list(APPEND ${protobuf_generate_cpp_DESCRIPTORS} ${_file})
|
|
else()
|
|
list(APPEND ${HDRS} ${_file})
|
|
endif()
|
|
endforeach()
|
|
set(${SRCS} ${${SRCS}} PARENT_SCOPE)
|
|
set(${HDRS} ${${HDRS}} PARENT_SCOPE)
|
|
if(protobuf_generate_cpp_DESCRIPTORS)
|
|
set(${protobuf_generate_cpp_DESCRIPTORS} "${${protobuf_generate_cpp_DESCRIPTORS}}" PARENT_SCOPE)
|
|
endif()
|
|
endfunction()
|
|
|
|
function(PROTOBUF_GENERATE_PYTHON SRCS)
|
|
if(NOT ARGN)
|
|
message(SEND_ERROR "Error: PROTOBUF_GENERATE_PYTHON() called without any proto files")
|
|
return()
|
|
endif()
|
|
|
|
if(PROTOBUF_GENERATE_CPP_APPEND_PATH)
|
|
set(_append_arg APPEND_PATH)
|
|
endif()
|
|
|
|
if(DEFINED PROTOBUF_IMPORT_DIRS AND NOT DEFINED Protobuf_IMPORT_DIRS)
|
|
set(Protobuf_IMPORT_DIRS "${PROTOBUF_IMPORT_DIRS}")
|
|
endif()
|
|
|
|
if(DEFINED Protobuf_IMPORT_DIRS)
|
|
set(_import_arg IMPORT_DIRS ${Protobuf_IMPORT_DIRS})
|
|
endif()
|
|
|
|
set(_outvar)
|
|
protobuf_generate(${_append_arg} LANGUAGE python OUT_VAR _outvar ${_import_arg} PROTOS ${ARGN})
|
|
set(${SRCS} ${_outvar} PARENT_SCOPE)
|
|
endfunction()
|
|
|
|
|
|
if(Protobuf_DEBUG)
|
|
# Output some of their choices
|
|
message(STATUS "[ ${CMAKE_CURRENT_LIST_FILE}:${CMAKE_CURRENT_LIST_LINE} ] "
|
|
"Protobuf_USE_STATIC_LIBS = ${Protobuf_USE_STATIC_LIBS}")
|
|
endif()
|
|
|
|
|
|
# Backwards compatibility
|
|
# Define camel case versions of input variables
|
|
foreach(UPPER
|
|
PROTOBUF_SRC_ROOT_FOLDER
|
|
PROTOBUF_IMPORT_DIRS
|
|
PROTOBUF_DEBUG
|
|
PROTOBUF_LIBRARY
|
|
PROTOBUF_PROTOC_LIBRARY
|
|
PROTOBUF_INCLUDE_DIR
|
|
PROTOBUF_PROTOC_EXECUTABLE
|
|
PROTOBUF_LIBRARY_DEBUG
|
|
PROTOBUF_PROTOC_LIBRARY_DEBUG
|
|
PROTOBUF_LITE_LIBRARY
|
|
PROTOBUF_LITE_LIBRARY_DEBUG
|
|
)
|
|
if (DEFINED ${UPPER})
|
|
string(REPLACE "PROTOBUF_" "Protobuf_" Camel ${UPPER})
|
|
if (NOT DEFINED ${Camel})
|
|
set(${Camel} ${${UPPER}})
|
|
endif()
|
|
endif()
|
|
endforeach()
|
|
|
|
if(CMAKE_SIZEOF_VOID_P EQUAL 8)
|
|
set(_PROTOBUF_ARCH_DIR x64/)
|
|
endif()
|
|
|
|
|
|
# Support preference of static libs by adjusting CMAKE_FIND_LIBRARY_SUFFIXES
|
|
if( Protobuf_USE_STATIC_LIBS )
|
|
set( _protobuf_ORIG_CMAKE_FIND_LIBRARY_SUFFIXES ${CMAKE_FIND_LIBRARY_SUFFIXES})
|
|
if(WIN32)
|
|
set(CMAKE_FIND_LIBRARY_SUFFIXES .lib .a ${CMAKE_FIND_LIBRARY_SUFFIXES})
|
|
else()
|
|
set(CMAKE_FIND_LIBRARY_SUFFIXES .a )
|
|
endif()
|
|
endif()
|
|
|
|
include(${CMAKE_CURRENT_LIST_DIR}/SelectLibraryConfigurations.cmake)
|
|
|
|
# Internal function: search for normal library as well as a debug one
|
|
# if the debug one is specified also include debug/optimized keywords
|
|
# in *_LIBRARIES variable
|
|
function(_protobuf_find_libraries name filename)
|
|
if(${name}_LIBRARIES)
|
|
# Use result recorded by a previous call.
|
|
return()
|
|
elseif(${name}_LIBRARY)
|
|
# Honor cache entry used by CMake 3.5 and lower.
|
|
set(${name}_LIBRARIES "${${name}_LIBRARY}" PARENT_SCOPE)
|
|
else()
|
|
find_library(${name}_LIBRARY_RELEASE
|
|
NAMES ${filename}
|
|
NAMES_PER_DIR
|
|
PATHS ${Protobuf_SRC_ROOT_FOLDER}/vsprojects/${_PROTOBUF_ARCH_DIR}Release)
|
|
mark_as_advanced(${name}_LIBRARY_RELEASE)
|
|
|
|
find_library(${name}_LIBRARY_DEBUG
|
|
NAMES ${filename}d ${filename}
|
|
NAMES_PER_DIR
|
|
PATHS ${Protobuf_SRC_ROOT_FOLDER}/vsprojects/${_PROTOBUF_ARCH_DIR}Debug)
|
|
mark_as_advanced(${name}_LIBRARY_DEBUG)
|
|
|
|
select_library_configurations(${name})
|
|
|
|
if(UNIX AND Threads_FOUND AND ${name}_LIBRARY)
|
|
list(APPEND ${name}_LIBRARIES ${CMAKE_THREAD_LIBS_INIT})
|
|
endif()
|
|
|
|
set(${name}_LIBRARY "${${name}_LIBRARY}" PARENT_SCOPE)
|
|
set(${name}_LIBRARIES "${${name}_LIBRARIES}" PARENT_SCOPE)
|
|
endif()
|
|
endfunction()
|
|
|
|
#
|
|
# Main.
|
|
#
|
|
|
|
# By default have PROTOBUF_GENERATE_CPP macro pass -I to protoc
|
|
# for each directory where a proto file is referenced.
|
|
if(NOT DEFINED PROTOBUF_GENERATE_CPP_APPEND_PATH)
|
|
set(PROTOBUF_GENERATE_CPP_APPEND_PATH TRUE)
|
|
endif()
|
|
|
|
|
|
# Google's provided vcproj files generate libraries with a "lib"
|
|
# prefix on Windows
|
|
if(MSVC)
|
|
set(Protobuf_ORIG_FIND_LIBRARY_PREFIXES "${CMAKE_FIND_LIBRARY_PREFIXES}")
|
|
set(CMAKE_FIND_LIBRARY_PREFIXES "lib" "")
|
|
|
|
find_path(Protobuf_SRC_ROOT_FOLDER protobuf.pc.in)
|
|
endif()
|
|
|
|
if(UNIX)
|
|
# Protobuf headers may depend on threading.
|
|
find_package(Threads QUIET)
|
|
endif()
|
|
|
|
# The Protobuf library
|
|
_protobuf_find_libraries(Protobuf protobuf)
|
|
#DOC "The Google Protocol Buffers RELEASE Library"
|
|
|
|
_protobuf_find_libraries(Protobuf_LITE protobuf-lite)
|
|
|
|
# The Protobuf Protoc Library
|
|
_protobuf_find_libraries(Protobuf_PROTOC protoc)
|
|
|
|
# Restore original find library prefixes
|
|
if(MSVC)
|
|
set(CMAKE_FIND_LIBRARY_PREFIXES "${Protobuf_ORIG_FIND_LIBRARY_PREFIXES}")
|
|
endif()
|
|
|
|
# Find the include directory
|
|
find_path(Protobuf_INCLUDE_DIR
|
|
google/protobuf/service.h
|
|
PATHS ${Protobuf_SRC_ROOT_FOLDER}/src
|
|
)
|
|
mark_as_advanced(Protobuf_INCLUDE_DIR)
|
|
|
|
# Find the protoc Executable
|
|
find_program(Protobuf_PROTOC_EXECUTABLE
|
|
NAMES protoc
|
|
DOC "The Google Protocol Buffers Compiler"
|
|
PATHS
|
|
${Protobuf_SRC_ROOT_FOLDER}/vsprojects/${_PROTOBUF_ARCH_DIR}Release
|
|
${Protobuf_SRC_ROOT_FOLDER}/vsprojects/${_PROTOBUF_ARCH_DIR}Debug
|
|
)
|
|
mark_as_advanced(Protobuf_PROTOC_EXECUTABLE)
|
|
|
|
if(Protobuf_DEBUG)
|
|
message(STATUS "[ ${CMAKE_CURRENT_LIST_FILE}:${CMAKE_CURRENT_LIST_LINE} ] "
|
|
"requested version of Google Protobuf is ${Protobuf_FIND_VERSION}")
|
|
endif()
|
|
|
|
if(Protobuf_INCLUDE_DIR)
|
|
set(_PROTOBUF_COMMON_HEADER ${Protobuf_INCLUDE_DIR}/google/protobuf/stubs/common.h)
|
|
|
|
if(Protobuf_DEBUG)
|
|
message(STATUS "[ ${CMAKE_CURRENT_LIST_FILE}:${CMAKE_CURRENT_LIST_LINE} ] "
|
|
"location of common.h: ${_PROTOBUF_COMMON_HEADER}")
|
|
endif()
|
|
|
|
set(Protobuf_VERSION "")
|
|
set(Protobuf_LIB_VERSION "")
|
|
file(STRINGS ${_PROTOBUF_COMMON_HEADER} _PROTOBUF_COMMON_H_CONTENTS REGEX "#define[ \t]+GOOGLE_PROTOBUF_VERSION[ \t]+")
|
|
if(_PROTOBUF_COMMON_H_CONTENTS MATCHES "#define[ \t]+GOOGLE_PROTOBUF_VERSION[ \t]+([0-9]+)")
|
|
set(Protobuf_LIB_VERSION "${CMAKE_MATCH_1}")
|
|
endif()
|
|
unset(_PROTOBUF_COMMON_H_CONTENTS)
|
|
|
|
math(EXPR _PROTOBUF_MAJOR_VERSION "${Protobuf_LIB_VERSION} / 1000000")
|
|
math(EXPR _PROTOBUF_MINOR_VERSION "${Protobuf_LIB_VERSION} / 1000 % 1000")
|
|
math(EXPR _PROTOBUF_SUBMINOR_VERSION "${Protobuf_LIB_VERSION} % 1000")
|
|
set(Protobuf_VERSION "${_PROTOBUF_MAJOR_VERSION}.${_PROTOBUF_MINOR_VERSION}.${_PROTOBUF_SUBMINOR_VERSION}")
|
|
|
|
if(Protobuf_DEBUG)
|
|
message(STATUS "[ ${CMAKE_CURRENT_LIST_FILE}:${CMAKE_CURRENT_LIST_LINE} ] "
|
|
"${_PROTOBUF_COMMON_HEADER} reveals protobuf ${Protobuf_VERSION}")
|
|
endif()
|
|
|
|
if(Protobuf_PROTOC_EXECUTABLE)
|
|
# Check Protobuf compiler version to be aligned with libraries version
|
|
execute_process(COMMAND ${Protobuf_PROTOC_EXECUTABLE} --version
|
|
OUTPUT_VARIABLE _PROTOBUF_PROTOC_EXECUTABLE_VERSION)
|
|
|
|
if("${_PROTOBUF_PROTOC_EXECUTABLE_VERSION}" MATCHES "libprotoc ([0-9.]+)")
|
|
set(_PROTOBUF_PROTOC_EXECUTABLE_VERSION "${CMAKE_MATCH_1}")
|
|
endif()
|
|
|
|
if(Protobuf_DEBUG)
|
|
message(STATUS "[ ${CMAKE_CURRENT_LIST_FILE}:${CMAKE_CURRENT_LIST_LINE} ] "
|
|
"${Protobuf_PROTOC_EXECUTABLE} reveals version ${_PROTOBUF_PROTOC_EXECUTABLE_VERSION}")
|
|
endif()
|
|
|
|
# protoc version 22 and up don't print the major version any more
|
|
if(NOT "${_PROTOBUF_PROTOC_EXECUTABLE_VERSION}" VERSION_EQUAL "${Protobuf_VERSION}" AND
|
|
NOT "${_PROTOBUF_PROTOC_EXECUTABLE_VERSION}" VERSION_EQUAL "${_PROTOBUF_MINOR_VERSION}.${_PROTOBUF_SUBMINOR_VERSION}")
|
|
message(WARNING "Protobuf compiler version ${_PROTOBUF_PROTOC_EXECUTABLE_VERSION}"
|
|
" doesn't match library version ${Protobuf_VERSION}")
|
|
endif()
|
|
endif()
|
|
|
|
if(Protobuf_LIBRARY)
|
|
if(NOT TARGET protobuf::libprotobuf)
|
|
add_library(protobuf::libprotobuf UNKNOWN IMPORTED)
|
|
set_target_properties(protobuf::libprotobuf PROPERTIES
|
|
INTERFACE_INCLUDE_DIRECTORIES "${Protobuf_INCLUDE_DIR}")
|
|
if(EXISTS "${Protobuf_LIBRARY}")
|
|
set_target_properties(protobuf::libprotobuf PROPERTIES
|
|
IMPORTED_LOCATION "${Protobuf_LIBRARY}")
|
|
endif()
|
|
if(EXISTS "${Protobuf_LIBRARY_RELEASE}")
|
|
set_property(TARGET protobuf::libprotobuf APPEND PROPERTY
|
|
IMPORTED_CONFIGURATIONS RELEASE)
|
|
set_target_properties(protobuf::libprotobuf PROPERTIES
|
|
IMPORTED_LOCATION_RELEASE "${Protobuf_LIBRARY_RELEASE}")
|
|
endif()
|
|
if(EXISTS "${Protobuf_LIBRARY_DEBUG}")
|
|
set_property(TARGET protobuf::libprotobuf APPEND PROPERTY
|
|
IMPORTED_CONFIGURATIONS DEBUG)
|
|
set_target_properties(protobuf::libprotobuf PROPERTIES
|
|
IMPORTED_LOCATION_DEBUG "${Protobuf_LIBRARY_DEBUG}")
|
|
endif()
|
|
if (Protobuf_VERSION VERSION_GREATER_EQUAL "3.6")
|
|
set_property(TARGET protobuf::libprotobuf APPEND PROPERTY
|
|
INTERFACE_COMPILE_FEATURES cxx_std_11
|
|
)
|
|
endif()
|
|
if (WIN32 AND NOT Protobuf_USE_STATIC_LIBS)
|
|
set_property(TARGET protobuf::libprotobuf APPEND PROPERTY
|
|
INTERFACE_COMPILE_DEFINITIONS "PROTOBUF_USE_DLLS"
|
|
)
|
|
endif()
|
|
if(UNIX AND TARGET Threads::Threads)
|
|
set_property(TARGET protobuf::libprotobuf APPEND PROPERTY
|
|
INTERFACE_LINK_LIBRARIES Threads::Threads)
|
|
endif()
|
|
endif()
|
|
endif()
|
|
|
|
if(Protobuf_LITE_LIBRARY)
|
|
if(NOT TARGET protobuf::libprotobuf-lite)
|
|
add_library(protobuf::libprotobuf-lite UNKNOWN IMPORTED)
|
|
set_target_properties(protobuf::libprotobuf-lite PROPERTIES
|
|
INTERFACE_INCLUDE_DIRECTORIES "${Protobuf_INCLUDE_DIR}")
|
|
if(EXISTS "${Protobuf_LITE_LIBRARY}")
|
|
set_target_properties(protobuf::libprotobuf-lite PROPERTIES
|
|
IMPORTED_LOCATION "${Protobuf_LITE_LIBRARY}")
|
|
endif()
|
|
if(EXISTS "${Protobuf_LITE_LIBRARY_RELEASE}")
|
|
set_property(TARGET protobuf::libprotobuf-lite APPEND PROPERTY
|
|
IMPORTED_CONFIGURATIONS RELEASE)
|
|
set_target_properties(protobuf::libprotobuf-lite PROPERTIES
|
|
IMPORTED_LOCATION_RELEASE "${Protobuf_LITE_LIBRARY_RELEASE}")
|
|
endif()
|
|
if(EXISTS "${Protobuf_LITE_LIBRARY_DEBUG}")
|
|
set_property(TARGET protobuf::libprotobuf-lite APPEND PROPERTY
|
|
IMPORTED_CONFIGURATIONS DEBUG)
|
|
set_target_properties(protobuf::libprotobuf-lite PROPERTIES
|
|
IMPORTED_LOCATION_DEBUG "${Protobuf_LITE_LIBRARY_DEBUG}")
|
|
endif()
|
|
if (WIN32 AND NOT Protobuf_USE_STATIC_LIBS)
|
|
set_property(TARGET protobuf::libprotobuf-lite APPEND PROPERTY
|
|
INTERFACE_COMPILE_DEFINITIONS "PROTOBUF_USE_DLLS"
|
|
)
|
|
endif()
|
|
if(UNIX AND TARGET Threads::Threads)
|
|
set_property(TARGET protobuf::libprotobuf-lite APPEND PROPERTY
|
|
INTERFACE_LINK_LIBRARIES Threads::Threads)
|
|
endif()
|
|
endif()
|
|
endif()
|
|
|
|
if(Protobuf_PROTOC_LIBRARY)
|
|
if(NOT TARGET protobuf::libprotoc)
|
|
add_library(protobuf::libprotoc UNKNOWN IMPORTED)
|
|
set_target_properties(protobuf::libprotoc PROPERTIES
|
|
INTERFACE_INCLUDE_DIRECTORIES "${Protobuf_INCLUDE_DIR}")
|
|
if(EXISTS "${Protobuf_PROTOC_LIBRARY}")
|
|
set_target_properties(protobuf::libprotoc PROPERTIES
|
|
IMPORTED_LOCATION "${Protobuf_PROTOC_LIBRARY}")
|
|
endif()
|
|
if(EXISTS "${Protobuf_PROTOC_LIBRARY_RELEASE}")
|
|
set_property(TARGET protobuf::libprotoc APPEND PROPERTY
|
|
IMPORTED_CONFIGURATIONS RELEASE)
|
|
set_target_properties(protobuf::libprotoc PROPERTIES
|
|
IMPORTED_LOCATION_RELEASE "${Protobuf_PROTOC_LIBRARY_RELEASE}")
|
|
endif()
|
|
if(EXISTS "${Protobuf_PROTOC_LIBRARY_DEBUG}")
|
|
set_property(TARGET protobuf::libprotoc APPEND PROPERTY
|
|
IMPORTED_CONFIGURATIONS DEBUG)
|
|
set_target_properties(protobuf::libprotoc PROPERTIES
|
|
IMPORTED_LOCATION_DEBUG "${Protobuf_PROTOC_LIBRARY_DEBUG}")
|
|
endif()
|
|
if (Protobuf_VERSION VERSION_GREATER_EQUAL "3.6")
|
|
set_property(TARGET protobuf::libprotoc APPEND PROPERTY
|
|
INTERFACE_COMPILE_FEATURES cxx_std_11
|
|
)
|
|
endif()
|
|
if (WIN32 AND NOT Protobuf_USE_STATIC_LIBS)
|
|
set_property(TARGET protobuf::libprotoc APPEND PROPERTY
|
|
INTERFACE_COMPILE_DEFINITIONS "PROTOBUF_USE_DLLS"
|
|
)
|
|
endif()
|
|
if(UNIX AND TARGET Threads::Threads)
|
|
set_property(TARGET protobuf::libprotoc APPEND PROPERTY
|
|
INTERFACE_LINK_LIBRARIES Threads::Threads)
|
|
endif()
|
|
endif()
|
|
endif()
|
|
|
|
if(Protobuf_PROTOC_EXECUTABLE)
|
|
if(NOT TARGET protobuf::protoc)
|
|
add_executable(protobuf::protoc IMPORTED)
|
|
if(EXISTS "${Protobuf_PROTOC_EXECUTABLE}")
|
|
set_target_properties(protobuf::protoc PROPERTIES
|
|
IMPORTED_LOCATION "${Protobuf_PROTOC_EXECUTABLE}")
|
|
endif()
|
|
endif()
|
|
endif()
|
|
endif()
|
|
|
|
include(FindPackageHandleStandardArgs)
|
|
find_package_handle_standard_args(Protobuf
|
|
REQUIRED_VARS Protobuf_LIBRARIES Protobuf_INCLUDE_DIR
|
|
VERSION_VAR Protobuf_VERSION
|
|
)
|
|
|
|
if(Protobuf_FOUND)
|
|
set(Protobuf_INCLUDE_DIRS ${Protobuf_INCLUDE_DIR})
|
|
endif()
|
|
|
|
# Restore the original find library ordering
|
|
if( Protobuf_USE_STATIC_LIBS )
|
|
set(CMAKE_FIND_LIBRARY_SUFFIXES ${_protobuf_ORIG_CMAKE_FIND_LIBRARY_SUFFIXES})
|
|
endif()
|
|
|
|
# Backwards compatibility
|
|
# Define upper case versions of output variables
|
|
foreach(Camel
|
|
Protobuf_SRC_ROOT_FOLDER
|
|
Protobuf_IMPORT_DIRS
|
|
Protobuf_DEBUG
|
|
Protobuf_INCLUDE_DIRS
|
|
Protobuf_LIBRARIES
|
|
Protobuf_PROTOC_LIBRARIES
|
|
Protobuf_LITE_LIBRARIES
|
|
Protobuf_LIBRARY
|
|
Protobuf_PROTOC_LIBRARY
|
|
Protobuf_INCLUDE_DIR
|
|
Protobuf_PROTOC_EXECUTABLE
|
|
Protobuf_LIBRARY_DEBUG
|
|
Protobuf_PROTOC_LIBRARY_DEBUG
|
|
Protobuf_LITE_LIBRARY
|
|
Protobuf_LITE_LIBRARY_DEBUG
|
|
)
|
|
string(TOUPPER ${Camel} UPPER)
|
|
set(${UPPER} ${${Camel}})
|
|
endforeach()
|
|
|
|
cmake_policy(POP)
|