CMakeLists.txt

   1 cmake_minimum_required(VERSION 2.8)
   2 # generate compile_commands.json
   3 set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
   4 include(CheckCXXSymbolExists)
   5
   6 project(FlatBuffers)
   7
   8 # NOTE: Code coverage only works on Linux & OSX.
   9 option(FLATBUFFERS_CODE_COVERAGE "Enable the code coverage build option." OFF)
  10 option(FLATBUFFERS_BUILD_TESTS "Enable the build of tests and samples." ON)
  11 option(FLATBUFFERS_INSTALL "Enable the installation of targets." ON)
  12 option(FLATBUFFERS_BUILD_FLATLIB "Enable the build of the flatbuffers library"
  13        ON)
  14 option(FLATBUFFERS_BUILD_FLATC "Enable the build of the flatbuffers compiler"
  15        ON)
  16 option(FLATBUFFERS_STATIC_FLATC "Build flatbuffers compiler with -static flag"
  17        OFF)
  18 option(FLATBUFFERS_BUILD_FLATHASH "Enable the build of flathash" ON)
  19 option(FLATBUFFERS_BUILD_GRPCTEST "Enable the build of grpctest" OFF)
  20 option(FLATBUFFERS_BUILD_SHAREDLIB
  21        "Enable the build of the flatbuffers shared library"
  22        OFF)
  23 option(FLATBUFFERS_LIBCXX_WITH_CLANG "Force libc++ when using Clang" ON)
  24 # NOTE: Sanitizer check only works on Linux & OSX (gcc & llvm).
  25 option(FLATBUFFERS_CODE_SANITIZE
  26       "Add '-fsanitize' flags to 'flattests' and 'flatc' targets."
  27       OFF)
  28 option(FLATBUFFERS_PACKAGE_REDHAT
  29        "Build an rpm using the 'package' target."
  30        OFF)
  31 option(FLATBUFFERS_PACKAGE_DEBIAN
  32        "Build an deb using the 'package' target."
  33        OFF)
  34
  35 if(NOT FLATBUFFERS_BUILD_FLATC AND FLATBUFFERS_BUILD_TESTS)
  36     message(WARNING
  37     "Cannot build tests without building the compiler. Tests will be disabled.")
  38     set(FLATBUFFERS_BUILD_TESTS OFF)
  39 endif()
  40
  41 if(DEFINED FLATBUFFERS_MAX_PARSING_DEPTH)
  42   # Override the default recursion depth limit.
  43   add_definitions(-DFLATBUFFERS_MAX_PARSING_DEPTH=${FLATBUFFERS_MAX_PARSING_DEPTH})
  44   message(STATUS "FLATBUFFERS_MAX_PARSING_DEPTH: ${FLATBUFFERS_MAX_PARSING_DEPTH}")
  45 endif()
  46
  47 # Auto-detect locale-narrow 'strtod_l' and  'strtoull_l' functions.
  48 if(NOT DEFINED FLATBUFFERS_LOCALE_INDEPENDENT)
  49   set(FLATBUFFERS_LOCALE_INDEPENDENT 0)
  50   if(MSVC)
  51     check_cxx_symbol_exists(_strtof_l stdlib.h FLATBUFFERS_HAS_STRTOF_L)
  52     check_cxx_symbol_exists(_strtoui64_l stdlib.h FLATBUFFERS_HAS_STRTOULL_L)
  53   else()
  54     check_cxx_symbol_exists(strtof_l stdlib.h FLATBUFFERS_HAS_STRTOF_L)
  55     check_cxx_symbol_exists(strtoull_l stdlib.h FLATBUFFERS_HAS_STRTOULL_L)
  56   endif()
  57   if(FLATBUFFERS_HAS_STRTOF_L AND FLATBUFFERS_HAS_STRTOULL_L)
  58     set(FLATBUFFERS_LOCALE_INDEPENDENT 1)
  59   endif()
  60 endif()
  61 add_definitions(-DFLATBUFFERS_LOCALE_INDEPENDENT=$<BOOL:${FLATBUFFERS_LOCALE_INDEPENDENT}>)
  62
  63 set(FlatBuffers_Library_SRCS
  64   include/flatbuffers/code_generators.h
  65   include/flatbuffers/base.h
  66   include/flatbuffers/flatbuffers.h
  67   include/flatbuffers/hash.h
  68   include/flatbuffers/idl.h
  69   include/flatbuffers/util.h
  70   include/flatbuffers/reflection.h
  71   include/flatbuffers/reflection_generated.h
  72   include/flatbuffers/stl_emulation.h
  73   include/flatbuffers/flexbuffers.h
  74   include/flatbuffers/registry.h
  75   include/flatbuffers/minireflect.h
  76   src/code_generators.cpp
  77   src/idl_parser.cpp
  78   src/idl_gen_text.cpp
  79   src/reflection.cpp
  80   src/util.cpp
  81 )
  82
  83 set(FlatBuffers_Compiler_SRCS
  84   ${FlatBuffers_Library_SRCS}
  85   src/idl_gen_cpp.cpp
  86   src/idl_gen_csharp.cpp
  87   src/idl_gen_dart.cpp
  88   src/idl_gen_kotlin.cpp
  89   src/idl_gen_go.cpp
  90   src/idl_gen_java.cpp
  91   src/idl_gen_js_ts.cpp
  92   src/idl_gen_php.cpp
  93   src/idl_gen_python.cpp
  94   src/idl_gen_lobster.cpp
  95   src/idl_gen_lua.cpp
  96   src/idl_gen_rust.cpp
  97   src/idl_gen_fbs.cpp
  98   src/idl_gen_grpc.cpp
  99   src/idl_gen_json_schema.cpp
 100   src/flatc.cpp
 101   src/flatc_main.cpp
 102   grpc/src/compiler/schema_interface.h
 103   grpc/src/compiler/cpp_generator.h
 104   grpc/src/compiler/cpp_generator.cc
 105   grpc/src/compiler/go_generator.h
 106   grpc/src/compiler/go_generator.cc
 107   grpc/src/compiler/java_generator.h
 108   grpc/src/compiler/java_generator.cc
 109   grpc/src/compiler/python_generator.h
 110   grpc/src/compiler/python_private_generator.h
 111   grpc/src/compiler/python_generator.cc
 112 )
 113
 114 set(FlatHash_SRCS
 115   include/flatbuffers/hash.h
 116   src/flathash.cpp
 117 )
 118
 119 set(FlatBuffers_Tests_SRCS
 120   ${FlatBuffers_Library_SRCS}
 121   src/idl_gen_fbs.cpp
 122   tests/test.cpp
 123   tests/test_assert.h
 124   tests/test_assert.cpp
 125   tests/test_builder.h
 126   tests/test_builder.cpp
 127   tests/native_type_test_impl.h
 128   tests/native_type_test_impl.cpp
 129   # file generate by running compiler on tests/monster_test.fbs
 130   ${CMAKE_CURRENT_BINARY_DIR}/tests/monster_test_generated.h
 131   # file generate by running compiler on tests/arrays_test.fbs
 132   ${CMAKE_CURRENT_BINARY_DIR}/tests/arrays_test_generated.h
 133   # file generate by running compiler on tests/native_type_test.fbs
 134   ${CMAKE_CURRENT_BINARY_DIR}/tests/native_type_test_generated.h
 135   # file generate by running compiler on tests/monster_extra.fbs
 136   ${CMAKE_CURRENT_BINARY_DIR}/tests/monster_extra_generated.h
 137 )
 138
 139 set(FlatBuffers_Sample_Binary_SRCS
 140   include/flatbuffers/flatbuffers.h
 141   samples/sample_binary.cpp
 142   # file generated by running compiler on samples/monster.fbs
 143   ${CMAKE_CURRENT_BINARY_DIR}/samples/monster_generated.h
 144 )
 145
 146 set(FlatBuffers_Sample_Text_SRCS
 147   ${FlatBuffers_Library_SRCS}
 148   samples/sample_text.cpp
 149   # file generated by running compiler on samples/monster.fbs
 150   ${CMAKE_CURRENT_BINARY_DIR}/samples/monster_generated.h
 151 )
 152
 153 set(FlatBuffers_Sample_BFBS_SRCS
 154   ${FlatBuffers_Library_SRCS}
 155   samples/sample_bfbs.cpp
 156   # file generated by running compiler on samples/monster.fbs
 157   ${CMAKE_CURRENT_BINARY_DIR}/samples/monster_generated.h
 158 )
 159
 160 set(FlatBuffers_GRPCTest_SRCS
 161   include/flatbuffers/flatbuffers.h
 162   include/flatbuffers/grpc.h
 163   include/flatbuffers/util.h
 164   src/util.cpp
 165   tests/monster_test.grpc.fb.h
 166   tests/test_assert.h
 167   tests/test_builder.h
 168   tests/monster_test.grpc.fb.cc
 169   tests/test_assert.cpp
 170   tests/test_builder.cpp
 171   grpc/tests/grpctest.cpp
 172   grpc/tests/message_builder_test.cpp
 173   # file generated by running compiler on samples/monster.fbs
 174   ${CMAKE_CURRENT_BINARY_DIR}/samples/monster_generated.h
 175 )
 176
 177 # source_group(Compiler FILES ${FlatBuffers_Compiler_SRCS})
 178 # source_group(Tests FILES ${FlatBuffers_Tests_SRCS})
 179
 180 if(EXISTS "${CMAKE_TOOLCHAIN_FILE}")
 181   # do not apply any global settings if the toolchain
 182   # is being configured externally
 183   message(STATUS "Using toolchain file: ${CMAKE_TOOLCHAIN_FILE}.")
 184 elseif(APPLE)
 185   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -stdlib=libc++")
 186   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -pedantic -Werror -Wextra -Wno-unused-parameter")
 187   set(FLATBUFFERS_PRIVATE_CXX_FLAGS "-Wold-style-cast")
 188 elseif(CMAKE_COMPILER_IS_GNUCXX)
 189   if(CYGWIN)
 190     set(CMAKE_CXX_FLAGS
 191       "${CMAKE_CXX_FLAGS} -std=gnu++11")
 192   else(CYGWIN)
 193     set(CMAKE_CXX_FLAGS
 194       "${CMAKE_CXX_FLAGS} -std=c++0x")
 195   endif(CYGWIN)
 196   set(CMAKE_CXX_FLAGS
 197     "${CMAKE_CXX_FLAGS} -Wall -pedantic -Werror -Wextra -Werror=shadow")
 198   set(FLATBUFFERS_PRIVATE_CXX_FLAGS "-Wold-style-cast")
 199   if (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 4.4)
 200     if (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 7.0)
 201       set(CMAKE_CXX_FLAGS
 202         "${CMAKE_CXX_FLAGS} -faligned-new -Werror=implicit-fallthrough=2")
 203     endif()
 204     set(CMAKE_CXX_FLAGS
 205       "${CMAKE_CXX_FLAGS} -Wunused-result -Werror=unused-result -Wunused-parameter -Werror=unused-parameter")
 206   endif()
 207
 208   # Certain platforms such as ARM do not use signed chars by default
 209   # which causes issues with certain bounds checks.
 210   set(CMAKE_CXX_FLAGS
 211     "${CMAKE_CXX_FLAGS} -fsigned-char")
 212
 213 elseif(${CMAKE_CXX_COMPILER_ID} MATCHES "Clang")
 214   set(CMAKE_CXX_FLAGS
 215       "${CMAKE_CXX_FLAGS} -std=c++0x -Wall -pedantic -Werror -Wextra -Wno-unused-parameter")
 216   set(FLATBUFFERS_PRIVATE_CXX_FLAGS "-Wold-style-cast")
 217   if(NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 3.8)
 218     list(APPEND FLATBUFFERS_PRIVATE_CXX_FLAGS "-Wimplicit-fallthrough" "-Wextra-semi" "-Werror=unused-private-field") # enable warning
 219   endif()
 220   if(FLATBUFFERS_LIBCXX_WITH_CLANG)
 221     if(NOT "${CMAKE_SYSTEM_NAME}" MATCHES "Linux")
 222       set(CMAKE_CXX_FLAGS
 223           "${CMAKE_CXX_FLAGS} -stdlib=libc++")
 224     endif()
 225     if(NOT ("${CMAKE_SYSTEM_NAME}" MATCHES "FreeBSD" OR
 226             "${CMAKE_SYSTEM_NAME}" MATCHES "Linux"))
 227       set(CMAKE_EXE_LINKER_FLAGS
 228           "${CMAKE_EXE_LINKER_FLAGS} -lc++abi")
 229     endif()
 230   endif()
 231
 232   # Certain platforms such as ARM do not use signed chars by default
 233   # which causes issues with certain bounds checks.
 234   set(CMAKE_CXX_FLAGS
 235     "${CMAKE_CXX_FLAGS} -fsigned-char")
 236
 237 elseif(MSVC)
 238   # Visual Studio pedantic build settings
 239   # warning C4512: assignment operator could not be generated
 240   # warning C4316: object allocated on the heap may not be aligned
 241   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W4 /WX /wd4512 /wd4316")
 242 endif()
 243
 244 if(FLATBUFFERS_CODE_COVERAGE)
 245   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g -fprofile-arcs -ftest-coverage")
 246   set(CMAKE_EXE_LINKER_FLAGS
 247       "${CMAKE_EXE_LINKER_FLAGS} -fprofile-arcs -ftest-coverage")
 248 endif()
 249
 250 function(add_fsanitize_to_target _target _sanitizer)
 251   # FLATBUFFERS_CODE_SANITIZE: boolean {ON,OFF,YES,NO} or string with list of sanitizer.
 252   # List of sanitizer is string starts with '=': "=address,undefined,thread,memory".
 253   if((${CMAKE_CXX_COMPILER_ID} MATCHES "Clang") OR
 254     ((${CMAKE_CXX_COMPILER_ID} MATCHES "GNU") AND NOT (CMAKE_CXX_COMPILER_VERSION VERSION_LESS "4.9"))
 255   )
 256     set(_sanitizer_flags "=address,undefined")
 257     if(_sanitizer MATCHES "=.*")
 258       # override default by user-defined sanitizer list
 259       set(_sanitizer_flags ${_sanitizer})
 260     endif()
 261     target_compile_options(${_target} PRIVATE
 262       -g -fsigned-char -fno-omit-frame-pointer
 263       "-fsanitize${_sanitizer_flags}")
 264     target_link_libraries(${_target} PRIVATE
 265       "-fsanitize${_sanitizer_flags}")
 266     set_property(TARGET ${_target} PROPERTY POSITION_INDEPENDENT_CODE ON)
 267     message(STATUS "Sanitizer ${_sanitizer_flags} added to ${_target}")
 268   endif()
 269 endfunction()
 270
 271 if(BIICODE)
 272   include(biicode/cmake/biicode.cmake)
 273   return()
 274 endif()
 275
 276 include_directories(include)
 277 include_directories(grpc)
 278
 279 if(FLATBUFFERS_BUILD_FLATLIB)
 280   add_library(flatbuffers STATIC ${FlatBuffers_Library_SRCS})
 281   # CMake > 2.8.11: Attach header directory for when build via add_subdirectory().
 282   target_include_directories(flatbuffers INTERFACE
 283     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>)
 284   target_compile_options(flatbuffers PRIVATE "${FLATBUFFERS_PRIVATE_CXX_FLAGS}")
 285 endif()
 286
 287 if(FLATBUFFERS_BUILD_FLATC)
 288   add_executable(flatc ${FlatBuffers_Compiler_SRCS})
 289   target_compile_options(flatc PRIVATE "${FLATBUFFERS_PRIVATE_CXX_FLAGS}")
 290   if(FLATBUFFERS_CODE_SANITIZE AND NOT WIN32)
 291     add_fsanitize_to_target(flatc ${FLATBUFFERS_CODE_SANITIZE})
 292   endif()
 293   if(NOT FLATBUFFERS_FLATC_EXECUTABLE)
 294     set(FLATBUFFERS_FLATC_EXECUTABLE $<TARGET_FILE:flatc>)
 295   endif()
 296   if(MSVC)
 297     # Make flatc.exe not depend on runtime dlls for easy distribution.
 298     target_compile_options(flatc PUBLIC $<$<CONFIG:Release>:/MT>)
 299   endif()
 300   if(FLATBUFFERS_STATIC_FLATC AND NOT MSVC)
 301     target_link_libraries(flatc PRIVATE -static)
 302   endif()
 303 endif()
 304
 305 if(FLATBUFFERS_BUILD_FLATHASH)
 306   add_executable(flathash ${FlatHash_SRCS})
 307 endif()
 308
 309 if(FLATBUFFERS_BUILD_SHAREDLIB)
 310   add_library(flatbuffers_shared SHARED ${FlatBuffers_Library_SRCS})
 311
 312   # Shared object version: "major.minor.micro"
 313   # - micro updated every release when there is no API/ABI changes
 314   # - minor updated when there are additions in API/ABI
 315   # - major (ABI number) updated when there are changes in ABI (or removals)
 316   set(FlatBuffers_Library_SONAME_MAJOR "1")
 317   set(FlatBuffers_Library_SONAME_FULL "${FlatBuffers_Library_SONAME_MAJOR}.11.0")
 318   set_target_properties(flatbuffers_shared PROPERTIES OUTPUT_NAME flatbuffers
 319                         SOVERSION "${FlatBuffers_Library_SONAME_MAJOR}"
 320                         VERSION "${FlatBuffers_Library_SONAME_FULL}")
 321 endif()
 322
 323 function(compile_flatbuffers_schema_to_cpp_opt SRC_FBS OPT)
 324   message(STATUS "Add the code-generation command for the `${SRC_FBS}` schema.")
 325   get_filename_component(SRC_FBS_DIR ${SRC_FBS} PATH)
 326   string(REGEX REPLACE "\\.fbs$" "_generated.h" GEN_HEADER ${SRC_FBS})
 327   add_custom_command(
 328     OUTPUT ${GEN_HEADER}
 329     COMMAND "${FLATBUFFERS_FLATC_EXECUTABLE}" -c --gen-mutable
 330             --gen-object-api -o "${SRC_FBS_DIR}"
 331             --cpp-ptr-type flatbuffers::unique_ptr # Used to test with C++98 STLs
 332             --reflect-names ${OPT}
 333             -I "${CMAKE_CURRENT_SOURCE_DIR}/tests/include_test"
 334             "${CMAKE_CURRENT_SOURCE_DIR}/${SRC_FBS}"
 335     DEPENDS flatc)
 336 endfunction()
 337
 338 function(compile_flatbuffers_schema_to_cpp SRC_FBS)
 339     compile_flatbuffers_schema_to_cpp_opt(${SRC_FBS} "--no-includes;--gen-compare")
 340 endfunction()
 341
 342 function(compile_flatbuffers_schema_to_binary SRC_FBS)
 343   get_filename_component(SRC_FBS_DIR ${SRC_FBS} PATH)
 344   string(REGEX REPLACE "\\.fbs$" ".bfbs" GEN_BINARY_SCHEMA ${SRC_FBS})
 345   add_custom_command(
 346     OUTPUT ${GEN_BINARY_SCHEMA}
 347     COMMAND "${FLATBUFFERS_FLATC_EXECUTABLE}" -b --schema -o "${SRC_FBS_DIR}"
 348             "${CMAKE_CURRENT_SOURCE_DIR}/${SRC_FBS}"
 349     DEPENDS flatc)
 350 endfunction()
 351
 352 if(FLATBUFFERS_BUILD_TESTS)
 353   compile_flatbuffers_schema_to_cpp(tests/monster_test.fbs)
 354   compile_flatbuffers_schema_to_cpp_opt(tests/native_type_test.fbs "")
 355   compile_flatbuffers_schema_to_cpp_opt(tests/arrays_test.fbs "--scoped-enums;--gen-compare")
 356   if(NOT (MSVC AND MSVC_VERSION LESS 1900))
 357     compile_flatbuffers_schema_to_cpp(tests/monster_extra.fbs) # Test floating-point NAN/INF.
 358   endif()
 359   include_directories(${CMAKE_CURRENT_BINARY_DIR}/tests)
 360   add_executable(flattests ${FlatBuffers_Tests_SRCS})
 361   set_property(TARGET flattests
 362     PROPERTY COMPILE_DEFINITIONS FLATBUFFERS_TRACK_VERIFIER_BUFFER_SIZE
 363     FLATBUFFERS_DEBUG_VERIFICATION_FAILURE=1)
 364   if(FLATBUFFERS_CODE_SANITIZE)
 365     if(WIN32)
 366       target_compile_definitions(flattests PRIVATE FLATBUFFERS_MEMORY_LEAK_TRACKING)
 367       message(STATUS "Sanitizer MSVC::_CrtDumpMemoryLeaks added to flattests")
 368     else()
 369       add_fsanitize_to_target(flattests ${FLATBUFFERS_CODE_SANITIZE})
 370     endif()
 371   endif()
 372
 373   compile_flatbuffers_schema_to_cpp(samples/monster.fbs)
 374   include_directories(${CMAKE_CURRENT_BINARY_DIR}/samples)
 375   add_executable(flatsamplebinary ${FlatBuffers_Sample_Binary_SRCS})
 376   add_executable(flatsampletext ${FlatBuffers_Sample_Text_SRCS})
 377   add_executable(flatsamplebfbs ${FlatBuffers_Sample_BFBS_SRCS})
 378 endif()
 379
 380 if(FLATBUFFERS_BUILD_GRPCTEST)
 381   if(CMAKE_COMPILER_IS_GNUCXX)
 382     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-unused-parameter -Wno-shadow")
 383   endif()
 384   if(NOT GRPC_INSTALL_PATH)
 385     message(SEND_ERROR "GRPC_INSTALL_PATH variable is not defined. See grpc/README.md")
 386   endif()
 387   if(NOT PROTOBUF_DOWNLOAD_PATH)
 388     message(SEND_ERROR "PROTOBUF_DOWNLOAD_PATH variable is not defined. See grpc/README.md")
 389   endif()
 390   INCLUDE_DIRECTORIES(${GRPC_INSTALL_PATH}/include)
 391   INCLUDE_DIRECTORIES(${PROTOBUF_DOWNLOAD_PATH}/src)
 392   LINK_DIRECTORIES(${GRPC_INSTALL_PATH}/lib)
 393   add_executable(grpctest ${FlatBuffers_GRPCTest_SRCS})
 394   target_link_libraries(grpctest grpc++_unsecure grpc_unsecure gpr pthread dl)
 395 endif()
 396
 397 include(CMake/Version.cmake)
 398
 399 if(FLATBUFFERS_INSTALL)
 400   include(GNUInstallDirs)
 401
 402   install(DIRECTORY include/flatbuffers DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
 403
 404   set(FB_CMAKE_DIR "${CMAKE_INSTALL_LIBDIR}/cmake/flatbuffers")
 405
 406   configure_file(CMake/FlatbuffersConfigVersion.cmake.in FlatbuffersConfigVersion.cmake @ONLY)
 407   install(
 408       FILES "CMake/FlatbuffersConfig.cmake" "${CMAKE_CURRENT_BINARY_DIR}/FlatbuffersConfigVersion.cmake"
 409       DESTINATION ${FB_CMAKE_DIR}
 410   )
 411
 412   if(FLATBUFFERS_BUILD_FLATLIB)
 413     if(CMAKE_VERSION VERSION_LESS 3.0)
 414       install(
 415         TARGETS flatbuffers EXPORT FlatbuffersTargets
 416         ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
 417       )
 418     else()
 419       install(
 420         TARGETS flatbuffers EXPORT FlatbuffersTargets
 421         ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
 422         INCLUDES DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
 423       )
 424     endif()
 425
 426     install(EXPORT FlatbuffersTargets
 427       FILE FlatbuffersTargets.cmake
 428       NAMESPACE flatbuffers::
 429       DESTINATION ${FB_CMAKE_DIR}
 430     )
 431   endif()
 432
 433   if(FLATBUFFERS_BUILD_FLATC)
 434     install(
 435       TARGETS flatc EXPORT FlatcTargets
 436       RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
 437     )
 438
 439     install(
 440       EXPORT FlatcTargets
 441       FILE FlatcTargets.cmake
 442       NAMESPACE flatbuffers::
 443       DESTINATION ${FB_CMAKE_DIR}
 444     )
 445   endif()
 446
 447   if(FLATBUFFERS_BUILD_SHAREDLIB)
 448     if(CMAKE_VERSION VERSION_LESS 3.0)
 449       install(
 450         TARGETS flatbuffers_shared EXPORT FlatbuffersSharedTargets
 451         ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
 452         RUNTIME DESTINATION ${CMAKE_INSTALL_LIBDIR}
 453         LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
 454       )
 455     else()
 456       install(
 457         TARGETS flatbuffers_shared EXPORT FlatbuffersSharedTargets
 458         ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
 459         RUNTIME DESTINATION ${CMAKE_INSTALL_LIBDIR}
 460         LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
 461         INCLUDES DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
 462       )
 463     endif()
 464
 465   install(
 466       EXPORT FlatbuffersSharedTargets
 467       FILE FlatbuffersSharedTargets.cmake
 468       NAMESPACE flatbuffers::
 469       DESTINATION ${FB_CMAKE_DIR}
 470     )
 471   endif()
 472 endif()
 473
 474 if(FLATBUFFERS_BUILD_TESTS)
 475   enable_testing()
 476
 477   file(COPY "${CMAKE_CURRENT_SOURCE_DIR}/tests" DESTINATION
 478        "${CMAKE_CURRENT_BINARY_DIR}")
 479   add_test(NAME flattests COMMAND flattests)
 480   if(FLATBUFFERS_BUILD_GRPCTEST)
 481     add_test(NAME grpctest COMMAND grpctest)
 482   endif()
 483 endif()
 484
 485 include(CMake/BuildFlatBuffers.cmake)
 486
 487 if(UNIX)
 488     # Use of CPack only supported on Linux systems.
 489     if(FLATBUFFERS_PACKAGE_DEBIAN)
 490         include(CMake/PackageDebian.cmake)
 491     endif()
 492     if (FLATBUFFERS_PACKAGE_REDHAT)
 493         include(CMake/PackageRedhat.cmake)
 494     endif()
 495     include(CPack)
 496 endif()