templates/CMakeLists.txt.template

%YAML 1.2
--- |
  # GRPC global cmake file
  # This currently builds C and C++ code.
  # This file has been automatically generated from a template file.
  # Please look at the templates directory instead.
  # This file can be regenerated from the template by running
  # tools/buildgen/generate_projects.sh
  #
  # Additionally, this is currently very experimental, and unsupported.
  # Further work will happen on that file.
  #
  # Copyright 2015, Google Inc.
  # All rights reserved.
  #
  # Redistribution and use in source and binary forms, with or without
  # modification, are permitted provided that the following conditions are
  # met:
  #
  #     * Redistributions of source code must retain the above copyright
  # notice, this list of conditions and the following disclaimer.
  #     * Redistributions in binary form must reproduce the above
  # copyright notice, this list of conditions and the following disclaimer
  # in the documentation and/or other materials provided with the
  # distribution.
  #     * Neither the name of Google Inc. nor the names of its
  # contributors may be used to endorse or promote products derived from
  # this software without specific prior written permission.
  #
  # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

  <%!
  def get_deps(target_dict):
    deps = []
    if target_dict.get('baselib', False):
      deps.append("${_gRPC_BASELIB_LIBRARIES}")
    if target_dict.get('build', None) in ['protoc']:
      deps.append("${_gRPC_PROTOBUF_PROTOC_LIBRARIES}")
    if target_dict.get('secure', False):
      deps.append("${_gRPC_SSL_LIBRARIES}")
    if target_dict['name'] in ['grpc++', 'grpc++_unsecure', 'grpc++_codegen_lib']:
      deps.append("${_gRPC_PROTOBUF_LIBRARIES}")
    elif target_dict['name'] in ['grpc']:
      deps.append("${_gRPC_ZLIB_LIBRARIES}")
    for d in target_dict.get('deps', []):
      deps.append(d)
    return deps
  %>

  cmake_minimum_required(VERSION 2.8)

  set(PACKAGE_NAME      "grpc")
  set(PACKAGE_VERSION   "${settings.core_version}")
  set(PACKAGE_STRING    "<%text>${PACKAGE_NAME} ${PACKAGE_VERSION}</%text>")
  set(PACKAGE_TARNAME   "<%text>${PACKAGE_NAME}-${PACKAGE_VERSION}</%text>")
  set(PACKAGE_BUGREPORT "https://github.com/grpc/grpc/issues/")
  project(<%text>${PACKAGE_NAME}</%text> C CXX)

  if (NOT MSVC)
    set(gRPC_INSTALL ON CACHE BOOL "Generate installation target")
  else()
    set(gRPC_INSTALL OFF CACHE BOOL "Generate installation target")
  endif()

  set(gRPC_ZLIB_PROVIDER "module" CACHE STRING "Provider of zlib library")
  set_property(CACHE gRPC_ZLIB_PROVIDER PROPERTY STRINGS "module" "package")

  set(gRPC_SSL_PROVIDER "module" CACHE STRING "Provider of ssl library")
  set_property(CACHE gRPC_SSL_PROVIDER PROPERTY STRINGS "module" "package")

  set(gRPC_PROTOBUF_PROVIDER "module" CACHE STRING "Provider of protobuf library")
  set_property(CACHE gRPC_PROTOBUF_PROVIDER PROPERTY STRINGS "module" "package")

  set(gRPC_USE_PROTO_LITE OFF CACHE BOOL "Use the protobuf-lite library")

  if (MSVC)
    add_definitions( -D_WIN32_WINNT=0x600 )
  endif()

  if (gRPC_USE_PROTO_LITE)
    set(_gRPC_PROTOBUF_LIBRARY_NAME "libprotobuf-lite")
    add_definitions("-DGRPC_USE_PROTO_LITE")
  else()
    set(_gRPC_PROTOBUF_LIBRARY_NAME "libprotobuf")
  endif()

  if("<%text>${gRPC_ZLIB_PROVIDER}</%text>" STREQUAL "module")
    if(NOT ZLIB_ROOT_DIR)
      set(ZLIB_ROOT_DIR <%text>${CMAKE_CURRENT_SOURCE_DIR}</%text>/third_party/zlib)
    endif()
    set(ZLIB_INCLUDE_DIR "<%text>${ZLIB_ROOT_DIR}</%text>")
    if(EXISTS "<%text>${ZLIB_ROOT_DIR}</%text>/CMakeLists.txt")
        add_subdirectory(<%text>${ZLIB_ROOT_DIR}</%text> third_party/zlib)
        if(TARGET zlibstatic)
            set(_gRPC_ZLIB_LIBRARIES zlibstatic)
        endif()
    else()
        message(WARNING "gRPC_ZLIB_PROVIDER is \"module\" but ZLIB_ROOT_DIR is wrong")
    endif()
  elseif("<%text>${gRPC_ZLIB_PROVIDER}</%text>" STREQUAL "package")
    find_package(ZLIB)
    if(TARGET ZLIB::ZLIB)
      set(_gRPC_ZLIB_LIBRARIES ZLIB::ZLIB)
    endif()
    set(_gRPC_FIND_ZLIB "if(NOT ZLIB_FOUND)\n  find_package(ZLIB)\nendif()")
  endif()

  if("<%text>${gRPC_PROTOBUF_PROVIDER}</%text>" STREQUAL "module")
    # Building the protobuf tests require gmock what is not part of a standard protobuf checkout.
    # Disable them unless they are explicitly requested from the cmake command line (when we assume
    # gmock is downloaded to the right location inside protobuf).
    if(NOT protobuf_BUILD_TESTS)
      set(protobuf_BUILD_TESTS OFF CACHE BOOL "Build protobuf tests")
    endif()
    if(NOT PROTOBUF_ROOT_DIR)
      set(PROTOBUF_ROOT_DIR <%text>${CMAKE_CURRENT_SOURCE_DIR}</%text>/third_party/protobuf)
    endif()
    if(EXISTS "<%text>${PROTOBUF_ROOT_DIR}</%text>/cmake/CMakeLists.txt")
      set(protobuf_MSVC_STATIC_RUNTIME OFF CACHE BOOL "Link static runtime libraries")
      add_subdirectory(<%text>${PROTOBUF_ROOT_DIR}</%text>/cmake third_party/protobuf)
      if(TARGET <%text>${_gRPC_PROTOBUF_LIBRARY_NAME}</%text>)
        set(_gRPC_PROTOBUF_LIBRARIES <%text>${_gRPC_PROTOBUF_LIBRARY_NAME}</%text>)
      endif()
      if(TARGET libprotoc)
        set(_gRPC_PROTOBUF_PROTOC_LIBRARIES libprotoc)
      endif()
    else()
        message(WARNING "gRPC_PROTOBUF_PROVIDER is \"module\" but PROTOBUF_ROOT_DIR is wrong")
    endif()
  elseif("<%text>${gRPC_PROTOBUF_PROVIDER}</%text>" STREQUAL "package")
    find_package(protobuf CONFIG)
    if(protobuf_FOUND)
      if(TARGET protobuf::<%text>${_gRPC_PROTOBUF_LIBRARY_NAME}</%text>)
        set(_gRPC_PROTOBUF_LIBRARIES protobuf::<%text>${_gRPC_PROTOBUF_LIBRARY_NAME}</%text>)
      endif()
      if(TARGET protobuf::libprotoc)
        set(_gRPC_PROTOBUF_PROTOC_LIBRARIES protobuf::libprotoc)
      endif()
      set(_gRPC_FIND_PROTOBUF "if(NOT protobuf_FOUND)\n  find_package(protobuf CONFIG)\nendif()")
    else()
      find_package(Protobuf MODULE)
      set(_gRPC_FIND_PROTOBUF "if(NOT Protobuf_FOUND)\n  find_package(Protobuf)\nendif()")
    endif()
  endif()

  if("<%text>${gRPC_SSL_PROVIDER}</%text>" STREQUAL "module")
    if(NOT BORINGSSL_ROOT_DIR)
      set(BORINGSSL_ROOT_DIR <%text>${CMAKE_CURRENT_SOURCE_DIR}</%text>/third_party/boringssl)
    endif()
    if(EXISTS "<%text>${BORINGSSL_ROOT_DIR}</%text>/CMakeLists.txt")
      add_subdirectory(<%text>${BORINGSSL_ROOT_DIR}</%text> third_party/boringssl)
      if(TARGET ssl)
        set(_gRPC_SSL_LIBRARIES ssl)
      endif()
    else()
        message(WARNING "gRPC_SSL_PROVIDER is \"module\" but BORINGSSL_ROOT_DIR is wrong")
    endif()
  elseif("<%text>${gRPC_SSL_PROVIDER}</%text>" STREQUAL "package")
    find_package(OpenSSL)
    if(TARGET OpenSSL::SSL)
      set(_gRPC_SSL_LIBRARIES OpenSSL::SSL)
    endif()
    set(_gRPC_FIND_SSL "if(NOT OpenSSL_FOUND)\n  find_package(OpenSSL)\nendif()")
  endif()

  if(NOT MSVC)
    set(CMAKE_C_FLAGS   "<%text>${CMAKE_C_FLAGS}</%text>   -std=c11")
    set(CMAKE_CXX_FLAGS "<%text>${CMAKE_CXX_FLAGS}</%text> -std=c++11")
  endif()

  if(WIN32 AND MSVC)
    set(_gRPC_BASELIB_LIBRARIES wsock32 ws2_32)
  endif()

  include(GNUInstallDirs)
  if(NOT DEFINED CMAKE_INSTALL_CMAKEDIR)
    set(CMAKE_INSTALL_CMAKEDIR "<%text>${CMAKE_INSTALL_LIBDIR}</%text>/cmake/gRPC")
  endif()

  % for lib in libs:
  % if lib.build in ["all", "protoc", "tool"]:
    ${cc_library(lib)}
    ${cc_install(lib)}
  % endif
  % endfor

  % for tgt in targets:
  % if tgt.build in ["all", "protoc", "tool"]:
  ${cc_binary(tgt)}
  ${cc_install(tgt)}
  % endif
  % endfor

  <%def name="cc_library(lib)">
  add_library(${lib.name}
  % for src in lib.src:
    ${src}
  % endfor
  )

  target_include_directories(${lib.name}
    PRIVATE <%text>${CMAKE_CURRENT_SOURCE_DIR}</%text>
    PRIVATE <%text>${CMAKE_CURRENT_SOURCE_DIR}</%text>/include
    PRIVATE <%text>${BORINGSSL_ROOT_DIR}</%text>/include
    PRIVATE <%text>${PROTOBUF_ROOT_DIR}</%text>/src
    PRIVATE <%text>${ZLIB_INCLUDE_DIR}</%text>
    PRIVATE <%text>${CMAKE_CURRENT_BINARY_DIR}</%text>/third_party/zlib
  )

  % if len(get_deps(lib)) > 0:
  target_link_libraries(${lib.name}
  % for dep in get_deps(lib):
    ${dep}
  % endfor
  )
  % endif

  % if len(lib.get('public_headers', [])) > 0:
  foreach(_hdr
  % for hdr in lib.get('public_headers', []):
    ${hdr}
  % endfor
  )
    string(REPLACE "include/" "" _path <%text>${_hdr}</%text>)
    get_filename_component(_path <%text>${_path}</%text> PATH)
    install(FILES <%text>${_hdr}</%text>
      DESTINATION "<%text>${CMAKE_INSTALL_INCLUDEDIR}/${_path}</%text>"
    )
  endforeach()
  % endif
  </%def>

  <%def name="cc_binary(tgt)">
  add_executable(${tgt.name}
  % for src in tgt.src:
    ${src}
  % endfor
  )

  target_include_directories(${tgt.name}
    PRIVATE <%text>${CMAKE_CURRENT_SOURCE_DIR}</%text>
    PRIVATE <%text>${CMAKE_CURRENT_SOURCE_DIR}</%text>/include
    PRIVATE <%text>${BORINGSSL_ROOT_DIR}</%text>/include
    PRIVATE <%text>${PROTOBUF_ROOT_DIR}</%text>/src
    PRIVATE <%text>${ZLIB_ROOT_DIR}</%text>
    PRIVATE <%text>${CMAKE_CURRENT_BINARY_DIR}</%text>/third_party/zlib
  )

  % if len(get_deps(tgt)) > 0:
  target_link_libraries(${tgt.name}
  % for dep in get_deps(tgt):
    ${dep}
  % endfor
  )
  % endif
  </%def>

  <%def name="cc_install(tgt)">
  if (gRPC_INSTALL)
    install(TARGETS ${tgt.name} EXPORT gRPCTargets
      RUNTIME DESTINATION <%text>${CMAKE_INSTALL_BINDIR}</%text>
      LIBRARY DESTINATION <%text>${CMAKE_INSTALL_LIBDIR}</%text>
      ARCHIVE DESTINATION <%text>${CMAKE_INSTALL_LIBDIR}</%text>
    )
  endif()
  </%def>

  if (gRPC_INSTALL)
    install(EXPORT gRPCTargets
      DESTINATION <%text>${CMAKE_INSTALL_CMAKEDIR}</%text>
      NAMESPACE gRPC::
    )
  endif()

  foreach(_config gRPCConfig gRPCConfigVersion)
    configure_file(tools/cmake/<%text>${_config}</%text>.cmake.in
      <%text>${_config}</%text>.cmake @ONLY)
    install(FILES <%text>${CMAKE_CURRENT_BINARY_DIR}/${_config}</%text>.cmake
      DESTINATION <%text>${CMAKE_INSTALL_CMAKEDIR}</%text>
    )
  endforeach()