Squashed 'third_party/flatbuffers/' changes from e5f331db9..bc44fad35
bc44fad35 UnPackTo disable merge by default (#7527)
4fca4dc60 [TS/JS] Move TS tests to dedicated folder and deps upgrade (#7508)
036032373 Bump junit from 4.13 to 4.13.1 in /java (#7526)
89dfb43f3 Replace `bash JavaTest.sh` with `mvn test` (#7500)
c49aff4b6 enabled cpp17 tests in CI (#7524)
56e60223c prevent force_align attribute on enums (#7523)
89b1f5aa1 remove travis config (#7522)
b90159823 [Java][Flexbuffers] Add API to add nullables into the buffer. (#7521)
8cdc6a288 Install BuildFlatBuffers.cmake (#7519)
a67e35aff Moves all of the swift test code into tests/swift (#7509)
f124e41ae Updated Readme
4c954181c [Java][FlexBuffers] throwing exception for untyped fixed vectors (#7507)
7f7547737 [Android] Remove maven dependency of flatbuffers and use source folder (#7503)
a79d61ea8 Fixes issue with cocoapods failing to be published because of docc (#7505)
d465b39c3 [CMake]: fix breaking find_package change (#7499) (#7502)
c5a609dc2 [C#] Prepares for official Nuget release (#7496)
5634dc3d0 [ISSUE-6268] returns NaN insteadof nan (#7498)
37e37b8ca Updates cocoapods version (#7497)
8fd4534fb update android multidex setting (#7495)
d5427da52 Disable Android Build (#7494)
06c5c7ed0 FlatBuffers Version 2.0.8 (#7492)
b190ce11b Verifier Refinements (#7490)
bf5d23230 Namer applied to Typescript generator (#7488)
ce382d6dd [TS/JS] Add rollup and config to generate iife flatbuffers bundle (#7449)
41d9add7e C++: Add option to skip verifying nested flatbuffers (#7489)
6a8742754 [C++] support native_inline attribute for vector of tables (#7479)
694add668 Refactor test.cpp (#7487)
7edf8c908 Update scorecard to 1.1.2
b86387442 Fix typos (#7483)
e2eb5ee67 Include <array> head in stl_emulation.h (#7480)
994502b6d Version number in file package.json updated to 2.0.7 (#7476)
fa41e8367 [C++] Fixed crash when copying table with empty shared strings (#7477)
799cc8f7b Use type traits for specialization (#7475)
b7eb44147 Disable RTTI and rework use in idl_gen_ts.cpp (#7474)
8d01c5859 CMake project version detection made more robust (#7473)
237e8b71f Moved compiler warnings around (#7471)
eeb8fd60d Include builder.addOffset for vector of structs (#7470)
fef2ffc4d Use schema include name for keep-prefix (#7469)
8367664f1 Flatbuffers Version 2.0.7 (#7462)
d6f06c33f Reworked keep prefix (#7456)
627e8bf36 update grpc version (#7457)
883c42b7d disabling unpackto optimization (#7459)
7aae0af30 Remove old GRPC bash script and convert to python3 (#7454)
b057aa917 Grouped anonymous namespaces together, (#7455)
f1b26ff7f Change to GetTypeName (#7453)
9610a666b Generate SLSA signatures for Released zip files (#7450)
1e0f75a64 [WIP] speedup (#7452)
82b75407a Wrap types in namespace for --ts-flat-files and --gen-all (#7451)
f7c511957 Audit and fixups for GCC and Clang (#7212)
a66de58af Partial support for --ts-flat-files and --gen-all (#7446)
a3508f36d [Kotlin] Make sure namespace path exist for code generation (#7357)
137fec716 Stop using __has_trivial_copy on recent clang versions. (#7443)
214125e41 [C#] Rework how sorted vectors are looked up (#7441)
44a7dc999 Define minimum buffer size (#7440)
3cc2daa78 make_span overloads for pointer to vector (#7374) (#7435)
fa1174aa7 [TypeScript] Fix namespaceless schema generation (#7432)
83d4e2a10 Add checks to verifier (#7438)
8a09f3fb0 Fix FlexBuffers JS/TS bug https://github.com/google/flatbuffers/issues/6934 (#7434)
9dbe819ef Add flatc python tests to CI (#7437)
67c414958 Update TypeScriptTest.py to work better cross platform (#7436)
8b8c7dbdf Update gitingore to reflect name change (#7431)
2ee20a5f3 Remove auto including locale functions (#7430)
4be605604 [C++] Set StructDef::has_key property when deserializing from binary schema (#7386) (#7428)
fc5d86f1e [C++] Make template parameter in stl_emulation.h more explicit to avoid conflicts with cpprestsdk U macro (#7424)
9dce287ad Issue#6959 :Updated Automatically generated rust files. (#7425)
7798be3bb avoid zero-as-null-pointer warning (#7423)
966362e07 [C++] Vector of Tables equality (#7415)
a89c279ed [golang] Perform keyword escaping after case conversion (#7421)
a212b3c03 Turn of fail fast for C++ CI
9230f600d Remove stringop-overflow from error (#7422)
c79362156 [golang] Add support for text parsing with json struct tags (#7353)
ee2ced236 Moved TypeScriptTests to python script (#7411)
468c00a3f Rebased: grpc/compiler: Respect filename suffix and extension during code generation (#7414)
47c757f71 Add tests for flatc (#7405)
9a5ff8900 Add FLATBUFFERS_STRICT_MODE (#7408)
950444a34 [TS] Use TextEncoder and TextDecoder (#7400)
30d76198c Compilation issue msys2 #7399 (#7409)
cce3a66f0 Delete .travis directory
8d1cc6ac7 Revert "Compilation issue msys2 (#7403)" (#7407)
5b207639a Update readme.md
359e0f9d6 Revert "grpc/compiler: Respect filename suffix and extension during code generation (#7343)" (#7406)
ebbed0513 Delete cpp-linter.yml
aa395e5a5 (#7323) Rename CMake files according to project name (#7378)
32328075d Fix error msg format when generate GRPC failed (#7350)
97e89c5ac grpc/compiler: Respect filename suffix and extension during code generation (#7343)
5f6672be4 Fix Clang-Cl compile on Windows (#7308)
28e858c85 [TS/Bazel] Minor improvements to typescript.bzl (#7300)
987bebe67 [TS] fix incorrect reverse when writting array of structs (#7271)
ec0129369 Fix FlexBuffers Verifier tracking vectors reuse at wrong offset
50dd385b3 Add missing const (#7401)
da702cfd8 Compilation issue msys2 (#7403)
6e2791640 keep-prefix keeps relative pathing (#7394)
52fce5e53 fix(#7360): grpc used deprecated functions (#7361)
b7f13cd8e cpp_generator: comment out unused parameter to avoid warnings (#7381)
e42985e5a Updated Newtonsoft.Json to 13.0.1 (#7393)
0a8064637 Fix references to LICENSE file (#7377)
b9eea76a8 [Dart] Implement putBool to fix errors when serializing structs with bools (#7359)
1b9030015 Bump Newtonsoft.Json from 12.0.3 to 13.0.1 in /tests/FlatBuffers.Test (#7363)
83a43fc79 Reenable optional json (#7352)
5f0137602 Only include direct included filed (#7348)
9a1913a87 Revert "Implement optional scalars for JSON (#7322)" (#7351)
b4647beb8 Revert "Move reflection_ts_fbs into a separate directory (#7342)" (#7349)
d6060977a Remove asserting in verifier for flattests
987aa5b5e move -Wextra-semi to GCC 8.0+
42acdb63c [TS] Don't generate self-imports with --ts-flat-file (#7340)
0cc1aeb8c [golang] Create missing namespace directory structure (#7324) (#7325)
ba6c67170 [Kotlin] Remove download benchmark files dependency (#7314)
d2f33fc45 Disable Android on Linux CI build
0d1b72cbc [TS] fix ts import path issue (#7298)
9fce2fbf2 replace io/ioutil to os (#7281)
a18ea40d6 Implement optional scalars for JSON (#7322)
090caa280 Move reflection_ts_fbs into a separate directory (#7342)
49e1ea333 Implement optional scalars for Python (#7318)
11a198870 Started implementation for private flags in rust (#7269)
967df08b1 Adds full supposed for Wasm in the swift lib (#7328)
9aa08a429 Use keep case for Rust union discriminant type. (#7321)
9e8c758f5 Add explicit return types to lobster generated code (#7312)
74a25536b Add size check to fix out of bounds read risk (#7304)
12917af8a Update Rust docs page (#7296)
1ea2472f7 [swift] add had<ArrayName> property for arrays to check presence in a message (#7280)
0fe13cb28 Remove span ConstIterator/cbegin()/cend(). (#7295)
385dddc66 Namerkot (#7245)
750dde766 Make `flatc` generate Rust files not requiring `std` (#7273)
9917a168c [swift] Make swift module public (#7274)
76d3cca19 Rust: fix a name conflict when building with "no_std" feature (#7268)
c86e6d0e3 json inf parsing
d34dc32c2 fix include order
234d86c92 fixed off-by-one in parser
746c73b91 Add Annotations for Monster schema and example buffer
0bbfd4b2e fixes for annotator
716521953 Update readme.md (#7257)
a45f564cf [performance] Add aggressive systematic inlining in ByteBuffer and FlatBufferBuilder (#7253)
9d45a6403 more google merge fixes
ccfb4c20b Handle +/-inf in protos (#7256)
7bcd857b8 Specialize CreateVector with std::initializer_list (#7254)
23c8ab34c Swift update performance benchmark infrastructure (#7255)
70002dc5c various fixes for google merge
6e0e79f24 Add test for nested buffer verifier (#7252)
b856368d7 Turn off go modules temporary until we get a proper fix (#7251)
e37156a30 Keep the underlying storage capacity when clearing the FlatBufferBuilder. Gives a significant performance boost for serialisation of many small messages. (#7250)
a10b0e546 Java namer variable keep case (#7249)
275b73994 allow overriding FLATBUFFERS_MAX_ALIGNMENT
9d1ce9a10 Add parameter back to EndVector (#7246)
79afe6c3d Make Java namespaces keep case by default (#7243)
c6dbb2230 Add write permissions for labeller
18bacd3ea Expand test to make sure {}-initializers are properly understood by template. (#7242)
a2c913aec Add -Wnon-virtual-dtor
67b33b294 set workflows permissions to read-only (#7239)
7b5fd2bd0 [Kotlin] Fix key lookup returning null clashing with default value (#7237)
7181d7770 [Java] Fix key lookup returning null clashing with default value (#7236)
7f663b120 Allow CreateVectorOfStrings() to work with any string-type. (#7238)
173ebb694 Fixes a bug where the create function doesnt optional + required items (#7228)
d65823948 [Kotlin] Update gradle to 7.4.1 and simplify config files. (#7231)
ab4bf59e8 remove toascii (#7234)
eee44bbb2 disable cpp-linter (#7229)
a63fa51a1 Create cpp-linter.yml (#7208)
2049e5210 Adds a way to verify/exposes Entities ids (#7221)
832c618f5 Adds implementation flag for swift (#7202)
14615699f Started to migrate to target_compile_options (#7222)
20aad0c41 [C++] stl_emulation span::count_ is not const anymore (#7226) (#7227)
f083b33f2 code gen flexbuffer verifier (#7207)
bf17df346 [C++] generate sorted #include directives (#7213)
35281dedb Fix for [C++] flatc generates invalid Code in the default constructor for structs, when --cpp-field-case-style is used #7209 (#7211)
c9651b742 Add overloads for C# ByteBuffer/FlatBufferBuilder to allow adding vector blocks from ArraySegments or IntPtr (#7193)
26c3b3ada Update codeql.yml
da6e1b985 Update codeql.yml
ad27d751e Added Oss fuzz badge
0aab623cb Create codeql.yml
6a446bdd8 maximize parallel builds in CI (#7206)
21fb5cbbc Create scorecards.yml
0da6f9486 [C++] Static assert on Flatbuffers Version (#7203)
59e971308 reduce fuzzing time to 1 minute in CI
40866a892 fixed padding in struct for annotated binary (#7199)
b71d968fa Apply Namer prefix/suffix to other generators (#7197)
fac0d7be0 Apply Namer to Java. (#7194)
6c5603fd9 [C#] Fix collision of field name and type name (#7149)
2d21853a7 monster fuzzer fix for json default scalars
fec1a8d01 [swift] Add bazel configuration for Swift (#7195)
7fd857623 structured comments (#7192)
a4cb1599d Namerdart (#7187)
ae4ce7265 fuzzed binary annotator (#7188)
e2be0c0b0 Handle root offset and root table vtable invalidation (#7177)
2ad408697 [TS] Fix generation of struct members in object api (#7148)
4213d9105 VerifySizePrefixed (reflection::Schema) and GetAnySizePrefixedRoot added (#7181)
5a13f622c Correctly parse lists of enums in Dart generated code (#7157)
23a7e4e0b Adds no-includes flags to the swift code generator (#7182)
eeb49c275 Move flatbuffer_ts_library to typescript.bzl (#7183)
824763b31 Typo in flatc options (warning-as-errors instead of warnings-as-errors) (#7180)
d3aeee32b Annotated Flatbuffer Binary (#7174)
0bceba24d [Lua] Apply Namer to Lua (#7171)
b8c77d404 Make inclusion of header <optional> opt-out via macro (#7168)
8468eab83 Namersw (#7167)
2b2e8d4ae Nameroverloads (#7164)
b80b32bfa Use DESCRIPTION only if CMake version >= 3.9 (#7166)
Change-Id: Ic2681dabb1a798b7515e62753ee06aecb9933260
git-subtree-dir: third_party/flatbuffers
git-subtree-split: bc44fad35271e43fd7a79b4d691ac9e41708797f
Signed-off-by: Austin Schuh <austin.schuh@bluerivertech.com>
diff --git a/include/flatbuffers/base.h b/include/flatbuffers/base.h
index 458ac3f..870a811 100644
--- a/include/flatbuffers/base.h
+++ b/include/flatbuffers/base.h
@@ -140,7 +140,7 @@
#define FLATBUFFERS_VERSION_MAJOR 2
#define FLATBUFFERS_VERSION_MINOR 0
-#define FLATBUFFERS_VERSION_REVISION 6
+#define FLATBUFFERS_VERSION_REVISION 8
#define FLATBUFFERS_STRING_EXPAND(X) #X
#define FLATBUFFERS_STRING(X) FLATBUFFERS_STRING_EXPAND(X)
namespace flatbuffers {
@@ -260,9 +260,12 @@
#endif // !FLATBUFFERS_HAS_NEW_STRTOD
#ifndef FLATBUFFERS_LOCALE_INDEPENDENT
- // Enable locale independent functions {strtof_l, strtod_l,strtoll_l, strtoull_l}.
- #if ((defined(_MSC_VER) && _MSC_VER >= 1800) || \
- (defined(_XOPEN_VERSION) && (_XOPEN_VERSION>=700)) && (!defined(__ANDROID_API__) || (defined(__ANDROID_API__) && (__ANDROID_API__>=21))))
+ // Enable locale independent functions {strtof_l, strtod_l,strtoll_l,
+ // strtoull_l}.
+ #if (defined(_MSC_VER) && _MSC_VER >= 1800) || \
+ (defined(__ANDROID_API__) && __ANDROID_API__>= 21) || \
+ (defined(_XOPEN_VERSION) && (_XOPEN_VERSION >= 700)) && \
+ (!defined(__Fuchsia__) && !defined(__ANDROID_API__))
#define FLATBUFFERS_LOCALE_INDEPENDENT 1
#else
#define FLATBUFFERS_LOCALE_INDEPENDENT 0
@@ -270,14 +273,14 @@
#endif // !FLATBUFFERS_LOCALE_INDEPENDENT
// Suppress Undefined Behavior Sanitizer (recoverable only). Usage:
-// - __supress_ubsan__("undefined")
-// - __supress_ubsan__("signed-integer-overflow")
+// - __suppress_ubsan__("undefined")
+// - __suppress_ubsan__("signed-integer-overflow")
#if defined(__clang__) && (__clang_major__ > 3 || (__clang_major__ == 3 && __clang_minor__ >=7))
- #define __supress_ubsan__(type) __attribute__((no_sanitize(type)))
+ #define __suppress_ubsan__(type) __attribute__((no_sanitize(type)))
#elif defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ >= 409)
- #define __supress_ubsan__(type) __attribute__((no_sanitize_undefined))
+ #define __suppress_ubsan__(type) __attribute__((no_sanitize_undefined))
#else
- #define __supress_ubsan__(type)
+ #define __suppress_ubsan__(type)
#endif
// This is constexpr function used for checking compile-time constants.
@@ -328,8 +331,17 @@
// In 32bits, this evaluates to 2GB - 1
#define FLATBUFFERS_MAX_BUFFER_SIZE ((1ULL << (sizeof(::flatbuffers::soffset_t) * 8 - 1)) - 1)
+// The minimum size buffer that can be a valid flatbuffer.
+// Includes the offset to the root table (uoffset_t), the offset to the vtable
+// of the root table (soffset_t), the size of the vtable (uint16_t), and the
+// size of the referring table (uint16_t).
+#define FLATBUFFERS_MIN_BUFFER_SIZE sizeof(uoffset_t) + sizeof(soffset_t) + \
+ sizeof(uint16_t) + sizeof(uint16_t)
+
// We support aligning the contents of buffers up to this size.
-#define FLATBUFFERS_MAX_ALIGNMENT 16
+#ifndef FLATBUFFERS_MAX_ALIGNMENT
+ #define FLATBUFFERS_MAX_ALIGNMENT 32
+#endif
/// @brief The length of a FlatBuffer file header.
static const size_t kFileIdentifierLength = 4;
@@ -401,7 +413,7 @@
template<typename T>
// UBSAN: C++ aliasing type rules, see std::bit_cast<> for details.
-__supress_ubsan__("alignment")
+__suppress_ubsan__("alignment")
T ReadScalar(const void *p) {
return EndianScalar(*reinterpret_cast<const T *>(p));
}
@@ -415,13 +427,13 @@
template<typename T>
// UBSAN: C++ aliasing type rules, see std::bit_cast<> for details.
-__supress_ubsan__("alignment")
+__suppress_ubsan__("alignment")
void WriteScalar(void *p, T t) {
*reinterpret_cast<T *>(p) = EndianScalar(t);
}
template<typename T> struct Offset;
-template<typename T> __supress_ubsan__("alignment") void WriteScalar(void *p, Offset<T> t) {
+template<typename T> __suppress_ubsan__("alignment") void WriteScalar(void *p, Offset<T> t) {
*reinterpret_cast<uoffset_t *>(p) = EndianScalar(t.o);
}
@@ -432,7 +444,7 @@
// Computes how many bytes you'd have to pad to be able to write an
// "scalar_size" scalar if the buffer had grown to "buf_size" (downwards in
// memory).
-__supress_ubsan__("unsigned-integer-overflow")
+__suppress_ubsan__("unsigned-integer-overflow")
inline size_t PaddingBytes(size_t buf_size, size_t scalar_size) {
return ((~buf_size) + 1) & (scalar_size - 1);
}
diff --git a/include/flatbuffers/buffer.h b/include/flatbuffers/buffer.h
index e8d2ce9..ca005f7 100644
--- a/include/flatbuffers/buffer.h
+++ b/include/flatbuffers/buffer.h
@@ -95,7 +95,7 @@
}
};
-/// @brief Get a pointer to the the file_identifier section of the buffer.
+/// @brief Get a pointer to the file_identifier section of the buffer.
/// @return Returns a const char pointer to the start of the file_identifier
/// characters in the buffer. The returned char * has length
/// 'flatbuffers::FlatBufferBuilder::kFileIdentifierLength'.
diff --git a/include/flatbuffers/code_generators.h b/include/flatbuffers/code_generators.h
index 71ad0df..7275521 100644
--- a/include/flatbuffers/code_generators.h
+++ b/include/flatbuffers/code_generators.h
@@ -138,7 +138,8 @@
std::string WrapInNameSpace(const Namespace *ns,
const std::string &name) const;
- std::string WrapInNameSpace(const Definition &def) const;
+ std::string WrapInNameSpace(const Definition &def,
+ const std::string &suffix = "") const;
std::string GetNameSpace(const Definition &def) const;
diff --git a/include/flatbuffers/flatbuffer_builder.h b/include/flatbuffers/flatbuffer_builder.h
index 9994193..f943233 100644
--- a/include/flatbuffers/flatbuffer_builder.h
+++ b/include/flatbuffers/flatbuffer_builder.h
@@ -18,6 +18,7 @@
#define FLATBUFFERS_FLATBUFFER_BUILDER_H_
#include <functional>
+#include <initializer_list>
#include "flatbuffers/allocator.h"
#include "flatbuffers/array.h"
@@ -357,7 +358,7 @@
// If you get this assert, a corresponding StartTable wasn't called.
FLATBUFFERS_ASSERT(nested);
// Write the vtable offset, which is the start of any Table.
- // We fill it's value later.
+ // We fill its value later.
auto vtableoffsetloc = PushElement<soffset_t>(0);
// Write a vtable, which consists entirely of voffset_t elements.
// It starts with the number of offsets, followed by a type id, followed
@@ -442,6 +443,7 @@
// Aligns such that when "len" bytes are written, an object can be written
// after it with "alignment" without padding.
void PreAlign(size_t len, size_t alignment) {
+ if (len == 0) return;
TrackMinAlign(alignment);
buf_.fill(PaddingBytes(GetSize() + len, alignment));
}
@@ -577,7 +579,7 @@
/// @param[in] str A const pointer to a `String` struct to add to the buffer.
/// @return Returns the offset in the buffer where the string starts
Offset<String> CreateSharedString(const String *str) {
- return CreateSharedString(str->c_str(), str->size());
+ return str ? CreateSharedString(str->c_str(), str->size()) : 0;
}
/// @cond FLATBUFFERS_INTERNAL
@@ -600,12 +602,14 @@
// This is useful when storing a nested_flatbuffer in a vector of bytes,
// or when storing SIMD floats, etc.
void ForceVectorAlignment(size_t len, size_t elemsize, size_t alignment) {
+ if (len == 0) return;
FLATBUFFERS_ASSERT(VerifyAlignmentRequirements(alignment));
PreAlign(len * elemsize, alignment);
}
// Similar to ForceVectorAlignment but for String fields.
void ForceStringAlignment(size_t len, size_t alignment) {
+ if (len == 0) return;
FLATBUFFERS_ASSERT(VerifyAlignmentRequirements(alignment));
PreAlign((len + 1) * sizeof(char), alignment);
}
@@ -652,6 +656,16 @@
return CreateVector(array.data(), array.size());
}
+ /// @brief Serialize an initializer list into a FlatBuffer `vector`.
+ /// @tparam T The data type of the initializer list elements.
+ /// @param[in] v The value of the initializer list.
+ /// @return Returns a typed `Offset` into the serialized data indicating
+ /// where the vector is stored.
+ template<typename T>
+ Offset<Vector<T>> CreateVector(std::initializer_list<T> v) {
+ return CreateVector(v.begin(), v.size());
+ }
+
template<typename T>
Offset<Vector<Offset<T>>> CreateVector(const Offset<T> *v, size_t len) {
StartVector(len, sizeof(Offset<T>));
@@ -716,21 +730,24 @@
return CreateVector(elems);
}
- /// @brief Serialize a `std::vector<std::string>` into a FlatBuffer `vector`.
+ /// @brief Serialize a `std::vector<StringType>` into a FlatBuffer `vector`.
+ /// whereas StringType is any type that is accepted by the CreateString()
+ /// overloads.
/// This is a convenience function for a common case.
/// @param v A const reference to the `std::vector` to serialize into the
/// buffer as a `vector`.
/// @return Returns a typed `Offset` into the serialized data indicating
/// where the vector is stored.
- template<typename Alloc = std::allocator<std::string>>
+ template<typename StringType = std::string,
+ typename Alloc = std::allocator<StringType>>
Offset<Vector<Offset<String>>> CreateVectorOfStrings(
- const std::vector<std::string, Alloc> &v) {
+ const std::vector<StringType, Alloc> &v) {
return CreateVectorOfStrings(v.cbegin(), v.cend());
}
/// @brief Serialize a collection of Strings into a FlatBuffer `vector`.
/// This is a convenience function for a common case.
- /// @param begin The begining iterator of the collection
+ /// @param begin The beginning iterator of the collection
/// @param end The ending iterator of the collection
/// @return Returns a typed `Offset` into the serialized data indicating
/// where the vector is stored.
@@ -740,7 +757,7 @@
auto scratch_buffer_usage = size * sizeof(Offset<String>);
// If there is not enough space to store the offsets, there definitely won't
// be enough space to store all the strings. So ensuring space for the
- // scratch region is OK, for it it fails, it would have failed later.
+ // scratch region is OK, for if it fails, it would have failed later.
buf_.ensure_space(scratch_buffer_usage);
for (auto it = begin; it != end; ++it) {
buf_.scratch_push_small(CreateString(*it));
diff --git a/include/flatbuffers/flatc.h b/include/flatbuffers/flatc.h
index 3dba5e1..af4ccae 100644
--- a/include/flatbuffers/flatc.h
+++ b/include/flatbuffers/flatc.h
@@ -103,6 +103,11 @@
void Error(const std::string &err, bool usage = true,
bool show_exe_name = true) const;
+ void AnnotateBinaries(const uint8_t *binary_schema,
+ uint64_t binary_schema_size,
+ const std::string & schema_filename,
+ const std::vector<std::string> &binary_files);
+
InitParams params_;
};
diff --git a/include/flatbuffers/flex_flat_util.h b/include/flatbuffers/flex_flat_util.h
new file mode 100644
index 0000000..020957e
--- /dev/null
+++ b/include/flatbuffers/flex_flat_util.h
@@ -0,0 +1,36 @@
+/*
+ * Copyright 2022 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef FLATBUFFERS_FLEX_FLAT_UTIL_H_
+#define FLATBUFFERS_FLEX_FLAT_UTIL_H_
+
+#include "flatbuffers/flatbuffers.h"
+#include "flatbuffers/flexbuffers.h"
+
+namespace flexbuffers {
+
+// Verifies the `nested` flexbuffer within a flatbuffer vector is valid.
+inline bool VerifyNestedFlexBuffer(
+ const flatbuffers::Vector<uint8_t> *const nested,
+ flatbuffers::Verifier &verifier) {
+ if (!nested) return true;
+ return verifier.Check(flexbuffers::VerifyBuffer(
+ nested->data(), nested->size(), verifier.GetFlexReuseTracker()));
+}
+
+} // namespace flexbuffers
+
+#endif // FLATBUFFERS_FLEX_FLAT_UTIL_H_
diff --git a/include/flatbuffers/flexbuffers.h b/include/flatbuffers/flexbuffers.h
index b4b0332..7bf8430 100644
--- a/include/flatbuffers/flexbuffers.h
+++ b/include/flatbuffers/flexbuffers.h
@@ -156,6 +156,7 @@
// TODO: GCC apparently replaces memcpy by a rep movsb, but only if count is a
// constant, which here it isn't. Test if memcpy is still faster than
// the conditionals in ReadSizedScalar. Can also use inline asm.
+
// clang-format off
#if defined(_MSC_VER) && defined(_M_X64) && !defined(_M_ARM64EC)
// This is 64-bit Windows only, __movsb does not work on 32-bit Windows.
@@ -578,7 +579,7 @@
// unquoted if it looks like an "identifier":
const char *p = keys[i].AsKey();
if (!flatbuffers::is_alpha(*p) && *p != '_') {
- kq = true;
+ kq = true;
} else {
while (*++p) {
if (!flatbuffers::is_alnum(*p) && *p != '_') {
@@ -1422,10 +1423,12 @@
template<typename T> static Type GetScalarType() {
static_assert(flatbuffers::is_scalar<T>::value, "Unrelated types");
- return flatbuffers::is_floating_point<T>::value ? FBT_FLOAT
- : flatbuffers::is_same<T, bool>::value
- ? FBT_BOOL
- : (flatbuffers::is_unsigned<T>::value ? FBT_UINT : FBT_INT);
+ return flatbuffers::is_floating_point<T>::value
+ ? FBT_FLOAT
+ : flatbuffers::is_same<T, bool>::value
+ ? FBT_BOOL
+ : (flatbuffers::is_unsigned<T>::value ? FBT_UINT
+ : FBT_INT);
}
public:
@@ -1737,9 +1740,9 @@
if (!Check(depth_ <= max_depth_ && num_vectors_ <= max_vectors_))
return false;
auto size_byte_width = r.byte_width_;
- FLEX_CHECK_VERIFIED(p,
- PackedType(Builder::WidthB(size_byte_width), r.type_));
if (!VerifyBeforePointer(p, size_byte_width)) return false;
+ FLEX_CHECK_VERIFIED(p - size_byte_width,
+ PackedType(Builder::WidthB(size_byte_width), r.type_));
auto sized = Sized(p, size_byte_width);
auto num_elems = sized.size();
auto elem_byte_width = r.type_ == FBT_STRING || r.type_ == FBT_BLOB
@@ -1868,7 +1871,7 @@
std::vector<uint8_t> *reuse_tracker_;
};
-// Utility function that contructs the Verifier for you, see above for
+// Utility function that constructs the Verifier for you, see above for
// parameters.
inline bool VerifyBuffer(const uint8_t *buf, size_t buf_len,
std::vector<uint8_t> *reuse_tracker = nullptr) {
@@ -1876,18 +1879,6 @@
return verifier.VerifyBuffer();
}
-#ifdef FLATBUFFERS_H_
-// This is a verifier utility function that works together with the
-// FlatBuffers verifier, which should only be present if flatbuffer.h
-// has been included (which it typically is in generated code).
-inline bool VerifyNestedFlexBuffer(const flatbuffers::Vector<uint8_t> *nv,
- flatbuffers::Verifier &verifier) {
- if (!nv) return true;
- return verifier.Check(flexbuffers::VerifyBuffer(
- nv->data(), nv->size(), verifier.GetFlexReuseTracker()));
-}
-#endif
-
} // namespace flexbuffers
#if defined(_MSC_VER)
diff --git a/include/flatbuffers/idl.h b/include/flatbuffers/idl.h
index 260061f..4cfd7eb 100644
--- a/include/flatbuffers/idl.h
+++ b/include/flatbuffers/idl.h
@@ -164,7 +164,7 @@
enum_def(_ed),
fixed_length(_fixed_length) {}
- bool operator==(const Type &o) {
+ bool operator==(const Type &o) const {
return base_type == o.base_type && element == o.element &&
struct_def == o.struct_def && enum_def == o.enum_def;
}
@@ -295,7 +295,7 @@
native_inline(false),
flexbuffer(false),
presence(kDefault),
- nested_flatbuffer(NULL),
+ nested_flatbuffer(nullptr),
padding(0) {}
Offset<reflection::Field> Serialize(FlatBufferBuilder *builder, uint16_t id,
@@ -464,6 +464,10 @@
return type.base_type == BASE_TYPE_STRUCT && type.struct_def->fixed;
}
+inline bool IsTable(const Type &type) {
+ return type.base_type == BASE_TYPE_STRUCT && !type.struct_def->fixed;
+}
+
inline bool IsUnion(const Type &type) {
return type.enum_def != nullptr && type.enum_def->is_union;
}
@@ -476,6 +480,14 @@
return type.base_type == BASE_TYPE_VECTOR;
}
+inline bool IsVectorOfStruct(const Type& type) {
+ return IsVector(type) && IsStruct(type.VectorType());
+}
+
+inline bool IsVectorOfTable(const Type& type) {
+ return IsVector(type) && IsTable(type.VectorType());
+}
+
inline bool IsArray(const Type &type) {
return type.base_type == BASE_TYPE_ARRAY;
}
@@ -537,6 +549,24 @@
SymbolTable<RPCCall> calls;
};
+struct IncludedFile {
+ // The name of the schema file being included, as defined in the .fbs file.
+ // This includes the prefix (e.g., include "foo/bar/baz.fbs" would mean this
+ // value is "foo/bar/baz.fbs").
+ std::string schema_name;
+
+ // The filename of where the included file was found, after searching the
+ // relative paths plus any other paths included with `flatc -I ...`. Note,
+ // while this is sometimes the same as schema_name, it is not always, since it
+ // can be defined relative to where flatc was invoked.
+ std::string filename;
+};
+
+// Since IncludedFile is contained within a std::set, need to provide ordering.
+inline bool operator<(const IncludedFile &a, const IncludedFile &b) {
+ return a.filename < b.filename;
+}
+
// Container of options that may apply to any of the source/text generators.
struct IDLOptions {
// field case style options for C++
@@ -551,6 +581,7 @@
bool output_enum_identifiers;
bool prefixed_enums;
bool scoped_enums;
+ bool swift_implementation_only;
bool include_dependence_headers;
bool mutable_buffer;
bool one_file;
@@ -576,7 +607,7 @@
bool allow_non_utf8;
bool natural_utf8;
std::string include_prefix;
- bool keep_include_path;
+ bool keep_prefix;
bool binary_schema_comments;
bool binary_schema_builtins;
bool binary_schema_gen_embed;
@@ -602,6 +633,7 @@
bool json_nested_flexbuffers;
bool json_nested_legacy_flatbuffers;
bool ts_flat_file;
+ bool no_leak_private_annotations;
// Possible options for the more general generator below.
enum Language {
@@ -658,6 +690,7 @@
output_enum_identifiers(true),
prefixed_enums(true),
scoped_enums(false),
+ swift_implementation_only(false),
include_dependence_headers(true),
mutable_buffer(false),
one_file(false),
@@ -680,7 +713,7 @@
union_value_namespacing(true),
allow_non_utf8(false),
natural_utf8(false),
- keep_include_path(false),
+ keep_prefix(false),
binary_schema_comments(false),
binary_schema_builtins(false),
binary_schema_gen_embed(false),
@@ -700,6 +733,7 @@
json_nested_flexbuffers(true),
json_nested_legacy_flatbuffers(false),
ts_flat_file(false),
+ no_leak_private_annotations(false),
mini_reflect(IDLOptions::kNone),
require_explicit_ids(false),
rust_serialize(false),
@@ -907,6 +941,11 @@
// @param opts Options used to parce a schema and generate code.
static bool SupportsOptionalScalars(const flatbuffers::IDLOptions &opts);
+ // Get the set of included files that are directly referenced by the file
+ // being parsed. This does not include files that are transitively included by
+ // others includes.
+ std::vector<IncludedFile> GetIncludedFiles() const;
+
private:
class ParseDepthGuard;
@@ -991,6 +1030,9 @@
FLATBUFFERS_CHECKED_ERROR ParseRoot(const char *_source,
const char **include_paths,
const char *source_filename);
+ FLATBUFFERS_CHECKED_ERROR CheckPrivateLeak();
+ FLATBUFFERS_CHECKED_ERROR CheckPrivatelyLeakedFields(
+ const Definition &def, const Definition &value_type);
FLATBUFFERS_CHECKED_ERROR DoParse(const char *_source,
const char **include_paths,
const char *source_filename,
@@ -1031,7 +1073,7 @@
std::string file_extension_;
std::map<uint64_t, std::string> included_files_;
- std::map<std::string, std::set<std::string>> files_included_per_file_;
+ std::map<std::string, std::set<IncludedFile>> files_included_per_file_;
std::vector<std::string> native_included_files_;
std::map<std::string, bool> known_attributes_;
@@ -1042,11 +1084,11 @@
uint64_t advanced_features_;
+ std::string file_being_parsed_;
+
private:
const char *source_;
- std::string file_being_parsed_;
-
std::vector<std::pair<Value, FieldDef *>> field_stack_;
// TODO(cneo): Refactor parser to use string_cache more often to save
diff --git a/include/flatbuffers/reflection.h b/include/flatbuffers/reflection.h
index 8e700f0..e445d79 100644
--- a/include/flatbuffers/reflection.h
+++ b/include/flatbuffers/reflection.h
@@ -88,13 +88,22 @@
}
// Get the root, regardless of what type it is.
-inline Table *GetAnyRoot(uint8_t *flatbuf) {
+inline Table *GetAnyRoot(uint8_t *const flatbuf) {
return GetMutableRoot<Table>(flatbuf);
}
-inline const Table *GetAnyRoot(const uint8_t *flatbuf) {
+
+inline const Table *GetAnyRoot(const uint8_t *const flatbuf) {
return GetRoot<Table>(flatbuf);
}
+inline Table *GetAnySizePrefixedRoot(uint8_t *const flatbuf) {
+ return GetMutableSizePrefixedRoot<Table>(flatbuf);
+}
+
+inline const Table *GetAnySizePrefixedRoot(const uint8_t *const flatbuf) {
+ return GetSizePrefixedRoot<Table>(flatbuf);
+}
+
// Get a field's default, if you know it's an integer, and its exact type.
template<typename T> T GetFieldDefaultI(const reflection::Field &field) {
FLATBUFFERS_ASSERT(sizeof(T) == GetTypeSize(field.type()->base_type()));
@@ -279,6 +288,12 @@
return reinterpret_cast<T *>(st.GetAddressOf(field.offset()));
}
+// Loop over all the fields of the provided `object` and call `func` on each one
+// in increasing order by their field->id(). If `reverse` is true, `func` is
+// called in descending order
+void ForAllFields(const reflection::Object *object, bool reverse,
+ std::function<void(const reflection::Field *)> func);
+
// ------------------------- SETTERS -------------------------
// Set any scalar field, if you know its exact type.
@@ -497,6 +512,11 @@
const uint8_t *buf, size_t length, uoffset_t max_depth = 64,
uoffset_t max_tables = 1000000);
+bool VerifySizePrefixed(const reflection::Schema &schema,
+ const reflection::Object &root, const uint8_t *buf,
+ size_t length, uoffset_t max_depth = 64,
+ uoffset_t max_tables = 1000000);
+
} // namespace flatbuffers
#endif // FLATBUFFERS_REFLECTION_H_
diff --git a/include/flatbuffers/reflection_generated.h b/include/flatbuffers/reflection_generated.h
index dcb0f7e..78674db 100644
--- a/include/flatbuffers/reflection_generated.h
+++ b/include/flatbuffers/reflection_generated.h
@@ -6,6 +6,13 @@
#include "flatbuffers/flatbuffers.h"
+// Ensure the included flatbuffers.h is the same version as when this file was
+// generated, otherwise it may not be compatible.
+static_assert(FLATBUFFERS_VERSION_MAJOR == 2 &&
+ FLATBUFFERS_VERSION_MINOR == 0 &&
+ FLATBUFFERS_VERSION_REVISION == 8,
+ "Non-compatible flatbuffers version included");
+
namespace reflection {
struct Type;
diff --git a/include/flatbuffers/stl_emulation.h b/include/flatbuffers/stl_emulation.h
index 75d13b2..452ddb8 100644
--- a/include/flatbuffers/stl_emulation.h
+++ b/include/flatbuffers/stl_emulation.h
@@ -26,22 +26,27 @@
#include <memory>
#include <limits>
-// Detect C++17 compatible compiler.
-// __cplusplus >= 201703L - a compiler has support of 'static inline' variables.
-#if defined(FLATBUFFERS_USE_STD_OPTIONAL) \
- || (defined(__cplusplus) && __cplusplus >= 201703L) \
- || (defined(_MSVC_LANG) && (_MSVC_LANG >= 201703L))
+#ifndef FLATBUFFERS_USE_STD_OPTIONAL
+ // Detect C++17 compatible compiler.
+ // __cplusplus >= 201703L - a compiler has support of 'static inline' variables.
+ #if (defined(__cplusplus) && __cplusplus >= 201703L) \
+ || (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L)
+ #define FLATBUFFERS_USE_STD_OPTIONAL 1
+ #else
+ #define FLATBUFFERS_USE_STD_OPTIONAL 0
+ #endif // (defined(__cplusplus) && __cplusplus >= 201703L) ...
+#endif // FLATBUFFERS_USE_STD_OPTIONAL
+
+#if FLATBUFFERS_USE_STD_OPTIONAL
#include <optional>
- #ifndef FLATBUFFERS_USE_STD_OPTIONAL
- #define FLATBUFFERS_USE_STD_OPTIONAL
- #endif
-#endif // defined(FLATBUFFERS_USE_STD_OPTIONAL) ...
+#endif
// The __cpp_lib_span is the predefined feature macro.
#if defined(FLATBUFFERS_USE_STD_SPAN)
#include <span>
#elif defined(__cpp_lib_span) && defined(__has_include)
#if __has_include(<span>)
+ #include <array>
#include <span>
#define FLATBUFFERS_USE_STD_SPAN
#endif
@@ -128,7 +133,7 @@
};
#endif // defined(FLATBUFFERS_TEMPLATES_ALIASES)
-#ifdef FLATBUFFERS_USE_STD_OPTIONAL
+#if FLATBUFFERS_USE_STD_OPTIONAL
template<class T>
using Optional = std::optional<T>;
using nullopt_t = std::nullopt_t;
@@ -284,13 +289,13 @@
namespace internal {
// This is SFINAE helper class for checking of a common condition:
// > This overload only participates in overload resolution
- // > Check whether a pointer to an array of U can be converted
- // > to a pointer to an array of E.
- // This helper is used for checking of 'U -> const U'.
- template<class E, std::size_t Extent, class U, std::size_t N>
- struct is_span_convertable {
+ // > Check whether a pointer to an array of From can be converted
+ // > to a pointer to an array of To.
+ // This helper is used for checking of 'From -> const From'.
+ template<class To, std::size_t Extent, class From, std::size_t N>
+ struct is_span_convertible {
using type =
- typename std::conditional<std::is_convertible<U (*)[], E (*)[]>::value
+ typename std::conditional<std::is_convertible<From (*)[], To (*)[]>::value
&& (Extent == dynamic_extent || N == Extent),
int, void>::type;
};
@@ -362,13 +367,9 @@
#if !defined(FLATBUFFERS_SPAN_MINIMAL)
using Iterator = internal::SpanIterator<T>;
- using ConstIterator = internal::SpanIterator<const T>;
Iterator begin() const { return Iterator(data()); }
Iterator end() const { return Iterator(data() + size()); }
-
- ConstIterator cbegin() const { return ConstIterator(data()); }
- ConstIterator cend() const { return ConstIterator(data() + size()); }
#endif
// Returns a reference to the idx-th element of the sequence.
@@ -414,7 +415,7 @@
// extent == 0 || extent == flatbuffers::dynamic_extent.
// A dummy template argument N is need dependency for SFINAE.
template<std::size_t N = 0,
- typename internal::is_span_convertable<element_type, Extent, element_type, (N - N)>::type = 0>
+ typename internal::is_span_convertible<element_type, Extent, element_type, (N - N)>::type = 0>
FLATBUFFERS_CONSTEXPR_CPP11 span() FLATBUFFERS_NOEXCEPT : data_(nullptr),
count_(0) {
static_assert(extent == 0 || extent == dynamic_extent, "invalid span");
@@ -427,12 +428,12 @@
// std::remove_pointer_t<decltype(std::data(arr))>(*)[]
// is convertible to element_type (*)[].
template<std::size_t N,
- typename internal::is_span_convertable<element_type, Extent, element_type, N>::type = 0>
+ typename internal::is_span_convertible<element_type, Extent, element_type, N>::type = 0>
FLATBUFFERS_CONSTEXPR_CPP11 span(element_type (&arr)[N]) FLATBUFFERS_NOEXCEPT
: data_(arr), count_(N) {}
template<class U, std::size_t N,
- typename internal::is_span_convertable<element_type, Extent, U, N>::type = 0>
+ typename internal::is_span_convertible<element_type, Extent, U, N>::type = 0>
FLATBUFFERS_CONSTEXPR_CPP11 span(std::array<U, N> &arr) FLATBUFFERS_NOEXCEPT
: data_(arr.data()), count_(N) {}
@@ -442,7 +443,7 @@
// : data_(arr.data()), count_(N) {}
template<class U, std::size_t N,
- typename internal::is_span_convertable<element_type, Extent, U, N>::type = 0>
+ typename internal::is_span_convertible<element_type, Extent, U, N>::type = 0>
FLATBUFFERS_CONSTEXPR_CPP11 span(const std::array<U, N> &arr) FLATBUFFERS_NOEXCEPT
: data_(arr.data()), count_(N) {}
@@ -452,7 +453,7 @@
// if extent == std::dynamic_extent || N == extent is true and U (*)[]
// is convertible to element_type (*)[].
template<class U, std::size_t N,
- typename internal::is_span_convertable<element_type, Extent, U, N>::type = 0>
+ typename internal::is_span_convertible<element_type, Extent, U, N>::type = 0>
FLATBUFFERS_CONSTEXPR_CPP11 span(const flatbuffers::span<U, N> &s) FLATBUFFERS_NOEXCEPT
: span(s.data(), s.size()) {
}
@@ -462,45 +463,45 @@
private:
// This is a naive implementation with 'count_' member even if (Extent != dynamic_extent).
pointer const data_;
- const size_type count_;
+ size_type count_;
};
#endif // defined(FLATBUFFERS_USE_STD_SPAN)
#if !defined(FLATBUFFERS_SPAN_MINIMAL)
-template<class U, std::size_t N>
+template<class ElementType, std::size_t Extent>
FLATBUFFERS_CONSTEXPR_CPP11
-flatbuffers::span<U, N> make_span(U(&arr)[N]) FLATBUFFERS_NOEXCEPT {
- return span<U, N>(arr);
+flatbuffers::span<ElementType, Extent> make_span(ElementType(&arr)[Extent]) FLATBUFFERS_NOEXCEPT {
+ return span<ElementType, Extent>(arr);
}
-template<class U, std::size_t N>
+template<class ElementType, std::size_t Extent>
FLATBUFFERS_CONSTEXPR_CPP11
-flatbuffers::span<const U, N> make_span(const U(&arr)[N]) FLATBUFFERS_NOEXCEPT {
- return span<const U, N>(arr);
+flatbuffers::span<const ElementType, Extent> make_span(const ElementType(&arr)[Extent]) FLATBUFFERS_NOEXCEPT {
+ return span<const ElementType, Extent>(arr);
}
-template<class U, std::size_t N>
+template<class ElementType, std::size_t Extent>
FLATBUFFERS_CONSTEXPR_CPP11
-flatbuffers::span<U, N> make_span(std::array<U, N> &arr) FLATBUFFERS_NOEXCEPT {
- return span<U, N>(arr);
+flatbuffers::span<ElementType, Extent> make_span(std::array<ElementType, Extent> &arr) FLATBUFFERS_NOEXCEPT {
+ return span<ElementType, Extent>(arr);
}
-template<class U, std::size_t N>
+template<class ElementType, std::size_t Extent>
FLATBUFFERS_CONSTEXPR_CPP11
-flatbuffers::span<const U, N> make_span(const std::array<U, N> &arr) FLATBUFFERS_NOEXCEPT {
- return span<const U, N>(arr);
+flatbuffers::span<const ElementType, Extent> make_span(const std::array<ElementType, Extent> &arr) FLATBUFFERS_NOEXCEPT {
+ return span<const ElementType, Extent>(arr);
}
-template<class U, std::size_t N>
+template<class ElementType, std::size_t Extent>
FLATBUFFERS_CONSTEXPR_CPP11
-flatbuffers::span<U, dynamic_extent> make_span(U *first, std::size_t count) FLATBUFFERS_NOEXCEPT {
- return span<U, dynamic_extent>(first, count);
+flatbuffers::span<ElementType, dynamic_extent> make_span(ElementType *first, std::size_t count) FLATBUFFERS_NOEXCEPT {
+ return span<ElementType, dynamic_extent>(first, count);
}
-template<class U, std::size_t N>
+template<class ElementType, std::size_t Extent>
FLATBUFFERS_CONSTEXPR_CPP11
-flatbuffers::span<const U, dynamic_extent> make_span(const U *first, std::size_t count) FLATBUFFERS_NOEXCEPT {
- return span<const U, dynamic_extent>(first, count);
+flatbuffers::span<const ElementType, dynamic_extent> make_span(const ElementType *first, std::size_t count) FLATBUFFERS_NOEXCEPT {
+ return span<const ElementType, dynamic_extent>(first, count);
}
#endif // !defined(FLATBUFFERS_SPAN_MINIMAL)
diff --git a/include/flatbuffers/util.h b/include/flatbuffers/util.h
index 2e0ce73..73a3ab7 100644
--- a/include/flatbuffers/util.h
+++ b/include/flatbuffers/util.h
@@ -255,7 +255,7 @@
}
// UBSAN: double to float is safe if numeric_limits<float>::is_iec559 is true.
-__supress_ubsan__("float-cast-overflow")
+__suppress_ubsan__("float-cast-overflow")
inline void strtoval_impl(float *val, const char *str, char **endptr) {
*val = __strtof_impl(str, endptr);
}
@@ -448,6 +448,9 @@
// Strip the last component of the path + separator.
std::string StripFileName(const std::string &filepath);
+std::string StripPrefix(const std::string &filepath,
+ const std::string &prefix_to_remove);
+
// Concatenates a path with a filename, regardless of whether the path
// ends in a separator or not.
std::string ConCatPathFileName(const std::string &path,
@@ -682,9 +685,6 @@
bool ReadEnvironmentVariable(const char *var_name,
std::string *_value = nullptr);
-// MSVC specific: Send all assert reports to STDOUT to prevent CI hangs.
-void SetupDefaultCRTReportMode();
-
enum class Case {
kUnknown = 0,
// TheQuickBrownFox
@@ -703,6 +703,8 @@
kDasher = 7,
// THEQuiCKBr_ownFox (or whatever you want, we won't change it)
kKeep = 8,
+ // the_quick_brown_fox123 (as opposed to the_quick_brown_fox_123)
+ kSnake2 = 9,
};
// Convert the `input` string of case `input_case` to the specified `output_case`.
diff --git a/include/flatbuffers/vector.h b/include/flatbuffers/vector.h
index f8a5d88..6bcdfe2 100644
--- a/include/flatbuffers/vector.h
+++ b/include/flatbuffers/vector.h
@@ -19,6 +19,7 @@
#include "flatbuffers/base.h"
#include "flatbuffers/buffer.h"
+#include "flatbuffers/stl_emulation.h"
namespace flatbuffers {
@@ -326,6 +327,24 @@
return span<const uint8_t>(vec.Data(), vec.size() * sizeof(U));
}
+// Convenient helper functions to get a span of any vector, regardless
+// of whether it is null or not (the field is not set).
+template<class U>
+FLATBUFFERS_CONSTEXPR_CPP11 flatbuffers::span<U> make_span(Vector<U> *ptr)
+ FLATBUFFERS_NOEXCEPT {
+ static_assert(Vector<U>::is_span_observable,
+ "wrong type U, only LE-scalar, or byte types are allowed");
+ return ptr ? make_span(*ptr) : span<U>();
+}
+
+template<class U>
+FLATBUFFERS_CONSTEXPR_CPP11 flatbuffers::span<const U> make_span(
+ const Vector<U> *ptr) FLATBUFFERS_NOEXCEPT {
+ static_assert(Vector<U>::is_span_observable,
+ "wrong type U, only LE-scalar, or byte types are allowed");
+ return ptr ? make_span(*ptr) : span<const U>();
+}
+
// Represent a vector much like the template above, but in this case we
// don't know what the element types are (used with reflection.h).
class VectorOfAny {
diff --git a/include/flatbuffers/vector_downward.h b/include/flatbuffers/vector_downward.h
index 3391391..d25e544 100644
--- a/include/flatbuffers/vector_downward.h
+++ b/include/flatbuffers/vector_downward.h
@@ -24,7 +24,7 @@
namespace flatbuffers {
// This is a minimal replication of std::vector<uint8_t> functionality,
-// except growing from higher to lower addresses. i.e push_back() inserts data
+// except growing from higher to lower addresses. i.e. push_back() inserts data
// in the lowest address in the vector.
// Since this vector leaves the lower part unused, we support a "scratch-pad"
// that can be stored there for temporary data, to share the allocated space.
diff --git a/include/flatbuffers/verifier.h b/include/flatbuffers/verifier.h
index 4512d45..87d3f54 100644
--- a/include/flatbuffers/verifier.h
+++ b/include/flatbuffers/verifier.h
@@ -18,7 +18,6 @@
#define FLATBUFFERS_VERIFIER_H_
#include "flatbuffers/base.h"
-#include "flatbuffers/util.h"
#include "flatbuffers/vector.h"
namespace flatbuffers {
@@ -26,22 +25,37 @@
// Helper class to verify the integrity of a FlatBuffer
class Verifier FLATBUFFERS_FINAL_CLASS {
public:
- Verifier(const uint8_t *buf, size_t buf_len, uoffset_t _max_depth = 64,
- uoffset_t _max_tables = 1000000, bool _check_alignment = true)
- : buf_(buf),
- size_(buf_len),
- depth_(0),
- max_depth_(_max_depth),
- num_tables_(0),
- max_tables_(_max_tables),
- upper_bound_(0),
- check_alignment_(_check_alignment),
- flex_reuse_tracker_(nullptr) {
+ struct Options {
+ // The maximum nesting of tables and vectors before we call it invalid.
+ uoffset_t max_depth = 64;
+ // The maximum number of tables we will verify before we call it invalid.
+ uoffset_t max_tables = 1000000;
+ // If true, verify all data is aligned.
+ bool check_alignment = true;
+ // If true, run verifier on nested flatbuffers
+ bool check_nested_flatbuffers = true;
+ };
+
+ explicit Verifier(const uint8_t *const buf, const size_t buf_len,
+ const Options &opts)
+ : buf_(buf), size_(buf_len), opts_(opts) {
FLATBUFFERS_ASSERT(size_ < FLATBUFFERS_MAX_BUFFER_SIZE);
}
+ // Deprecated API, please construct with Verifier::Options.
+ Verifier(const uint8_t *const buf, const size_t buf_len,
+ const uoffset_t max_depth = 64, const uoffset_t max_tables = 1000000,
+ const bool check_alignment = true)
+ : Verifier(buf, buf_len, [&] {
+ Options opts;
+ opts.max_depth = max_depth;
+ opts.max_tables = max_tables;
+ opts.check_alignment = check_alignment;
+ return opts;
+ }()) {}
+
// Central location where any verification failures register.
- bool Check(bool ok) const {
+ bool Check(const bool ok) const {
// clang-format off
#ifdef FLATBUFFERS_DEBUG_VERIFICATION_FAILURE
FLATBUFFERS_ASSERT(ok);
@@ -55,7 +69,7 @@
}
// Verify any range within the buffer.
- bool Verify(size_t elem, size_t elem_len) const {
+ bool Verify(const size_t elem, const size_t elem_len) const {
// clang-format off
#ifdef FLATBUFFERS_TRACK_VERIFIER_BUFFER_SIZE
auto upper_bound = elem + elem_len;
@@ -66,52 +80,52 @@
return Check(elem_len < size_ && elem <= size_ - elem_len);
}
- bool VerifyAlignment(size_t elem, size_t align) const {
- return Check((elem & (align - 1)) == 0 || !check_alignment_);
+ bool VerifyAlignment(const size_t elem, const size_t align) const {
+ return Check((elem & (align - 1)) == 0 || !opts_.check_alignment);
}
// Verify a range indicated by sizeof(T).
- template<typename T> bool Verify(size_t elem) const {
+ template<typename T> bool Verify(const size_t elem) const {
return VerifyAlignment(elem, sizeof(T)) && Verify(elem, sizeof(T));
}
- bool VerifyFromPointer(const uint8_t *p, size_t len) {
- auto o = static_cast<size_t>(p - buf_);
- return Verify(o, len);
+ bool VerifyFromPointer(const uint8_t *const p, const size_t len) {
+ return Verify(static_cast<size_t>(p - buf_), len);
}
// Verify relative to a known-good base pointer.
- bool VerifyFieldStruct(const uint8_t *base, voffset_t elem_off,
- size_t elem_len, size_t align) const {
- auto f = static_cast<size_t>(base - buf_) + elem_off;
+ bool VerifyFieldStruct(const uint8_t *const base, const voffset_t elem_off,
+ const size_t elem_len, const size_t align) const {
+ const auto f = static_cast<size_t>(base - buf_) + elem_off;
return VerifyAlignment(f, align) && Verify(f, elem_len);
}
template<typename T>
- bool VerifyField(const uint8_t *base, voffset_t elem_off,
- size_t align) const {
- auto f = static_cast<size_t>(base - buf_) + elem_off;
+ bool VerifyField(const uint8_t *const base, const voffset_t elem_off,
+ const size_t align) const {
+ const auto f = static_cast<size_t>(base - buf_) + elem_off;
return VerifyAlignment(f, align) && Verify(f, sizeof(T));
}
// Verify a pointer (may be NULL) of a table type.
- template<typename T> bool VerifyTable(const T *table) {
+ template<typename T> bool VerifyTable(const T *const table) {
return !table || table->Verify(*this);
}
// Verify a pointer (may be NULL) of any vector type.
- template<typename T> bool VerifyVector(const Vector<T> *vec) const {
+ template<typename T> bool VerifyVector(const Vector<T> *const vec) const {
return !vec || VerifyVectorOrString(reinterpret_cast<const uint8_t *>(vec),
sizeof(T));
}
// Verify a pointer (may be NULL) of a vector to struct.
- template<typename T> bool VerifyVector(const Vector<const T *> *vec) const {
+ template<typename T>
+ bool VerifyVector(const Vector<const T *> *const vec) const {
return VerifyVector(reinterpret_cast<const Vector<T> *>(vec));
}
// Verify a pointer (may be NULL) to string.
- bool VerifyString(const String *str) const {
+ bool VerifyString(const String *const str) const {
size_t end;
return !str || (VerifyVectorOrString(reinterpret_cast<const uint8_t *>(str),
1, &end) &&
@@ -120,24 +134,24 @@
}
// Common code between vectors and strings.
- bool VerifyVectorOrString(const uint8_t *vec, size_t elem_size,
- size_t *end = nullptr) const {
- auto veco = static_cast<size_t>(vec - buf_);
+ bool VerifyVectorOrString(const uint8_t *const vec, const size_t elem_size,
+ size_t *const end = nullptr) const {
+ const auto veco = static_cast<size_t>(vec - buf_);
// Check we can read the size field.
if (!Verify<uoffset_t>(veco)) return false;
- // Check the whole array. If this is a string, the byte past the array
- // must be 0.
- auto size = ReadScalar<uoffset_t>(vec);
- auto max_elems = FLATBUFFERS_MAX_BUFFER_SIZE / elem_size;
+ // Check the whole array. If this is a string, the byte past the array must
+ // be 0.
+ const auto size = ReadScalar<uoffset_t>(vec);
+ const auto max_elems = FLATBUFFERS_MAX_BUFFER_SIZE / elem_size;
if (!Check(size < max_elems))
return false; // Protect against byte_size overflowing.
- auto byte_size = sizeof(size) + elem_size * size;
+ const auto byte_size = sizeof(size) + elem_size * size;
if (end) *end = veco + byte_size;
return Verify(veco, byte_size);
}
// Special case for string contents, after the above has been called.
- bool VerifyVectorOfStrings(const Vector<Offset<String>> *vec) const {
+ bool VerifyVectorOfStrings(const Vector<Offset<String>> *const vec) const {
if (vec) {
for (uoffset_t i = 0; i < vec->size(); i++) {
if (!VerifyString(vec->Get(i))) return false;
@@ -147,7 +161,8 @@
}
// Special case for table contents, after the above has been called.
- template<typename T> bool VerifyVectorOfTables(const Vector<Offset<T>> *vec) {
+ template<typename T>
+ bool VerifyVectorOfTables(const Vector<Offset<T>> *const vec) {
if (vec) {
for (uoffset_t i = 0; i < vec->size(); i++) {
if (!vec->Get(i)->Verify(*this)) return false;
@@ -156,31 +171,41 @@
return true;
}
- __supress_ubsan__("unsigned-integer-overflow") bool VerifyTableStart(
- const uint8_t *table) {
+ __suppress_ubsan__("unsigned-integer-overflow") bool VerifyTableStart(
+ const uint8_t *const table) {
// Check the vtable offset.
- auto tableo = static_cast<size_t>(table - buf_);
+ const auto tableo = static_cast<size_t>(table - buf_);
if (!Verify<soffset_t>(tableo)) return false;
// This offset may be signed, but doing the subtraction unsigned always
// gives the result we want.
- auto vtableo = tableo - static_cast<size_t>(ReadScalar<soffset_t>(table));
+ const auto vtableo =
+ tableo - static_cast<size_t>(ReadScalar<soffset_t>(table));
// Check the vtable size field, then check vtable fits in its entirety.
- return VerifyComplexity() && Verify<voffset_t>(vtableo) &&
- VerifyAlignment(ReadScalar<voffset_t>(buf_ + vtableo),
- sizeof(voffset_t)) &&
- Verify(vtableo, ReadScalar<voffset_t>(buf_ + vtableo));
+ if (!(VerifyComplexity() && Verify<voffset_t>(vtableo) &&
+ VerifyAlignment(ReadScalar<voffset_t>(buf_ + vtableo),
+ sizeof(voffset_t))))
+ return false;
+ const auto vsize = ReadScalar<voffset_t>(buf_ + vtableo);
+ return Check((vsize & 1) == 0) && Verify(vtableo, vsize);
}
template<typename T>
- bool VerifyBufferFromStart(const char *identifier, size_t start) {
+ bool VerifyBufferFromStart(const char *const identifier, const size_t start) {
+ // Buffers have to be of some size to be valid. The reason it is a runtime
+ // check instead of static_assert, is that nested flatbuffers go through
+ // this call and their size is determined at runtime.
+ if (!Check(size_ >= FLATBUFFERS_MIN_BUFFER_SIZE)) return false;
+
+ // If an identifier is provided, check that we have a buffer
if (identifier && !Check((size_ >= 2 * sizeof(flatbuffers::uoffset_t) &&
BufferHasIdentifier(buf_ + start, identifier)))) {
return false;
}
// Call T::Verify, which must be in the generated code for this type.
- auto o = VerifyOffset(start);
- return o && reinterpret_cast<const T *>(buf_ + start + o)->Verify(*this)
+ const auto o = VerifyOffset(start);
+ return Check(o != 0) &&
+ reinterpret_cast<const T *>(buf_ + start + o)->Verify(*this)
// clang-format off
#ifdef FLATBUFFERS_TRACK_VERIFIER_BUFFER_SIZE
&& GetComputedSize()
@@ -190,9 +215,17 @@
}
template<typename T>
- bool VerifyNestedFlatBuffer(const Vector<uint8_t> *buf,
- const char *identifier) {
+ bool VerifyNestedFlatBuffer(const Vector<uint8_t> *const buf,
+ const char *const identifier) {
+ // Caller opted out of this.
+ if (!opts_.check_nested_flatbuffers) return true;
+
+ // An empty buffer is OK as it indicates not present.
if (!buf) return true;
+
+ // If there is a nested buffer, it must be greater than the min size.
+ if (!Check(buf->size() >= FLATBUFFERS_MIN_BUFFER_SIZE)) return false;
+
Verifier nested_verifier(buf->data(), buf->size());
return nested_verifier.VerifyBuffer<T>(identifier);
}
@@ -200,19 +233,20 @@
// Verify this whole buffer, starting with root type T.
template<typename T> bool VerifyBuffer() { return VerifyBuffer<T>(nullptr); }
- template<typename T> bool VerifyBuffer(const char *identifier) {
+ template<typename T> bool VerifyBuffer(const char *const identifier) {
return VerifyBufferFromStart<T>(identifier, 0);
}
- template<typename T> bool VerifySizePrefixedBuffer(const char *identifier) {
+ template<typename T>
+ bool VerifySizePrefixedBuffer(const char *const identifier) {
return Verify<uoffset_t>(0U) &&
- ReadScalar<uoffset_t>(buf_) == size_ - sizeof(uoffset_t) &&
+ Check(ReadScalar<uoffset_t>(buf_) == size_ - sizeof(uoffset_t)) &&
VerifyBufferFromStart<T>(identifier, sizeof(uoffset_t));
}
- uoffset_t VerifyOffset(size_t start) const {
+ uoffset_t VerifyOffset(const size_t start) const {
if (!Verify<uoffset_t>(start)) return 0;
- auto o = ReadScalar<uoffset_t>(buf_ + start);
+ const auto o = ReadScalar<uoffset_t>(buf_ + start);
// May not point to itself.
if (!Check(o != 0)) return 0;
// Can't wrap around / buffers are max 2GB.
@@ -223,18 +257,18 @@
return o;
}
- uoffset_t VerifyOffset(const uint8_t *base, voffset_t start) const {
+ uoffset_t VerifyOffset(const uint8_t *const base,
+ const voffset_t start) const {
return VerifyOffset(static_cast<size_t>(base - buf_) + start);
}
// Called at the start of a table to increase counters measuring data
- // structure depth and amount, and possibly bails out with false if
- // limits set by the constructor have been hit. Needs to be balanced
- // with EndTable().
+ // structure depth and amount, and possibly bails out with false if limits set
+ // by the constructor have been hit. Needs to be balanced with EndTable().
bool VerifyComplexity() {
depth_++;
num_tables_++;
- return Check(depth_ <= max_depth_ && num_tables_ <= max_tables_);
+ return Check(depth_ <= opts_.max_depth && num_tables_ <= opts_.max_tables);
}
// Called at the end of a table to pop the depth count.
@@ -262,20 +296,20 @@
std::vector<uint8_t> *GetFlexReuseTracker() { return flex_reuse_tracker_; }
- void SetFlexReuseTracker(std::vector<uint8_t> *rt) {
+ void SetFlexReuseTracker(std::vector<uint8_t> *const rt) {
flex_reuse_tracker_ = rt;
}
private:
const uint8_t *buf_;
- size_t size_;
- uoffset_t depth_;
- uoffset_t max_depth_;
- uoffset_t num_tables_;
- uoffset_t max_tables_;
- mutable size_t upper_bound_;
- bool check_alignment_;
- std::vector<uint8_t> *flex_reuse_tracker_;
+ const size_t size_;
+ const Options opts_;
+
+ mutable size_t upper_bound_ = 0;
+
+ uoffset_t depth_ = 0;
+ uoffset_t num_tables_ = 0;
+ std::vector<uint8_t> *flex_reuse_tracker_ = nullptr;
};
} // namespace flatbuffers