Added verifier alignment checking to table fields (#7018)

diff --git a/include/flatbuffers/reflection_generated.h b/include/flatbuffers/reflection_generated.h
index 56d45fd..cd5cbc2 100644 (file)
--- a/include/flatbuffers/reflection_generated.h
+++ b/include/flatbuffers/reflection_generated.h
@@ -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()) &&

diff --git a/include/flatbuffers/table.h b/include/flatbuffers/table.h
index 4247069..dd35e91 100644 (file)
--- a/include/flatbuffers/table.h
+++ b/include/flatbuffers/table.h
@@ -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_
\ No newline at end of file
+#endif  // FLATBUFFERS_TABLE_H_

diff --git a/include/flatbuffers/verifier.h b/include/flatbuffers/verifier.h
index dfa3da8..bc1976d 100644 (file)
--- a/include/flatbuffers/verifier.h
+++ b/include/flatbuffers/verifier.h
@@ -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));
   }
 

diff --git a/samples/monster_generated.h b/samples/monster_generated.h
index efddb8d..b3fc655 100644 (file)
--- a/samples/monster_generated.h
+++ b/samples/monster_generated.h
@@ -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;

diff --git a/src/idl_gen_cpp.cpp b/src/idl_gen_cpp.cpp
index e8d0c8a..2abdca5 100644 (file)
--- a/src/idl_gen_cpp.cpp
+++ b/src/idl_gen_cpp.cpp
@@ -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}})\\";
     }

diff --git a/src/reflection.cpp b/src/reflection.cpp
index 6fbc019..16fd5c1 100644 (file)
--- a/src/reflection.cpp
+++ b/src/reflection.cpp
@@ -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;
         }

diff --git a/tests/arrays_test_generated.h b/tests/arrays_test_generated.h
index 5c22b86..d568070 100644 (file)
--- a/tests/arrays_test_generated.h
+++ b/tests/arrays_test_generated.h
@@ -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;

diff --git a/tests/cpp17/generated_cpp17/monster_test_generated.h b/tests/cpp17/generated_cpp17/monster_test_generated.h
index 2b3cf6c..1a6f569 100644 (file)
--- a/tests/cpp17/generated_cpp17/monster_test_generated.h
+++ b/tests/cpp17/generated_cpp17/monster_test_generated.h
@@ -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) &&

diff --git a/tests/cpp17/generated_cpp17/optional_scalars_generated.h b/tests/cpp17/generated_cpp17/optional_scalars_generated.h
index 6566132..7395077 100644 (file)
--- a/tests/cpp17/generated_cpp17/optional_scalars_generated.h
+++ b/tests/cpp17/generated_cpp17/optional_scalars_generated.h
@@ -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;

diff --git a/tests/cpp17/generated_cpp17/union_vector_generated.h b/tests/cpp17/generated_cpp17/union_vector_generated.h
index 6b794fb..a617913 100644 (file)
--- a/tests/cpp17/generated_cpp17/union_vector_generated.h
+++ b/tests/cpp17/generated_cpp17/union_vector_generated.h
@@ -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);

diff --git a/tests/evolution_test/evolution_v1_generated.h b/tests/evolution_test/evolution_v1_generated.h
index bcde2c6..d5ddf8f 100644 (file)
--- a/tests/evolution_test/evolution_v1_generated.h
+++ b/tests/evolution_test/evolution_v1_generated.h
@@ -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();

diff --git a/tests/evolution_test/evolution_v2_generated.h b/tests/evolution_test/evolution_v2_generated.h
index c56c780..2a0efcb 100644 (file)
--- a/tests/evolution_test/evolution_v2_generated.h
+++ b/tests/evolution_test/evolution_v2_generated.h
@@ -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();
   }
 };

diff --git a/tests/monster_extra_generated.h b/tests/monster_extra_generated.h
index cf3a10f..4cfe719 100644 (file)
--- a/tests/monster_extra_generated.h
+++ b/tests/monster_extra_generated.h
@@ -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) &&

diff --git a/tests/monster_test_generated.h b/tests/monster_test_generated.h
index 9b49d0b..1d96bae 100644 (file)
--- a/tests/monster_test_generated.h
+++ b/tests/monster_test_generated.h
@@ -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) &&

diff --git a/tests/namespace_test/namespace_test1_generated.h b/tests/namespace_test/namespace_test1_generated.h
index ed52a27..bb82236 100644 (file)
--- a/tests/namespace_test/namespace_test1_generated.h
+++ b/tests/namespace_test/namespace_test1_generated.h
@@ -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;

diff --git a/tests/namespace_test/namespace_test2_generated.h b/tests/namespace_test/namespace_test2_generated.h
index 6f2d9cd..73dddd7 100644 (file)
--- a/tests/namespace_test/namespace_test2_generated.h
+++ b/tests/namespace_test/namespace_test2_generated.h
@@ -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;

diff --git a/tests/optional_scalars_generated.h b/tests/optional_scalars_generated.h
index 33df6fb..724c0eb 100644 (file)
--- a/tests/optional_scalars_generated.h
+++ b/tests/optional_scalars_generated.h
@@ -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;

diff --git a/tests/union_vector/union_vector_generated.h b/tests/union_vector/union_vector_generated.h
index d705b4b..489ac94 100644 (file)
--- a/tests/union_vector/union_vector_generated.h
+++ b/tests/union_vector/union_vector_generated.h
@@ -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);