Rooba
/
flatbuffers
mirror of https://github.com/google/flatbuffers.git
1
1
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Added verifier alignment checking to table fields (#7018)

This commit is contained in:
Wouter van Oortmerssen 2022-01-14 14:39:15 -08:00 committed by GitHub
parent 96cc2f3ee3
commit a42e898979
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
18 changed files with 273 additions and 248 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

42
include/flatbuffers/reflection_generated.h
View File

@ -188,12 +188,12 @@ struct Type FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int8_t>(verifier, VT_BASE_TYPE) &&
VerifyField<int8_t>(verifier, VT_ELEMENT) &&
VerifyField<int32_t>(verifier, VT_INDEX) &&
VerifyField<uint16_t>(verifier, VT_FIXED_LENGTH) &&
VerifyField<uint32_t>(verifier, VT_BASE_SIZE) &&
VerifyField<uint32_t>(verifier, VT_ELEMENT_SIZE) &&
VerifyField<int8_t>(verifier, VT_BASE_TYPE, 1) &&
VerifyField<int8_t>(verifier, VT_ELEMENT, 1) &&
VerifyField<int32_t>(verifier, VT_INDEX, 4) &&
VerifyField<uint16_t>(verifier, VT_FIXED_LENGTH, 2) &&
VerifyField<uint32_t>(verifier, VT_BASE_SIZE, 4) &&
VerifyField<uint32_t>(verifier, VT_ELEMENT_SIZE, 4) &&
verifier.EndTable();
}
};
@ -351,7 +351,7 @@ struct EnumVal FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
return VerifyTableStart(verifier) &&
VerifyOffsetRequired(verifier, VT_NAME) &&
verifier.VerifyString(name()) &&
VerifyField<int64_t>(verifier, VT_VALUE) &&
VerifyField<int64_t>(verifier, VT_VALUE, 8) &&
VerifyOffset(verifier, VT_UNION_TYPE) &&
verifier.VerifyTable(union_type()) &&
VerifyOffset(verifier, VT_DOCUMENTATION) &&
@ -465,7 +465,7 @@ struct Enum FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
VerifyOffsetRequired(verifier, VT_VALUES) &&
verifier.VerifyVector(values()) &&
verifier.VerifyVectorOfTables(values()) &&
VerifyField<uint8_t>(verifier, VT_IS_UNION) &&
VerifyField<uint8_t>(verifier, VT_IS_UNION, 1) &&
VerifyOffsetRequired(verifier, VT_UNDERLYING_TYPE) &&
verifier.VerifyTable(underlying_type()) &&
VerifyOffset(verifier, VT_ATTRIBUTES) &&
@ -633,21 +633,21 @@ struct Field FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
verifier.VerifyString(name()) &&
VerifyOffsetRequired(verifier, VT_TYPE) &&
verifier.VerifyTable(type()) &&
VerifyField<uint16_t>(verifier, VT_ID) &&
VerifyField<uint16_t>(verifier, VT_OFFSET) &&
VerifyField<int64_t>(verifier, VT_DEFAULT_INTEGER) &&
VerifyField<double>(verifier, VT_DEFAULT_REAL) &&
VerifyField<uint8_t>(verifier, VT_DEPRECATED) &&
VerifyField<uint8_t>(verifier, VT_REQUIRED) &&
VerifyField<uint8_t>(verifier, VT_KEY) &&
VerifyField<uint16_t>(verifier, VT_ID, 2) &&
VerifyField<uint16_t>(verifier, VT_OFFSET, 2) &&
VerifyField<int64_t>(verifier, VT_DEFAULT_INTEGER, 8) &&
VerifyField<double>(verifier, VT_DEFAULT_REAL, 8) &&
VerifyField<uint8_t>(verifier, VT_DEPRECATED, 1) &&
VerifyField<uint8_t>(verifier, VT_REQUIRED, 1) &&
VerifyField<uint8_t>(verifier, VT_KEY, 1) &&
VerifyOffset(verifier, VT_ATTRIBUTES) &&
verifier.VerifyVector(attributes()) &&
verifier.VerifyVectorOfTables(attributes()) &&
VerifyOffset(verifier, VT_DOCUMENTATION) &&
verifier.VerifyVector(documentation()) &&
verifier.VerifyVectorOfStrings(documentation()) &&
VerifyField<uint8_t>(verifier, VT_OPTIONAL) &&
VerifyField<uint16_t>(verifier, VT_PADDING) &&
VerifyField<uint8_t>(verifier, VT_OPTIONAL, 1) &&
VerifyField<uint16_t>(verifier, VT_PADDING, 2) &&
verifier.EndTable();
}
};
@ -825,9 +825,9 @@ struct Object FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
VerifyOffsetRequired(verifier, VT_FIELDS) &&
verifier.VerifyVector(fields()) &&
verifier.VerifyVectorOfTables(fields()) &&
VerifyField<uint8_t>(verifier, VT_IS_STRUCT) &&
VerifyField<int32_t>(verifier, VT_MINALIGN) &&
VerifyField<int32_t>(verifier, VT_BYTESIZE) &&
VerifyField<uint8_t>(verifier, VT_IS_STRUCT, 1) &&
VerifyField<int32_t>(verifier, VT_MINALIGN, 4) &&
VerifyField<int32_t>(verifier, VT_BYTESIZE, 4) &&
VerifyOffset(verifier, VT_ATTRIBUTES) &&
verifier.VerifyVector(attributes()) &&
verifier.VerifyVectorOfTables(attributes()) &&
@ -1297,7 +1297,7 @@ struct Schema FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
VerifyOffset(verifier, VT_SERVICES) &&
verifier.VerifyVector(services()) &&
verifier.VerifyVectorOfTables(services()) &&
VerifyField<uint64_t>(verifier, VT_ADVANCED_FEATURES) &&
VerifyField<uint64_t>(verifier, VT_ADVANCED_FEATURES, 8) &&
VerifyOffset(verifier, VT_FBS_FILES) &&
verifier.VerifyVector(fbs_files()) &&
verifier.VerifyVectorOfTables(fbs_files()) &&

11
include/flatbuffers/table.h
View File

@ -112,20 +112,21 @@ class Table {
// Verify a particular field.
template<typename T>
bool VerifyField(const Verifier &verifier, voffset_t field) const {
bool VerifyField(const Verifier &verifier, voffset_t field, size_t align) const {
// Calling GetOptionalFieldOffset should be safe now thanks to
// VerifyTable().
auto field_offset = GetOptionalFieldOffset(field);
// Check the actual field.
return !field_offset || verifier.Verify<T>(data_, field_offset);
return !field_offset ||
verifier.VerifyField<T>(data_, field_offset, align);
}
// VerifyField for required fields.
template<typename T>
bool VerifyFieldRequired(const Verifier &verifier, voffset_t field) const {
bool VerifyFieldRequired(const Verifier &verifier, voffset_t field, size_t align) const {
auto field_offset = GetOptionalFieldOffset(field);
return verifier.Check(field_offset != 0) &&
verifier.Verify<T>(data_, field_offset);
verifier.VerifyField<T>(data_, field_offset, align);
}
// Versions for offsets.
@ -163,4 +164,4 @@ inline flatbuffers::Optional<bool> Table::GetOptional<uint8_t, bool>(
} // namespace flatbuffers
#endif // FLATBUFFERS_TABLE_H_
#endif // FLATBUFFERS_TABLE_H_

20
include/flatbuffers/verifier.h
View File

@ -66,13 +66,13 @@ class Verifier FLATBUFFERS_FINAL_CLASS {
return Check(elem_len < size_ && elem <= size_ - elem_len);
}
template<typename T> bool VerifyAlignment(size_t elem) const {
return Check((elem & (sizeof(T) - 1)) == 0 || !check_alignment_);
bool VerifyAlignment(size_t elem, size_t align) const {
return Check((elem & (align - 1)) == 0 || !check_alignment_);
}
// Verify a range indicated by sizeof(T).
template<typename T> bool Verify(size_t elem) const {
return VerifyAlignment<T>(elem) && Verify(elem, sizeof(T));
return VerifyAlignment(elem, sizeof(T)) && Verify(elem, sizeof(T));
}
bool VerifyFromPointer(const uint8_t *p, size_t len) {
@ -81,13 +81,16 @@ class Verifier FLATBUFFERS_FINAL_CLASS {
}
// Verify relative to a known-good base pointer.
bool Verify(const uint8_t *base, voffset_t elem_off, size_t elem_len) const {
return Verify(static_cast<size_t>(base - buf_) + elem_off, elem_len);
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;
return VerifyAlignment(f, align) && Verify(f, elem_len);
}
template<typename T>
bool Verify(const uint8_t *base, voffset_t elem_off) const {
return Verify(static_cast<size_t>(base - buf_) + elem_off, sizeof(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;
return VerifyAlignment(f, align) && Verify(f, sizeof(T));
}
// Verify a pointer (may be NULL) of a table type.
@ -162,7 +165,8 @@ class Verifier FLATBUFFERS_FINAL_CLASS {
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<voffset_t>(ReadScalar<voffset_t>(buf_ + vtableo)) &&
VerifyAlignment(ReadScalar<voffset_t>(buf_ + vtableo),
sizeof(voffset_t)) &&
Verify(vtableo, ReadScalar<voffset_t>(buf_ + vtableo));
}

12
samples/monster_generated.h
View File

@ -322,18 +322,18 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<MyGame::Sample::Vec3>(verifier, VT_POS) &&
VerifyField<int16_t>(verifier, VT_MANA) &&
VerifyField<int16_t>(verifier, VT_HP) &&
VerifyField<MyGame::Sample::Vec3>(verifier, VT_POS, 4) &&
VerifyField<int16_t>(verifier, VT_MANA, 2) &&
VerifyField<int16_t>(verifier, VT_HP, 2) &&
VerifyOffset(verifier, VT_NAME) &&
verifier.VerifyString(name()) &&
VerifyOffset(verifier, VT_INVENTORY) &&
verifier.VerifyVector(inventory()) &&
VerifyField<int8_t>(verifier, VT_COLOR) &&
VerifyField<int8_t>(verifier, VT_COLOR, 1) &&
VerifyOffset(verifier, VT_WEAPONS) &&
verifier.VerifyVector(weapons()) &&
verifier.VerifyVectorOfTables(weapons()) &&
VerifyField<uint8_t>(verifier, VT_EQUIPPED_TYPE) &&
VerifyField<uint8_t>(verifier, VT_EQUIPPED_TYPE, 1) &&
VerifyOffset(verifier, VT_EQUIPPED) &&
VerifyEquipment(verifier, equipped(), equipped_type()) &&
VerifyOffset(verifier, VT_PATH) &&
@ -484,7 +484,7 @@ struct Weapon FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_NAME) &&
verifier.VerifyString(name()) &&
VerifyField<int16_t>(verifier, VT_DAMAGE) &&
VerifyField<int16_t>(verifier, VT_DAMAGE, 2) &&
verifier.EndTable();
}
WeaponT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;

11
src/idl_gen_cpp.cpp
View File

@ -1471,9 +1471,11 @@ class CppGenerator : public BaseGenerator {
" auto ptr = reinterpret_cast<const {{TYPE}} *>(obj);";
if (ev.union_type.base_type == BASE_TYPE_STRUCT) {
if (ev.union_type.struct_def->fixed) {
code_.SetValue("ALIGN",
NumToString(ev.union_type.struct_def->minalign));
code_ +=
" return verifier.Verify<{{TYPE}}>(static_cast<const "
"uint8_t *>(obj), 0);";
" return verifier.VerifyField<{{TYPE}}>("
"static_cast<const uint8_t *>(obj), 0, {{ALIGN}});";
} else {
code_ += getptr;
code_ += " return verifier.VerifyTable(ptr);";
@ -1951,8 +1953,9 @@ class CppGenerator : public BaseGenerator {
code_.SetValue("SIZE", GenTypeSize(field.value.type));
code_.SetValue("OFFSET", GenFieldOffsetName(field));
if (IsScalar(field.value.type.base_type) || IsStruct(field.value.type)) {
code_ +=
"{{PRE}}VerifyField{{REQUIRED}}<{{SIZE}}>(verifier, {{OFFSET}})\\";
code_.SetValue("ALIGN", NumToString(InlineAlignment(field.value.type)));
code_ += "{{PRE}}VerifyField{{REQUIRED}}<{{SIZE}}>(verifier, "
"{{OFFSET}}, {{ALIGN}})\\";
} else {
code_ += "{{PRE}}VerifyOffset{{REQUIRED}}(verifier, {{OFFSET}})\\";
}

39
src/reflection.cpp
View File

@ -505,8 +505,9 @@ bool VerifyStruct(flatbuffers::Verifier &v,
auto offset = parent_table.GetOptionalFieldOffset(field_offset);
if (required && !offset) { return false; }
return !offset || v.Verify(reinterpret_cast<const uint8_t *>(&parent_table),
offset, obj.bytesize());
return !offset ||
v.VerifyFieldStruct(reinterpret_cast<const uint8_t *>(&parent_table),
offset, obj.bytesize(), obj.minalign());
}
bool VerifyVectorOfStructs(flatbuffers::Verifier &v,
@ -553,7 +554,8 @@ bool VerifyVector(flatbuffers::Verifier &v, const reflection::Schema &schema,
const flatbuffers::Table &table,
const reflection::Field &vec_field) {
FLATBUFFERS_ASSERT(vec_field.type()->base_type() == reflection::Vector);
if (!table.VerifyField<uoffset_t>(v, vec_field.offset())) return false;
if (!table.VerifyField<uoffset_t>(v, vec_field.offset(), sizeof(uoffset_t)))
return false;
switch (vec_field.type()->element()) {
case reflection::UType:
@ -636,33 +638,48 @@ bool VerifyObject(flatbuffers::Verifier &v, const reflection::Schema &schema,
switch (field_def->type()->base_type()) {
case reflection::None: FLATBUFFERS_ASSERT(false); break;
case reflection::UType:
if (!table->VerifyField<uint8_t>(v, field_def->offset())) return false;
if (!table->VerifyField<uint8_t>(v, field_def->offset(),
sizeof(uint8_t)))
return false;
break;
case reflection::Bool:
case reflection::Byte:
case reflection::UByte:
if (!table->VerifyField<int8_t>(v, field_def->offset())) return false;
if (!table->VerifyField<int8_t>(v, field_def->offset(),
sizeof(int8_t)))
return false;
break;
case reflection::Short:
case reflection::UShort:
if (!table->VerifyField<int16_t>(v, field_def->offset())) return false;
if (!table->VerifyField<int16_t>(v, field_def->offset(),
sizeof(int16_t)))
return false;
break;
case reflection::Int:
case reflection::UInt:
if (!table->VerifyField<int32_t>(v, field_def->offset())) return false;
if (!table->VerifyField<int32_t>(v, field_def->offset(),
sizeof(int32_t)))
return false;
break;
case reflection::Long:
case reflection::ULong:
if (!table->VerifyField<int64_t>(v, field_def->offset())) return false;
if (!table->VerifyField<int64_t>(v, field_def->offset(),
sizeof(int64_t)))
return false;
break;
case reflection::Float:
if (!table->VerifyField<float>(v, field_def->offset())) return false;
if (!table->VerifyField<float>(v, field_def->offset(),
sizeof(float)))
return false;
break;
case reflection::Double:
if (!table->VerifyField<double>(v, field_def->offset())) return false;
if (!table->VerifyField<double>(v, field_def->offset(),
sizeof(double)))
return false;
break;
case reflection::String:
if (!table->VerifyField<uoffset_t>(v, field_def->offset()) ||
if (!table->VerifyField<uoffset_t>(v, field_def->offset(),
sizeof(uoffset_t)) ||
!v.VerifyString(flatbuffers::GetFieldS(*table, *field_def))) {
return false;
}

2
tests/arrays_test_generated.h
View File

@ -284,7 +284,7 @@ struct ArrayTable FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<MyGame::Example::ArrayStruct>(verifier, VT_A) &&
VerifyField<MyGame::Example::ArrayStruct>(verifier, VT_A, 8) &&
verifier.EndTable();
}
ArrayTableT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;

74
tests/cpp17/generated_cpp17/monster_test_generated.h
View File

@ -928,7 +928,7 @@ struct TestSimpleTableWithEnum FLATBUFFERS_FINAL_CLASS : private flatbuffers::Ta
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint8_t>(verifier, VT_COLOR) &&
VerifyField<uint8_t>(verifier, VT_COLOR, 1) &&
verifier.EndTable();
}
TestSimpleTableWithEnumT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
@ -1031,8 +1031,8 @@ struct Stat FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_ID) &&
verifier.VerifyString(id()) &&
VerifyField<int64_t>(verifier, VT_VAL) &&
VerifyField<uint16_t>(verifier, VT_COUNT) &&
VerifyField<int64_t>(verifier, VT_VAL, 8) &&
VerifyField<uint16_t>(verifier, VT_COUNT, 2) &&
verifier.EndTable();
}
StatT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
@ -1140,7 +1140,7 @@ struct Referrable FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint64_t>(verifier, VT_ID) &&
VerifyField<uint64_t>(verifier, VT_ID, 8) &&
verifier.EndTable();
}
ReferrableT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
@ -1693,15 +1693,15 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<MyGame::Example::Vec3>(verifier, VT_POS) &&
VerifyField<int16_t>(verifier, VT_MANA) &&
VerifyField<int16_t>(verifier, VT_HP) &&
VerifyField<MyGame::Example::Vec3>(verifier, VT_POS, 8) &&
VerifyField<int16_t>(verifier, VT_MANA, 2) &&
VerifyField<int16_t>(verifier, VT_HP, 2) &&
VerifyOffsetRequired(verifier, VT_NAME) &&
verifier.VerifyString(name()) &&
VerifyOffset(verifier, VT_INVENTORY) &&
verifier.VerifyVector(inventory()) &&
VerifyField<uint8_t>(verifier, VT_COLOR) &&
VerifyField<uint8_t>(verifier, VT_TEST_TYPE) &&
VerifyField<uint8_t>(verifier, VT_COLOR, 1) &&
VerifyField<uint8_t>(verifier, VT_TEST_TYPE, 1) &&
VerifyOffset(verifier, VT_TEST) &&
VerifyAny(verifier, test(), test_type()) &&
VerifyOffset(verifier, VT_TEST4) &&
@ -1719,20 +1719,20 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
verifier.VerifyNestedFlatBuffer<MyGame::Example::Monster>(testnestedflatbuffer(), nullptr) &&
VerifyOffset(verifier, VT_TESTEMPTY) &&
verifier.VerifyTable(testempty()) &&
VerifyField<uint8_t>(verifier, VT_TESTBOOL) &&
VerifyField<int32_t>(verifier, VT_TESTHASHS32_FNV1) &&
VerifyField<uint32_t>(verifier, VT_TESTHASHU32_FNV1) &&
VerifyField<int64_t>(verifier, VT_TESTHASHS64_FNV1) &&
VerifyField<uint64_t>(verifier, VT_TESTHASHU64_FNV1) &&
VerifyField<int32_t>(verifier, VT_TESTHASHS32_FNV1A) &&
VerifyField<uint32_t>(verifier, VT_TESTHASHU32_FNV1A) &&
VerifyField<int64_t>(verifier, VT_TESTHASHS64_FNV1A) &&
VerifyField<uint64_t>(verifier, VT_TESTHASHU64_FNV1A) &&
VerifyField<uint8_t>(verifier, VT_TESTBOOL, 1) &&
VerifyField<int32_t>(verifier, VT_TESTHASHS32_FNV1, 4) &&
VerifyField<uint32_t>(verifier, VT_TESTHASHU32_FNV1, 4) &&
VerifyField<int64_t>(verifier, VT_TESTHASHS64_FNV1, 8) &&
VerifyField<uint64_t>(verifier, VT_TESTHASHU64_FNV1, 8) &&
VerifyField<int32_t>(verifier, VT_TESTHASHS32_FNV1A, 4) &&
VerifyField<uint32_t>(verifier, VT_TESTHASHU32_FNV1A, 4) &&
VerifyField<int64_t>(verifier, VT_TESTHASHS64_FNV1A, 8) &&
VerifyField<uint64_t>(verifier, VT_TESTHASHU64_FNV1A, 8) &&
VerifyOffset(verifier, VT_TESTARRAYOFBOOLS) &&
verifier.VerifyVector(testarrayofbools()) &&
VerifyField<float>(verifier, VT_TESTF) &&
VerifyField<float>(verifier, VT_TESTF2) &&
VerifyField<float>(verifier, VT_TESTF3) &&
VerifyField<float>(verifier, VT_TESTF, 4) &&
VerifyField<float>(verifier, VT_TESTF2, 4) &&
VerifyField<float>(verifier, VT_TESTF3, 4) &&
VerifyOffset(verifier, VT_TESTARRAYOFSTRING2) &&
verifier.VerifyVector(testarrayofstring2()) &&
verifier.VerifyVectorOfStrings(testarrayofstring2()) &&
@ -1752,27 +1752,27 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
VerifyOffset(verifier, VT_VECTOR_OF_REFERRABLES) &&
verifier.VerifyVector(vector_of_referrables()) &&
verifier.VerifyVectorOfTables(vector_of_referrables()) &&
VerifyField<uint64_t>(verifier, VT_SINGLE_WEAK_REFERENCE) &&
VerifyField<uint64_t>(verifier, VT_SINGLE_WEAK_REFERENCE, 8) &&
VerifyOffset(verifier, VT_VECTOR_OF_WEAK_REFERENCES) &&
verifier.VerifyVector(vector_of_weak_references()) &&
VerifyOffset(verifier, VT_VECTOR_OF_STRONG_REFERRABLES) &&
verifier.VerifyVector(vector_of_strong_referrables()) &&
verifier.VerifyVectorOfTables(vector_of_strong_referrables()) &&
VerifyField<uint64_t>(verifier, VT_CO_OWNING_REFERENCE) &&
VerifyField<uint64_t>(verifier, VT_CO_OWNING_REFERENCE, 8) &&
VerifyOffset(verifier, VT_VECTOR_OF_CO_OWNING_REFERENCES) &&
verifier.VerifyVector(vector_of_co_owning_references()) &&
VerifyField<uint64_t>(verifier, VT_NON_OWNING_REFERENCE) &&
VerifyField<uint64_t>(verifier, VT_NON_OWNING_REFERENCE, 8) &&
VerifyOffset(verifier, VT_VECTOR_OF_NON_OWNING_REFERENCES) &&
verifier.VerifyVector(vector_of_non_owning_references()) &&
VerifyField<uint8_t>(verifier, VT_ANY_UNIQUE_TYPE) &&
VerifyField<uint8_t>(verifier, VT_ANY_UNIQUE_TYPE, 1) &&
VerifyOffset(verifier, VT_ANY_UNIQUE) &&
VerifyAnyUniqueAliases(verifier, any_unique(), any_unique_type()) &&
VerifyField<uint8_t>(verifier, VT_ANY_AMBIGUOUS_TYPE) &&
VerifyField<uint8_t>(verifier, VT_ANY_AMBIGUOUS_TYPE, 1) &&
VerifyOffset(verifier, VT_ANY_AMBIGUOUS) &&
VerifyAnyAmbiguousAliases(verifier, any_ambiguous(), any_ambiguous_type()) &&
VerifyOffset(verifier, VT_VECTOR_OF_ENUMS) &&
verifier.VerifyVector(vector_of_enums()) &&
VerifyField<int8_t>(verifier, VT_SIGNED_ENUM) &&
VerifyField<int8_t>(verifier, VT_SIGNED_ENUM, 1) &&
VerifyOffset(verifier, VT_TESTREQUIREDNESTEDFLATBUFFER) &&
verifier.VerifyVector(testrequirednestedflatbuffer()) &&
verifier.VerifyNestedFlatBuffer<MyGame::Example::Monster>(testrequirednestedflatbuffer(), nullptr) &&
@ -2400,16 +2400,16 @@ struct TypeAliases FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int8_t>(verifier, VT_I8) &&
VerifyField<uint8_t>(verifier, VT_U8) &&
VerifyField<int16_t>(verifier, VT_I16) &&
VerifyField<uint16_t>(verifier, VT_U16) &&
VerifyField<int32_t>(verifier, VT_I32) &&
VerifyField<uint32_t>(verifier, VT_U32) &&
VerifyField<int64_t>(verifier, VT_I64) &&
VerifyField<uint64_t>(verifier, VT_U64) &&
VerifyField<float>(verifier, VT_F32) &&
VerifyField<double>(verifier, VT_F64) &&
VerifyField<int8_t>(verifier, VT_I8, 1) &&
VerifyField<uint8_t>(verifier, VT_U8, 1) &&
VerifyField<int16_t>(verifier, VT_I16, 2) &&
VerifyField<uint16_t>(verifier, VT_U16, 2) &&
VerifyField<int32_t>(verifier, VT_I32, 4) &&
VerifyField<uint32_t>(verifier, VT_U32, 4) &&
VerifyField<int64_t>(verifier, VT_I64, 8) &&
VerifyField<uint64_t>(verifier, VT_U64, 8) &&
VerifyField<float>(verifier, VT_F32, 4) &&
VerifyField<double>(verifier, VT_F64, 8) &&
VerifyOffset(verifier, VT_V8) &&
verifier.VerifyVector(v8()) &&
VerifyOffset(verifier, VT_VF64) &&

72
tests/cpp17/generated_cpp17/optional_scalars_generated.h
View File

@ -390,42 +390,42 @@ struct ScalarStuff FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int8_t>(verifier, VT_JUST_I8) &&
VerifyField<int8_t>(verifier, VT_MAYBE_I8) &&
VerifyField<int8_t>(verifier, VT_DEFAULT_I8) &&
VerifyField<uint8_t>(verifier, VT_JUST_U8) &&
VerifyField<uint8_t>(verifier, VT_MAYBE_U8) &&
VerifyField<uint8_t>(verifier, VT_DEFAULT_U8) &&
VerifyField<int16_t>(verifier, VT_JUST_I16) &&
VerifyField<int16_t>(verifier, VT_MAYBE_I16) &&
VerifyField<int16_t>(verifier, VT_DEFAULT_I16) &&
VerifyField<uint16_t>(verifier, VT_JUST_U16) &&
VerifyField<uint16_t>(verifier, VT_MAYBE_U16) &&
VerifyField<uint16_t>(verifier, VT_DEFAULT_U16) &&
VerifyField<int32_t>(verifier, VT_JUST_I32) &&
VerifyField<int32_t>(verifier, VT_MAYBE_I32) &&
VerifyField<int32_t>(verifier, VT_DEFAULT_I32) &&
VerifyField<uint32_t>(verifier, VT_JUST_U32) &&
VerifyField<uint32_t>(verifier, VT_MAYBE_U32) &&
VerifyField<uint32_t>(verifier, VT_DEFAULT_U32) &&
VerifyField<int64_t>(verifier, VT_JUST_I64) &&
VerifyField<int64_t>(verifier, VT_MAYBE_I64) &&
VerifyField<int64_t>(verifier, VT_DEFAULT_I64) &&
VerifyField<uint64_t>(verifier, VT_JUST_U64) &&
VerifyField<uint64_t>(verifier, VT_MAYBE_U64) &&
VerifyField<uint64_t>(verifier, VT_DEFAULT_U64) &&
VerifyField<float>(verifier, VT_JUST_F32) &&
VerifyField<float>(verifier, VT_MAYBE_F32) &&
VerifyField<float>(verifier, VT_DEFAULT_F32) &&
VerifyField<double>(verifier, VT_JUST_F64) &&
VerifyField<double>(verifier, VT_MAYBE_F64) &&
VerifyField<double>(verifier, VT_DEFAULT_F64) &&
VerifyField<uint8_t>(verifier, VT_JUST_BOOL) &&
VerifyField<uint8_t>(verifier, VT_MAYBE_BOOL) &&
VerifyField<uint8_t>(verifier, VT_DEFAULT_BOOL) &&
VerifyField<int8_t>(verifier, VT_JUST_ENUM) &&
VerifyField<int8_t>(verifier, VT_MAYBE_ENUM) &&
VerifyField<int8_t>(verifier, VT_DEFAULT_ENUM) &&
VerifyField<int8_t>(verifier, VT_JUST_I8, 1) &&
VerifyField<int8_t>(verifier, VT_MAYBE_I8, 1) &&
VerifyField<int8_t>(verifier, VT_DEFAULT_I8, 1) &&
VerifyField<uint8_t>(verifier, VT_JUST_U8, 1) &&
VerifyField<uint8_t>(verifier, VT_MAYBE_U8, 1) &&
VerifyField<uint8_t>(verifier, VT_DEFAULT_U8, 1) &&
VerifyField<int16_t>(verifier, VT_JUST_I16, 2) &&
VerifyField<int16_t>(verifier, VT_MAYBE_I16, 2) &&
VerifyField<int16_t>(verifier, VT_DEFAULT_I16, 2) &&
VerifyField<uint16_t>(verifier, VT_JUST_U16, 2) &&
VerifyField<uint16_t>(verifier, VT_MAYBE_U16, 2) &&
VerifyField<uint16_t>(verifier, VT_DEFAULT_U16, 2) &&
VerifyField<int32_t>(verifier, VT_JUST_I32, 4) &&
VerifyField<int32_t>(verifier, VT_MAYBE_I32, 4) &&
VerifyField<int32_t>(verifier, VT_DEFAULT_I32, 4) &&
VerifyField<uint32_t>(verifier, VT_JUST_U32, 4) &&
VerifyField<uint32_t>(verifier, VT_MAYBE_U32, 4) &&
VerifyField<uint32_t>(verifier, VT_DEFAULT_U32, 4) &&
VerifyField<int64_t>(verifier, VT_JUST_I64, 8) &&
VerifyField<int64_t>(verifier, VT_MAYBE_I64, 8) &&
VerifyField<int64_t>(verifier, VT_DEFAULT_I64, 8) &&
VerifyField<uint64_t>(verifier, VT_JUST_U64, 8) &&
VerifyField<uint64_t>(verifier, VT_MAYBE_U64, 8) &&
VerifyField<uint64_t>(verifier, VT_DEFAULT_U64, 8) &&
VerifyField<float>(verifier, VT_JUST_F32, 4) &&
VerifyField<float>(verifier, VT_MAYBE_F32, 4) &&
VerifyField<float>(verifier, VT_DEFAULT_F32, 4) &&
VerifyField<double>(verifier, VT_JUST_F64, 8) &&
VerifyField<double>(verifier, VT_MAYBE_F64, 8) &&
VerifyField<double>(verifier, VT_DEFAULT_F64, 8) &&
VerifyField<uint8_t>(verifier, VT_JUST_BOOL, 1) &&
VerifyField<uint8_t>(verifier, VT_MAYBE_BOOL, 1) &&
VerifyField<uint8_t>(verifier, VT_DEFAULT_BOOL, 1) &&
VerifyField<int8_t>(verifier, VT_JUST_ENUM, 1) &&
VerifyField<int8_t>(verifier, VT_MAYBE_ENUM, 1) &&
VerifyField<int8_t>(verifier, VT_DEFAULT_ENUM, 1) &&
verifier.EndTable();
}
ScalarStuffT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;

14
tests/cpp17/generated_cpp17/union_vector_generated.h
View File

@ -413,7 +413,7 @@ struct Attacker FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int32_t>(verifier, VT_SWORD_ATTACK_DAMAGE) &&
VerifyField<int32_t>(verifier, VT_SWORD_ATTACK_DAMAGE, 4) &&
verifier.EndTable();
}
AttackerT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
@ -490,7 +490,7 @@ struct HandFan FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int32_t>(verifier, VT_LENGTH) &&
VerifyField<int32_t>(verifier, VT_LENGTH, 4) &&
verifier.EndTable();
}
HandFanT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
@ -607,7 +607,7 @@ struct Movie FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint8_t>(verifier, VT_MAIN_CHARACTER_TYPE) &&
VerifyField<uint8_t>(verifier, VT_MAIN_CHARACTER_TYPE, 1) &&
VerifyOffset(verifier, VT_MAIN_CHARACTER) &&
VerifyCharacter(verifier, main_character(), main_character_type()) &&
VerifyOffset(verifier, VT_CHARACTERS_TYPE) &&
@ -794,13 +794,13 @@ inline bool VerifyCharacter(flatbuffers::Verifier &verifier, const void *obj, Ch
return verifier.VerifyTable(ptr);
}
case Character::Rapunzel: {
return verifier.Verify<Rapunzel>(static_cast<const uint8_t *>(obj), 0);
return verifier.VerifyField<Rapunzel>(static_cast<const uint8_t *>(obj), 0, 4);
}
case Character::Belle: {
return verifier.Verify<BookReader>(static_cast<const uint8_t *>(obj), 0);
return verifier.VerifyField<BookReader>(static_cast<const uint8_t *>(obj), 0, 4);
}
case Character::BookFan: {
return verifier.Verify<BookReader>(static_cast<const uint8_t *>(obj), 0);
return verifier.VerifyField<BookReader>(static_cast<const uint8_t *>(obj), 0, 4);
}
case Character::Other: {
auto ptr = reinterpret_cast<const flatbuffers::String *>(obj);
@ -963,7 +963,7 @@ inline bool VerifyGadget(flatbuffers::Verifier &verifier, const void *obj, Gadge
return true;
}
case Gadget::FallingTub: {
return verifier.Verify<FallingTub>(static_cast<const uint8_t *>(obj), 0);
return verifier.VerifyField<FallingTub>(static_cast<const uint8_t *>(obj), 0, 4);
}
case Gadget::HandFan: {
auto ptr = reinterpret_cast<const HandFan *>(obj);

20
tests/evolution_test/evolution_v1_generated.h
View File

@ -151,8 +151,8 @@ struct TableA FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<float>(verifier, VT_A) &&
VerifyField<int32_t>(verifier, VT_B) &&
VerifyField<float>(verifier, VT_A, 4) &&
VerifyField<int32_t>(verifier, VT_B, 4) &&
verifier.EndTable();
}
};
@ -198,7 +198,7 @@ struct TableB FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int32_t>(verifier, VT_A) &&
VerifyField<int32_t>(verifier, VT_A, 4) &&
verifier.EndTable();
}
};
@ -297,22 +297,22 @@ struct Root FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int32_t>(verifier, VT_A) &&
VerifyField<uint8_t>(verifier, VT_B) &&
VerifyField<uint8_t>(verifier, VT_C_TYPE) &&
VerifyField<int32_t>(verifier, VT_A, 4) &&
VerifyField<uint8_t>(verifier, VT_B, 1) &&
VerifyField<uint8_t>(verifier, VT_C_TYPE, 1) &&
VerifyOffset(verifier, VT_C) &&
VerifyUnion(verifier, c(), c_type()) &&
VerifyField<int8_t>(verifier, VT_D) &&
VerifyField<int8_t>(verifier, VT_D, 1) &&
VerifyOffset(verifier, VT_E) &&
verifier.VerifyTable(e()) &&
VerifyField<Evolution::V1::Struct>(verifier, VT_F) &&
VerifyField<Evolution::V1::Struct>(verifier, VT_F, 8) &&
VerifyOffset(verifier, VT_G) &&
verifier.VerifyVector(g()) &&
VerifyOffset(verifier, VT_H) &&
verifier.VerifyVector(h()) &&
verifier.VerifyVectorOfTables(h()) &&
VerifyField<int32_t>(verifier, VT_I) &&
VerifyField<uint8_t>(verifier, VT_J_TYPE) &&
VerifyField<int32_t>(verifier, VT_I, 4) &&
VerifyField<uint8_t>(verifier, VT_J_TYPE, 1) &&
VerifyOffset(verifier, VT_J) &&
VerifyUnion(verifier, j(), j_type()) &&
verifier.EndTable();

20
tests/evolution_test/evolution_v2_generated.h
View File

@ -171,8 +171,8 @@ struct TableA FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<float>(verifier, VT_A) &&
VerifyField<int32_t>(verifier, VT_B) &&
VerifyField<float>(verifier, VT_A, 4) &&
VerifyField<int32_t>(verifier, VT_B, 4) &&
VerifyOffset(verifier, VT_C) &&
verifier.VerifyString(c()) &&
verifier.EndTable();
@ -238,7 +238,7 @@ struct TableB FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int32_t>(verifier, VT_A) &&
VerifyField<int32_t>(verifier, VT_A, 4) &&
verifier.EndTable();
}
};
@ -283,7 +283,7 @@ struct TableC FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<double>(verifier, VT_A) &&
VerifyField<double>(verifier, VT_A, 8) &&
VerifyOffset(verifier, VT_B) &&
verifier.VerifyString(b()) &&
verifier.EndTable();
@ -392,23 +392,23 @@ struct Root FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint8_t>(verifier, VT_B) &&
VerifyField<uint8_t>(verifier, VT_C_TYPE) &&
VerifyField<uint8_t>(verifier, VT_B, 1) &&
VerifyField<uint8_t>(verifier, VT_C_TYPE, 1) &&
VerifyOffset(verifier, VT_C) &&
VerifyUnion(verifier, c(), c_type()) &&
VerifyField<int8_t>(verifier, VT_D) &&
VerifyField<int8_t>(verifier, VT_D, 1) &&
VerifyOffset(verifier, VT_E) &&
verifier.VerifyTable(e()) &&
VerifyField<Evolution::V2::Struct>(verifier, VT_FF) &&
VerifyField<Evolution::V2::Struct>(verifier, VT_FF, 8) &&
VerifyOffset(verifier, VT_G) &&
verifier.VerifyVector(g()) &&
VerifyOffset(verifier, VT_H) &&
verifier.VerifyVector(h()) &&
verifier.VerifyVectorOfTables(h()) &&
VerifyField<uint32_t>(verifier, VT_I) &&
VerifyField<uint32_t>(verifier, VT_I, 4) &&
VerifyOffset(verifier, VT_K) &&
verifier.VerifyTable(k()) &&
VerifyField<uint8_t>(verifier, VT_L) &&
VerifyField<uint8_t>(verifier, VT_L, 1) &&
verifier.EndTable();
}
};

16
tests/monster_extra_generated.h
View File

@ -111,14 +111,14 @@ struct MonsterExtra FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<double>(verifier, VT_D0) &&
VerifyField<double>(verifier, VT_D1) &&
VerifyField<double>(verifier, VT_D2) &&
VerifyField<double>(verifier, VT_D3) &&
VerifyField<float>(verifier, VT_F0) &&
VerifyField<float>(verifier, VT_F1) &&
VerifyField<float>(verifier, VT_F2) &&
VerifyField<float>(verifier, VT_F3) &&
VerifyField<double>(verifier, VT_D0, 8) &&
VerifyField<double>(verifier, VT_D1, 8) &&
VerifyField<double>(verifier, VT_D2, 8) &&
VerifyField<double>(verifier, VT_D3, 8) &&
VerifyField<float>(verifier, VT_F0, 4) &&
VerifyField<float>(verifier, VT_F1, 4) &&
VerifyField<float>(verifier, VT_F2, 4) &&
VerifyField<float>(verifier, VT_F3, 4) &&
VerifyOffset(verifier, VT_DVEC) &&
verifier.VerifyVector(dvec()) &&
VerifyOffset(verifier, VT_FVEC) &&

74
tests/monster_test_generated.h
View File

@ -978,7 +978,7 @@ struct TestSimpleTableWithEnum FLATBUFFERS_FINAL_CLASS : private flatbuffers::Ta
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint8_t>(verifier, VT_COLOR) &&
VerifyField<uint8_t>(verifier, VT_COLOR, 1) &&
verifier.EndTable();
}
TestSimpleTableWithEnumT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
@ -1060,8 +1060,8 @@ struct Stat FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_ID) &&
verifier.VerifyString(id()) &&
VerifyField<int64_t>(verifier, VT_VAL) &&
VerifyField<uint16_t>(verifier, VT_COUNT) &&
VerifyField<int64_t>(verifier, VT_VAL, 8) &&
VerifyField<uint16_t>(verifier, VT_COUNT, 2) &&
verifier.EndTable();
}
StatT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
@ -1148,7 +1148,7 @@ struct Referrable FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint64_t>(verifier, VT_ID) &&
VerifyField<uint64_t>(verifier, VT_ID, 8) &&
verifier.EndTable();
}
ReferrableT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
@ -1633,15 +1633,15 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<MyGame::Example::Vec3>(verifier, VT_POS) &&
VerifyField<int16_t>(verifier, VT_MANA) &&
VerifyField<int16_t>(verifier, VT_HP) &&
VerifyField<MyGame::Example::Vec3>(verifier, VT_POS, 8) &&
VerifyField<int16_t>(verifier, VT_MANA, 2) &&
VerifyField<int16_t>(verifier, VT_HP, 2) &&
VerifyOffsetRequired(verifier, VT_NAME) &&
verifier.VerifyString(name()) &&
VerifyOffset(verifier, VT_INVENTORY) &&
verifier.VerifyVector(inventory()) &&
VerifyField<uint8_t>(verifier, VT_COLOR) &&
VerifyField<uint8_t>(verifier, VT_TEST_TYPE) &&
VerifyField<uint8_t>(verifier, VT_COLOR, 1) &&
VerifyField<uint8_t>(verifier, VT_TEST_TYPE, 1) &&
VerifyOffset(verifier, VT_TEST) &&
VerifyAny(verifier, test(), test_type()) &&
VerifyOffset(verifier, VT_TEST4) &&
@ -1659,20 +1659,20 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
verifier.VerifyNestedFlatBuffer<MyGame::Example::Monster>(testnestedflatbuffer(), nullptr) &&
VerifyOffset(verifier, VT_TESTEMPTY) &&
verifier.VerifyTable(testempty()) &&
VerifyField<uint8_t>(verifier, VT_TESTBOOL) &&
VerifyField<int32_t>(verifier, VT_TESTHASHS32_FNV1) &&
VerifyField<uint32_t>(verifier, VT_TESTHASHU32_FNV1) &&
VerifyField<int64_t>(verifier, VT_TESTHASHS64_FNV1) &&
VerifyField<uint64_t>(verifier, VT_TESTHASHU64_FNV1) &&
VerifyField<int32_t>(verifier, VT_TESTHASHS32_FNV1A) &&
VerifyField<uint32_t>(verifier, VT_TESTHASHU32_FNV1A) &&
VerifyField<int64_t>(verifier, VT_TESTHASHS64_FNV1A) &&
VerifyField<uint64_t>(verifier, VT_TESTHASHU64_FNV1A) &&
VerifyField<uint8_t>(verifier, VT_TESTBOOL, 1) &&
VerifyField<int32_t>(verifier, VT_TESTHASHS32_FNV1, 4) &&
VerifyField<uint32_t>(verifier, VT_TESTHASHU32_FNV1, 4) &&
VerifyField<int64_t>(verifier, VT_TESTHASHS64_FNV1, 8) &&
VerifyField<uint64_t>(verifier, VT_TESTHASHU64_FNV1, 8) &&
VerifyField<int32_t>(verifier, VT_TESTHASHS32_FNV1A, 4) &&
VerifyField<uint32_t>(verifier, VT_TESTHASHU32_FNV1A, 4) &&
VerifyField<int64_t>(verifier, VT_TESTHASHS64_FNV1A, 8) &&
VerifyField<uint64_t>(verifier, VT_TESTHASHU64_FNV1A, 8) &&
VerifyOffset(verifier, VT_TESTARRAYOFBOOLS) &&
verifier.VerifyVector(testarrayofbools()) &&
VerifyField<float>(verifier, VT_TESTF) &&
VerifyField<float>(verifier, VT_TESTF2) &&
VerifyField<float>(verifier, VT_TESTF3) &&
VerifyField<float>(verifier, VT_TESTF, 4) &&
VerifyField<float>(verifier, VT_TESTF2, 4) &&
VerifyField<float>(verifier, VT_TESTF3, 4) &&
VerifyOffset(verifier, VT_TESTARRAYOFSTRING2) &&
verifier.VerifyVector(testarrayofstring2()) &&
verifier.VerifyVectorOfStrings(testarrayofstring2()) &&
@ -1692,27 +1692,27 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
VerifyOffset(verifier, VT_VECTOR_OF_REFERRABLES) &&
verifier.VerifyVector(vector_of_referrables()) &&
verifier.VerifyVectorOfTables(vector_of_referrables()) &&
VerifyField<uint64_t>(verifier, VT_SINGLE_WEAK_REFERENCE) &&
VerifyField<uint64_t>(verifier, VT_SINGLE_WEAK_REFERENCE, 8) &&
VerifyOffset(verifier, VT_VECTOR_OF_WEAK_REFERENCES) &&
verifier.VerifyVector(vector_of_weak_references()) &&
VerifyOffset(verifier, VT_VECTOR_OF_STRONG_REFERRABLES) &&
verifier.VerifyVector(vector_of_strong_referrables()) &&
verifier.VerifyVectorOfTables(vector_of_strong_referrables()) &&
VerifyField<uint64_t>(verifier, VT_CO_OWNING_REFERENCE) &&
VerifyField<uint64_t>(verifier, VT_CO_OWNING_REFERENCE, 8) &&
VerifyOffset(verifier, VT_VECTOR_OF_CO_OWNING_REFERENCES) &&
verifier.VerifyVector(vector_of_co_owning_references()) &&
VerifyField<uint64_t>(verifier, VT_NON_OWNING_REFERENCE) &&
VerifyField<uint64_t>(verifier, VT_NON_OWNING_REFERENCE, 8) &&
VerifyOffset(verifier, VT_VECTOR_OF_NON_OWNING_REFERENCES) &&
verifier.VerifyVector(vector_of_non_owning_references()) &&
VerifyField<uint8_t>(verifier, VT_ANY_UNIQUE_TYPE) &&
VerifyField<uint8_t>(verifier, VT_ANY_UNIQUE_TYPE, 1) &&
VerifyOffset(verifier, VT_ANY_UNIQUE) &&
VerifyAnyUniqueAliases(verifier, any_unique(), any_unique_type()) &&
VerifyField<uint8_t>(verifier, VT_ANY_AMBIGUOUS_TYPE) &&
VerifyField<uint8_t>(verifier, VT_ANY_AMBIGUOUS_TYPE, 1) &&
VerifyOffset(verifier, VT_ANY_AMBIGUOUS) &&
VerifyAnyAmbiguousAliases(verifier, any_ambiguous(), any_ambiguous_type()) &&
VerifyOffset(verifier, VT_VECTOR_OF_ENUMS) &&
verifier.VerifyVector(vector_of_enums()) &&
VerifyField<int8_t>(verifier, VT_SIGNED_ENUM) &&
VerifyField<int8_t>(verifier, VT_SIGNED_ENUM, 1) &&
VerifyOffset(verifier, VT_TESTREQUIREDNESTEDFLATBUFFER) &&
verifier.VerifyVector(testrequirednestedflatbuffer()) &&
verifier.VerifyNestedFlatBuffer<MyGame::Example::Monster>(testrequirednestedflatbuffer(), nullptr) &&
@ -2261,16 +2261,16 @@ struct TypeAliases FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int8_t>(verifier, VT_I8) &&
VerifyField<uint8_t>(verifier, VT_U8) &&
VerifyField<int16_t>(verifier, VT_I16) &&
VerifyField<uint16_t>(verifier, VT_U16) &&
VerifyField<int32_t>(verifier, VT_I32) &&
VerifyField<uint32_t>(verifier, VT_U32) &&
VerifyField<int64_t>(verifier, VT_I64) &&
VerifyField<uint64_t>(verifier, VT_U64) &&
VerifyField<float>(verifier, VT_F32) &&
VerifyField<double>(verifier, VT_F64) &&
VerifyField<int8_t>(verifier, VT_I8, 1) &&
VerifyField<uint8_t>(verifier, VT_U8, 1) &&
VerifyField<int16_t>(verifier, VT_I16, 2) &&
VerifyField<uint16_t>(verifier, VT_U16, 2) &&
VerifyField<int32_t>(verifier, VT_I32, 4) &&
VerifyField<uint32_t>(verifier, VT_U32, 4) &&
VerifyField<int64_t>(verifier, VT_I64, 8) &&
VerifyField<uint64_t>(verifier, VT_U64, 8) &&
VerifyField<float>(verifier, VT_F32, 4) &&
VerifyField<double>(verifier, VT_F64, 8) &&
VerifyOffset(verifier, VT_V8) &&
verifier.VerifyVector(v8()) &&
VerifyOffset(verifier, VT_VF64) &&

2
tests/namespace_test/namespace_test1_generated.h
View File

@ -241,7 +241,7 @@ struct TableInNestedNS FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int32_t>(verifier, VT_FOO) &&
VerifyField<int32_t>(verifier, VT_FOO, 4) &&
verifier.EndTable();
}
TableInNestedNST *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;

6
tests/namespace_test/namespace_test2_generated.h
View File

@ -119,11 +119,11 @@ struct TableInFirstNS FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_FOO_TABLE) &&
verifier.VerifyTable(foo_table()) &&
VerifyField<int8_t>(verifier, VT_FOO_ENUM) &&
VerifyField<uint8_t>(verifier, VT_FOO_UNION_TYPE) &&
VerifyField<int8_t>(verifier, VT_FOO_ENUM, 1) &&
VerifyField<uint8_t>(verifier, VT_FOO_UNION_TYPE, 1) &&
VerifyOffset(verifier, VT_FOO_UNION) &&
VerifyUnionInNestedNS(verifier, foo_union(), foo_union_type()) &&
VerifyField<NamespaceA::NamespaceB::StructInNestedNS>(verifier, VT_FOO_STRUCT) &&
VerifyField<NamespaceA::NamespaceB::StructInNestedNS>(verifier, VT_FOO_STRUCT, 4) &&
verifier.EndTable();
}
TableInFirstNST *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;

72
tests/optional_scalars_generated.h
View File

@ -352,42 +352,42 @@ struct ScalarStuff FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int8_t>(verifier, VT_JUST_I8) &&
VerifyField<int8_t>(verifier, VT_MAYBE_I8) &&
VerifyField<int8_t>(verifier, VT_DEFAULT_I8) &&
VerifyField<uint8_t>(verifier, VT_JUST_U8) &&
VerifyField<uint8_t>(verifier, VT_MAYBE_U8) &&
VerifyField<uint8_t>(verifier, VT_DEFAULT_U8) &&
VerifyField<int16_t>(verifier, VT_JUST_I16) &&
VerifyField<int16_t>(verifier, VT_MAYBE_I16) &&
VerifyField<int16_t>(verifier, VT_DEFAULT_I16) &&
VerifyField<uint16_t>(verifier, VT_JUST_U16) &&
VerifyField<uint16_t>(verifier, VT_MAYBE_U16) &&
VerifyField<uint16_t>(verifier, VT_DEFAULT_U16) &&
VerifyField<int32_t>(verifier, VT_JUST_I32) &&
VerifyField<int32_t>(verifier, VT_MAYBE_I32) &&
VerifyField<int32_t>(verifier, VT_DEFAULT_I32) &&
VerifyField<uint32_t>(verifier, VT_JUST_U32) &&
VerifyField<uint32_t>(verifier, VT_MAYBE_U32) &&
VerifyField<uint32_t>(verifier, VT_DEFAULT_U32) &&
VerifyField<int64_t>(verifier, VT_JUST_I64) &&
VerifyField<int64_t>(verifier, VT_MAYBE_I64) &&
VerifyField<int64_t>(verifier, VT_DEFAULT_I64) &&
VerifyField<uint64_t>(verifier, VT_JUST_U64) &&
VerifyField<uint64_t>(verifier, VT_MAYBE_U64) &&
VerifyField<uint64_t>(verifier, VT_DEFAULT_U64) &&
VerifyField<float>(verifier, VT_JUST_F32) &&
VerifyField<float>(verifier, VT_MAYBE_F32) &&
VerifyField<float>(verifier, VT_DEFAULT_F32) &&
VerifyField<double>(verifier, VT_JUST_F64) &&
VerifyField<double>(verifier, VT_MAYBE_F64) &&
VerifyField<double>(verifier, VT_DEFAULT_F64) &&
VerifyField<uint8_t>(verifier, VT_JUST_BOOL) &&
VerifyField<uint8_t>(verifier, VT_MAYBE_BOOL) &&
VerifyField<uint8_t>(verifier, VT_DEFAULT_BOOL) &&
VerifyField<int8_t>(verifier, VT_JUST_ENUM) &&
VerifyField<int8_t>(verifier, VT_MAYBE_ENUM) &&
VerifyField<int8_t>(verifier, VT_DEFAULT_ENUM) &&
VerifyField<int8_t>(verifier, VT_JUST_I8, 1) &&
VerifyField<int8_t>(verifier, VT_MAYBE_I8, 1) &&
VerifyField<int8_t>(verifier, VT_DEFAULT_I8, 1) &&
VerifyField<uint8_t>(verifier, VT_JUST_U8, 1) &&
VerifyField<uint8_t>(verifier, VT_MAYBE_U8, 1) &&
VerifyField<uint8_t>(verifier, VT_DEFAULT_U8, 1) &&
VerifyField<int16_t>(verifier, VT_JUST_I16, 2) &&
VerifyField<int16_t>(verifier, VT_MAYBE_I16, 2) &&
VerifyField<int16_t>(verifier, VT_DEFAULT_I16, 2) &&
VerifyField<uint16_t>(verifier, VT_JUST_U16, 2) &&
VerifyField<uint16_t>(verifier, VT_MAYBE_U16, 2) &&
VerifyField<uint16_t>(verifier, VT_DEFAULT_U16, 2) &&
VerifyField<int32_t>(verifier, VT_JUST_I32, 4) &&
VerifyField<int32_t>(verifier, VT_MAYBE_I32, 4) &&
VerifyField<int32_t>(verifier, VT_DEFAULT_I32, 4) &&
VerifyField<uint32_t>(verifier, VT_JUST_U32, 4) &&
VerifyField<uint32_t>(verifier, VT_MAYBE_U32, 4) &&
VerifyField<uint32_t>(verifier, VT_DEFAULT_U32, 4) &&
VerifyField<int64_t>(verifier, VT_JUST_I64, 8) &&
VerifyField<int64_t>(verifier, VT_MAYBE_I64, 8) &&
VerifyField<int64_t>(verifier, VT_DEFAULT_I64, 8) &&
VerifyField<uint64_t>(verifier, VT_JUST_U64, 8) &&
VerifyField<uint64_t>(verifier, VT_MAYBE_U64, 8) &&
VerifyField<uint64_t>(verifier, VT_DEFAULT_U64, 8) &&
VerifyField<float>(verifier, VT_JUST_F32, 4) &&
VerifyField<float>(verifier, VT_MAYBE_F32, 4) &&
VerifyField<float>(verifier, VT_DEFAULT_F32, 4) &&
VerifyField<double>(verifier, VT_JUST_F64, 8) &&
VerifyField<double>(verifier, VT_MAYBE_F64, 8) &&
VerifyField<double>(verifier, VT_DEFAULT_F64, 8) &&
VerifyField<uint8_t>(verifier, VT_JUST_BOOL, 1) &&
VerifyField<uint8_t>(verifier, VT_MAYBE_BOOL, 1) &&
VerifyField<uint8_t>(verifier, VT_DEFAULT_BOOL, 1) &&
VerifyField<int8_t>(verifier, VT_JUST_ENUM, 1) &&
VerifyField<int8_t>(verifier, VT_MAYBE_ENUM, 1) &&
VerifyField<int8_t>(verifier, VT_DEFAULT_ENUM, 1) &&
verifier.EndTable();
}
ScalarStuffT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;

14
tests/union_vector/union_vector_generated.h
View File

@ -477,7 +477,7 @@ struct Attacker FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int32_t>(verifier, VT_SWORD_ATTACK_DAMAGE) &&
VerifyField<int32_t>(verifier, VT_SWORD_ATTACK_DAMAGE, 4) &&
verifier.EndTable();
}
AttackerT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
@ -541,7 +541,7 @@ struct HandFan FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int32_t>(verifier, VT_LENGTH) &&
VerifyField<int32_t>(verifier, VT_LENGTH, 4) &&
verifier.EndTable();
}
HandFanT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
@ -642,7 +642,7 @@ struct Movie FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint8_t>(verifier, VT_MAIN_CHARACTER_TYPE) &&
VerifyField<uint8_t>(verifier, VT_MAIN_CHARACTER_TYPE, 1) &&
VerifyOffset(verifier, VT_MAIN_CHARACTER) &&
VerifyCharacter(verifier, main_character(), main_character_type()) &&
VerifyOffset(verifier, VT_CHARACTERS_TYPE) &&
@ -847,13 +847,13 @@ inline bool VerifyCharacter(flatbuffers::Verifier &verifier, const void *obj, Ch
return verifier.VerifyTable(ptr);
}
case Character_Rapunzel: {
return verifier.Verify<Rapunzel>(static_cast<const uint8_t *>(obj), 0);
return verifier.VerifyField<Rapunzel>(static_cast<const uint8_t *>(obj), 0, 4);
}
case Character_Belle: {
return verifier.Verify<BookReader>(static_cast<const uint8_t *>(obj), 0);
return verifier.VerifyField<BookReader>(static_cast<const uint8_t *>(obj), 0, 4);
}
case Character_BookFan: {
return verifier.Verify<BookReader>(static_cast<const uint8_t *>(obj), 0);
return verifier.VerifyField<BookReader>(static_cast<const uint8_t *>(obj), 0, 4);
}
case Character_Other: {
auto ptr = reinterpret_cast<const flatbuffers::String *>(obj);
@ -1016,7 +1016,7 @@ inline bool VerifyGadget(flatbuffers::Verifier &verifier, const void *obj, Gadge
return true;
}
case Gadget_FallingTub: {
return verifier.Verify<FallingTub>(static_cast<const uint8_t *>(obj), 0);
return verifier.VerifyField<FallingTub>(static_cast<const uint8_t *>(obj), 0, 4);
}
case Gadget_HandFan: {
auto ptr = reinterpret_cast<const HandFan *>(obj);