dilim/CMake
1
0 Fork 0
mirror of https://github.com/Kitware/CMake.git synced 2026-11-06 05:16:58 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
release
CMake/Modules/FindProtobuf.cmake
T
15daksh-2003 5a082c7dde FindProtobuf: Fix protobuf_generate COMMENT with multiple PROTOC_OPTIONS 
With two or more PROTOC_OPTIONS the custom command's comment picked up
the raw list separator, so the unquoted COMMENT expanded to several
arguments. Since CMP0175 that's a configure error under NEW and a
policy warning otherwise, and the comment only ever showed the last
option.

We're now joining the options with spaces before they go into the
comment, which is how upstream protobuf fixed the same code in v33.0
(protocolbuffers/protobuf@aa1f665cdc). The COMMENT argument is also
quoted now, and the module sets CMP0175 to NEW for its own
add_custom_command() call instead of inheriting the project's setting.
That keeps a stray separator from splitting the comment again, and it
stops the policy warning that pointed into this module.

Fixes: #28078
2026-09-25 22:43:49 +05:30

1177 lines
38 KiB
CMake
Raw Permalink Blame History

# 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``
.. versionadded:: 3.3
Boolean indicating whether the (requested version of) Protobuf library
was 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>
cmake_policy(SET CMP0175 NEW) # add_custom_command() rejects invalid arguments
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)
string(REPLACE ";" " " _protoc_options_str "${protobuf_generate_PROTOC_OPTIONS}")
set(_comment "${_comment}, protoc-options: ${_protoc_options_str}")
endif()
if(_plugin_options)
string(REPLACE ";" " " _plugin_options_str "${_plugin_options}")
set(_comment "${_comment}, plugin-options: ${_plugin_options_str}")
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
RESULT_VARIABLE _PROTOBUF_PROTOC_EXECUTABLE_VERSION_RESULT)
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)
Reference in new issue View Git Blame Copy Permalink