static inline int verify_string_vector(const void *buf, uoffset_t end, uoffset_t base, uoffset_t offset)
{
uoffset_t i, n;
check_result(verify_vector(buf, end, base, offset, offset_size, offset_size, FLATBUFFERS_COUNT_MAX(offset_size)));
base += offset;
n = read_uoffset(buf, base);
base += offset_size;
for (i = 0; i < n; ++i, base += offset_size) {
check_result(verify_string(buf, end, base, read_uoffset(buf, base)));
}
return flatcc_verify_ok;
}
static inline int verify_table_vector(const void *buf, uoffset_t end, uoffset_t base, uoffset_t offset, int ttl, flatcc_table_verifier_f tvf)
{
uoffset_t i, n;
verify(ttl-- > 0, flatcc_verify_error_max_nesting_level_reached);
check_result(verify_vector(buf, end, base, offset, offset_size, offset_size, FLATBUFFERS_COUNT_MAX(offset_size)));
base += offset;
n = read_uoffset(buf, base);
base += offset_size;
for (i = 0; i < n; ++i, base += offset_size) {
check_result(verify_table(buf, end, base, read_uoffset(buf, base), ttl, tvf));
}
return flatcc_verify_ok;
}
int flatcc_verify_struct_as_nested_root(flatcc_table_verifier_descriptor_t *td,
voffset_t id, int required, const char *fid, uint16_t align, size_t size)
{
const uoffset_t *buf;
uoffset_t bufsiz;
check_result(flatcc_verify_vector_field(td, id, required, align, 1, FLATBUFFERS_COUNT_MAX(1)));
if (0 == (buf = get_field_ptr(td, id))) {
return flatcc_verify_ok;
}
buf = (const uoffset_t *)((size_t)buf + read_uoffset(buf, 0));
bufsiz = read_uoffset(buf, 0);
++buf;
return flatcc_verify_struct_as_root(buf, bufsiz, fid, align, size);
}
int flatcc_verify_table_as_nested_root(flatcc_table_verifier_descriptor_t *td,
voffset_t id, int required, const char *fid,
uint16_t align, flatcc_table_verifier_f tvf)
{
const uoffset_t *buf;
uoffset_t bufsiz;
check_result(flatcc_verify_vector_field(td, id, required, align, 1, FLATBUFFERS_COUNT_MAX(1)));
if (0 == (buf = get_field_ptr(td, id))) {
return flatcc_verify_ok;
}
buf = (const uoffset_t *)((size_t)buf + read_uoffset(buf, 0));
bufsiz = read_uoffset(buf, 0);
++buf;
/*
* Don't verify nested buffers identifier - information is difficult to get and
* might not be what is desired anyway. User can do it later.
*/
check_result(flatcc_verify_buffer_header(buf, bufsiz, fid));
return verify_table(buf, bufsiz, 0, read_uoffset(buf, 0), td->ttl, tvf);
}
static int gen_table_verifier(output_t *out, fb_compound_type_t *ct)
{
fb_symbol_t *sym;
fb_member_t *member;
fb_scoped_name_t snt, snref;
int required, first = 1;
fb_clear(snt);
fb_clear(snref);
fb_compound_name(ct, &snt);
fprintf(out->fp,
"static int __%s_table_verifier(flatcc_table_verifier_descriptor_t *td)\n{\n",
snt.text);
for (sym = ct->members; sym; sym = sym->link) {
member = (fb_member_t *)sym;
if (member->metadata_flags & fb_f_deprecated) {
continue;
}
if (first) {
fprintf(out->fp, " int ret;\n if ((ret = ");
} else {
fprintf(out->fp, ")) return ret;\n if ((ret = ");
}
first = 0;
required = (member->metadata_flags & fb_f_required) != 0;
switch (member->type.type) {
case vt_scalar_type:
fprintf(
out->fp,
"flatcc_verify_field(td, %"PRIu64", %"PRIu16", %"PRIu64")",
member->id, member->align, member->size);
break;
case vt_vector_type:
if (member->nest) {
fb_compound_name((fb_compound_type_t *)&member->nest->symbol, &snref);
if (member->nest->symbol.kind == fb_is_table) {
fprintf(out->fp,
"flatcc_verify_table_as_nested_root(td, %"PRIu64", "
"%u, 0, %"PRIu16", __%s_table_verifier)",
member->id, required, member->align, snref.text);
} else {
fprintf(out->fp,
"flatcc_verify_struct_as_nested_root(td, %"PRIu64", "
"%u, 0, %"PRIu16", %"PRIu64")",
member->id, required, member->align, member->size);
}
} else {
fprintf(out->fp,
"flatcc_verify_vector_field(td, %"PRIu64", %d, %"PRId16", %"PRIu64", %"PRIu64")",
member->id, required, member->align, member->size, (uint64_t)FLATBUFFERS_COUNT_MAX(member->size));
};
break;
case vt_string_type:
fprintf(out->fp,
"flatcc_verify_string_field(td, %"PRIu64", %d)",
member->id, required);
break;
case vt_vector_string_type:
fprintf(out->fp,
"flatcc_verify_string_vector_field(td, %"PRIu64", %d)",
member->id, required);
break;
case vt_compound_type_ref:
fb_compound_name(member->type.ct, &snref);
switch (member->type.ct->symbol.kind) {
case fb_is_enum:
case fb_is_struct:
fprintf(out->fp,
"flatcc_verify_field(td, %"PRIu64", %"PRIu16", %"PRIu64")",
member->id, member->align, member->size);
break;
case fb_is_table:
fprintf(out->fp,
"flatcc_verify_table_field(td, %"PRIu64", %d, &__%s_table_verifier)",
member->id, required, snref.text);
break;
case fb_is_union:
fprintf(out->fp,
"flatcc_verify_union_field(td, %"PRIu64", %d, &__%s_union_verifier)",
member->id, required, snref.text);
break;
default:
gen_panic(out, "internal error: unexpected compound type for table verifier");
return -1;
}
break;
case vt_vector_compound_type_ref:
fb_compound_name(member->type.ct, &snref);
switch (member->type.ct->symbol.kind) {
case fb_is_table:
fprintf(out->fp,
"flatcc_verify_table_vector_field(td, %"PRIu64", %d, &__%s_table_verifier)",
member->id, required, snref.text);
break;
case fb_is_enum:
case fb_is_struct:
fprintf(out->fp,
"flatcc_verify_vector_field(td, %"PRIu64", %d, %"PRId16", %"PRIu64", %"PRIu64")",
member->id, required, member->align, member->size, (uint64_t)FLATBUFFERS_COUNT_MAX(member->size));
break;
default:
gen_panic(out, "internal error: unexpected vector compound type for table verifier");
return -1;
}
break;
}
fprintf(out->fp, " /* %.*s */", (int)sym->ident->len, sym->ident->text);
}
if (!first) {
fprintf(out->fp, ")) return ret;\n");
}
fprintf(out->fp, " return flatcc_verify_ok;\n");
fprintf(out->fp, "}\n\n");
fprintf(out->fp,
"static inline int %s_verify_as_root(const void *buf, size_t bufsiz, const char *fid)\n"
"{\n return flatcc_verify_table_as_root(buf, bufsiz, fid, &__%s_table_verifier);\n}\n\n",
snt.text, snt.text);
return 0;
}
