CMakeLists.txt

   1 cmake_minimum_required(VERSION 2.8.12)
   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 option(FLATBUFFERS_BUILD_CPP17
  35        "Enable the build of c++17 test target. \"
  36        Requirements: Clang6, GCC7, MSVC2017 (_MSC_VER >= 1914)  or higher."
  37        OFF)
  38 option(FLATBUFFERS_BUILD_LEGACY
  39        "Run C++ code generator with '--cpp-std c++0x' switch."
  40        OFF)
  41 option(FLATBUFFERS_ENABLE_PCH
  42        "Enable precompile headers support for 'flatbuffers' and 'flatc'. \"
  43         Only work if CMake supports 'target_precompile_headers'. \"
  44         This can speed up compilation time."
  45        OFF)
  46
  47 if(NOT FLATBUFFERS_BUILD_FLATC AND FLATBUFFERS_BUILD_TESTS)
  48     message(WARNING
  49     "Cannot build tests without building the compiler. Tests will be disabled.")
  50     set(FLATBUFFERS_BUILD_TESTS OFF)
  51 endif()
  52
  53 if(DEFINED FLATBUFFERS_MAX_PARSING_DEPTH)
  54   # Override the default recursion depth limit.
  55   add_definitions(-DFLATBUFFERS_MAX_PARSING_DEPTH=${FLATBUFFERS_MAX_PARSING_DEPTH})
  56   message(STATUS "FLATBUFFERS_MAX_PARSING_DEPTH: ${FLATBUFFERS_MAX_PARSING_DEPTH}")
  57 endif()
  58
  59 # Auto-detect locale-narrow 'strtod_l' and  'strtoull_l' functions.
  60 if(NOT DEFINED FLATBUFFERS_LOCALE_INDEPENDENT)
  61   set(FLATBUFFERS_LOCALE_INDEPENDENT 0)
  62   if(MSVC)
  63     check_cxx_symbol_exists(_strtof_l stdlib.h FLATBUFFERS_HAS_STRTOF_L)
  64     check_cxx_symbol_exists(_strtoui64_l stdlib.h FLATBUFFERS_HAS_STRTOULL_L)
  65   else()
  66     check_cxx_symbol_exists(strtof_l stdlib.h FLATBUFFERS_HAS_STRTOF_L)
  67     check_cxx_symbol_exists(strtoull_l stdlib.h FLATBUFFERS_HAS_STRTOULL_L)
  68   endif()
  69   if(FLATBUFFERS_HAS_STRTOF_L AND FLATBUFFERS_HAS_STRTOULL_L)
  70     set(FLATBUFFERS_LOCALE_INDEPENDENT 1)
  71   endif()
  72 endif()
  73 add_definitions(-DFLATBUFFERS_LOCALE_INDEPENDENT=$<BOOL:${FLATBUFFERS_LOCALE_INDEPENDENT}>)
  74
  75 set(FlatBuffers_Library_SRCS
  76   include/flatbuffers/base.h
  77   include/flatbuffers/flatbuffers.h
  78   include/flatbuffers/hash.h
  79   include/flatbuffers/idl.h
  80   include/flatbuffers/util.h
  81   include/flatbuffers/reflection.h
  82   include/flatbuffers/reflection_generated.h
  83   include/flatbuffers/stl_emulation.h
  84   include/flatbuffers/flexbuffers.h
  85   include/flatbuffers/registry.h
  86   include/flatbuffers/minireflect.h
  87   src/idl_parser.cpp
  88   src/idl_gen_text.cpp
  89   src/reflection.cpp
  90   src/util.cpp
  91 )
  92
  93 set(FlatBuffers_Compiler_SRCS
  94   ${FlatBuffers_Library_SRCS}
  95   src/idl_gen_cpp.cpp
  96   src/idl_gen_csharp.cpp
  97   src/idl_gen_dart.cpp
  98   src/idl_gen_kotlin.cpp
  99   src/idl_gen_go.cpp
 100   src/idl_gen_java.cpp
 101   src/idl_gen_ts.cpp
 102   src/idl_gen_php.cpp
 103   src/idl_gen_python.cpp
 104   src/idl_gen_lobster.cpp
 105   src/idl_gen_lua.cpp
 106   src/idl_gen_rust.cpp
 107   src/idl_gen_fbs.cpp
 108   src/idl_gen_grpc.cpp
 109   src/idl_gen_json_schema.cpp
 110   src/idl_gen_swift.cpp
 111   src/flatc.cpp
 112   src/flatc_main.cpp
 113   include/flatbuffers/code_generators.h
 114   src/code_generators.cpp
 115   grpc/src/compiler/schema_interface.h
 116   grpc/src/compiler/cpp_generator.h
 117   grpc/src/compiler/cpp_generator.cc
 118   grpc/src/compiler/go_generator.h
 119   grpc/src/compiler/go_generator.cc
 120   grpc/src/compiler/java_generator.h
 121   grpc/src/compiler/java_generator.cc
 122   grpc/src/compiler/python_generator.h
 123   grpc/src/compiler/python_private_generator.h
 124   grpc/src/compiler/python_generator.cc
 125   grpc/src/compiler/swift_generator.h
 126   grpc/src/compiler/swift_generator.cc
 127   grpc/src/compiler/ts_generator.h
 128   grpc/src/compiler/ts_generator.cc
 129 )
 130
 131 set(FlatHash_SRCS
 132   include/flatbuffers/hash.h
 133   src/flathash.cpp
 134 )
 135
 136 set(FlatBuffers_Tests_SRCS
 137   ${FlatBuffers_Library_SRCS}
 138   src/idl_gen_fbs.cpp
 139   tests/test.cpp
 140   tests/test_assert.h
 141   tests/test_assert.cpp
 142   tests/test_builder.h
 143   tests/test_builder.cpp
 144   tests/native_type_test_impl.h
 145   tests/native_type_test_impl.cpp
 146   include/flatbuffers/code_generators.h
 147   src/code_generators.cpp
 148   # file generate by running compiler on tests/monster_test.fbs
 149   ${CMAKE_CURRENT_BINARY_DIR}/tests/monster_test_generated.h
 150   # file generate by running compiler on namespace_test/namespace_test1.fbs
 151   ${CMAKE_CURRENT_BINARY_DIR}/tests/namespace_test/namespace_test1_generated.h
 152   ${CMAKE_CURRENT_BINARY_DIR}/tests/namespace_test/namespace_test2_generated.h
 153   # file generate by running compiler on union_vector/union_vector.fbs
 154   ${CMAKE_CURRENT_BINARY_DIR}/tests/union_vector/union_vector_generated.h
 155   # file generate by running compiler on tests/arrays_test.fbs
 156   ${CMAKE_CURRENT_BINARY_DIR}/tests/arrays_test_generated.h
 157   # file generate by running compiler on tests/native_type_test.fbs
 158   ${CMAKE_CURRENT_BINARY_DIR}/tests/native_type_test_generated.h
 159   # file generate by running compiler on tests/monster_extra.fbs
 160   ${CMAKE_CURRENT_BINARY_DIR}/tests/monster_extra_generated.h
 161   # file generate by running compiler on tests/monster_test.fbs
 162   ${CMAKE_CURRENT_BINARY_DIR}/tests/monster_test_bfbs_generated.h
 163   # file generate by running compiler on tests/optional_scalars.fbs
 164   ${CMAKE_CURRENT_BINARY_DIR}/tests/optional_scalars_generated.h
 165 )
 166
 167 set(FlatBuffers_Tests_CPP17_SRCS
 168   ${FlatBuffers_Library_SRCS}
 169   tests/test_assert.h
 170   tests/test_assert.cpp
 171   tests/cpp17/test_cpp17.cpp
 172   # file generate by running compiler on tests/monster_test.fbs
 173   ${CMAKE_CURRENT_BINARY_DIR}/tests/cpp17/generated_cpp17/monster_test_generated.h
 174   ${CMAKE_CURRENT_BINARY_DIR}/tests/monster_test_generated.h
 175   ${CMAKE_CURRENT_BINARY_DIR}/tests/cpp17/generated_cpp17/optional_scalars_generated.h
 176   ${CMAKE_CURRENT_BINARY_DIR}/tests/optional_scalars_generated.h
 177 )
 178
 179 set(FlatBuffers_Sample_Binary_SRCS
 180   include/flatbuffers/flatbuffers.h
 181   samples/sample_binary.cpp
 182   # file generated by running compiler on samples/monster.fbs
 183   ${CMAKE_CURRENT_BINARY_DIR}/samples/monster_generated.h
 184 )
 185
 186 set(FlatBuffers_Sample_Text_SRCS
 187   ${FlatBuffers_Library_SRCS}
 188   samples/sample_text.cpp
 189   # file generated by running compiler on samples/monster.fbs
 190   ${CMAKE_CURRENT_BINARY_DIR}/samples/monster_generated.h
 191 )
 192
 193 set(FlatBuffers_Sample_BFBS_SRCS
 194   ${FlatBuffers_Library_SRCS}
 195   samples/sample_bfbs.cpp
 196   # file generated by running compiler on samples/monster.fbs
 197   ${CMAKE_CURRENT_BINARY_DIR}/samples/monster_generated.h
 198 )
 199
 200 set(FlatBuffers_GRPCTest_SRCS
 201   include/flatbuffers/flatbuffers.h
 202   include/flatbuffers/grpc.h
 203   include/flatbuffers/util.h
 204   src/util.cpp
 205   tests/monster_test.grpc.fb.h
 206   tests/test_assert.h
 207   tests/test_builder.h
 208   tests/monster_test.grpc.fb.cc
 209   tests/test_assert.cpp
 210   tests/test_builder.cpp
 211   grpc/tests/grpctest.cpp
 212   grpc/tests/message_builder_test.cpp
 213   # file generate by running compiler on tests/monster_test.fbs
 214   ${CMAKE_CURRENT_BINARY_DIR}/tests/monster_test_generated.h
 215 )
 216
 217 # source_group(Compiler FILES ${FlatBuffers_Compiler_SRCS})
 218 # source_group(Tests FILES ${FlatBuffers_Tests_SRCS})
 219
 220 if(EXISTS "${CMAKE_TOOLCHAIN_FILE}")
 221   # do not apply any global settings if the toolchain
 222   # is being configured externally
 223   message(STATUS "Using toolchain file: ${CMAKE_TOOLCHAIN_FILE}.")
 224 elseif(APPLE)
 225   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -stdlib=libc++")
 226   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -pedantic -Werror -Wextra -Wno-unused-parameter")
 227   set(FLATBUFFERS_PRIVATE_CXX_FLAGS "-Wold-style-cast")
 228 elseif(CMAKE_COMPILER_IS_GNUCXX)
 229   if(CYGWIN)
 230     set(CMAKE_CXX_FLAGS
 231       "${CMAKE_CXX_FLAGS} -std=gnu++11")
 232   else(CYGWIN)
 233     set(CMAKE_CXX_FLAGS
 234       "${CMAKE_CXX_FLAGS} -std=c++0x")
 235   endif(CYGWIN)
 236   set(CMAKE_CXX_FLAGS
 237     "${CMAKE_CXX_FLAGS} -Wall -pedantic -Werror -Wextra -Werror=shadow")
 238   set(FLATBUFFERS_PRIVATE_CXX_FLAGS "-Wold-style-cast")
 239   if (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 4.4)
 240     if (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 7.0)
 241       set(CMAKE_CXX_FLAGS
 242         "${CMAKE_CXX_FLAGS} -faligned-new -Werror=implicit-fallthrough=2")
 243     endif()
 244     set(CMAKE_CXX_FLAGS
 245       "${CMAKE_CXX_FLAGS} -Wunused-result -Werror=unused-result -Wunused-parameter -Werror=unused-parameter")
 246   endif()
 247
 248   # Certain platforms such as ARM do not use signed chars by default
 249   # which causes issues with certain bounds checks.
 250   set(CMAKE_CXX_FLAGS
 251     "${CMAKE_CXX_FLAGS} -fsigned-char")
 252
 253 elseif(${CMAKE_CXX_COMPILER_ID} MATCHES "Clang")
 254   set(CMAKE_CXX_FLAGS
 255       "${CMAKE_CXX_FLAGS} -std=c++0x -Wall -pedantic -Werror -Wextra -Wno-unused-parameter")
 256   set(FLATBUFFERS_PRIVATE_CXX_FLAGS "-Wold-style-cast")
 257   if(NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 3.8)
 258     list(APPEND FLATBUFFERS_PRIVATE_CXX_FLAGS "-Wimplicit-fallthrough" "-Wextra-semi" "-Werror=unused-private-field") # enable warning
 259   endif()
 260   if(FLATBUFFERS_LIBCXX_WITH_CLANG)
 261     if(NOT "${CMAKE_SYSTEM_NAME}" MATCHES "Linux")
 262       set(CMAKE_CXX_FLAGS
 263           "${CMAKE_CXX_FLAGS} -stdlib=libc++")
 264     endif()
 265     if(NOT ("${CMAKE_SYSTEM_NAME}" MATCHES "FreeBSD" OR
 266             "${CMAKE_SYSTEM_NAME}" MATCHES "Linux"))
 267       set(CMAKE_EXE_LINKER_FLAGS
 268           "${CMAKE_EXE_LINKER_FLAGS} -lc++abi")
 269     endif()
 270   endif()
 271
 272   # Certain platforms such as ARM do not use signed chars by default
 273   # which causes issues with certain bounds checks.
 274   set(CMAKE_CXX_FLAGS
 275     "${CMAKE_CXX_FLAGS} -fsigned-char")
 276
 277 elseif(MSVC)
 278   # Visual Studio pedantic build settings
 279   # warning C4512: assignment operator could not be generated
 280   # warning C4316: object allocated on the heap may not be aligned
 281   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W4 /WX /wd4512 /wd4316")
 282
 283   # multi-core build.
 284   add_definitions("/MP")
 285 endif()
 286
 287 # Append FLATBUFFERS_CXX_FLAGS to CMAKE_CXX_FLAGS.
 288 if(DEFINED FLATBUFFERS_CXX_FLAGS AND NOT EXISTS "${CMAKE_TOOLCHAIN_FILE}")
 289   message(STATUS "extend CXX_FLAGS with ${FLATBUFFERS_CXX_FLAGS}")
 290   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${FLATBUFFERS_CXX_FLAGS}")
 291 endif()
 292 message(STATUS "CMAKE_CXX_FLAGS: ${CMAKE_CXX_FLAGS}")
 293
 294 if(FLATBUFFERS_CODE_COVERAGE)
 295   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g -fprofile-arcs -ftest-coverage")
 296   set(CMAKE_EXE_LINKER_FLAGS
 297       "${CMAKE_EXE_LINKER_FLAGS} -fprofile-arcs -ftest-coverage")
 298 endif()
 299
 300 function(add_fsanitize_to_target _target _sanitizer)
 301   if(WIN32)
 302     target_compile_definitions(${_target} PRIVATE FLATBUFFERS_MEMORY_LEAK_TRACKING)
 303     message(STATUS "Sanitizer MSVC::_CrtDumpMemoryLeaks added to ${_target}")
 304   else()
 305     # FLATBUFFERS_CODE_SANITIZE: boolean {ON,OFF,YES,NO} or string with list of sanitizer.
 306     # List of sanitizer is string starts with '=': "=address,undefined,thread,memory".
 307     if((${CMAKE_CXX_COMPILER_ID} MATCHES "Clang") OR
 308       ((${CMAKE_CXX_COMPILER_ID} MATCHES "GNU") AND NOT (CMAKE_CXX_COMPILER_VERSION VERSION_LESS "4.9"))
 309     )
 310       set(_sanitizer_flags "=address,undefined")
 311       if(_sanitizer MATCHES "=.*")
 312         # override default by user-defined sanitizer list
 313         set(_sanitizer_flags ${_sanitizer})
 314       endif()
 315       target_compile_options(${_target} PRIVATE
 316         -g -fsigned-char -fno-omit-frame-pointer
 317         "-fsanitize${_sanitizer_flags}")
 318       target_link_libraries(${_target} PRIVATE
 319         "-fsanitize${_sanitizer_flags}")
 320       set_property(TARGET ${_target} PROPERTY POSITION_INDEPENDENT_CODE ON)
 321       message(STATUS "Sanitizer ${_sanitizer_flags} added to ${_target}")
 322     endif()
 323   endif()
 324 endfunction()
 325
 326 function(add_pch_to_target _target _pch_header)
 327   if(COMMAND target_precompile_headers)
 328     target_precompile_headers(${_target} PRIVATE ${_pch_header})
 329     if(NOT MSVC)
 330       set_source_files_properties(src/util.cpp PROPERTIES SKIP_PRECOMPILE_HEADERS ON)
 331     endif()
 332   endif()
 333 endfunction()
 334
 335 if(BIICODE)
 336   include(biicode/cmake/biicode.cmake)
 337   return()
 338 endif()
 339
 340 include_directories(include)
 341 include_directories(grpc)
 342
 343 if(FLATBUFFERS_BUILD_FLATLIB)
 344   add_library(flatbuffers STATIC ${FlatBuffers_Library_SRCS})
 345   # Attach header directory for when build via add_subdirectory().
 346   target_include_directories(flatbuffers INTERFACE
 347     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>)
 348   target_compile_options(flatbuffers PRIVATE "${FLATBUFFERS_PRIVATE_CXX_FLAGS}")
 349   if(FLATBUFFERS_ENABLE_PCH)
 350     add_pch_to_target(flatbuffers include/flatbuffers/pch/pch.h)
 351   endif()
 352 endif()
 353
 354 if(FLATBUFFERS_BUILD_FLATC)
 355   add_executable(flatc ${FlatBuffers_Compiler_SRCS})
 356   if(FLATBUFFERS_ENABLE_PCH)
 357     add_pch_to_target(flatc include/flatbuffers/pch/flatc_pch.h)
 358   endif()
 359   target_compile_options(flatc PRIVATE "${FLATBUFFERS_PRIVATE_CXX_FLAGS}")
 360   if(FLATBUFFERS_CODE_SANITIZE AND NOT WIN32)
 361     add_fsanitize_to_target(flatc ${FLATBUFFERS_CODE_SANITIZE})
 362   endif()
 363   if(NOT FLATBUFFERS_FLATC_EXECUTABLE)
 364     set(FLATBUFFERS_FLATC_EXECUTABLE $<TARGET_FILE:flatc>)
 365   endif()
 366   if(MSVC)
 367     # Make flatc.exe not depend on runtime dlls for easy distribution.
 368     target_compile_options(flatc PUBLIC $<$<CONFIG:Release>:/MT>)
 369   endif()
 370   if(FLATBUFFERS_STATIC_FLATC AND NOT MSVC)
 371     target_link_libraries(flatc PRIVATE -static)
 372   endif()
 373 endif()
 374
 375 if(FLATBUFFERS_BUILD_FLATHASH)
 376   add_executable(flathash ${FlatHash_SRCS})
 377 endif()
 378
 379 if(FLATBUFFERS_BUILD_SHAREDLIB)
 380   add_library(flatbuffers_shared SHARED ${FlatBuffers_Library_SRCS})
 381
 382   # Shared object version: "major.minor.micro"
 383   # - micro updated every release when there is no API/ABI changes
 384   # - minor updated when there are additions in API/ABI
 385   # - major (ABI number) updated when there are changes in ABI (or removals)
 386   set(FlatBuffers_Library_SONAME_MAJOR "1")
 387   set(FlatBuffers_Library_SONAME_FULL "${FlatBuffers_Library_SONAME_MAJOR}.12.0")
 388   set_target_properties(flatbuffers_shared PROPERTIES OUTPUT_NAME flatbuffers
 389                         SOVERSION "${FlatBuffers_Library_SONAME_MAJOR}"
 390                         VERSION "${FlatBuffers_Library_SONAME_FULL}")
 391   if(FLATBUFFERS_ENABLE_PCH)
 392     add_pch_to_target(flatbuffers_shared include/flatbuffers/pch/pch.h)
 393   endif()
 394 endif()
 395
 396 # Global list of generated files.
 397 # Use the global property to be independent of PARENT_SCOPE.
 398 set_property(GLOBAL PROPERTY FBS_GENERATED_OUTPUTS)
 399
 400 function(get_generated_output generated_files)
 401   get_property(tmp GLOBAL PROPERTY FBS_GENERATED_OUTPUTS)
 402   set(${generated_files} ${tmp} PARENT_SCOPE)
 403 endfunction(get_generated_output)
 404
 405 function(register_generated_output file_name)
 406   get_property(tmp GLOBAL PROPERTY FBS_GENERATED_OUTPUTS)
 407   list(APPEND tmp ${file_name})
 408   set_property(GLOBAL PROPERTY FBS_GENERATED_OUTPUTS ${tmp})
 409 endfunction(register_generated_output)
 410
 411 function(compile_flatbuffers_schema_to_cpp_opt SRC_FBS OPT)
 412   if(FLATBUFFERS_BUILD_LEGACY)
 413     set(OPT ${OPT};--cpp-std c++0x)
 414   else()
 415     # --cpp-std is defined by flatc default settings.
 416   endif()
 417   message(STATUS "`${SRC_FBS}`: add generation of C++ code with '${OPT}'")
 418   get_filename_component(SRC_FBS_DIR ${SRC_FBS} PATH)
 419   string(REGEX REPLACE "\\.fbs$" "_generated.h" GEN_HEADER ${SRC_FBS})
 420   add_custom_command(
 421     OUTPUT ${GEN_HEADER}
 422     COMMAND "${FLATBUFFERS_FLATC_EXECUTABLE}"
 423             --cpp --gen-mutable --gen-object-api --reflect-names
 424             --cpp-ptr-type flatbuffers::unique_ptr # Used to test with C++98 STLs
 425             ${OPT}
 426             -I "${CMAKE_CURRENT_SOURCE_DIR}/tests/include_test"
 427             -o "${SRC_FBS_DIR}"
 428             "${CMAKE_CURRENT_SOURCE_DIR}/${SRC_FBS}"
 429     DEPENDS flatc
 430     COMMENT "Run generation: '${GEN_HEADER}'")
 431   register_generated_output(${GEN_HEADER})
 432 endfunction()
 433
 434 function(compile_flatbuffers_schema_to_cpp SRC_FBS)
 435   compile_flatbuffers_schema_to_cpp_opt(${SRC_FBS} "--no-includes;--gen-compare")
 436 endfunction()
 437
 438 function(compile_flatbuffers_schema_to_binary SRC_FBS)
 439   message(STATUS "`${SRC_FBS}`: add generation of binary (.bfbs) schema")
 440   get_filename_component(SRC_FBS_DIR ${SRC_FBS} PATH)
 441   string(REGEX REPLACE "\\.fbs$" ".bfbs" GEN_BINARY_SCHEMA ${SRC_FBS})
 442   # For details about flags see generate_code.bat(sh)
 443   add_custom_command(
 444     OUTPUT ${GEN_BINARY_SCHEMA}
 445     COMMAND "${FLATBUFFERS_FLATC_EXECUTABLE}"
 446             -b --schema --bfbs-comments --bfbs-builtins
 447             -I "${CMAKE_CURRENT_SOURCE_DIR}/tests/include_test"
 448             -o "${SRC_FBS_DIR}"
 449             "${CMAKE_CURRENT_SOURCE_DIR}/${SRC_FBS}"
 450     DEPENDS flatc
 451     COMMENT "Run generation: '${GEN_BINARY_SCHEMA}'")
 452   register_generated_output(${GEN_BINARY_SCHEMA})
 453 endfunction()
 454
 455 function(compile_flatbuffers_schema_to_embedded_binary SRC_FBS OPT)
 456   if(FLATBUFFERS_BUILD_LEGACY)
 457     set(OPT ${OPT};--cpp-std c++0x)
 458   else()
 459     # --cpp-std is defined by flatc default settings.
 460   endif()
 461   message(STATUS "`${SRC_FBS}`: add generation of C++ embedded binary schema code with '${OPT}'")
 462   get_filename_component(SRC_FBS_DIR ${SRC_FBS} PATH)
 463   string(REGEX REPLACE "\\.fbs$" "_bfbs_generated.h" GEN_BFBS_HEADER ${SRC_FBS})
 464   # For details about flags see generate_code.bat(sh)
 465   add_custom_command(
 466           OUTPUT ${GEN_BFBS_HEADER}
 467           COMMAND "${FLATBUFFERS_FLATC_EXECUTABLE}"
 468           --cpp --gen-mutable --gen-object-api --reflect-names
 469           --cpp-ptr-type flatbuffers::unique_ptr # Used to test with C++98 STLs
 470           ${OPT}
 471           --bfbs-comments --bfbs-builtins --bfbs-gen-embed
 472           -I "${CMAKE_CURRENT_SOURCE_DIR}/tests/include_test"
 473           -o "${SRC_FBS_DIR}"
 474           "${CMAKE_CURRENT_SOURCE_DIR}/${SRC_FBS}"
 475           DEPENDS flatc
 476           COMMENT "Run generation: '${GEN_BFBS_HEADER}'")
 477   register_generated_output(${GEN_BFBS_HEADER})
 478 endfunction()
 479
 480 if(FLATBUFFERS_BUILD_TESTS)
 481   file(COPY "${CMAKE_CURRENT_SOURCE_DIR}/tests" DESTINATION "${CMAKE_CURRENT_BINARY_DIR}")
 482   file(COPY "${CMAKE_CURRENT_SOURCE_DIR}/samples" DESTINATION "${CMAKE_CURRENT_BINARY_DIR}")
 483
 484   # TODO Add (monster_test.fbs monsterdata_test.json)->monsterdata_test.mon
 485   compile_flatbuffers_schema_to_cpp(tests/monster_test.fbs)
 486   compile_flatbuffers_schema_to_binary(tests/monster_test.fbs)
 487   compile_flatbuffers_schema_to_cpp(tests/namespace_test/namespace_test1.fbs)
 488   compile_flatbuffers_schema_to_cpp(tests/namespace_test/namespace_test2.fbs)
 489   compile_flatbuffers_schema_to_cpp(tests/union_vector/union_vector.fbs)
 490   compile_flatbuffers_schema_to_cpp(tests/optional_scalars.fbs)
 491   compile_flatbuffers_schema_to_cpp_opt(tests/native_type_test.fbs "")
 492   compile_flatbuffers_schema_to_cpp_opt(tests/arrays_test.fbs "--scoped-enums;--gen-compare")
 493   compile_flatbuffers_schema_to_binary(tests/arrays_test.fbs)
 494   compile_flatbuffers_schema_to_embedded_binary(tests/monster_test.fbs "--no-includes;--gen-compare")
 495   if(NOT (MSVC AND (MSVC_VERSION LESS 1900)))
 496     compile_flatbuffers_schema_to_cpp(tests/monster_extra.fbs) # Test floating-point NAN/INF.
 497   endif()
 498   include_directories(${CMAKE_CURRENT_BINARY_DIR}/tests)
 499   add_executable(flattests ${FlatBuffers_Tests_SRCS})
 500   add_dependencies(flattests generated_code)
 501   set_property(TARGET flattests
 502     PROPERTY COMPILE_DEFINITIONS FLATBUFFERS_TRACK_VERIFIER_BUFFER_SIZE
 503     FLATBUFFERS_DEBUG_VERIFICATION_FAILURE=1)
 504   if(FLATBUFFERS_CODE_SANITIZE)
 505     add_fsanitize_to_target(flattests ${FLATBUFFERS_CODE_SANITIZE})
 506   endif()
 507
 508   compile_flatbuffers_schema_to_cpp(samples/monster.fbs)
 509   compile_flatbuffers_schema_to_binary(samples/monster.fbs)
 510   include_directories(${CMAKE_CURRENT_BINARY_DIR}/samples)
 511   add_executable(flatsamplebinary ${FlatBuffers_Sample_Binary_SRCS})
 512   add_dependencies(flatsamplebinary generated_code)
 513   add_executable(flatsampletext ${FlatBuffers_Sample_Text_SRCS})
 514   add_dependencies(flatsampletext generated_code)
 515   add_executable(flatsamplebfbs ${FlatBuffers_Sample_BFBS_SRCS})
 516   add_dependencies(flatsamplebfbs generated_code)
 517
 518   if(FLATBUFFERS_BUILD_CPP17)
 519     # Don't generate header for flattests_cpp17 target.
 520     # This target uses "generated_cpp17/monster_test_generated.h"
 521     # produced by direct call of generate_code.bat(sh) script.
 522     add_executable(flattests_cpp17 ${FlatBuffers_Tests_CPP17_SRCS})
 523     add_dependencies(flattests_cpp17 generated_code)
 524     target_compile_features(flattests_cpp17 PRIVATE cxx_std_17)
 525     target_compile_definitions(flattests_cpp17 PRIVATE
 526       FLATBUFFERS_TRACK_VERIFIER_BUFFER_SIZE
 527       FLATBUFFERS_DEBUG_VERIFICATION_FAILURE=1
 528     )
 529     if(FLATBUFFERS_CODE_SANITIZE)
 530       add_fsanitize_to_target(flattests_cpp17 ${FLATBUFFERS_CODE_SANITIZE})
 531     endif()
 532   endif(FLATBUFFERS_BUILD_CPP17)
 533 endif()
 534
 535 if(FLATBUFFERS_BUILD_GRPCTEST)
 536   if(CMAKE_COMPILER_IS_GNUCXX)
 537     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-unused-parameter -Wno-shadow")
 538   endif()
 539   if(NOT GRPC_INSTALL_PATH)
 540     message(SEND_ERROR "GRPC_INSTALL_PATH variable is not defined. See grpc/README.md")
 541   endif()
 542   if(NOT PROTOBUF_DOWNLOAD_PATH)
 543     message(SEND_ERROR "PROTOBUF_DOWNLOAD_PATH variable is not defined. See grpc/README.md")
 544   endif()
 545   INCLUDE_DIRECTORIES(${GRPC_INSTALL_PATH}/include)
 546   INCLUDE_DIRECTORIES(${PROTOBUF_DOWNLOAD_PATH}/src)
 547   LINK_DIRECTORIES(${GRPC_INSTALL_PATH}/lib)
 548   add_executable(grpctest ${FlatBuffers_GRPCTest_SRCS})
 549   add_dependencies(grpctest generated_code)
 550   target_link_libraries(grpctest PRIVATE grpc++_unsecure grpc_unsecure gpr pthread dl)
 551   if(FLATBUFFERS_CODE_SANITIZE AND NOT WIN32)
 552     # GRPC test has problems with alignment and will fail under ASAN/UBSAN.
 553     # add_fsanitize_to_target(grpctest ${FLATBUFFERS_CODE_SANITIZE})
 554   endif()
 555 endif()
 556
 557 include(CMake/Version.cmake)
 558
 559 if(FLATBUFFERS_INSTALL)
 560   include(GNUInstallDirs)
 561
 562   install(DIRECTORY include/flatbuffers DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
 563
 564   set(FB_CMAKE_DIR "${CMAKE_INSTALL_LIBDIR}/cmake/flatbuffers")
 565
 566   configure_file(CMake/FlatbuffersConfigVersion.cmake.in FlatbuffersConfigVersion.cmake @ONLY)
 567   install(
 568       FILES "CMake/FlatbuffersConfig.cmake" "${CMAKE_CURRENT_BINARY_DIR}/FlatbuffersConfigVersion.cmake"
 569       DESTINATION ${FB_CMAKE_DIR}
 570   )
 571
 572   if(FLATBUFFERS_BUILD_FLATLIB)
 573     if(CMAKE_VERSION VERSION_LESS 3.0)
 574       install(
 575         TARGETS flatbuffers EXPORT FlatbuffersTargets
 576         ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
 577       )
 578     else()
 579       install(
 580         TARGETS flatbuffers EXPORT FlatbuffersTargets
 581         ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
 582         INCLUDES DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
 583       )
 584     endif()
 585
 586     install(EXPORT FlatbuffersTargets
 587       FILE FlatbuffersTargets.cmake
 588       NAMESPACE flatbuffers::
 589       DESTINATION ${FB_CMAKE_DIR}
 590     )
 591   endif()
 592
 593   if(FLATBUFFERS_BUILD_FLATC)
 594     install(
 595       TARGETS flatc EXPORT FlatcTargets
 596       RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
 597     )
 598
 599     install(
 600       EXPORT FlatcTargets
 601       FILE FlatcTargets.cmake
 602       NAMESPACE flatbuffers::
 603       DESTINATION ${FB_CMAKE_DIR}
 604     )
 605   endif()
 606
 607   if(FLATBUFFERS_BUILD_SHAREDLIB)
 608     if(CMAKE_VERSION VERSION_LESS 3.0)
 609       install(
 610         TARGETS flatbuffers_shared EXPORT FlatbuffersSharedTargets
 611         ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
 612         RUNTIME DESTINATION ${CMAKE_INSTALL_LIBDIR}
 613         LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
 614       )
 615     else()
 616       install(
 617         TARGETS flatbuffers_shared EXPORT FlatbuffersSharedTargets
 618         ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
 619         RUNTIME DESTINATION ${CMAKE_INSTALL_LIBDIR}
 620         LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
 621         INCLUDES DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
 622       )
 623     endif()
 624
 625   install(
 626       EXPORT FlatbuffersSharedTargets
 627       FILE FlatbuffersSharedTargets.cmake
 628       NAMESPACE flatbuffers::
 629       DESTINATION ${FB_CMAKE_DIR}
 630     )
 631   endif()
 632 endif()
 633
 634 if(FLATBUFFERS_BUILD_TESTS)
 635   enable_testing()
 636
 637   add_test(NAME flattests COMMAND flattests)
 638   if(FLATBUFFERS_BUILD_CPP17)
 639     add_test(NAME flattests_cpp17 COMMAND flattests_cpp17)
 640   endif()
 641   if(FLATBUFFERS_BUILD_GRPCTEST)
 642     add_test(NAME grpctest COMMAND grpctest)
 643   endif()
 644 endif()
 645
 646 # This target is sync-barrier.
 647 # Other generate-dependent targets can depend on 'generated_code' only.
 648 get_generated_output(fbs_generated)
 649 if(fbs_generated)
 650   # message(STATUS "Add generated_code target with files:${fbs_generated}")
 651   add_custom_target(generated_code
 652     DEPENDS ${fbs_generated}
 653     COMMENT "All generated files were updated.")
 654 endif()
 655
 656 include(CMake/BuildFlatBuffers.cmake)
 657
 658 if(UNIX)
 659     # Use of CPack only supported on Linux systems.
 660     if(FLATBUFFERS_PACKAGE_DEBIAN)
 661         include(CMake/PackageDebian.cmake)
 662         include(CPack)
 663     endif()
 664     if (FLATBUFFERS_PACKAGE_REDHAT)
 665         include(CMake/PackageRedhat.cmake)
 666         include(CPack)
 667     endif()
 668 endif()