diff options
Diffstat (limited to 'src/idl_parser.cpp')
| -rw-r--r-- | src/idl_parser.cpp | 304 |
1 files changed, 143 insertions, 161 deletions
diff --git a/src/idl_parser.cpp b/src/idl_parser.cpp index 37692f98..56b1547c 100644 --- a/src/idl_parser.cpp +++ b/src/idl_parser.cpp @@ -15,12 +15,11 @@ */ #include <algorithm> +#include <cmath> #include <list> #include <string> #include <utility> -#include <cmath> - #include "flatbuffers/idl.h" #include "flatbuffers/util.h" @@ -114,8 +113,8 @@ std::string MakeScreamingCamel(const std::string &in) { return s; } -void DeserializeDoc( std::vector<std::string> &doc, - const Vector<Offset<String>> *documentation) { +void DeserializeDoc(std::vector<std::string> &doc, + const Vector<Offset<String>> *documentation) { if (documentation == nullptr) return; for (uoffset_t index = 0; index < documentation->size(); index++) doc.push_back(documentation->Get(index)->str()); @@ -399,7 +398,8 @@ CheckedError Parser::Next() { "illegal Unicode sequence (unpaired high surrogate)"); } // reset if non-printable - attr_is_trivial_ascii_string_ &= check_ascii_range(*cursor_, ' ', '~'); + attr_is_trivial_ascii_string_ &= + check_ascii_range(*cursor_, ' ', '~'); attribute_ += *cursor_++; } @@ -437,7 +437,7 @@ CheckedError Parser::Next() { cursor_ += 2; break; } - FLATBUFFERS_FALLTHROUGH(); // else fall thru + FLATBUFFERS_FALLTHROUGH(); // else fall thru default: const auto has_sign = (c == '+') || (c == '-'); // '-'/'+' and following identifier - can be a predefined constant like: @@ -451,14 +451,15 @@ CheckedError Parser::Next() { return NoError(); } - auto dot_lvl = (c == '.') ? 0 : 1; // dot_lvl==0 <=> exactly one '.' seen - if (!dot_lvl && !is_digit(*cursor_)) return NoError(); // enum? + auto dot_lvl = + (c == '.') ? 0 : 1; // dot_lvl==0 <=> exactly one '.' seen + if (!dot_lvl && !is_digit(*cursor_)) return NoError(); // enum? // Parser accepts hexadecimal-floating-literal (see C++ 5.13.4). if (is_digit(c) || has_sign || !dot_lvl) { const auto start = cursor_ - 1; auto start_digits = !is_digit(c) ? cursor_ : cursor_ - 1; - if (!is_digit(c) && is_digit(*cursor_)){ - start_digits = cursor_; // see digit in cursor_ position + if (!is_digit(c) && is_digit(*cursor_)) { + start_digits = cursor_; // see digit in cursor_ position c = *cursor_++; } // hex-float can't begind with '.' @@ -501,7 +502,8 @@ CheckedError Parser::Next() { } std::string ch; ch = c; - if (false == check_ascii_range(c, ' ', '~')) ch = "code: " + NumToString(c); + if (false == check_ascii_range(c, ' ', '~')) + ch = "code: " + NumToString(c); return Error("illegal character: " + ch); } } @@ -730,7 +732,7 @@ CheckedError Parser::ParseField(StructDef &struct_def) { if (!IsScalar(type.base_type) || (struct_def.fixed && field->value.constant != "0")) return Error( - "default values currently only supported for scalars in tables"); + "default values currently only supported for scalars in tables"); } // Append .0 if the value has not it (skip hex and scientific floats). // This suffix needed for generated C++ code. @@ -738,7 +740,7 @@ CheckedError Parser::ParseField(StructDef &struct_def) { auto &text = field->value.constant; FLATBUFFERS_ASSERT(false == text.empty()); auto s = text.c_str(); - while(*s == ' ') s++; + while (*s == ' ') s++; if (*s == '-' || *s == '+') s++; // 1) A float constants (nan, inf, pi, etc) is a kind of identifier. // 2) A float number needn't ".0" at the end if it has exponent. @@ -774,7 +776,8 @@ CheckedError Parser::ParseField(StructDef &struct_def) { field->deprecated = field->attributes.Lookup("deprecated") != nullptr; auto hash_name = field->attributes.Lookup("hash"); if (hash_name) { - switch ((type.base_type == BASE_TYPE_VECTOR) ? type.element : type.base_type) { + switch ((type.base_type == BASE_TYPE_VECTOR) ? type.element + : type.base_type) { case BASE_TYPE_SHORT: case BASE_TYPE_USHORT: { if (FindHashFunction16(hash_name->constant.c_str()) == nullptr) @@ -798,7 +801,8 @@ CheckedError Parser::ParseField(StructDef &struct_def) { } default: return Error( - "only short, ushort, int, uint, long and ulong data types support hashing."); + "only short, ushort, int, uint, long and ulong data types support " + "hashing."); } } auto cpp_type = field->attributes.Lookup("cpp_type"); @@ -817,8 +821,7 @@ CheckedError Parser::ParseField(StructDef &struct_def) { if (field->deprecated && struct_def.fixed) return Error("can't deprecate fields in a struct"); field->required = field->attributes.Lookup("required") != nullptr; - if (field->required && - (struct_def.fixed || IsScalar(type.base_type))) + if (field->required && (struct_def.fixed || IsScalar(type.base_type))) return Error("only non-scalar fields in tables may be 'required'"); field->key = field->attributes.Lookup("key") != nullptr; if (field->key) { @@ -861,8 +864,7 @@ CheckedError Parser::ParseField(StructDef &struct_def) { if (field->attributes.Lookup("flexbuffer")) { field->flexbuffer = true; uses_flexbuffers_ = true; - if (type.base_type != BASE_TYPE_VECTOR || - type.element != BASE_TYPE_UCHAR) + if (type.base_type != BASE_TYPE_VECTOR || type.element != BASE_TYPE_UCHAR) return Error("flexbuffer attribute may only apply to a vector of ubyte"); } @@ -902,8 +904,7 @@ CheckedError Parser::ParseComma() { CheckedError Parser::ParseAnyValue(Value &val, FieldDef *field, size_t parent_fieldn, const StructDef *parent_struct_def, - uoffset_t count, - bool inside_vector) { + uoffset_t count, bool inside_vector) { switch (val.type.base_type) { case BASE_TYPE_UNION: { FLATBUFFERS_ASSERT(field); @@ -921,8 +922,8 @@ CheckedError Parser::ParseAnyValue(Value &val, FieldDef *field, uoffset_t offset; ECHECK(atot(elem->first.constant.c_str(), *this, &offset)); vector_of_union_types = reinterpret_cast<Vector<uint8_t> *>( - builder_.GetCurrentBufferPointer() + - builder_.GetSize() - offset); + builder_.GetCurrentBufferPointer() + builder_.GetSize() - + offset); break; } } else { @@ -964,8 +965,7 @@ CheckedError Parser::ParseAnyValue(Value &val, FieldDef *field, } } if (constant.empty() && !vector_of_union_types) { - return Error("missing type field for this union value: " + - field->name); + return Error("missing type field for this union value: " + field->name); } uint8_t enum_idx; if (vector_of_union_types) { @@ -1040,10 +1040,9 @@ void Parser::SerializeStruct(FlatBufferBuilder &builder, builder.AddStructOffset(val.offset, builder.GetSize()); } -template <typename F> +template<typename F> CheckedError Parser::ParseTableDelimiters(size_t &fieldn, - const StructDef *struct_def, - F body) { + const StructDef *struct_def, F body) { // We allow tables both as JSON object{ .. } with field names // or vector[..] with all fields in order char terminator = '}'; @@ -1217,7 +1216,7 @@ CheckedError Parser::ParseTable(const StructDef &struct_def, std::string *value, reinterpret_cast<const uint8_t*>(field_value.constant.c_str()), InlineSize(field_value.type)); break; - // clang-format on + // clang-format on } } } @@ -1243,7 +1242,7 @@ CheckedError Parser::ParseTable(const StructDef &struct_def, std::string *value, return NoError(); } -template <typename F> +template<typename F> CheckedError Parser::ParseVectorDelimiters(uoffset_t &count, F body) { EXPECT('['); for (;;) { @@ -1259,12 +1258,11 @@ CheckedError Parser::ParseVectorDelimiters(uoffset_t &count, F body) { static bool CompareType(const uint8_t *a, const uint8_t *b, BaseType ftype) { switch (ftype) { - #define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE, JTYPE, GTYPE, NTYPE, \ - PTYPE, RTYPE, KTYPE) \ - case BASE_TYPE_ ## ENUM: \ - return ReadScalar<CTYPE>(a) < ReadScalar<CTYPE>(b); +#define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE, JTYPE, GTYPE, NTYPE, PTYPE, \ + RTYPE, KTYPE) \ + case BASE_TYPE_##ENUM: return ReadScalar<CTYPE>(a) < ReadScalar<CTYPE>(b); FLATBUFFERS_GEN_TYPES_SCALAR(FLATBUFFERS_TD) - #undef FLATBUFFERS_TD +#undef FLATBUFFERS_TD case BASE_TYPE_STRING: // Indirect offset pointer to string pointer. a += ReadScalar<uoffset_t>(a); @@ -1278,21 +1276,21 @@ static bool CompareType(const uint8_t *a, const uint8_t *b, BaseType ftype) { // See below for why we need our own sort :( template<typename T, typename F, typename S> void SimpleQsort(T *begin, T *end, size_t width, F comparator, S swapper) { - if (end - begin <= static_cast<ptrdiff_t>(width)) return; - auto l = begin + width; - auto r = end; - while (l < r) { - if (comparator(begin, l)) { - r -= width; - swapper(l, r); - } else { - l++; - } + if (end - begin <= static_cast<ptrdiff_t>(width)) return; + auto l = begin + width; + auto r = end; + while (l < r) { + if (comparator(begin, l)) { + r -= width; + swapper(l, r); + } else { + l++; } - l -= width; - swapper(begin, l); - SimpleQsort(begin, l, width, comparator, swapper); - SimpleQsort(r, end, width, comparator, swapper); + } + l -= width; + swapper(begin, l); + SimpleQsort(begin, l, width, comparator, swapper); + SimpleQsort(r, end, width, comparator, swapper); } CheckedError Parser::ParseVector(const Type &type, uoffset_t *ovalue, @@ -1359,46 +1357,49 @@ CheckedError Parser::ParseVector(const Type &type, uoffset_t *ovalue, static BaseType ftype = key->value.type.base_type; if (type.struct_def->fixed) { - auto v = reinterpret_cast<VectorOfAny *>( - builder_.GetCurrentBufferPointer()); - SimpleQsort<uint8_t>(v->Data(), - v->Data() + v->size() * type.struct_def->bytesize, - type.struct_def->bytesize, - [](const uint8_t *a, const uint8_t *b) -> bool { - return CompareType(a + offset, b + offset, ftype); - }, [&](uint8_t *a, uint8_t *b) { - // FIXME: faster? - for (size_t i = 0; i < type.struct_def->bytesize; i++) { - std::swap(a[i], b[i]); - } - }); + auto v = + reinterpret_cast<VectorOfAny *>(builder_.GetCurrentBufferPointer()); + SimpleQsort<uint8_t>( + v->Data(), v->Data() + v->size() * type.struct_def->bytesize, + type.struct_def->bytesize, + [](const uint8_t *a, const uint8_t *b) -> bool { + return CompareType(a + offset, b + offset, ftype); + }, + [&](uint8_t *a, uint8_t *b) { + // FIXME: faster? + for (size_t i = 0; i < type.struct_def->bytesize; i++) { + std::swap(a[i], b[i]); + } + }); } else { auto v = reinterpret_cast<Vector<Offset<Table>> *>( - builder_.GetCurrentBufferPointer()); + builder_.GetCurrentBufferPointer()); // Here also can't use std::sort. We do have an iterator type for it, // but it is non-standard as it will dereference the offsets, and thus // can't be used to swap elements. - SimpleQsort<Offset<Table>>(v->data(), v->data() + v->size(), 1, - [](const Offset<Table> *_a, const Offset<Table> *_b) -> bool { - // Indirect offset pointer to table pointer. - auto a = reinterpret_cast<const uint8_t *>(_a) + - ReadScalar<uoffset_t>(_a); - auto b = reinterpret_cast<const uint8_t *>(_b) + - ReadScalar<uoffset_t>(_b); - // Fetch field address from table. - a = reinterpret_cast<const Table *>(a)->GetAddressOf(offset); - b = reinterpret_cast<const Table *>(b)->GetAddressOf(offset); - return CompareType(a, b, ftype); - }, [&](Offset<Table> *a, Offset<Table> *b) { - // These are serialized offsets, so are relative where they are - // stored in memory, so compute the distance between these pointers: - ptrdiff_t diff = (b - a) * sizeof(Offset<Table>); - assert(diff >= 0); // Guaranteed by SimpleQsort. - auto udiff = static_cast<uoffset_t>(diff); - a->o = EndianScalar(ReadScalar<uoffset_t>(a) - udiff); - b->o = EndianScalar(ReadScalar<uoffset_t>(b) + udiff); - std::swap(*a, *b); - }); + SimpleQsort<Offset<Table>>( + v->data(), v->data() + v->size(), 1, + [](const Offset<Table> *_a, const Offset<Table> *_b) -> bool { + // Indirect offset pointer to table pointer. + auto a = reinterpret_cast<const uint8_t *>(_a) + + ReadScalar<uoffset_t>(_a); + auto b = reinterpret_cast<const uint8_t *>(_b) + + ReadScalar<uoffset_t>(_b); + // Fetch field address from table. + a = reinterpret_cast<const Table *>(a)->GetAddressOf(offset); + b = reinterpret_cast<const Table *>(b)->GetAddressOf(offset); + return CompareType(a, b, ftype); + }, + [&](Offset<Table> *a, Offset<Table> *b) { + // These are serialized offsets, so are relative where they are + // stored in memory, so compute the distance between these pointers: + ptrdiff_t diff = (b - a) * sizeof(Offset<Table>); + assert(diff >= 0); // Guaranteed by SimpleQsort. + auto udiff = static_cast<uoffset_t>(diff); + a->o = EndianScalar(ReadScalar<uoffset_t>(a) - udiff); + b->o = EndianScalar(ReadScalar<uoffset_t>(b) + udiff); + std::swap(*a, *b); + }); } } return NoError(); @@ -1478,12 +1479,11 @@ CheckedError Parser::ParseNestedFlatbuffer(Value &val, FieldDef *field, nested_parser.enums_.dict.clear(); nested_parser.enums_.vec.clear(); - if (!ok) { - ECHECK(Error(nested_parser.error_)); - } + if (!ok) { ECHECK(Error(nested_parser.error_)); } // Force alignment for nested flatbuffer - builder_.ForceVectorAlignment(nested_parser.builder_.GetSize(), sizeof(uint8_t), - nested_parser.builder_.GetBufferMinAlignment()); + builder_.ForceVectorAlignment( + nested_parser.builder_.GetSize(), sizeof(uint8_t), + nested_parser.builder_.GetBufferMinAlignment()); auto off = builder_.CreateVector(nested_parser.builder_.GetBufferPointer(), nested_parser.builder_.GetSize()); @@ -1499,7 +1499,7 @@ CheckedError Parser::ParseMetaData(SymbolTable<Value> *attributes) { auto name = attribute_; if (false == (Is(kTokenIdentifier) || Is(kTokenStringConstant))) return Error("attribute name must be either identifier or string: " + - name); + name); if (known_attributes_.find(name) == known_attributes_.end()) return Error("user define attributes must be declared before use: " + name); @@ -1648,10 +1648,10 @@ template<typename T> inline void SingleValueRepack(Value &e, T val) { } #if defined(FLATBUFFERS_HAS_NEW_STRTOD) && (FLATBUFFERS_HAS_NEW_STRTOD > 0) // Normilaze defaults NaN to unsigned quiet-NaN(0). -static inline void SingleValueRepack(Value& e, float val) { +static inline void SingleValueRepack(Value &e, float val) { if (val != val) e.constant = "nan"; } -static inline void SingleValueRepack(Value& e, double val) { +static inline void SingleValueRepack(Value &e, double val) { if (val != val) e.constant = "nan"; } #endif @@ -1774,7 +1774,7 @@ CheckedError Parser::ParseSingleValue(const std::string *name, Value &e, "' to value of <" + std::string(kTypeNames[in_type]) + "> type."; return Error(msg); } - const auto match_type = e.type.base_type; // may differ from in_type + const auto match_type = e.type.base_type; // may differ from in_type // The check_now flag must be true when parse a fbs-schema. // This flag forces to check default scalar values or metadata of field. // For JSON parser the flag should be false. @@ -2210,11 +2210,10 @@ CheckedError Parser::CheckClash(std::vector<FieldDef *> &fields, bool Parser::SupportsAdvancedUnionFeatures() const { return opts.lang_to_generate != 0 && - (opts.lang_to_generate & ~(IDLOptions::kCpp | IDLOptions::kJs | - IDLOptions::kTs | IDLOptions::kPhp | - IDLOptions::kJava | IDLOptions::kCSharp | - IDLOptions::kKotlin | - IDLOptions::kBinary)) == 0; + (opts.lang_to_generate & + ~(IDLOptions::kCpp | IDLOptions::kJs | IDLOptions::kTs | + IDLOptions::kPhp | IDLOptions::kJava | IDLOptions::kCSharp | + IDLOptions::kKotlin | IDLOptions::kBinary)) == 0; } bool Parser::SupportsAdvancedArrayFeatures() const { @@ -2486,8 +2485,8 @@ CheckedError Parser::StartEnum(const std::string &enum_name, bool is_union, if (enums_.Add(current_namespace_->GetFullyQualifiedName(enum_name), &enum_def)) return Error("enum already exists: " + enum_name); - enum_def.underlying_type.base_type = is_union ? BASE_TYPE_UTYPE - : BASE_TYPE_INT; + enum_def.underlying_type.base_type = + is_union ? BASE_TYPE_UTYPE : BASE_TYPE_INT; enum_def.underlying_type.enum_def = &enum_def; if (dest) *dest = &enum_def; return NoError(); @@ -2623,8 +2622,8 @@ CheckedError Parser::ParseProtoFields(StructDef *struct_def, bool isextend, if (oneof_type.base_type != BASE_TYPE_STRUCT || !oneof_type.struct_def || oneof_type.struct_def->fixed) return Error("oneof '" + name + - "' cannot be mapped to a union because member '" + - oneof_field.name + "' is not a table type."); + "' cannot be mapped to a union because member '" + + oneof_field.name + "' is not a table type."); EnumValBuilder evb(*this, *oneof_union); auto ev = evb.CreateEnumerator(oneof_type.struct_def->name); ev->union_type = oneof_type; @@ -2989,9 +2988,7 @@ CheckedError Parser::DoParse(const char *source, const char **include_paths, // entered into included_files_. // This is recursive, but only go as deep as the number of include // statements. - if (source_filename) { - included_files_.erase(source_filename); - } + if (source_filename) { included_files_.erase(source_filename); } return DoParse(source, include_paths, source_filename, include_filename); } @@ -3015,9 +3012,9 @@ CheckedError Parser::DoParse(const char *source, const char **include_paths, uoffset_t toff; ECHECK(ParseTable(*root_struct_def_, nullptr, &toff)); if (opts.size_prefixed) { - builder_.FinishSizePrefixed(Offset<Table>(toff), file_identifier_.length() - ? file_identifier_.c_str() - : nullptr); + builder_.FinishSizePrefixed( + Offset<Table>(toff), + file_identifier_.length() ? file_identifier_.c_str() : nullptr); } else { builder_.Finish(Offset<Table>(toff), file_identifier_.length() ? file_identifier_.c_str() @@ -3038,8 +3035,7 @@ CheckedError Parser::DoParse(const char *source, const char **include_paths, if (opts.root_type.empty()) { if (!SetRootType(root_type.c_str())) return Error("unknown root type: " + root_type); - if (root_struct_def_->fixed) - return Error("root type must be a table"); + if (root_struct_def_->fixed) return Error("root type must be a table"); } EXPECT(';'); } else if (IsIdent("file_identifier")) { @@ -3144,10 +3140,9 @@ void Parser::Serialize() { auto fiid__ = builder_.CreateString(file_identifier_); auto fext__ = builder_.CreateString(file_extension_); auto serv__ = builder_.CreateVectorOfSortedTables(&service_offsets); - auto schema_offset = - reflection::CreateSchema(builder_, objs__, enum__, fiid__, fext__, - (root_struct_def_ ? root_struct_def_->serialized_location : 0), - serv__); + auto schema_offset = reflection::CreateSchema( + builder_, objs__, enum__, fiid__, fext__, + (root_struct_def_ ? root_struct_def_->serialized_location : 0), serv__); if (opts.size_prefixed) { builder_.FinishSizePrefixed(schema_offset, reflection::SchemaIdentifier()); } else { @@ -3193,22 +3188,20 @@ Offset<reflection::Object> StructDef::Serialize(FlatBufferBuilder *builder, auto flds__ = builder->CreateVectorOfSortedTables(&field_offsets); auto attr__ = SerializeAttributes(builder, parser); auto docs__ = parser.opts.binary_schema_comments - ? builder->CreateVectorOfStrings(doc_comment) - : 0; + ? builder->CreateVectorOfStrings(doc_comment) + : 0; return reflection::CreateObject(*builder, name__, flds__, fixed, static_cast<int>(minalign), - static_cast<int>(bytesize), - attr__, docs__); + static_cast<int>(bytesize), attr__, docs__); } bool StructDef::Deserialize(Parser &parser, const reflection::Object *object) { - if (!DeserializeAttributes(parser, object->attributes())) - return false; + if (!DeserializeAttributes(parser, object->attributes())) return false; DeserializeDoc(doc_comment, object->documentation()); name = parser.UnqualifiedName(object->name()->str()); predecl = false; sortbysize = attributes.Lookup("original_order") == nullptr && !fixed; - const auto& of = *(object->fields()); + const auto &of = *(object->fields()); auto indexes = std::vector<uoffset_t>(of.size()); for (uoffset_t i = 0; i < of.size(); i++) indexes[of.Get(i)->id()] = i; size_t tmp_struct_size = 0; @@ -3224,9 +3217,7 @@ bool StructDef::Deserialize(Parser &parser, const reflection::Object *object) { // Recompute padding since that's currently not serialized. auto size = InlineSize(field_def->value.type); auto next_field = - i + 1 < indexes.size() - ? of.Get(indexes[i+1]) - : nullptr; + i + 1 < indexes.size() ? of.Get(indexes[i + 1]) : nullptr; tmp_struct_size += size; field_def->padding = next_field ? (next_field->offset() - field_def->value.offset) - size @@ -3245,9 +3236,10 @@ Offset<reflection::Field> FieldDef::Serialize(FlatBufferBuilder *builder, auto type__ = value.type.Serialize(builder); auto attr__ = SerializeAttributes(builder, parser); auto docs__ = parser.opts.binary_schema_comments - ? builder->CreateVectorOfStrings(doc_comment) - : 0; - return reflection::CreateField(*builder, name__, type__, id, value.offset, + ? builder->CreateVectorOfStrings(doc_comment) + : 0; + return reflection::CreateField( + *builder, name__, type__, id, value.offset, // Is uint64>max(int64) tested? IsInteger(value.type.base_type) ? StringToInt(value.constant.c_str()) : 0, // result may be platform-dependent if underlying is float (not double) @@ -3261,8 +3253,7 @@ Offset<reflection::Field> FieldDef::Serialize(FlatBufferBuilder *builder, bool FieldDef::Deserialize(Parser &parser, const reflection::Field *field) { name = field->name()->str(); defined_namespace = parser.current_namespace_; - if (!value.type.Deserialize(parser, field->type())) - return false; + if (!value.type.Deserialize(parser, field->type())) return false; value.offset = field->offset(); if (IsInteger(value.type.base_type)) { value.constant = NumToString(field->default_integer()); @@ -3276,8 +3267,7 @@ bool FieldDef::Deserialize(Parser &parser, const reflection::Field *field) { deprecated = field->deprecated(); required = field->required(); key = field->key(); - if (!DeserializeAttributes(parser, field->attributes())) - return false; + if (!DeserializeAttributes(parser, field->attributes())) return false; // TODO: this should probably be handled by a separate attribute if (attributes.Lookup("flexbuffer")) { flexbuffer = true; @@ -3301,18 +3291,16 @@ Offset<reflection::RPCCall> RPCCall::Serialize(FlatBufferBuilder *builder, auto name__ = builder->CreateString(name); auto attr__ = SerializeAttributes(builder, parser); auto docs__ = parser.opts.binary_schema_comments - ? builder->CreateVectorOfStrings(doc_comment) - : 0; - return reflection::CreateRPCCall(*builder, name__, - request->serialized_location, - response->serialized_location, - attr__, docs__); + ? builder->CreateVectorOfStrings(doc_comment) + : 0; + return reflection::CreateRPCCall( + *builder, name__, request->serialized_location, + response->serialized_location, attr__, docs__); } bool RPCCall::Deserialize(Parser &parser, const reflection::RPCCall *call) { name = call->name()->str(); - if (!DeserializeAttributes(parser, call->attributes())) - return false; + if (!DeserializeAttributes(parser, call->attributes())) return false; DeserializeDoc(doc_comment, call->documentation()); request = parser.structs_.Lookup(call->request()->name()->str()); response = parser.structs_.Lookup(call->response()->name()->str()); @@ -3331,8 +3319,8 @@ Offset<reflection::Service> ServiceDef::Serialize(FlatBufferBuilder *builder, auto call__ = builder->CreateVector(servicecall_offsets); auto attr__ = SerializeAttributes(builder, parser); auto docs__ = parser.opts.binary_schema_comments - ? builder->CreateVectorOfStrings(doc_comment) - : 0; + ? builder->CreateVectorOfStrings(doc_comment) + : 0; return reflection::CreateService(*builder, name__, call__, attr__, docs__); } @@ -3349,8 +3337,7 @@ bool ServiceDef::Deserialize(Parser &parser, } } } - if (!DeserializeAttributes(parser, service->attributes())) - return false; + if (!DeserializeAttributes(parser, service->attributes())) return false; DeserializeDoc(doc_comment, service->documentation()); return true; } @@ -3367,8 +3354,8 @@ Offset<reflection::Enum> EnumDef::Serialize(FlatBufferBuilder *builder, auto type__ = underlying_type.Serialize(builder); auto attr__ = SerializeAttributes(builder, parser); auto docs__ = parser.opts.binary_schema_comments - ? builder->CreateVectorOfStrings(doc_comment) - : 0; + ? builder->CreateVectorOfStrings(doc_comment) + : 0; return reflection::CreateEnum(*builder, name__, vals__, is_union, type__, attr__, docs__); } @@ -3387,8 +3374,7 @@ bool EnumDef::Deserialize(Parser &parser, const reflection::Enum *_enum) { if (!underlying_type.Deserialize(parser, _enum->underlying_type())) { return false; } - if (!DeserializeAttributes(parser, _enum->attributes())) - return false; + if (!DeserializeAttributes(parser, _enum->attributes())) return false; DeserializeDoc(doc_comment, _enum->documentation()); return true; } @@ -3398,9 +3384,10 @@ Offset<reflection::EnumVal> EnumVal::Serialize(FlatBufferBuilder *builder, auto name__ = builder->CreateString(name); auto type__ = union_type.Serialize(builder); auto docs__ = parser.opts.binary_schema_comments - ? builder->CreateVectorOfStrings(doc_comment) - : 0; - return reflection::CreateEnumVal(*builder, name__, value, + ? builder->CreateVectorOfStrings(doc_comment) + : 0; + return reflection::CreateEnumVal( + *builder, name__, value, union_type.struct_def ? union_type.struct_def->serialized_location : 0, type__, docs__); } @@ -3409,8 +3396,7 @@ bool EnumVal::Deserialize(const Parser &parser, const reflection::EnumVal *val) { name = val->name()->str(); value = val->value(); - if (!union_type.Deserialize(parser, val->union_type())) - return false; + if (!union_type.Deserialize(parser, val->union_type())) return false; DeserializeDoc(doc_comment, val->documentation()); return true; } @@ -3432,8 +3418,7 @@ bool Type::Deserialize(const Parser &parser, const reflection::Type *type) { bool is_series = type->base_type() == reflection::Vector || type->base_type() == reflection::Array; if (type->base_type() == reflection::Obj || - (is_series && - type->element() == reflection::Obj)) { + (is_series && type->element() == reflection::Obj)) { if (static_cast<size_t>(type->index()) < parser.structs_.vec.size()) { struct_def = parser.structs_.vec[type->index()]; struct_def->refcount++; @@ -3474,8 +3459,7 @@ Definition::SerializeAttributes(FlatBufferBuilder *builder, bool Definition::DeserializeAttributes( Parser &parser, const Vector<Offset<reflection::KeyValue>> *attrs) { - if (attrs == nullptr) - return true; + if (attrs == nullptr) return true; for (uoffset_t i = 0; i < attrs->size(); ++i) { auto kv = attrs->Get(i); auto value = new Value(); @@ -3495,7 +3479,7 @@ bool Definition::DeserializeAttributes( bool Parser::Deserialize(const uint8_t *buf, const size_t size) { flatbuffers::Verifier verifier(reinterpret_cast<const uint8_t *>(buf), size); bool size_prefixed = false; - if(!reflection::SchemaBufferHasIdentifier(buf)) { + if (!reflection::SchemaBufferHasIdentifier(buf)) { if (!flatbuffers::BufferHasIdentifier(buf, reflection::SchemaIdentifier(), true)) return false; @@ -3504,9 +3488,7 @@ bool Parser::Deserialize(const uint8_t *buf, const size_t size) { } auto verify_fn = size_prefixed ? &reflection::VerifySizePrefixedSchemaBuffer : &reflection::VerifySchemaBuffer; - if (!verify_fn(verifier)) { - return false; - } + if (!verify_fn(verifier)) { return false; } auto schema = size_prefixed ? reflection::GetSizePrefixedSchema(buf) : reflection::GetSchema(buf); return Deserialize(schema); @@ -3555,7 +3537,7 @@ bool Parser::Deserialize(const reflection::Schema *schema) { auto struct_def = structs_.Lookup(qualified_name); struct_def->defined_namespace = GetNamespace(qualified_name, namespaces_, namespaces_index); - if (!struct_def->Deserialize(*this, * it)) { return false; } + if (!struct_def->Deserialize(*this, *it)) { return false; } if (schema->root_table() == *it) { root_struct_def_ = struct_def; } } for (auto it = schema->enums()->begin(); it != schema->enums()->end(); ++it) { |