_ZN11flatbuffers9AllocatorD2Ev: 28| 199k| virtual ~Allocator() {} _ZN11flatbuffers12PaddingBytesEmm: 458| 1.45M|inline size_t PaddingBytes(size_t buf_size, size_t scalar_size) { 459| 1.45M| return ((~buf_size) + 1) & (scalar_size - 1); 460| 1.45M|} _ZN11flatbuffers12EndianScalarIjEET_S1_: 416| 720k|template T EndianScalar(T t) { 417| 720k| #if FLATBUFFERS_LITTLEENDIAN 418| 720k| return t; 419| | #else 420| | return EndianSwap(t); 421| | #endif 422| 720k|} _ZN11flatbuffers10ReadScalarImEET_PKv: 427| 45.6k|T ReadScalar(const void *p) { 428| 45.6k| return EndianScalar(*reinterpret_cast(p)); 429| 45.6k|} _ZN11flatbuffers12EndianScalarImEET_S1_: 416| 75.9k|template T EndianScalar(T t) { 417| 75.9k| #if FLATBUFFERS_LITTLEENDIAN 418| 75.9k| return t; 419| | #else 420| | return EndianSwap(t); 421| | #endif 422| 75.9k|} _ZN11flatbuffers10ReadScalarIiEET_PKv: 427| 1.19M|T ReadScalar(const void *p) { 428| 1.19M| return EndianScalar(*reinterpret_cast(p)); 429| 1.19M|} _ZN11flatbuffers12EndianScalarIiEET_S1_: 416| 1.80M|template T EndianScalar(T t) { 417| 1.80M| #if FLATBUFFERS_LITTLEENDIAN 418| 1.80M| return t; 419| | #else 420| | return EndianSwap(t); 421| | #endif 422| 1.80M|} _ZN11flatbuffers10ReadScalarItEET_PKv: 427| 2.53M|T ReadScalar(const void *p) { 428| 2.53M| return EndianScalar(*reinterpret_cast(p)); 429| 2.53M|} _ZN11flatbuffers12EndianScalarItEET_S1_: 416| 3.32M|template T EndianScalar(T t) { 417| 3.32M| #if FLATBUFFERS_LITTLEENDIAN 418| 3.32M| return t; 419| | #else 420| | return EndianSwap(t); 421| | #endif 422| 3.32M|} _ZN11flatbuffers10ReadScalarIhEET_PKv: 427| 26.0k|T ReadScalar(const void *p) { 428| 26.0k| return EndianScalar(*reinterpret_cast(p)); 429| 26.0k|} _ZN11flatbuffers12EndianScalarIhEET_S1_: 416| 43.3k|template T EndianScalar(T t) { 417| 43.3k| #if FLATBUFFERS_LITTLEENDIAN 418| 43.3k| return t; 419| | #else 420| | return EndianSwap(t); 421| | #endif 422| 43.3k|} _ZN11flatbuffers10ReadScalarIjEET_PKv: 427| 25.8k|T ReadScalar(const void *p) { 428| 25.8k| return EndianScalar(*reinterpret_cast(p)); 429| 25.8k|} _ZN11flatbuffers10ReadScalarIaEET_PKv: 427| 16.5k|T ReadScalar(const void *p) { 428| 16.5k| return EndianScalar(*reinterpret_cast(p)); 429| 16.5k|} _ZN11flatbuffers12EndianScalarIaEET_S1_: 416| 27.5k|template T EndianScalar(T t) { 417| 27.5k| #if FLATBUFFERS_LITTLEENDIAN 418| 27.5k| return t; 419| | #else 420| | return EndianSwap(t); 421| | #endif 422| 27.5k|} _ZN11flatbuffers10ReadScalarIsEET_PKv: 427| 20.9k|T ReadScalar(const void *p) { 428| 20.9k| return EndianScalar(*reinterpret_cast(p)); 429| 20.9k|} _ZN11flatbuffers12EndianScalarIsEET_S1_: 416| 35.1k|template T EndianScalar(T t) { 417| 35.1k| #if FLATBUFFERS_LITTLEENDIAN 418| 35.1k| return t; 419| | #else 420| | return EndianSwap(t); 421| | #endif 422| 35.1k|} _ZN11flatbuffers10ReadScalarIlEET_PKv: 427| 29.7k|T ReadScalar(const void *p) { 428| 29.7k| return EndianScalar(*reinterpret_cast(p)); 429| 29.7k|} _ZN11flatbuffers12EndianScalarIlEET_S1_: 416| 49.6k|template T EndianScalar(T t) { 417| 49.6k| #if FLATBUFFERS_LITTLEENDIAN 418| 49.6k| return t; 419| | #else 420| | return EndianSwap(t); 421| | #endif 422| 49.6k|} _ZN11flatbuffers10ReadScalarIfEET_PKv: 427| 34.5k|T ReadScalar(const void *p) { 428| 34.5k| return EndianScalar(*reinterpret_cast(p)); 429| 34.5k|} _ZN11flatbuffers12EndianScalarIfEET_S1_: 416| 57.2k|template T EndianScalar(T t) { 417| 57.2k| #if FLATBUFFERS_LITTLEENDIAN 418| 57.2k| return t; 419| | #else 420| | return EndianSwap(t); 421| | #endif 422| 57.2k|} _ZN11flatbuffers10ReadScalarIdEET_PKv: 427| 31.0k|T ReadScalar(const void *p) { 428| 31.0k| return EndianScalar(*reinterpret_cast(p)); 429| 31.0k|} _ZN11flatbuffers12EndianScalarIdEET_S1_: 416| 51.6k|template T EndianScalar(T t) { 417| 51.6k| #if FLATBUFFERS_LITTLEENDIAN 418| 51.6k| return t; 419| | #else 420| | return EndianSwap(t); 421| | #endif 422| 51.6k|} _ZN11flatbuffers11IsTheSameAsIaEEbT_S1_: 469| 11.0k|template inline bool IsTheSameAs(T e, T def) { return e == def; } _ZN11flatbuffers11IsTheSameAsIiEEbT_S1_: 469| 24.8k|template inline bool IsTheSameAs(T e, T def) { return e == def; } _ZN11flatbuffers11IsTheSameAsItEEbT_S1_: 469| 14.3k|template inline bool IsTheSameAs(T e, T def) { return e == def; } _ZN11flatbuffers11IsTheSameAsIjEEbT_S1_: 469| 17.0k|template inline bool IsTheSameAs(T e, T def) { return e == def; } _ZN11flatbuffers11WriteScalarItEEvPvT_: 441| 773k|void WriteScalar(void *p, T t) { 442| 773k| *reinterpret_cast(p) = EndianScalar(t); 443| 773k|} _ZN11flatbuffers11WriteScalarIiEEvPvT_: 441| 290k|void WriteScalar(void *p, T t) { 442| 290k| *reinterpret_cast(p) = EndianScalar(t); 443| 290k|} _ZN11flatbuffers11IsTheSameAsIlEEbT_S1_: 469| 19.9k|template inline bool IsTheSameAs(T e, T def) { return e == def; } _ZN11flatbuffers11IsTheSameAsIhEEbT_S1_: 469| 17.2k|template inline bool IsTheSameAs(T e, T def) { return e == def; } _ZN11flatbuffers11IsTheSameAsIdEEbT_S1_: 469| 20.5k|template inline bool IsTheSameAs(T e, T def) { return e == def; } _ZN11flatbuffers11IsTheSameAsImEEbT_S1_: 469| 30.3k|template inline bool IsTheSameAs(T e, T def) { return e == def; } _ZN11flatbuffers11IsTheSameAsIsEEbT_S1_: 469| 14.1k|template inline bool IsTheSameAs(T e, T def) { return e == def; } _ZN11flatbuffers11IsTheSameAsIfEEbT_S1_: 469| 22.6k|template inline bool IsTheSameAs(T e, T def) { return e == def; } _ZN11flatbuffers7AlignOfImEEmv: 77| 103k|FLATBUFFERS_CONSTEXPR size_t AlignOf() { 78| | // clang-format off 79| | #ifdef _MSC_VER 80| | return __alignof(T); 81| | #else 82| 103k| #ifndef alignof 83| 103k| return __alignof__(T); 84| | #else 85| | return alignof(T); 86| | #endif 87| 103k| #endif 88| | // clang-format on 89| 103k|} _ZN11flatbuffers11EndianCheckEv: 68| 490k|inline void EndianCheck() { 69| 490k| int endiantest = 1; 70| | // If this fails, see FLATBUFFERS_LITTLEENDIAN above. 71| 490k| FLATBUFFERS_ASSERT(*reinterpret_cast(&endiantest) == 72| 490k| FLATBUFFERS_LITTLEENDIAN); 73| 490k| (void)endiantest; 74| 490k|} _ZN11flatbuffers14GetMutableRootINS_5TableEEEPT_Pv: 201| 387k|T* GetMutableRoot(void* buf) { 202| 387k| if (!buf) return nullptr; ------------------ | Branch (202:7): [True: 0, False: 387k] ------------------ 203| 387k| EndianCheck(); 204| 387k| return reinterpret_cast(reinterpret_cast(buf) + 205| 387k| EndianScalar(*reinterpret_cast(buf))); 206| 387k|} _ZN11flatbuffers7GetRootINS_5TableEEEPKT_PKv: 214| 387k|const T* GetRoot(const void* buf) { 215| 387k| return GetMutableRoot(const_cast(buf)); 216| 387k|} _ZN11flatbuffers6OffsetINS_5TableEEC2Ej: 36| 290k| Offset(const offset_type _o) : o(_o) {} _ZN11flatbuffers10DeallocateEPNS_9AllocatorEPhm: 46| 99.6k|inline void Deallocate(Allocator* allocator, uint8_t* p, size_t size) { 47| 99.6k| if (allocator) ------------------ | Branch (47:7): [True: 0, False: 99.6k] ------------------ 48| 0| allocator->deallocate(p, size); 49| 99.6k| else 50| 99.6k| DefaultAllocator().deallocate(p, size); 51| 99.6k|} _ZN11flatbuffers16DefaultAllocator8allocateEm: 28| 99.6k| uint8_t* allocate(size_t size) FLATBUFFERS_OVERRIDE { 29| 99.6k| return new uint8_t[size]; 30| 99.6k| } _ZN11flatbuffers16DefaultAllocator10deallocateEPhm: 32| 99.6k| void deallocate(uint8_t* p, size_t) FLATBUFFERS_OVERRIDE { delete[] p; } _ZN11flatbuffers8AllocateEPNS_9AllocatorEm: 41| 99.6k|inline uint8_t* Allocate(Allocator* allocator, size_t size) { 42| 99.6k| return allocator ? allocator->allocate(size) ------------------ | Branch (42:10): [True: 0, False: 99.6k] ------------------ 43| 99.6k| : DefaultAllocator().allocate(size); 44| 99.6k|} _ZN11flatbuffers21FlatBufferBuilderImplILb0EEC2EmPNS_9AllocatorEbm: 100| 103k| : buf_(initial_size, allocator, own_allocator, buffer_minalign, 101| 103k| static_cast(Is64Aware ? FLATBUFFERS_MAX_64_BUFFER_SIZE ------------------ | | 343| 0|#define FLATBUFFERS_MAX_64_BUFFER_SIZE (std::numeric_limits<::flatbuffers::soffset64_t>::max)() ------------------ | Branch (101:33): [Folded, False: 103k] ------------------ 102| 103k| : FLATBUFFERS_MAX_BUFFER_SIZE)), ------------------ | | 342| 206k|#define FLATBUFFERS_MAX_BUFFER_SIZE (std::numeric_limits<::flatbuffers::soffset_t>::max)() ------------------ 103| 103k| num_field_loc(0), 104| 103k| max_voffset_(0), 105| 103k| length_of_64_bit_region_(0), 106| 103k| nested(false), 107| 103k| finished(false), 108| 103k| minalign_(1), 109| 103k| force_defaults_(false), 110| 103k| dedup_vtables_(true), 111| 103k| string_pool(nullptr) { 112| 103k| EndianCheck(); 113| 103k| } _ZN11flatbuffers21FlatBufferBuilderImplILb0EE13ForceDefaultsEb: 277| 103k| void ForceDefaults(bool fd) { force_defaults_ = fd; } _ZN11flatbuffers21FlatBufferBuilderImplILb0EED2Ev: 158| 103k| ~FlatBufferBuilderImpl() { 159| 103k| if (string_pool) delete string_pool; ------------------ | Branch (159:9): [True: 0, False: 103k] ------------------ 160| 103k| } _ZNK11flatbuffers21FlatBufferBuilderImplILb0EE16GetBufferPointerEv: 209| 387k| uint8_t* GetBufferPointer() const { 210| 387k| Finished(); 211| 387k| return buf_.data(); 212| 387k| } _ZNK11flatbuffers21FlatBufferBuilderImplILb0EE8FinishedEv: 262| 387k| void Finished() const { 263| | // If you get this assert, you're attempting to get access a buffer 264| | // which hasn't been finished yet. Be sure to call 265| | // FlatBufferBuilder::Finish with your root table. 266| | // If you really need to access an unfinished buffer, call 267| | // GetCurrentBufferPointer instead. 268| 387k| FLATBUFFERS_ASSERT(finished); 269| 387k| } _ZN11flatbuffers18FieldIndexToOffsetEt: 44| 394k|inline voffset_t FieldIndexToOffset(voffset_t field_id) { 45| | // Should correspond to what EndTable() below builds up. 46| 394k| const voffset_t fixed_fields = 47| 394k| 2 * sizeof(voffset_t); // Vtable size and Object Size. 48| 394k| size_t offset = fixed_fields + field_id * sizeof(voffset_t); 49| 394k| FLATBUFFERS_ASSERT(offset < std::numeric_limits::max()); 50| 394k| return static_cast(offset); 51| 394k|} _ZN11flatbuffers21FlatBufferBuilderImplILb0EE10AddElementIaEEvtT_S3_: 338| 11.0k| void AddElement(voffset_t field, T e, T def) { 339| | // We don't serialize values equal to the default. 340| 11.0k| if (IsTheSameAs(e, def) && !force_defaults_) return; ------------------ | Branch (340:9): [True: 2.56k, False: 8.49k] | Branch (340:32): [True: 0, False: 2.56k] ------------------ 341| 11.0k| TrackField(field, PushElement(e)); 342| 11.0k| } _ZN11flatbuffers21FlatBufferBuilderImplILb0EE10TrackFieldEtj: 327| 192k| void TrackField(voffset_t field, uoffset_t off) { 328| 192k| FieldLoc fl = {off, field}; 329| 192k| buf_.scratch_push_small(fl); 330| 192k| num_field_loc++; 331| 192k| if (field > max_voffset_) { ------------------ | Branch (331:9): [True: 192k, False: 0] ------------------ 332| 192k| max_voffset_ = field; 333| 192k| } 334| 192k| } _ZN11flatbuffers21FlatBufferBuilderImplILb0EE11PushElementIajEET0_T_: 312| 11.0k| ReturnT PushElement(T element) { 313| 11.0k| AssertScalarT(); 314| 11.0k| Align(sizeof(T)); 315| 11.0k| buf_.push_small(EndianScalar(element)); 316| 11.0k| return CalculateOffset(); 317| 11.0k| } _ZN11flatbuffers21FlatBufferBuilderImplILb0EE13AssertScalarTIaEEvv: 305| 11.0k| void AssertScalarT() { 306| | // The code assumes power of 2 sizes and endian-swap-ability. 307| 11.0k| static_assert(flatbuffers::is_scalar::value, "T must be a scalar type"); 308| 11.0k| } _ZN11flatbuffers21FlatBufferBuilderImplILb0EE5AlignEm: 290| 1.06M| void Align(size_t elem_size) { 291| 1.06M| TrackMinAlign(elem_size); 292| 1.06M| buf_.fill(PaddingBytes(buf_.size(), elem_size)); 293| 1.06M| } _ZN11flatbuffers21FlatBufferBuilderImplILb0EE13TrackMinAlignEm: 286| 1.64M| void TrackMinAlign(size_t elem_size) { 287| 1.64M| if (elem_size > minalign_) minalign_ = elem_size; ------------------ | Branch (287:9): [True: 319k, False: 1.32M] ------------------ 288| 1.64M| } _ZN11flatbuffers21FlatBufferBuilderImplILb0EE15CalculateOffsetIjEENSt3__19enable_ifIXsr3std7is_sameIT_jEE5valueES5_E4typeEv: 1440| 773k| CalculateOffset() { 1441| | // Default to the end of the 32-bit region. This may or may not be the end 1442| | // of the buffer, depending on if any 64-bit offsets have been added. 1443| 773k| return GetSizeRelative32BitRegion(); 1444| 773k| } _ZNK11flatbuffers21FlatBufferBuilderImplILb0EE26GetSizeRelative32BitRegionILb0EEENSt3__19enable_ifIXntT_EjE4typeEv: 202| 2.15M| const { 203| 2.15M| return static_cast(GetSize()); 204| 2.15M| } _ZNK11flatbuffers21FlatBufferBuilderImplILb0EE7GetSizeEv: 181| 3.20M| SizeT GetSize() const { return buf_.size(); } _ZN11flatbuffers21FlatBufferBuilderImplILb0EE10AddElementIiEEvtT_S3_: 338| 24.8k| void AddElement(voffset_t field, T e, T def) { 339| | // We don't serialize values equal to the default. 340| 24.8k| if (IsTheSameAs(e, def) && !force_defaults_) return; ------------------ | Branch (340:9): [True: 2.81k, False: 22.0k] | Branch (340:32): [True: 0, False: 2.81k] ------------------ 341| 24.8k| TrackField(field, PushElement(e)); 342| 24.8k| } _ZN11flatbuffers21FlatBufferBuilderImplILb0EE11PushElementIijEET0_T_: 312| 315k| ReturnT PushElement(T element) { 313| 315k| AssertScalarT(); 314| 315k| Align(sizeof(T)); 315| 315k| buf_.push_small(EndianScalar(element)); 316| 315k| return CalculateOffset(); 317| 315k| } _ZN11flatbuffers21FlatBufferBuilderImplILb0EE13AssertScalarTIiEEvv: 305| 315k| void AssertScalarT() { 306| | // The code assumes power of 2 sizes and endian-swap-ability. 307| 315k| static_assert(flatbuffers::is_scalar::value, "T must be a scalar type"); 308| 315k| } _ZN11flatbuffers21FlatBufferBuilderImplILb0EE10AddElementItEEvtT_S3_: 338| 14.3k| void AddElement(voffset_t field, T e, T def) { 339| | // We don't serialize values equal to the default. 340| 14.3k| if (IsTheSameAs(e, def) && !force_defaults_) return; ------------------ | Branch (340:9): [True: 3.55k, False: 10.8k] | Branch (340:32): [True: 0, False: 3.55k] ------------------ 341| 14.3k| TrackField(field, PushElement(e)); 342| 14.3k| } _ZN11flatbuffers21FlatBufferBuilderImplILb0EE11PushElementItjEET0_T_: 312| 14.3k| ReturnT PushElement(T element) { 313| 14.3k| AssertScalarT(); 314| 14.3k| Align(sizeof(T)); 315| 14.3k| buf_.push_small(EndianScalar(element)); 316| 14.3k| return CalculateOffset(); 317| 14.3k| } _ZN11flatbuffers21FlatBufferBuilderImplILb0EE13AssertScalarTItEEvv: 305| 14.3k| void AssertScalarT() { 306| | // The code assumes power of 2 sizes and endian-swap-ability. 307| 14.3k| static_assert(flatbuffers::is_scalar::value, "T must be a scalar type"); 308| 14.3k| } _ZN11flatbuffers21FlatBufferBuilderImplILb0EE10AddElementIjEEvtT_S3_: 338| 17.0k| void AddElement(voffset_t field, T e, T def) { 339| | // We don't serialize values equal to the default. 340| 17.0k| if (IsTheSameAs(e, def) && !force_defaults_) return; ------------------ | Branch (340:9): [True: 3.48k, False: 13.5k] | Branch (340:32): [True: 0, False: 3.48k] ------------------ 341| 17.0k| TrackField(field, PushElement(e)); 342| 17.0k| } _ZN11flatbuffers21FlatBufferBuilderImplILb0EE11PushElementIjjEET0_T_: 312| 307k| ReturnT PushElement(T element) { 313| 307k| AssertScalarT(); 314| 307k| Align(sizeof(T)); 315| 307k| buf_.push_small(EndianScalar(element)); 316| 307k| return CalculateOffset(); 317| 307k| } _ZN11flatbuffers21FlatBufferBuilderImplILb0EE13AssertScalarTIjEEvv: 305| 307k| void AssertScalarT() { 306| | // The code assumes power of 2 sizes and endian-swap-ability. 307| 307k| static_assert(flatbuffers::is_scalar::value, "T must be a scalar type"); 308| 307k| } _ZN11flatbuffers21FlatBufferBuilderImplILb0EE10StartTableEv: 420| 507k| uoffset_t StartTable() { 421| 507k| NotNested(); 422| 507k| nested = true; 423| 507k| return GetSizeRelative32BitRegion(); 424| 507k| } _ZN11flatbuffers21FlatBufferBuilderImplILb0EE9NotNestedEv: 404| 797k| void NotNested() { 405| | // If you hit this, you're trying to construct a Table/Vector/String 406| | // during the construction of its parent table (between the MyTableBuilder 407| | // and table.Finish(). 408| | // Move the creation of these sub-objects to above the MyTableBuilder to 409| | // not get this assert. 410| | // Ignoring this assert may appear to work in simple cases, but the reason 411| | // it is here is that storing objects in-line may cause vtable offsets 412| | // to not fit anymore. It also leads to vtable duplication. 413| 797k| FLATBUFFERS_ASSERT(!nested); 414| | // If you hit this, fields were added outside the scope of a table. 415| 797k| FLATBUFFERS_ASSERT(!num_field_loc); 416| 797k| } _ZN11flatbuffers21FlatBufferBuilderImplILb0EE8EndTableEj: 429| 290k| uoffset_t EndTable(uoffset_t start) { 430| | // If you get this assert, a corresponding StartTable wasn't called. 431| 290k| FLATBUFFERS_ASSERT(nested); 432| | // Write the vtable offset, which is the start of any Table. 433| | // We fill its value later. 434| | // This is relative to the end of the 32-bit region. 435| 290k| const uoffset_t vtable_offset_loc = 436| 290k| static_cast(PushElement(0)); 437| | // Write a vtable, which consists entirely of voffset_t elements. 438| | // It starts with the number of offsets, followed by a type id, followed 439| | // by the offsets themselves. In reverse: 440| | // Include space for the last offset and ensure empty tables have a 441| | // minimum size. 442| 290k| max_voffset_ = 443| 290k| (std::max)(static_cast(max_voffset_ + sizeof(voffset_t)), 444| 290k| FieldIndexToOffset(0)); 445| 290k| buf_.fill_big(max_voffset_); 446| 290k| const uoffset_t table_object_size = vtable_offset_loc - start; 447| | // Vtable use 16bit offsets. 448| 290k| FLATBUFFERS_ASSERT(table_object_size < 0x10000); 449| 290k| WriteScalar(buf_.data() + sizeof(voffset_t), 450| 290k| static_cast(table_object_size)); 451| 290k| WriteScalar(buf_.data(), max_voffset_); 452| | // Write the offsets into the table 453| 290k| for (auto it = buf_.scratch_end() - num_field_loc * sizeof(FieldLoc); 454| 482k| it < buf_.scratch_end(); it += sizeof(FieldLoc)) { ------------------ | Branch (454:10): [True: 192k, False: 290k] ------------------ 455| 192k| auto field_location = reinterpret_cast(it); 456| 192k| const voffset_t pos = 457| 192k| static_cast(vtable_offset_loc - field_location->off); 458| | // If this asserts, it means you've set a field twice. 459| 192k| FLATBUFFERS_ASSERT( 460| 192k| !ReadScalar(buf_.data() + field_location->id)); 461| 192k| WriteScalar(buf_.data() + field_location->id, pos); 462| 192k| } 463| 290k| ClearOffsets(); 464| 290k| auto vt1 = reinterpret_cast(buf_.data()); 465| 290k| auto vt1_size = ReadScalar(vt1); 466| 290k| auto vt_use = GetSizeRelative32BitRegion(); 467| | // See if we already have generated a vtable with this exact same 468| | // layout before. If so, make it point to the old one, remove this one. 469| 290k| if (dedup_vtables_) { ------------------ | Branch (469:9): [True: 290k, False: 0] ------------------ 470| 290k| for (auto it = buf_.scratch_data(); it < buf_.scratch_end(); ------------------ | Branch (470:43): [True: 0, False: 290k] ------------------ 471| 290k| it += sizeof(uoffset_t)) { 472| 0| auto vt_offset_ptr = reinterpret_cast(it); 473| 0| auto vt2 = reinterpret_cast( 474| 0| buf_.data_at(*vt_offset_ptr + length_of_64_bit_region_)); 475| 0| auto vt2_size = ReadScalar(vt2); 476| 0| if (vt1_size != vt2_size || 0 != memcmp(vt2, vt1, vt1_size)) continue; ------------------ | Branch (476:13): [True: 0, False: 0] | Branch (476:37): [True: 0, False: 0] ------------------ 477| 0| vt_use = *vt_offset_ptr; 478| 0| buf_.pop(GetSizeRelative32BitRegion() - vtable_offset_loc); 479| 0| break; 480| 0| } 481| 290k| } 482| | // If this is a new vtable, remember it. 483| 290k| if (vt_use == GetSizeRelative32BitRegion()) { ------------------ | Branch (483:9): [True: 290k, False: 0] ------------------ 484| 290k| buf_.scratch_push_small(vt_use); 485| 290k| } 486| | // Fill the vtable offset we created above. 487| | // The offset points from the beginning of the object to where the vtable is 488| | // stored. 489| | // Offsets default direction is downward in memory for future format 490| | // flexibility (storing all vtables at the start of the file). 491| 290k| WriteScalar(buf_.data_at(vtable_offset_loc + length_of_64_bit_region_), 492| 290k| static_cast(vt_use) - 493| 290k| static_cast(vtable_offset_loc)); 494| 290k| nested = false; 495| 290k| return vtable_offset_loc; 496| 290k| } _ZN11flatbuffers21FlatBufferBuilderImplILb0EE12ClearOffsetsEv: 521| 1.06M| void ClearOffsets() { 522| 1.06M| buf_.scratch_pop(num_field_loc * sizeof(FieldLoc)); 523| 1.06M| num_field_loc = 0; 524| 1.06M| max_voffset_ = 0; 525| 1.06M| } _ZN11flatbuffers21FlatBufferBuilderImplILb0EE7ReferToEj: 376| 290k| uoffset_t ReferTo(uoffset_t off) { 377| | // Align to ensure GetSizeRelative32BitRegion() below is correct. 378| 290k| Align(sizeof(uoffset_t)); 379| | // 32-bit offsets are relative to the tail of the 32-bit region of the 380| | // buffer. For most cases (without 64-bit entities) this is equivalent to 381| | // size of the whole buffer (e.g. GetSize()) 382| 290k| return ReferTo(off, GetSizeRelative32BitRegion()); 383| 290k| } _ZN11flatbuffers21FlatBufferBuilderImplILb0EE7ReferToIjEET_S3_S3_: 399| 290k| T ReferTo(const T off, const T size) { 400| 290k| FLATBUFFERS_ASSERT(off && off <= size); 401| 290k| return size - off + static_cast(sizeof(T)); 402| 290k| } _ZN11flatbuffers21FlatBufferBuilderImplILb0EE8PreAlignEmm: 529| 290k| void PreAlign(size_t len, size_t alignment) { 530| 290k| if (len == 0) return; ------------------ | Branch (530:9): [True: 0, False: 290k] ------------------ 531| 290k| TrackMinAlign(alignment); 532| 290k| buf_.fill(PaddingBytes(GetSize() + len, alignment)); 533| 290k| } _ZN11flatbuffers21FlatBufferBuilderImplILb0EE10AddElementIlEEvtT_S3_: 338| 19.9k| void AddElement(voffset_t field, T e, T def) { 339| | // We don't serialize values equal to the default. 340| 19.9k| if (IsTheSameAs(e, def) && !force_defaults_) return; ------------------ | Branch (340:9): [True: 2.79k, False: 17.1k] | Branch (340:32): [True: 0, False: 2.79k] ------------------ 341| 19.9k| TrackField(field, PushElement(e)); 342| 19.9k| } _ZN11flatbuffers21FlatBufferBuilderImplILb0EE11PushElementIljEET0_T_: 312| 19.9k| ReturnT PushElement(T element) { 313| 19.9k| AssertScalarT(); 314| 19.9k| Align(sizeof(T)); 315| 19.9k| buf_.push_small(EndianScalar(element)); 316| 19.9k| return CalculateOffset(); 317| 19.9k| } _ZN11flatbuffers21FlatBufferBuilderImplILb0EE13AssertScalarTIlEEvv: 305| 19.9k| void AssertScalarT() { 306| | // The code assumes power of 2 sizes and endian-swap-ability. 307| 19.9k| static_assert(flatbuffers::is_scalar::value, "T must be a scalar type"); 308| 19.9k| } _ZN11flatbuffers21FlatBufferBuilderImplILb0EE10AddElementIhEEvtT_S3_: 338| 17.2k| void AddElement(voffset_t field, T e, T def) { 339| | // We don't serialize values equal to the default. 340| 17.2k| if (IsTheSameAs(e, def) && !force_defaults_) return; ------------------ | Branch (340:9): [True: 6.63k, False: 10.5k] | Branch (340:32): [True: 0, False: 6.63k] ------------------ 341| 17.2k| TrackField(field, PushElement(e)); 342| 17.2k| } _ZN11flatbuffers21FlatBufferBuilderImplILb0EE11PushElementIhjEET0_T_: 312| 17.2k| ReturnT PushElement(T element) { 313| 17.2k| AssertScalarT(); 314| 17.2k| Align(sizeof(T)); 315| 17.2k| buf_.push_small(EndianScalar(element)); 316| 17.2k| return CalculateOffset(); 317| 17.2k| } _ZN11flatbuffers21FlatBufferBuilderImplILb0EE13AssertScalarTIhEEvv: 305| 17.2k| void AssertScalarT() { 306| | // The code assumes power of 2 sizes and endian-swap-ability. 307| 17.2k| static_assert(flatbuffers::is_scalar::value, "T must be a scalar type"); 308| 17.2k| } _ZN11flatbuffers21FlatBufferBuilderImplILb0EE10AddElementIdEEvtT_S3_: 338| 20.5k| void AddElement(voffset_t field, T e, T def) { 339| | // We don't serialize values equal to the default. 340| 20.5k| if (IsTheSameAs(e, def) && !force_defaults_) return; ------------------ | Branch (340:9): [True: 4.08k, False: 16.4k] | Branch (340:32): [True: 0, False: 4.08k] ------------------ 341| 20.5k| TrackField(field, PushElement(e)); 342| 20.5k| } _ZN11flatbuffers21FlatBufferBuilderImplILb0EE11PushElementIdjEET0_T_: 312| 20.5k| ReturnT PushElement(T element) { 313| 20.5k| AssertScalarT(); 314| 20.5k| Align(sizeof(T)); 315| 20.5k| buf_.push_small(EndianScalar(element)); 316| 20.5k| return CalculateOffset(); 317| 20.5k| } _ZN11flatbuffers21FlatBufferBuilderImplILb0EE13AssertScalarTIdEEvv: 305| 20.5k| void AssertScalarT() { 306| | // The code assumes power of 2 sizes and endian-swap-ability. 307| 20.5k| static_assert(flatbuffers::is_scalar::value, "T must be a scalar type"); 308| 20.5k| } _ZN11flatbuffers21FlatBufferBuilderImplILb0EE10AddElementImEEvtT_S3_: 338| 30.3k| void AddElement(voffset_t field, T e, T def) { 339| | // We don't serialize values equal to the default. 340| 30.3k| if (IsTheSameAs(e, def) && !force_defaults_) return; ------------------ | Branch (340:9): [True: 3.59k, False: 26.7k] | Branch (340:32): [True: 0, False: 3.59k] ------------------ 341| 30.3k| TrackField(field, PushElement(e)); 342| 30.3k| } _ZN11flatbuffers21FlatBufferBuilderImplILb0EE11PushElementImjEET0_T_: 312| 30.3k| ReturnT PushElement(T element) { 313| 30.3k| AssertScalarT(); 314| 30.3k| Align(sizeof(T)); 315| 30.3k| buf_.push_small(EndianScalar(element)); 316| 30.3k| return CalculateOffset(); 317| 30.3k| } _ZN11flatbuffers21FlatBufferBuilderImplILb0EE13AssertScalarTImEEvv: 305| 30.3k| void AssertScalarT() { 306| | // The code assumes power of 2 sizes and endian-swap-ability. 307| 30.3k| static_assert(flatbuffers::is_scalar::value, "T must be a scalar type"); 308| 30.3k| } _ZN11flatbuffers21FlatBufferBuilderImplILb0EE6FinishEjPKcb: 1293| 290k| void Finish(uoffset_t root, const char* file_identifier, bool size_prefix) { 1294| | // A buffer can only be finished once. To reuse a builder use `clear()`. 1295| 290k| FLATBUFFERS_ASSERT(!finished); 1296| | 1297| 290k| NotNested(); 1298| 290k| buf_.clear_scratch(); 1299| | 1300| 290k| const size_t prefix_size = size_prefix ? sizeof(SizeT) : 0; ------------------ | Branch (1300:32): [True: 0, False: 290k] ------------------ 1301| | // Make sure we track the alignment of the size prefix. 1302| 290k| TrackMinAlign(prefix_size); 1303| | 1304| 290k| const size_t root_offset_size = sizeof(uoffset_t); 1305| 290k| const size_t file_id_size = file_identifier ? kFileIdentifierLength : 0; ------------------ | Branch (1305:33): [True: 0, False: 290k] ------------------ 1306| | 1307| | // This will cause the whole buffer to be aligned. 1308| 290k| PreAlign(prefix_size + root_offset_size + file_id_size, minalign_); 1309| | 1310| 290k| if (file_identifier) { ------------------ | Branch (1310:9): [True: 0, False: 290k] ------------------ 1311| 0| FLATBUFFERS_ASSERT(strlen(file_identifier) == kFileIdentifierLength); 1312| 0| PushBytes(reinterpret_cast(file_identifier), 1313| 0| kFileIdentifierLength); 1314| 0| } 1315| 290k| PushElement(ReferTo(root)); // Location of root. 1316| 290k| if (size_prefix) { ------------------ | Branch (1316:9): [True: 0, False: 290k] ------------------ 1317| 0| PushElement(GetSize()); 1318| 0| } 1319| 290k| finished = true; 1320| 290k| } _ZN11flatbuffers21FlatBufferBuilderImplILb0EE3PadEm: 284| 408k| void Pad(size_t num_bytes) { buf_.fill(num_bytes); } _ZN11flatbuffers21FlatBufferBuilderImplILb0EE11PushElementIsjEET0_T_: 312| 14.1k| ReturnT PushElement(T element) { 313| 14.1k| AssertScalarT(); 314| 14.1k| Align(sizeof(T)); 315| 14.1k| buf_.push_small(EndianScalar(element)); 316| 14.1k| return CalculateOffset(); 317| 14.1k| } _ZN11flatbuffers21FlatBufferBuilderImplILb0EE13AssertScalarTIsEEvv: 305| 14.1k| void AssertScalarT() { 306| | // The code assumes power of 2 sizes and endian-swap-ability. 307| 14.1k| static_assert(flatbuffers::is_scalar::value, "T must be a scalar type"); 308| 14.1k| } _ZN11flatbuffers21FlatBufferBuilderImplILb0EE10AddElementIsEEvtT_S3_: 338| 14.1k| void AddElement(voffset_t field, T e, T def) { 339| | // We don't serialize values equal to the default. 340| 14.1k| if (IsTheSameAs(e, def) && !force_defaults_) return; ------------------ | Branch (340:9): [True: 2.52k, False: 11.6k] | Branch (340:32): [True: 0, False: 2.52k] ------------------ 341| 14.1k| TrackField(field, PushElement(e)); 342| 14.1k| } _ZN11flatbuffers21FlatBufferBuilderImplILb0EE11PushElementIfjEET0_T_: 312| 22.6k| ReturnT PushElement(T element) { 313| 22.6k| AssertScalarT(); 314| 22.6k| Align(sizeof(T)); 315| 22.6k| buf_.push_small(EndianScalar(element)); 316| 22.6k| return CalculateOffset(); 317| 22.6k| } _ZN11flatbuffers21FlatBufferBuilderImplILb0EE13AssertScalarTIfEEvv: 305| 22.6k| void AssertScalarT() { 306| | // The code assumes power of 2 sizes and endian-swap-ability. 307| 22.6k| static_assert(flatbuffers::is_scalar::value, "T must be a scalar type"); 308| 22.6k| } _ZN11flatbuffers21FlatBufferBuilderImplILb0EE10AddElementIfEEvtT_S3_: 338| 22.6k| void AddElement(voffset_t field, T e, T def) { 339| | // We don't serialize values equal to the default. 340| 22.6k| if (IsTheSameAs(e, def) && !force_defaults_) return; ------------------ | Branch (340:9): [True: 2.83k, False: 19.8k] | Branch (340:32): [True: 0, False: 2.83k] ------------------ 341| 22.6k| TrackField(field, PushElement(e)); 342| 22.6k| } _ZN11flatbuffers21FlatBufferBuilderImplILb0EE5ClearEv: 169| 769k| void Clear() { 170| 769k| ClearOffsets(); 171| 769k| buf_.clear(); 172| 769k| nested = false; 173| 769k| finished = false; 174| 769k| minalign_ = 1; 175| 769k| length_of_64_bit_region_ = 0; 176| 769k| if (string_pool) string_pool->clear(); ------------------ | Branch (176:9): [True: 0, False: 769k] ------------------ 177| 769k| } _ZN11flatbuffers21FlatBufferBuilderImplILb0EE6FinishINS_5TableEEEvNS_6OffsetIT_EEPKc: 1263| 290k| void Finish(Offset root, const char* file_identifier = nullptr) { 1264| 290k| Finish(root.o, file_identifier, false); 1265| 290k| } _ZN11flexbuffers7BuilderC2EmNS_11BuilderFlagE: 1044| 103k| : buf_(initial_size), 1045| 103k| finished_(false), 1046| 103k| has_duplicate_keys_(false), 1047| 103k| flags_(flags), 1048| 103k| force_min_bit_width_(BIT_WIDTH_8), 1049| 103k| key_pool(KeyOffsetCompare(buf_)), 1050| 103k| string_pool(StringOffsetCompare(buf_)) { 1051| 103k| buf_.clear(); 1052| 103k| } _ZN11flexbuffers7Builder16KeyOffsetCompareC2ERKNSt3__16vectorIhNS2_9allocatorIhEEEE: 1812| 103k| explicit KeyOffsetCompare(const std::vector& buf) : buf_(&buf) {} _ZN11flexbuffers7Builder19StringOffsetCompareC2ERKNSt3__16vectorIhNS2_9allocatorIhEEEE: 1824| 103k| : buf_(&buf) {} _ZN11flexbuffers9ReferenceC2Ev: 407| 103k| : data_(nullptr), parent_width_(0), byte_width_(0), type_(FBT_NULL) {} _ZN11flatbuffers10IDLOptionsC2Ev: 811| 5.06k| : gen_jvmstatic(false), 812| 5.06k| use_flexbuffers(false), 813| 5.06k| strict_json(false), 814| 5.06k| output_default_scalars_in_json(false), 815| 5.06k| indent_step(2), 816| 5.06k| cpp_minify_enums(false), 817| 5.06k| output_enum_identifiers(true), 818| 5.06k| prefixed_enums(true), 819| 5.06k| scoped_enums(false), 820| 5.06k| emit_min_max_enum_values(true), 821| 5.06k| swift_implementation_only(false), 822| 5.06k| include_dependence_headers(true), 823| 5.06k| mutable_buffer(false), 824| 5.06k| one_file(false), 825| 5.06k| proto_mode(false), 826| 5.06k| proto_oneof_union(false), 827| 5.06k| generate_all(false), 828| 5.06k| skip_unexpected_fields_in_json(false), 829| 5.06k| generate_name_strings(false), 830| 5.06k| generate_object_based_api(false), 831| 5.06k| gen_compare(false), 832| 5.06k| gen_absl_hash(false), 833| 5.06k| cpp_object_api_pointer_type("std::unique_ptr"), 834| 5.06k| cpp_object_api_string_flexible_constructor(false), 835| 5.06k| cpp_object_api_field_case_style(CaseStyle_Unchanged), 836| 5.06k| cpp_direct_copy(true), 837| 5.06k| gen_nullable(false), 838| 5.06k| java_checkerframework(false), 839| 5.06k| gen_generated(false), 840| 5.06k| gen_json_coders(false), 841| 5.06k| object_suffix("T"), 842| 5.06k| union_value_namespacing(true), 843| 5.06k| allow_non_utf8(false), 844| 5.06k| natural_utf8(false), 845| 5.06k| keep_prefix(false), 846| 5.06k| binary_schema_comments(false), 847| 5.06k| binary_schema_builtins(false), 848| 5.06k| binary_schema_gen_embed(false), 849| 5.06k| binary_schema_absolute_paths(false), 850| 5.06k| protobuf_ascii_alike(false), 851| 5.06k| size_prefixed(false), 852| 5.06k| force_defaults(false), 853| 5.06k| java_primitive_has_method(false), 854| 5.06k| cs_gen_json_serializer(false), 855| 5.06k| cpp_static_reflection(false), 856| 5.06k| filename_suffix("_generated"), 857| 5.06k| filename_extension(), 858| 5.06k| no_warnings(false), 859| 5.06k| warnings_as_errors(false), 860| 5.06k| project_root(""), 861| 5.06k| cs_global_alias(false), 862| 5.06k| json_nested_flatbuffers(true), 863| 5.06k| json_nested_flexbuffers(true), 864| 5.06k| json_nested_legacy_flatbuffers(false), 865| 5.06k| ts_no_import_ext(false), 866| 5.06k| no_leak_private_annotations(false), 867| 5.06k| require_json_eof(true), 868| 5.06k| keep_proto_id(false), 869| 5.06k| python_no_type_prefix_suffix(false), 870| 5.06k| python_typing(false), 871| 5.06k| python_gen_numpy(true), 872| 5.06k| ts_omit_entrypoint(false), 873| 5.06k| ts_undefined_for_optionals(false), 874| 5.06k| proto_id_gap_action(ProtoIdGapAction::WARNING), 875| 5.06k| mini_reflect(IDLOptions::kNone), 876| 5.06k| require_explicit_ids(false), 877| 5.06k| rust_serialize(false), 878| 5.06k| rust_module_root_file(false), 879| 5.06k| lang_to_generate(0), 880| 5.06k| set_empty_strings_to_null(true), 881| 5.06k| set_empty_vectors_to_null(true), 882| 5.06k| grpc_filename_suffix(".fb"), 883| 5.06k| grpc_use_system_headers(true), 884| 5.06k| grpc_callback_api(false), 885| 5.06k| grpc_python_typed_handlers(false) {} _ZN11flatbuffers6ParserC2ERKNS_10IDLOptionsE: 979| 103k| : current_namespace_(nullptr), 980| 103k| empty_namespace_(nullptr), 981| 103k| flex_builder_(256, flexbuffers::BUILDER_FLAG_SHARE_ALL), 982| 103k| root_struct_def_(nullptr), 983| 103k| opts(options), 984| 103k| uses_flexbuffers_(false), 985| 103k| has_warning_(false), 986| 103k| advanced_features_(0), 987| 103k| source_(nullptr), 988| 103k| anonymous_counter_(0), 989| 103k| parse_depth_counter_(0) { 990| 103k| if (opts.force_defaults) { ------------------ | Branch (990:9): [True: 103k, False: 0] ------------------ 991| 103k| builder_.ForceDefaults(true); 992| 103k| } 993| | // Start out with the empty namespace being current. 994| 103k| empty_namespace_ = new Namespace(); 995| 103k| namespaces_.push_back(empty_namespace_); 996| 103k| current_namespace_ = empty_namespace_; 997| 103k| known_attributes_["deprecated"] = true; 998| 103k| known_attributes_["required"] = true; 999| 103k| known_attributes_["key"] = true; 1000| 103k| known_attributes_["shared"] = true; 1001| 103k| known_attributes_["hash"] = true; 1002| 103k| known_attributes_["id"] = true; 1003| 103k| known_attributes_["force_align"] = true; 1004| 103k| known_attributes_["bit_flags"] = true; 1005| 103k| known_attributes_["original_order"] = true; 1006| 103k| known_attributes_["nested_flatbuffer"] = true; 1007| 103k| known_attributes_["csharp_partial"] = true; 1008| 103k| known_attributes_["streaming"] = true; 1009| 103k| known_attributes_["idempotent"] = true; 1010| 103k| known_attributes_["cpp_type"] = true; 1011| 103k| known_attributes_["cpp_ptr_type"] = true; 1012| 103k| known_attributes_["cpp_ptr_type_get"] = true; 1013| 103k| known_attributes_["cpp_str_type"] = true; 1014| 103k| known_attributes_["cpp_str_flex_ctor"] = true; 1015| 103k| known_attributes_["native_inline"] = true; 1016| 103k| known_attributes_["native_custom_alloc"] = true; 1017| 103k| known_attributes_["native_type"] = true; 1018| 103k| known_attributes_["native_type_pack_name"] = true; 1019| 103k| known_attributes_["native_default"] = true; 1020| 103k| known_attributes_["flexbuffer"] = true; 1021| 103k| known_attributes_["private"] = true; 1022| | 1023| | // An attribute added to a field to indicate that is uses 64-bit addressing. 1024| 103k| known_attributes_["offset64"] = true; 1025| | 1026| | // An attribute added to a vector field to indicate that it uses 64-bit 1027| | // addressing and it has a 64-bit length. 1028| 103k| known_attributes_["vector64"] = true; 1029| 103k| } _ZN11flatbuffers11ParserStateC2Ev: 891| 103k| : prev_cursor_(nullptr), 892| 103k| cursor_(nullptr), 893| 103k| line_start_(nullptr), 894| 103k| line_(0), 895| 103k| token_(-1), 896| 103k| attr_is_trivial_ascii_string_(true) {} _ZN11flatbuffers9NamespaceC2Ev: 278| 103k| Namespace() : from_table(0) {} _ZN11flatbuffers11SymbolTableINS_10ServiceDefEED2Ev: 241| 103k| ~SymbolTable() { 242| 103k| for (auto it = vec.begin(); it != vec.end(); ++it) { ------------------ | Branch (242:33): [True: 0, False: 103k] ------------------ 243| 0| delete *it; 244| 0| } 245| 103k| } _ZN11flatbuffers11SymbolTableINS_5ValueEED2Ev: 241| 206k| ~SymbolTable() { 242| 206k| for (auto it = vec.begin(); it != vec.end(); ++it) { ------------------ | Branch (242:33): [True: 0, False: 206k] ------------------ 243| 0| delete *it; 244| 0| } 245| 206k| } _ZN11flatbuffers11SymbolTableINS_7EnumDefEED2Ev: 241| 103k| ~SymbolTable() { 242| 103k| for (auto it = vec.begin(); it != vec.end(); ++it) { ------------------ | Branch (242:33): [True: 0, False: 103k] ------------------ 243| 0| delete *it; 244| 0| } 245| 103k| } _ZN11flatbuffers11SymbolTableINS_9StructDefEED2Ev: 241| 103k| ~SymbolTable() { 242| 206k| for (auto it = vec.begin(); it != vec.end(); ++it) { ------------------ | Branch (242:33): [True: 103k, False: 103k] ------------------ 243| 103k| delete *it; 244| 103k| } 245| 103k| } _ZN11flatbuffers11SymbolTableINS_8FieldDefEED2Ev: 241| 103k| ~SymbolTable() { 242| 206k| for (auto it = vec.begin(); it != vec.end(); ++it) { ------------------ | Branch (242:33): [True: 103k, False: 103k] ------------------ 243| 103k| delete *it; 244| 103k| } 245| 103k| } _ZN11flatbuffers11SymbolTableINS_4TypeEED2Ev: 241| 103k| ~SymbolTable() { 242| 206k| for (auto it = vec.begin(); it != vec.end(); ++it) { ------------------ | Branch (242:33): [True: 103k, False: 103k] ------------------ 243| 103k| delete *it; 244| 103k| } 245| 103k| } _ZN11flatbuffers6ParserD2Ev: 1038| 103k| ~Parser() { 1039| 206k| for (auto it = namespaces_.begin(); it != namespaces_.end(); ++it) { ------------------ | Branch (1039:41): [True: 103k, False: 103k] ------------------ 1040| 103k| delete *it; 1041| 103k| } 1042| 103k| } _ZN11flatbuffers4TypeC2ENS_8BaseTypeEPNS_9StructDefEPNS_7EnumDefEt: 198| 310k| : base_type(_base_type), 199| 310k| element(BASE_TYPE_NONE), 200| 310k| struct_def(_sd), 201| 310k| enum_def(_ed), 202| 310k| fixed_length(_fixed_length) {} _ZN11flatbuffers5ValueC2Ev: 229| 103k| : constant("0"), 230| 103k| offset(static_cast(~(static_cast(0U)))) {} _ZN11flatbuffers10DefinitionC2Ev: 303| 206k| : generated(false), 304| 206k| defined_namespace(nullptr), 305| 206k| serialized_location(0), 306| 206k| index(-1), 307| 206k| refcount(1), 308| 206k| declaration_file(nullptr) {} _ZN11flatbuffers8FieldDefC2Ev: 333| 103k| : deprecated(false), 334| 103k| key(false), 335| 103k| shared(false), 336| 103k| native_inline(false), 337| 103k| flexbuffer(false), 338| 103k| offset64(false), 339| 103k| presence(kDefault), 340| 103k| nested_flatbuffer(nullptr), 341| 103k| padding(0), 342| 103k| sibling_union_field(nullptr) {} _ZNK11flatbuffers8FieldDef16IsScalarOptionalEv: 349| 512k| bool IsScalarOptional() const { return IsScalar() && IsOptional(); } ------------------ | Branch (349:42): [True: 512k, False: 0] | Branch (349:56): [True: 0, False: 512k] ------------------ _ZNK11flatbuffers8FieldDef8IsScalarEv: 350| 512k| bool IsScalar() const { 351| 512k| return ::flatbuffers::IsScalar(value.type.base_type); 352| 512k| } _ZNK11flatbuffers8FieldDef10IsOptionalEv: 353| 899k| bool IsOptional() const { return presence == kOptional; } _ZNK11flatbuffers8FieldDef10IsRequiredEv: 354| 507k| bool IsRequired() const { return presence == kRequired; } _ZN11flatbuffers8FieldDef17MakeFieldPresenceEbb: 377| 103k| Presence static MakeFieldPresence(bool optional, bool required) { 378| 103k| FLATBUFFERS_ASSERT(!(required && optional)); 379| | // clang-format off 380| 103k| return required ? FieldDef::kRequired ------------------ | Branch (380:12): [True: 0, False: 103k] ------------------ 381| 103k| : optional ? FieldDef::kOptional ------------------ | Branch (381:12): [True: 0, False: 103k] ------------------ 382| 103k| : FieldDef::kDefault; 383| | // clang-format on 384| 103k| } _ZN11flatbuffers9StructDefC2Ev: 405| 103k| : fixed(false), 406| 103k| predecl(true), 407| 103k| sortbysize(true), 408| 103k| has_key(false), 409| 103k| minalign(1), 410| 103k| bytesize(0), 411| 103k| cycle_status{CycleStatus::NotChecked} {} _ZN11flatbuffers9StructDef12PadLastFieldEm: 413| 103k| void PadLastField(size_t min_align) { 414| 103k| auto padding = PaddingBytes(bytesize, min_align); 415| 103k| bytesize += padding; 416| 103k| if (fields.vec.size()) fields.vec.back()->padding = padding; ------------------ | Branch (416:9): [True: 103k, False: 0] ------------------ 417| 103k| } _ZN11flatbuffers11ParserState10ResetStateEPKc: 899| 769k| void ResetState(const char* source) { 900| 769k| prev_cursor_ = source; 901| 769k| cursor_ = source; 902| 769k| line_ = 0; 903| 769k| MarkNewLine(); 904| 769k| } _ZN11flatbuffers11ParserState11MarkNewLineEv: 906| 842k| void MarkNewLine() { 907| 842k| line_start_ = cursor_; 908| 842k| line_ += 1; 909| 842k| } _ZNK11flatbuffers11ParserState14CursorPositionEv: 911| 578k| int64_t CursorPosition() const { 912| 578k| FLATBUFFERS_ASSERT(cursor_ && line_start_ && cursor_ >= line_start_); 913| 578k| return static_cast(cursor_ - line_start_); 914| 578k| } _ZN11flatbuffers12CheckedErrorC2Eb: 940| 16.4M| : is_error_(error), has_been_checked_(false) {} _ZN11flatbuffers12CheckedErroraSERKS0_: 942| 764k| CheckedError& operator=(const CheckedError& other) { 943| 764k| is_error_ = other.is_error_; 944| 764k| has_been_checked_ = false; 945| 764k| other.has_been_checked_ = true; 946| 764k| return *this; 947| 764k| } _ZN11flatbuffers12CheckedErrorC2ERKS0_: 949| 764k| CheckedError(const CheckedError& other) { 950| 764k| *this = other; // Use assignment operator. 951| 764k| } _ZN11flatbuffers12CheckedErrorD2Ev: 953| 17.1M| ~CheckedError() { FLATBUFFERS_ASSERT(has_been_checked_); } _ZN11flatbuffers12CheckedError5CheckEv: 955| 18.1M| bool Check() { 956| 18.1M| has_been_checked_ = true; 957| 18.1M| return is_error_; 958| 18.1M| } _ZN11flatbuffers8IsScalarENS_8BaseTypeE: 134| 2.55M|inline bool IsScalar (BaseType t) { return t >= BASE_TYPE_UTYPE && ------------------ | Branch (134:44): [True: 2.55M, False: 0] ------------------ 135| 2.55M| t <= BASE_TYPE_DOUBLE; } ------------------ | Branch (135:44): [True: 2.55M, False: 0] ------------------ _ZN11flatbuffers9IsIntegerENS_8BaseTypeE: 136| 874k|inline bool IsInteger(BaseType t) { return t >= BASE_TYPE_UTYPE && ------------------ | Branch (136:44): [True: 874k, False: 0] ------------------ 137| 874k| t <= BASE_TYPE_ULONG; } ------------------ | Branch (137:44): [True: 775k, False: 99.5k] ------------------ _ZN11flatbuffers7IsFloatENS_8BaseTypeE: 138| 1.47M|inline bool IsFloat (BaseType t) { return t == BASE_TYPE_FLOAT || ------------------ | Branch (138:44): [True: 326k, False: 1.14M] ------------------ 139| 1.14M| t == BASE_TYPE_DOUBLE; } ------------------ | Branch (139:44): [True: 195k, False: 949k] ------------------ _ZN11flatbuffers6IsBoolENS_8BaseTypeE: 142| 985k|inline bool IsBool (BaseType t) { return t == BASE_TYPE_BOOL; } _ZN11flatbuffers8IsVectorENS_8BaseTypeE: 145| 422k|inline bool IsVector (BaseType t) { return t == BASE_TYPE_VECTOR || ------------------ | Branch (145:44): [True: 0, False: 422k] ------------------ 146| 422k| t == BASE_TYPE_VECTOR64; } ------------------ | Branch (146:44): [True: 0, False: 422k] ------------------ _ZN11flatbuffers6SizeOfENS_8BaseTypeE: 154| 1.33M|inline size_t SizeOf(const BaseType t) { 155| 1.33M| switch (t) { 156| 0| #define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE, ...) \ 157| 0| case BASE_TYPE_##ENUM: return sizeof(CTYPE); 158| 0| FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD) ------------------ | | 112| 95.0k| FLATBUFFERS_GEN_TYPES_SCALAR(TD) \ | | ------------------ | | | | 50| 0| TD(NONE, "", uint8_t, byte, byte, byte, uint8, u8, UByte, UInt8, 0) \ | | | | ------------------ | | | | | | 158| 0| FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD) | | | | | | ------------------ | | | | | | | | 157| 0| case BASE_TYPE_##ENUM: return sizeof(CTYPE); | | | | | | | | ------------------ | | | | | | | | | Branch (157:5): [True: 0, False: 1.33M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 51| 0| TD(UTYPE, "", uint8_t, byte, byte, byte, uint8, u8, UByte, UInt8, 1) /* begin scalar/int */ \ | | | | ------------------ | | | | | | 158| 0| FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD) | | | | | | ------------------ | | | | | | | | 157| 0| case BASE_TYPE_##ENUM: return sizeof(CTYPE); | | | | | | | | ------------------ | | | | | | | | | Branch (157:5): [True: 0, False: 1.33M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 52| 119k| TD(BOOL, "bool", uint8_t, boolean,bool, bool, bool, bool, Boolean, Bool, 2) \ | | | | ------------------ | | | | | | 158| 119k| FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD) | | | | | | ------------------ | | | | | | | | 157| 119k| case BASE_TYPE_##ENUM: return sizeof(CTYPE); | | | | | | | | ------------------ | | | | | | | | | Branch (157:5): [True: 119k, False: 1.21M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 53| 155k| TD(CHAR, "byte", int8_t, byte, int8, sbyte, int8, i8, Byte, Int8, 3) \ | | | | ------------------ | | | | | | 158| 155k| FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD) | | | | | | ------------------ | | | | | | | | 157| 155k| case BASE_TYPE_##ENUM: return sizeof(CTYPE); | | | | | | | | ------------------ | | | | | | | | | Branch (157:5): [True: 155k, False: 1.17M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 54| 155k| TD(UCHAR, "ubyte", uint8_t, byte, byte, byte, uint8, u8, UByte, UInt8, 4) \ | | | | ------------------ | | | | | | 158| 95.0k| FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD) | | | | | | ------------------ | | | | | | | | 157| 95.0k| case BASE_TYPE_##ENUM: return sizeof(CTYPE); | | | | | | | | ------------------ | | | | | | | | | Branch (157:5): [True: 95.0k, False: 1.23M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 55| 120k| TD(SHORT, "short", int16_t, short, int16, short, int16, i16, Short, Int16, 5) \ | | | | ------------------ | | | | | | 158| 120k| FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD) | | | | | | ------------------ | | | | | | | | 157| 120k| case BASE_TYPE_##ENUM: return sizeof(CTYPE); | | | | | | | | ------------------ | | | | | | | | | Branch (157:5): [True: 120k, False: 1.21M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 56| 128k| TD(USHORT, "ushort", uint16_t, short, uint16, ushort, uint16, u16, UShort, UInt16, 6) \ | | | | ------------------ | | | | | | 158| 128k| FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD) | | | | | | ------------------ | | | | | | | | 157| 128k| case BASE_TYPE_##ENUM: return sizeof(CTYPE); | | | | | | | | ------------------ | | | | | | | | | Branch (157:5): [True: 128k, False: 1.20M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 57| 139k| TD(INT, "int", int32_t, int, int32, int, int32, i32, Int, Int32, 7) \ | | | | ------------------ | | | | | | 158| 139k| FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD) | | | | | | ------------------ | | | | | | | | 157| 139k| case BASE_TYPE_##ENUM: return sizeof(CTYPE); | | | | | | | | ------------------ | | | | | | | | | Branch (157:5): [True: 139k, False: 1.19M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 58| 139k| TD(UINT, "uint", uint32_t, int, uint32, uint, uint32, u32, UInt, UInt32, 8) \ | | | | ------------------ | | | | | | 158| 115k| FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD) | | | | | | ------------------ | | | | | | | | 157| 115k| case BASE_TYPE_##ENUM: return sizeof(CTYPE); | | | | | | | | ------------------ | | | | | | | | | Branch (157:5): [True: 115k, False: 1.21M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 59| 115k| TD(LONG, "long", int64_t, long, int64, long, int64, i64, Long, Int64, 9) \ | | | | ------------------ | | | | | | 158| 93.3k| FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD) | | | | | | ------------------ | | | | | | | | 157| 93.3k| case BASE_TYPE_##ENUM: return sizeof(CTYPE); | | | | | | | | ------------------ | | | | | | | | | Branch (157:5): [True: 93.3k, False: 1.23M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 60| 137k| TD(ULONG, "ulong", uint64_t, long, uint64, ulong, uint64, u64, ULong, UInt64, 10) /* end int */ \ | | | | ------------------ | | | | | | 158| 137k| FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD) | | | | | | ------------------ | | | | | | | | 157| 137k| case BASE_TYPE_##ENUM: return sizeof(CTYPE); | | | | | | | | ------------------ | | | | | | | | | Branch (157:5): [True: 137k, False: 1.19M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 61| 137k| TD(FLOAT, "float", float, float, float32, float, float32, f32, Float, Float32, 11) /* begin float */ \ | | | | ------------------ | | | | | | 158| 132k| FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD) | | | | | | ------------------ | | | | | | | | 157| 132k| case BASE_TYPE_##ENUM: return sizeof(CTYPE); | | | | | | | | ------------------ | | | | | | | | | Branch (157:5): [True: 132k, False: 1.20M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 62| 132k| TD(DOUBLE, "double", double, double, float64, double, float64, f64, Double, Double, 12) /* end float/scalar */ | | | | ------------------ | | | | | | 158| 95.0k| FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD) | | | | | | ------------------ | | | | | | | | 157| 95.0k| case BASE_TYPE_##ENUM: return sizeof(CTYPE); | | | | | | | | ------------------ | | | | | | | | | Branch (157:5): [True: 95.0k, False: 1.23M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 113| 95.0k| FLATBUFFERS_GEN_TYPES_POINTER(TD) \ | | ------------------ | | | | 64| 0| TD(STRING, "string", Offset, int, int, StringOffset, int, unused, Int, Offset, 13) \ | | | | ------------------ | | | | | | 158| 0| FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD) | | | | | | ------------------ | | | | | | | | 157| 0| case BASE_TYPE_##ENUM: return sizeof(CTYPE); | | | | | | | | ------------------ | | | | | | | | | Branch (157:5): [True: 0, False: 1.33M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 65| 0| TD(VECTOR, "", Offset, int, int, VectorOffset, int, unused, Int, Offset, 14) \ | | | | ------------------ | | | | | | 158| 0| FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD) | | | | | | ------------------ | | | | | | | | 157| 0| case BASE_TYPE_##ENUM: return sizeof(CTYPE); | | | | | | | | ------------------ | | | | | | | | | Branch (157:5): [True: 0, False: 1.33M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 66| 0| TD(VECTOR64, "", Offset64, int, int, VectorOffset, int, unused, Int, Offset, 18) \ | | | | ------------------ | | | | | | 158| 0| FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD) | | | | | | ------------------ | | | | | | | | 157| 0| case BASE_TYPE_##ENUM: return sizeof(CTYPE); | | | | | | | | ------------------ | | | | | | | | | Branch (157:5): [True: 0, False: 1.33M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 67| 0| TD(STRUCT, "", Offset, int, int, int, int, unused, Int, Offset, 15) \ | | | | ------------------ | | | | | | 158| 0| FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD) | | | | | | ------------------ | | | | | | | | 157| 0| case BASE_TYPE_##ENUM: return sizeof(CTYPE); | | | | | | | | ------------------ | | | | | | | | | Branch (157:5): [True: 0, False: 1.33M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 68| 0| TD(UNION, "", Offset, int, int, int, int, unused, Int, Offset, 16) | | | | ------------------ | | | | | | 158| 0| FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD) | | | | | | ------------------ | | | | | | | | 157| 0| case BASE_TYPE_##ENUM: return sizeof(CTYPE); | | | | | | | | ------------------ | | | | | | | | | Branch (157:5): [True: 0, False: 1.33M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 114| 0| FLATBUFFERS_GEN_TYPE_ARRAY(TD) | | ------------------ | | | | 70| 0| TD(ARRAY, "", int, int, int, int, int, unused, Int, Offset, 17) | | | | ------------------ | | | | | | 158| 0| FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD) | | | | | | ------------------ | | | | | | | | 157| 0| case BASE_TYPE_##ENUM: return sizeof(CTYPE); | | | | | | | | ------------------ | | | | | | | | | Branch (157:5): [True: 0, False: 1.33M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 159| 0| #undef FLATBUFFERS_TD 160| 0| default: FLATBUFFERS_ASSERT(0); ------------------ | Branch (160:5): [True: 0, False: 1.33M] ------------------ 161| 1.33M| } 162| 0| return 0; 163| 1.33M|} _ZN11flatbuffers8TypeNameENS_8BaseTypeE: 165| 42.7k|inline const char* TypeName(const BaseType t) { 166| 42.7k| switch (t) { 167| 0| #define FLATBUFFERS_TD(ENUM, IDLTYPE, ...) \ 168| 0| case BASE_TYPE_##ENUM: return IDLTYPE; 169| 0| FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD) ------------------ | | 112| 5.59k| FLATBUFFERS_GEN_TYPES_SCALAR(TD) \ | | ------------------ | | | | 50| 0| TD(NONE, "", uint8_t, byte, byte, byte, uint8, u8, UByte, UInt8, 0) \ | | | | ------------------ | | | | | | 169| 0| FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD) | | | | | | ------------------ | | | | | | | | 168| 0| case BASE_TYPE_##ENUM: return IDLTYPE; | | | | | | | | ------------------ | | | | | | | | | Branch (168:5): [True: 0, False: 42.7k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 51| 0| TD(UTYPE, "", uint8_t, byte, byte, byte, uint8, u8, UByte, UInt8, 1) /* begin scalar/int */ \ | | | | ------------------ | | | | | | 169| 0| FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD) | | | | | | ------------------ | | | | | | | | 168| 0| case BASE_TYPE_##ENUM: return IDLTYPE; | | | | | | | | ------------------ | | | | | | | | | Branch (168:5): [True: 0, False: 42.7k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 52| 2.44k| TD(BOOL, "bool", uint8_t, boolean,bool, bool, bool, bool, Boolean, Bool, 2) \ | | | | ------------------ | | | | | | 169| 2.44k| FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD) | | | | | | ------------------ | | | | | | | | 168| 2.44k| case BASE_TYPE_##ENUM: return IDLTYPE; | | | | | | | | ------------------ | | | | | | | | | Branch (168:5): [True: 2.44k, False: 40.3k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 53| 2.74k| TD(CHAR, "byte", int8_t, byte, int8, sbyte, int8, i8, Byte, Int8, 3) \ | | | | ------------------ | | | | | | 169| 2.74k| FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD) | | | | | | ------------------ | | | | | | | | 168| 2.74k| case BASE_TYPE_##ENUM: return IDLTYPE; | | | | | | | | ------------------ | | | | | | | | | Branch (168:5): [True: 2.74k, False: 40.0k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 54| 2.74k| TD(UCHAR, "ubyte", uint8_t, byte, byte, byte, uint8, u8, UByte, UInt8, 4) \ | | | | ------------------ | | | | | | 169| 1.52k| FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD) | | | | | | ------------------ | | | | | | | | 168| 1.52k| case BASE_TYPE_##ENUM: return IDLTYPE; | | | | | | | | ------------------ | | | | | | | | | Branch (168:5): [True: 1.52k, False: 41.2k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 55| 3.25k| TD(SHORT, "short", int16_t, short, int16, short, int16, i16, Short, Int16, 5) \ | | | | ------------------ | | | | | | 169| 3.25k| FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD) | | | | | | ------------------ | | | | | | | | 168| 3.25k| case BASE_TYPE_##ENUM: return IDLTYPE; | | | | | | | | ------------------ | | | | | | | | | Branch (168:5): [True: 3.25k, False: 39.5k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 56| 3.25k| TD(USHORT, "ushort", uint16_t, short, uint16, ushort, uint16, u16, UShort, UInt16, 6) \ | | | | ------------------ | | | | | | 169| 2.93k| FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD) | | | | | | ------------------ | | | | | | | | 168| 2.93k| case BASE_TYPE_##ENUM: return IDLTYPE; | | | | | | | | ------------------ | | | | | | | | | Branch (168:5): [True: 2.93k, False: 39.8k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 57| 3.57k| TD(INT, "int", int32_t, int, int32, int, int32, i32, Int, Int32, 7) \ | | | | ------------------ | | | | | | 169| 3.57k| FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD) | | | | | | ------------------ | | | | | | | | 168| 3.57k| case BASE_TYPE_##ENUM: return IDLTYPE; | | | | | | | | ------------------ | | | | | | | | | Branch (168:5): [True: 3.57k, False: 39.2k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 58| 3.57k| TD(UINT, "uint", uint32_t, int, uint32, uint, uint32, u32, UInt, UInt32, 8) \ | | | | ------------------ | | | | | | 169| 2.25k| FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD) | | | | | | ------------------ | | | | | | | | 168| 2.25k| case BASE_TYPE_##ENUM: return IDLTYPE; | | | | | | | | ------------------ | | | | | | | | | Branch (168:5): [True: 2.25k, False: 40.5k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 59| 3.25k| TD(LONG, "long", int64_t, long, int64, long, int64, i64, Long, Int64, 9) \ | | | | ------------------ | | | | | | 169| 3.25k| FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD) | | | | | | ------------------ | | | | | | | | 168| 3.25k| case BASE_TYPE_##ENUM: return IDLTYPE; | | | | | | | | ------------------ | | | | | | | | | Branch (168:5): [True: 3.25k, False: 39.5k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 60| 3.79k| TD(ULONG, "ulong", uint64_t, long, uint64, ulong, uint64, u64, ULong, UInt64, 10) /* end int */ \ | | | | ------------------ | | | | | | 169| 3.79k| FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD) | | | | | | ------------------ | | | | | | | | 168| 3.79k| case BASE_TYPE_##ENUM: return IDLTYPE; | | | | | | | | ------------------ | | | | | | | | | Branch (168:5): [True: 3.79k, False: 39.0k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 61| 11.4k| TD(FLOAT, "float", float, float, float32, float, float32, f32, Float, Float32, 11) /* begin float */ \ | | | | ------------------ | | | | | | 169| 11.4k| FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD) | | | | | | ------------------ | | | | | | | | 168| 11.4k| case BASE_TYPE_##ENUM: return IDLTYPE; | | | | | | | | ------------------ | | | | | | | | | Branch (168:5): [True: 11.4k, False: 31.3k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 62| 11.4k| TD(DOUBLE, "double", double, double, float64, double, float64, f64, Double, Double, 12) /* end float/scalar */ | | | | ------------------ | | | | | | 169| 5.59k| FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD) | | | | | | ------------------ | | | | | | | | 168| 5.59k| case BASE_TYPE_##ENUM: return IDLTYPE; | | | | | | | | ------------------ | | | | | | | | | Branch (168:5): [True: 5.59k, False: 37.2k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 113| 5.59k| FLATBUFFERS_GEN_TYPES_POINTER(TD) \ | | ------------------ | | | | 64| 0| TD(STRING, "string", Offset, int, int, StringOffset, int, unused, Int, Offset, 13) \ | | | | ------------------ | | | | | | 169| 0| FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD) | | | | | | ------------------ | | | | | | | | 168| 0| case BASE_TYPE_##ENUM: return IDLTYPE; | | | | | | | | ------------------ | | | | | | | | | Branch (168:5): [True: 0, False: 42.7k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 65| 0| TD(VECTOR, "", Offset, int, int, VectorOffset, int, unused, Int, Offset, 14) \ | | | | ------------------ | | | | | | 169| 0| FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD) | | | | | | ------------------ | | | | | | | | 168| 0| case BASE_TYPE_##ENUM: return IDLTYPE; | | | | | | | | ------------------ | | | | | | | | | Branch (168:5): [True: 0, False: 42.7k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 66| 0| TD(VECTOR64, "", Offset64, int, int, VectorOffset, int, unused, Int, Offset, 18) \ | | | | ------------------ | | | | | | 169| 0| FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD) | | | | | | ------------------ | | | | | | | | 168| 0| case BASE_TYPE_##ENUM: return IDLTYPE; | | | | | | | | ------------------ | | | | | | | | | Branch (168:5): [True: 0, False: 42.7k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 67| 0| TD(STRUCT, "", Offset, int, int, int, int, unused, Int, Offset, 15) \ | | | | ------------------ | | | | | | 169| 0| FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD) | | | | | | ------------------ | | | | | | | | 168| 0| case BASE_TYPE_##ENUM: return IDLTYPE; | | | | | | | | ------------------ | | | | | | | | | Branch (168:5): [True: 0, False: 42.7k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 68| 0| TD(UNION, "", Offset, int, int, int, int, unused, Int, Offset, 16) | | | | ------------------ | | | | | | 169| 0| FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD) | | | | | | ------------------ | | | | | | | | 168| 0| case BASE_TYPE_##ENUM: return IDLTYPE; | | | | | | | | ------------------ | | | | | | | | | Branch (168:5): [True: 0, False: 42.7k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 114| 0| FLATBUFFERS_GEN_TYPE_ARRAY(TD) | | ------------------ | | | | 70| 0| TD(ARRAY, "", int, int, int, int, int, unused, Int, Offset, 17) | | | | ------------------ | | | | | | 169| 0| FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD) | | | | | | ------------------ | | | | | | | | 168| 0| case BASE_TYPE_##ENUM: return IDLTYPE; | | | | | | | | ------------------ | | | | | | | | | Branch (168:5): [True: 0, False: 42.7k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 170| 0| #undef FLATBUFFERS_TD 171| 0| default: FLATBUFFERS_ASSERT(0); ------------------ | Branch (171:5): [True: 0, False: 42.7k] ------------------ 172| 42.7k| } 173| 0| return nullptr; 174| 42.7k|} _ZN11flatbuffers8IsStringERKNS_4TypeE: 529| 305k|inline bool IsString(const Type& type) { 530| 305k| return type.base_type == BASE_TYPE_STRING; 531| 305k|} _ZN11flatbuffers8IsStructERKNS_4TypeE: 533| 98.3k|inline bool IsStruct(const Type& type) { 534| 98.3k| return type.base_type == BASE_TYPE_STRUCT && type.struct_def->fixed; ------------------ | Branch (534:10): [True: 0, False: 98.3k] | Branch (534:48): [True: 0, False: 0] ------------------ 535| 98.3k|} _ZN11flatbuffers8IsVectorERKNS_4TypeE: 553| 422k|inline bool IsVector(const Type& type) { return IsVector(type.base_type); } _ZN11flatbuffers7IsArrayERKNS_4TypeE: 563| 206k|inline bool IsArray(const Type& type) { 564| 206k| return type.base_type == BASE_TYPE_ARRAY; 565| 206k|} _ZNK11flatbuffers11SymbolTableINS_5ValueEE6LookupERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE: 266| 1.65M| T* Lookup(const std::string& name) const { 267| 1.65M| auto it = dict.find(name); 268| 1.65M| return it == dict.end() ? nullptr : it->second; ------------------ | Branch (268:12): [True: 1.65M, False: 0] ------------------ 269| 1.65M| } _ZNK11flatbuffers11SymbolTableINS_9StructDefEE6LookupERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE: 266| 517k| T* Lookup(const std::string& name) const { 267| 517k| auto it = dict.find(name); 268| 517k| return it == dict.end() ? nullptr : it->second; ------------------ | Branch (268:12): [True: 413k, False: 103k] ------------------ 269| 517k| } _ZN11flatbuffers11SymbolTableINS_8FieldDefEE3AddERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEPS1_: 247| 103k| bool Add(const std::string& name, T* e) { 248| 103k| vec.emplace_back(e); 249| 103k| auto it = dict.find(name); 250| 103k| if (it != dict.end()) return true; ------------------ | Branch (250:9): [True: 0, False: 103k] ------------------ 251| 103k| dict[name] = e; 252| 103k| return false; 253| 103k| } _ZNK11flatbuffers11SymbolTableINS_8FieldDefEE6LookupERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE: 266| 575k| T* Lookup(const std::string& name) const { 267| 575k| auto it = dict.find(name); 268| 575k| return it == dict.end() ? nullptr : it->second; ------------------ | Branch (268:12): [True: 8.12k, False: 567k] ------------------ 269| 575k| } _ZN11flatbuffers11SymbolTableINS_9StructDefEE3AddERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEPS1_: 247| 103k| bool Add(const std::string& name, T* e) { 248| 103k| vec.emplace_back(e); 249| 103k| auto it = dict.find(name); 250| 103k| if (it != dict.end()) return true; ------------------ | Branch (250:9): [True: 0, False: 103k] ------------------ 251| 103k| dict[name] = e; 252| 103k| return false; 253| 103k| } _ZN11flatbuffers11SymbolTableINS_4TypeEE3AddERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEPS1_: 247| 103k| bool Add(const std::string& name, T* e) { 248| 103k| vec.emplace_back(e); 249| 103k| auto it = dict.find(name); 250| 103k| if (it != dict.end()) return true; ------------------ | Branch (250:9): [True: 0, False: 103k] ------------------ 251| 103k| dict[name] = e; 252| 103k| return false; 253| 103k| } _ZN11flatbuffers20UnionTypeFieldSuffixEv: 425| 103k|constexpr const char* UnionTypeFieldSuffix() { return "_type"; } _ZNK11flatbuffers5Table9GetVTableEv: 30| 1.16M| const uint8_t* GetVTable() const { 31| 1.16M| return data_ - ReadScalar(data_); 32| 1.16M| } _ZNK11flatbuffers5Table22GetOptionalFieldOffsetEt: 36| 1.16M| voffset_t GetOptionalFieldOffset(voffset_t field) const { 37| | // The vtable offset is always at the start. 38| 1.16M| auto vtable = GetVTable(); 39| | // The first element is the size of the vtable (fields + type id + itself). 40| 1.16M| auto vtsize = ReadScalar(vtable); 41| | // If the field we're accessing is outside the vtable, we're reading older 42| | // data, so it's the same as if the offset was 0 (not present). 43| 1.16M| return field < vtsize ? ReadScalar(vtable + field) : 0; ------------------ | Branch (43:12): [True: 866k, False: 295k] ------------------ 44| 1.16M| } _ZN11flatbuffers5Table12GetAddressOfEt: 138| 387k| uint8_t* GetAddressOf(voffset_t field) { 139| 387k| auto field_offset = GetOptionalFieldOffset(field); 140| 387k| return field_offset ? data_ + field_offset : nullptr; ------------------ | Branch (140:12): [True: 288k, False: 98.3k] ------------------ 141| 387k| } _ZNK11flatbuffers5Table12GetAddressOfEt: 142| 387k| const uint8_t* GetAddressOf(voffset_t field) const { 143| 387k| return const_cast(this)->GetAddressOf(field); 144| 387k| } _ZNK11flatbuffers5Table10CheckFieldEt: 146| 387k| bool CheckField(voffset_t field) const { 147| 387k| return GetOptionalFieldOffset(field) != 0; 148| 387k| } _ZNK11flatbuffers5Table8GetFieldIaEET_tS2_: 47| 22.1k| T GetField(voffset_t field, T defaultval) const { 48| 22.1k| auto field_offset = GetOptionalFieldOffset(field); 49| 22.1k| return field_offset ? ReadScalar(data_ + field_offset) : defaultval; ------------------ | Branch (49:12): [True: 16.5k, False: 5.59k] ------------------ 50| 22.1k| } _ZNK11flatbuffers5Table8GetFieldIiEET_tS2_: 47| 49.4k| T GetField(voffset_t field, T defaultval) const { 48| 49.4k| auto field_offset = GetOptionalFieldOffset(field); 49| 49.4k| return field_offset ? ReadScalar(data_ + field_offset) : defaultval; ------------------ | Branch (49:12): [True: 37.0k, False: 12.4k] ------------------ 50| 49.4k| } _ZNK11flatbuffers5Table8GetFieldItEET_tS2_: 47| 28.8k| T GetField(voffset_t field, T defaultval) const { 48| 28.8k| auto field_offset = GetOptionalFieldOffset(field); 49| 28.8k| return field_offset ? ReadScalar(data_ + field_offset) : defaultval; ------------------ | Branch (49:12): [True: 21.5k, False: 7.30k] ------------------ 50| 28.8k| } _ZNK11flatbuffers5Table8GetFieldIjEET_tS2_: 47| 34.5k| T GetField(voffset_t field, T defaultval) const { 48| 34.5k| auto field_offset = GetOptionalFieldOffset(field); 49| 34.5k| return field_offset ? ReadScalar(data_ + field_offset) : defaultval; ------------------ | Branch (49:12): [True: 25.8k, False: 8.75k] ------------------ 50| 34.5k| } _ZNK11flatbuffers5Table8GetFieldIlEET_tS2_: 47| 39.7k| T GetField(voffset_t field, T defaultval) const { 48| 39.7k| auto field_offset = GetOptionalFieldOffset(field); 49| 39.7k| return field_offset ? ReadScalar(data_ + field_offset) : defaultval; ------------------ | Branch (49:12): [True: 29.7k, False: 10.0k] ------------------ 50| 39.7k| } _ZNK11flatbuffers5Table8GetFieldIhEET_tS2_: 47| 34.9k| T GetField(voffset_t field, T defaultval) const { 48| 34.9k| auto field_offset = GetOptionalFieldOffset(field); 49| 34.9k| return field_offset ? ReadScalar(data_ + field_offset) : defaultval; ------------------ | Branch (49:12): [True: 26.0k, False: 8.86k] ------------------ 50| 34.9k| } _ZNK11flatbuffers5Table8GetFieldIdEET_tS2_: 47| 41.8k| T GetField(voffset_t field, T defaultval) const { 48| 41.8k| auto field_offset = GetOptionalFieldOffset(field); 49| 41.8k| return field_offset ? ReadScalar(data_ + field_offset) : defaultval; ------------------ | Branch (49:12): [True: 31.0k, False: 10.7k] ------------------ 50| 41.8k| } _ZNK11flatbuffers5Table8GetFieldImEET_tS2_: 47| 60.9k| T GetField(voffset_t field, T defaultval) const { 48| 60.9k| auto field_offset = GetOptionalFieldOffset(field); 49| 60.9k| return field_offset ? ReadScalar(data_ + field_offset) : defaultval; ------------------ | Branch (49:12): [True: 45.6k, False: 15.3k] ------------------ 50| 60.9k| } _ZNK11flatbuffers5Table8GetFieldIsEET_tS2_: 47| 28.0k| T GetField(voffset_t field, T defaultval) const { 48| 28.0k| auto field_offset = GetOptionalFieldOffset(field); 49| 28.0k| return field_offset ? ReadScalar(data_ + field_offset) : defaultval; ------------------ | Branch (49:12): [True: 20.9k, False: 7.08k] ------------------ 50| 28.0k| } _ZNK11flatbuffers5Table8GetFieldIfEET_tS2_: 47| 46.6k| T GetField(voffset_t field, T defaultval) const { 48| 46.6k| auto field_offset = GetOptionalFieldOffset(field); 49| 46.6k| return field_offset ? ReadScalar(data_ + field_offset) : defaultval; ------------------ | Branch (49:12): [True: 34.5k, False: 12.1k] ------------------ 50| 46.6k| } _ZN11flatbuffers13ClassicLocale3GetEv: 228| 1.11M| static locale_type Get() { return instance_.locale_; } _ZN11flatbuffers17check_ascii_rangeEccc: 44| 46.8M|inline bool check_ascii_range(char x, char a, char b) { 45| 46.8M| FLATBUFFERS_ASSERT(a <= b); 46| | // (Hacker's Delight): `a <= x <= b` <=> `(x-a) <={u} (b-a)`. 47| | // The x, a, b will be promoted to int and subtracted without overflow. 48| 46.8M| return static_cast(x - a) <= static_cast(b - a); 49| 46.8M|} _ZN11flatbuffers8is_alphaEc: 52| 6.72M|inline bool is_alpha(char c) { 53| | // ASCII only: alpha to upper case => reset bit 0x20 (~0x20 = 0xDF). 54| 6.72M| return check_ascii_range(c & 0xDF, 'a' & 0xDF, 'z' & 0xDF); 55| 6.72M|} _ZN11flatbuffers13is_alpha_charEcc: 61| 1.02M|inline bool is_alpha_char(char c, char alpha) { 62| 1.02M| FLATBUFFERS_ASSERT(is_alpha(alpha)); 63| | // ASCII only: alpha to upper case => reset bit 0x20 (~0x20 = 0xDF). 64| 1.02M| return ((c & 0xDF) == (alpha & 0xDF)); 65| 1.02M|} _ZN11flatbuffers8is_digitEc: 72| 14.7M|inline bool is_digit(char c) { return check_ascii_range(c, '0', '9'); } _ZN11flatbuffers9is_xdigitEc: 74| 2.28M|inline bool is_xdigit(char c) { 75| | // Replace by look-up table. 76| 2.28M| return is_digit(c) || check_ascii_range(c & 0xDF, 'a' & 0xDF, 'f' & 0xDF); ------------------ | Branch (76:10): [True: 1.64M, False: 631k] | Branch (76:25): [True: 562k, False: 68.0k] ------------------ 77| 2.28M|} _ZN11flatbuffers11NumToStringIaEENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEET_: 146| 70.9k|inline std::string NumToString(signed char t) { 147| 70.9k| return NumToString(static_cast(t)); 148| 70.9k|} _ZN11flatbuffers11NumToStringIhEENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEET_: 150| 67.1k|inline std::string NumToString(unsigned char t) { 151| 67.1k| return NumToString(static_cast(t)); 152| 67.1k|} _ZN11flatbuffers11NumToStringIcEENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEET_: 154| 24.6k|inline std::string NumToString(char t) { 155| 24.6k| return NumToString(static_cast(t)); 156| 24.6k|} _ZN11flatbuffers11NumToStringIdEENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEET_: 188| 41.8k|inline std::string NumToString(double t) { 189| 41.8k| return FloatToString(t, 12); 190| 41.8k|} _ZN11flatbuffers11NumToStringIfEENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEET_: 192| 46.6k|inline std::string NumToString(float t) { 193| 46.6k| return FloatToString(t, 6); 194| 46.6k|} _ZN11flatbuffers13strtoval_implEPlPKcPPci: 255| 701k| int base) { 256| 701k| *val = __strtoll_impl(str, endptr, base); ------------------ | | 238| 701k| #define __strtoll_impl(s, pe, b) strtoll_l(s, pe, b, ClassicLocale::Get()) ------------------ 257| 701k|} _ZN11flatbuffers13strtoval_implEPmPKcPPci: 260| 181k| int base) { 261| 181k| *val = __strtoull_impl(str, endptr, base); ------------------ | | 237| 181k| #define __strtoull_impl(s, pe, b) strtoull_l(s, pe, b, ClassicLocale::Get()) ------------------ 262| 181k|} _ZN11flatbuffers13strtoval_implEPdPKcPPc: 264| 109k|inline void strtoval_impl(double *val, const char *str, char **endptr) { 265| 109k| *val = __strtod_impl(str, endptr); ------------------ | | 239| 109k| #define __strtod_impl(s, pe) strtod_l(s, pe, ClassicLocale::Get()) ------------------ 266| 109k|} _ZN11flatbuffers13strtoval_implEPfPKcPPc: 270| 125k|inline void strtoval_impl(float *val, const char *str, char **endptr) { 271| 125k| *val = __strtof_impl(str, endptr); ------------------ | | 240| 125k| #define __strtof_impl(s, pe) strtof_l(s, pe, ClassicLocale::Get()) ------------------ 272| 125k|} _ZN11flatbuffers14StringToNumberIlEEbPKcPT_: 367| 103k|inline bool StringToNumber(const char* str, int64_t* val) { 368| 103k| return StringToIntegerImpl(val, str); 369| 103k|} _ZN11flatbuffers14StringToNumberImEEbPKcPT_: 372| 153k|inline bool StringToNumber(const char* str, uint64_t* val) { 373| 153k| if (!StringToIntegerImpl(val, str)) return false; ------------------ | Branch (373:7): [True: 11.9k, False: 141k] ------------------ 374| | // The strtoull accepts negative numbers: 375| | // If the minus sign was part of the input sequence, the numeric value 376| | // calculated from the sequence of digits is negated as if by unary minus 377| | // in the result type, which applies unsigned integer wraparound rules. 378| | // Fix this behaviour (except -0). 379| 141k| if (*val) { ------------------ | Branch (379:7): [True: 58.2k, False: 83.2k] ------------------ 380| 58.2k| auto s = str; 381| 64.8k| while (*s && !is_digit(*s)) s++; ------------------ | Branch (381:12): [True: 64.8k, False: 0] | Branch (381:18): [True: 6.56k, False: 58.2k] ------------------ 382| 58.2k| s = (s > str) ? (s - 1) : s; // step back to one symbol ------------------ | Branch (382:9): [True: 5.84k, False: 52.4k] ------------------ 383| 58.2k| if (*s == '-') { ------------------ | Branch (383:9): [True: 4.56k, False: 53.6k] ------------------ 384| | // For unsigned types return the max to distinguish from 385| | // "no conversion can be performed". 386| 4.56k| *val = (flatbuffers::numeric_limits::max)(); 387| 4.56k| return false; 388| 4.56k| } 389| 58.2k| } 390| 136k| return true; 391| 141k|} _ZN11flatbuffers14StringToNumberIfEEbPKcPT_: 394| 125k|inline bool StringToNumber(const char* s, float* val) { 395| 125k| return StringToFloatImpl(val, s); 396| 125k|} _ZN11flatbuffers14StringToNumberIdEEbPKcPT_: 399| 109k|inline bool StringToNumber(const char* s, double* val) { 400| 109k| return StringToFloatImpl(val, s); 401| 109k|} _ZN11flatbuffers12StringToUIntEPKci: 408| 27.9k|inline uint64_t StringToUInt(const char* s, int base = 10) { 409| 27.9k| uint64_t val; 410| 27.9k| return StringToIntegerImpl(&val, s, base) ? val : 0; ------------------ | Branch (410:10): [True: 27.9k, False: 0] ------------------ 411| 27.9k|} _ZN11flatbuffers6ToUTF8EjPNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE: 517| 9.64k|inline int ToUTF8(uint32_t ucc, std::string* out) { 518| 9.64k| FLATBUFFERS_ASSERT(!(ucc & 0x80000000)); // Top bit can't be set. 519| | // 6 possible encodings: http://en.wikipedia.org/wiki/UTF-8 520| 29.2k| for (int i = 0; i < 6; i++) { ------------------ | Branch (520:19): [True: 29.2k, False: 0] ------------------ 521| | // Max bits this encoding can represent. 522| 29.2k| uint32_t max_bits = 6 + i * 5 + static_cast(!i); 523| 29.2k| if (ucc < (1u << max_bits)) { // does it fit? ------------------ | Branch (523:9): [True: 9.64k, False: 19.6k] ------------------ 524| | // Remaining bits not encoded in the first byte, store 6 bits each 525| 9.64k| uint32_t remain_bits = i * 6; 526| | // Store first byte: 527| 9.64k| (*out) += static_cast((0xFE << (max_bits - remain_bits)) | 528| 9.64k| (ucc >> remain_bits)); 529| | // Store remaining bytes: 530| 29.2k| for (int j = i - 1; j >= 0; j--) { ------------------ | Branch (530:27): [True: 19.6k, False: 9.64k] ------------------ 531| 19.6k| (*out) += static_cast(((ucc >> (j * 6)) & 0x3F) | 0x80); 532| 19.6k| } 533| 9.64k| return i + 1; // Return the number of bytes added. 534| 9.64k| } 535| 29.2k| } 536| 0| FLATBUFFERS_ASSERT(0); // Impossible to arrive here. 537| 0| return -1; 538| 0|} _ZN11flatbuffers8FromUTF8EPPKc: 545| 1.80M|inline int FromUTF8(const char** in) { 546| 1.80M| int len = 0; 547| | // Count leading 1 bits. 548| 1.92M| for (int mask = 0x80; mask >= 0x04; mask >>= 1) { ------------------ | Branch (548:25): [True: 1.92M, False: 2.24k] ------------------ 549| 1.92M| if (**in & mask) { ------------------ | Branch (549:9): [True: 122k, False: 1.79M] ------------------ 550| 122k| len++; 551| 1.79M| } else { 552| 1.79M| break; 553| 1.79M| } 554| 1.92M| } 555| 1.80M| if ((static_cast(**in) << len) & 0x80) ------------------ | Branch (555:7): [True: 2.11k, False: 1.79M] ------------------ 556| 2.11k| return -1; // Bit after leading 1's must be 0. 557| 1.79M| if (!len) return *(*in)++; ------------------ | Branch (557:7): [True: 1.75M, False: 41.3k] ------------------ 558| | // UTF-8 encoded values with a length are between 2 and 4 bytes. 559| 41.3k| if (len < 2 || len > 4) { ------------------ | Branch (559:7): [True: 7.32k, False: 33.9k] | Branch (559:18): [True: 1.08k, False: 32.8k] ------------------ 560| 8.40k| return -1; 561| 8.40k| } 562| | // Grab initial bits of the code. 563| 32.8k| int ucc = *(*in)++ & ((1 << (7 - len)) - 1); 564| 84.6k| for (int i = 0; i < len - 1; i++) { ------------------ | Branch (564:19): [True: 60.4k, False: 24.2k] ------------------ 565| 60.4k| if ((**in & 0xC0) != 0x80) return -1; // Upper bits must 1 0. ------------------ | Branch (565:9): [True: 8.68k, False: 51.7k] ------------------ 566| 51.7k| ucc <<= 6; 567| 51.7k| ucc |= *(*in)++ & 0x3F; // Grab 6 more bits of the code. 568| 51.7k| } 569| | // UTF-8 cannot encode values between 0xD800 and 0xDFFF (reserved for 570| | // UTF-16 surrogate pairs). 571| 24.2k| if (ucc >= 0xD800 && ucc <= 0xDFFF) { ------------------ | Branch (571:7): [True: 12.1k, False: 12.0k] | Branch (571:24): [True: 1.40k, False: 10.7k] ------------------ 572| 1.40k| return -1; 573| 1.40k| } 574| | // UTF-8 must represent code points in their shortest possible encoding. 575| 22.8k| switch (len) { ------------------ | Branch (575:11): [True: 22.8k, False: 0] ------------------ 576| 5.23k| case 2: ------------------ | Branch (576:5): [True: 5.23k, False: 17.5k] ------------------ 577| | // Two bytes of UTF-8 can represent code points from U+0080 to U+07FF. 578| 5.23k| if (ucc < 0x0080 || ucc > 0x07FF) { ------------------ | Branch (578:11): [True: 696, False: 4.54k] | Branch (578:27): [True: 0, False: 4.54k] ------------------ 579| 696| return -1; 580| 696| } 581| 4.54k| break; 582| 9.91k| case 3: ------------------ | Branch (582:5): [True: 9.91k, False: 12.8k] ------------------ 583| | // Three bytes of UTF-8 can represent code points from U+0800 to U+FFFF. 584| 9.91k| if (ucc < 0x0800 || ucc > 0xFFFF) { ------------------ | Branch (584:11): [True: 1.06k, False: 8.84k] | Branch (584:27): [True: 0, False: 8.84k] ------------------ 585| 1.06k| return -1; 586| 1.06k| } 587| 8.84k| break; 588| 8.84k| case 4: ------------------ | Branch (588:5): [True: 7.65k, False: 15.1k] ------------------ 589| | // Four bytes of UTF-8 can represent code points from U+10000 to U+10FFFF. 590| 7.65k| if (ucc < 0x10000 || ucc > 0x10FFFF) { ------------------ | Branch (590:11): [True: 1.12k, False: 6.53k] | Branch (590:28): [True: 1.15k, False: 5.37k] ------------------ 591| 2.28k| return -1; 592| 2.28k| } 593| 5.37k| break; 594| 22.8k| } 595| 18.7k| return ucc; 596| 22.8k|} _ZN11flatbuffers11NumToStringIiEENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEET_: 131| 831k|std::string NumToString(T t) { 132| | // clang-format off 133| | 134| 831k| #ifndef FLATBUFFERS_PREFER_PRINTF 135| 831k| std::stringstream ss; 136| 831k| ss << t; 137| 831k| return ss.str(); 138| | #else // FLATBUFFERS_PREFER_PRINTF 139| | auto v = static_cast(t); 140| | return NumToStringImplWrapper(v, "%.*lld"); 141| | #endif // FLATBUFFERS_PREFER_PRINTF 142| | // clang-format on 143| 831k|} _ZN11flatbuffers13FloatToStringIdEENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEET_i: 160| 41.8k|std::string FloatToString(T t, int precision) { 161| | // clang-format off 162| | 163| 41.8k| #ifndef FLATBUFFERS_PREFER_PRINTF 164| | // to_string() prints different numbers of digits for floats depending on 165| | // platform and isn't available on Android, so we use stringstream 166| 41.8k| std::stringstream ss; 167| | // Use std::fixed to suppress scientific notation. 168| 41.8k| ss << std::fixed; 169| | // Default precision is 6, we want that to be higher for doubles. 170| 41.8k| ss << std::setprecision(precision); 171| 41.8k| ss << t; 172| 41.8k| auto s = ss.str(); 173| | #else // FLATBUFFERS_PREFER_PRINTF 174| | auto v = static_cast(t); 175| | auto s = NumToStringImplWrapper(v, "%0.*f", precision); 176| | #endif // FLATBUFFERS_PREFER_PRINTF 177| | // clang-format on 178| | // Sadly, std::fixed turns "1" into "1.00000", so here we undo that. 179| 41.8k| auto p = s.find_last_not_of('0'); 180| 41.8k| if (p != std::string::npos) { ------------------ | Branch (180:7): [True: 41.8k, False: 0] ------------------ 181| | // Strip trailing zeroes. If it is a whole number, keep one zero. 182| 41.8k| s.resize(p + (s[p] == '.' ? 2 : 1)); ------------------ | Branch (182:19): [True: 31.4k, False: 10.3k] ------------------ 183| 41.8k| } 184| 41.8k| return s; 185| 41.8k|} _ZN11flatbuffers13FloatToStringIfEENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEET_i: 160| 46.6k|std::string FloatToString(T t, int precision) { 161| | // clang-format off 162| | 163| 46.6k| #ifndef FLATBUFFERS_PREFER_PRINTF 164| | // to_string() prints different numbers of digits for floats depending on 165| | // platform and isn't available on Android, so we use stringstream 166| 46.6k| std::stringstream ss; 167| | // Use std::fixed to suppress scientific notation. 168| 46.6k| ss << std::fixed; 169| | // Default precision is 6, we want that to be higher for doubles. 170| 46.6k| ss << std::setprecision(precision); 171| 46.6k| ss << t; 172| 46.6k| auto s = ss.str(); 173| | #else // FLATBUFFERS_PREFER_PRINTF 174| | auto v = static_cast(t); 175| | auto s = NumToStringImplWrapper(v, "%0.*f", precision); 176| | #endif // FLATBUFFERS_PREFER_PRINTF 177| | // clang-format on 178| | // Sadly, std::fixed turns "1" into "1.00000", so here we undo that. 179| 46.6k| auto p = s.find_last_not_of('0'); 180| 46.6k| if (p != std::string::npos) { ------------------ | Branch (180:7): [True: 46.6k, False: 0] ------------------ 181| | // Strip trailing zeroes. If it is a whole number, keep one zero. 182| 46.6k| s.resize(p + (s[p] == '.' ? 2 : 1)); ------------------ | Branch (182:19): [True: 36.2k, False: 10.3k] ------------------ 183| 46.6k| } 184| 46.6k| return s; 185| 46.6k|} _ZN11flatbuffers19StringToIntegerImplIlEEbPT_PKcib: 294| 1.40M| const bool check_errno = true) { 295| | // T is int64_t or uint64_T 296| 1.40M| FLATBUFFERS_ASSERT(str); 297| 1.40M| if (base <= 0) { ------------------ | Branch (297:7): [True: 701k, False: 701k] ------------------ 298| 701k| auto s = str; 299| 1.12M| while (*s && !is_digit(*s)) s++; ------------------ | Branch (299:12): [True: 1.09M, False: 25.1k] | Branch (299:18): [True: 420k, False: 676k] ------------------ 300| 701k| if (s[0] == '0' && is_alpha_char(s[1], 'X')) ------------------ | Branch (300:9): [True: 433k, False: 267k] | Branch (300:24): [True: 66.5k, False: 367k] ------------------ 301| 66.5k| return StringToIntegerImpl(val, str, 16, check_errno); 302| | // if a prefix not match, try base=10 303| 634k| return StringToIntegerImpl(val, str, 10, check_errno); 304| 701k| } else { 305| 701k| if (check_errno) errno = 0; // clear thread-local errno ------------------ | Branch (305:9): [True: 103k, False: 598k] ------------------ 306| 701k| auto endptr = str; 307| 701k| strtoval_impl(val, str, const_cast(&endptr), base); 308| 701k| if ((*endptr != '\0') || (endptr == str)) { ------------------ | Branch (308:9): [True: 54.8k, False: 646k] | Branch (308:30): [True: 2.90k, False: 643k] ------------------ 309| 57.7k| *val = 0; // erase partial result 310| 57.7k| return false; // invalid string 311| 57.7k| } 312| | // errno is out-of-range, return MAX/MIN 313| 643k| if (check_errno && errno) return false; ------------------ | Branch (313:9): [True: 95.6k, False: 548k] | Branch (313:24): [True: 5.84k, False: 89.7k] ------------------ 314| 637k| return true; 315| 643k| } 316| 1.40M|} _ZN11flatbuffers19StringToIntegerImplImEEbPT_PKcib: 294| 335k| const bool check_errno = true) { 295| | // T is int64_t or uint64_T 296| 335k| FLATBUFFERS_ASSERT(str); 297| 335k| if (base <= 0) { ------------------ | Branch (297:7): [True: 153k, False: 181k] ------------------ 298| 153k| auto s = str; 299| 176k| while (*s && !is_digit(*s)) s++; ------------------ | Branch (299:12): [True: 174k, False: 2.02k] | Branch (299:18): [True: 22.7k, False: 151k] ------------------ 300| 153k| if (s[0] == '0' && is_alpha_char(s[1], 'X')) ------------------ | Branch (300:9): [True: 112k, False: 40.6k] | Branch (300:24): [True: 26.1k, False: 86.7k] ------------------ 301| 26.1k| return StringToIntegerImpl(val, str, 16, check_errno); 302| | // if a prefix not match, try base=10 303| 127k| return StringToIntegerImpl(val, str, 10, check_errno); 304| 181k| } else { 305| 181k| if (check_errno) errno = 0; // clear thread-local errno ------------------ | Branch (305:9): [True: 181k, False: 0] ------------------ 306| 181k| auto endptr = str; 307| 181k| strtoval_impl(val, str, const_cast(&endptr), base); 308| 181k| if ((*endptr != '\0') || (endptr == str)) { ------------------ | Branch (308:9): [True: 5.87k, False: 175k] | Branch (308:30): [True: 349, False: 175k] ------------------ 309| 6.22k| *val = 0; // erase partial result 310| 6.22k| return false; // invalid string 311| 6.22k| } 312| | // errno is out-of-range, return MAX/MIN 313| 175k| if (check_errno && errno) return false; ------------------ | Branch (313:9): [True: 175k, False: 0] | Branch (313:24): [True: 5.75k, False: 169k] ------------------ 314| 169k| return true; 315| 175k| } 316| 335k|} _ZN11flatbuffers17StringToFloatImplIfEEbPT_PKc: 319| 125k|inline bool StringToFloatImpl(T* val, const char* const str) { 320| | // Type T must be either float or double. 321| 125k| FLATBUFFERS_ASSERT(str && val); 322| 125k| auto end = str; 323| 125k| strtoval_impl(val, str, const_cast(&end)); 324| 125k| auto done = (end != str) && (*end == '\0'); ------------------ | Branch (324:15): [True: 110k, False: 14.4k] | Branch (324:31): [True: 104k, False: 6.41k] ------------------ 325| 125k| if (!done) *val = 0; // erase partial result ------------------ | Branch (325:7): [True: 20.8k, False: 104k] ------------------ 326| 125k| if (done && std::isnan(*val)) { ------------------ | Branch (326:7): [True: 104k, False: 20.8k] | Branch (326:15): [True: 4.63k, False: 99.5k] ------------------ 327| 4.63k| *val = std::numeric_limits::quiet_NaN(); 328| 4.63k| } 329| 125k| return done; 330| 125k|} _ZN11flatbuffers17StringToFloatImplIdEEbPT_PKc: 319| 109k|inline bool StringToFloatImpl(T* val, const char* const str) { 320| | // Type T must be either float or double. 321| 109k| FLATBUFFERS_ASSERT(str && val); 322| 109k| auto end = str; 323| 109k| strtoval_impl(val, str, const_cast(&end)); 324| 109k| auto done = (end != str) && (*end == '\0'); ------------------ | Branch (324:15): [True: 100k, False: 8.99k] | Branch (324:31): [True: 96.4k, False: 4.51k] ------------------ 325| 109k| if (!done) *val = 0; // erase partial result ------------------ | Branch (325:7): [True: 13.5k, False: 96.4k] ------------------ 326| 109k| if (done && std::isnan(*val)) { ------------------ | Branch (326:7): [True: 96.4k, False: 13.5k] | Branch (326:15): [True: 4.85k, False: 91.5k] ------------------ 327| 4.85k| *val = std::numeric_limits::quiet_NaN(); 328| 4.85k| } 329| 109k| return done; 330| 109k|} _ZN11flatbuffers11NumToStringIlEENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEET_: 131| 640k|std::string NumToString(T t) { 132| | // clang-format off 133| | 134| 640k| #ifndef FLATBUFFERS_PREFER_PRINTF 135| 640k| std::stringstream ss; 136| 640k| ss << t; 137| 640k| return ss.str(); 138| | #else // FLATBUFFERS_PREFER_PRINTF 139| | auto v = static_cast(t); 140| | return NumToStringImplWrapper(v, "%.*lld"); 141| | #endif // FLATBUFFERS_PREFER_PRINTF 142| | // clang-format on 143| 640k|} _ZN11flatbuffers11NumToStringImEENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEET_: 131| 96.9k|std::string NumToString(T t) { 132| | // clang-format off 133| | 134| 96.9k| #ifndef FLATBUFFERS_PREFER_PRINTF 135| 96.9k| std::stringstream ss; 136| 96.9k| ss << t; 137| 96.9k| return ss.str(); 138| | #else // FLATBUFFERS_PREFER_PRINTF 139| | auto v = static_cast(t); 140| | return NumToStringImplWrapper(v, "%.*lld"); 141| | #endif // FLATBUFFERS_PREFER_PRINTF 142| | // clang-format on 143| 96.9k|} _ZN11flatbuffers14StringToNumberIhEEbPKcPT_: 339| 114k|inline bool StringToNumber(const char* s, T* val) { 340| | // Assert on `unsigned long` and `signed long` on LP64. 341| | // If it is necessary, it could be solved with flatbuffers::enable_if. 342| 114k| static_assert(sizeof(T) < sizeof(int64_t), "unexpected type T"); 343| 114k| FLATBUFFERS_ASSERT(s && val); 344| 114k| int64_t i64; 345| | // The errno check isn't needed, will return MAX/MIN on overflow. 346| 114k| if (StringToIntegerImpl(&i64, s, 0, false)) { ------------------ | Branch (346:7): [True: 100k, False: 13.6k] ------------------ 347| 100k| const int64_t max = (flatbuffers::numeric_limits::max)(); 348| 100k| const int64_t min = flatbuffers::numeric_limits::lowest(); 349| 100k| if (i64 > max) { ------------------ | Branch (349:9): [True: 6.08k, False: 94.8k] ------------------ 350| 6.08k| *val = static_cast(max); 351| 6.08k| return false; 352| 6.08k| } 353| 94.8k| if (i64 < min) { ------------------ | Branch (353:9): [True: 16.6k, False: 78.2k] ------------------ 354| | // For unsigned types return max to distinguish from 355| | // "no conversion can be performed" when 0 is returned. 356| 16.6k| *val = static_cast(flatbuffers::is_unsigned::value ? max : min); ------------------ | Branch (356:29): [True: 16.6k, Folded] ------------------ 357| 16.6k| return false; 358| 16.6k| } 359| 78.2k| *val = static_cast(i64); 360| 78.2k| return true; 361| 94.8k| } 362| 13.6k| *val = 0; 363| 13.6k| return false; 364| 114k|} _ZN11flatbuffers14StringToNumberItEEbPKcPT_: 339| 88.6k|inline bool StringToNumber(const char* s, T* val) { 340| | // Assert on `unsigned long` and `signed long` on LP64. 341| | // If it is necessary, it could be solved with flatbuffers::enable_if. 342| 88.6k| static_assert(sizeof(T) < sizeof(int64_t), "unexpected type T"); 343| 88.6k| FLATBUFFERS_ASSERT(s && val); 344| 88.6k| int64_t i64; 345| | // The errno check isn't needed, will return MAX/MIN on overflow. 346| 88.6k| if (StringToIntegerImpl(&i64, s, 0, false)) { ------------------ | Branch (346:7): [True: 82.4k, False: 6.15k] ------------------ 347| 82.4k| const int64_t max = (flatbuffers::numeric_limits::max)(); 348| 82.4k| const int64_t min = flatbuffers::numeric_limits::lowest(); 349| 82.4k| if (i64 > max) { ------------------ | Branch (349:9): [True: 3.64k, False: 78.8k] ------------------ 350| 3.64k| *val = static_cast(max); 351| 3.64k| return false; 352| 3.64k| } 353| 78.8k| if (i64 < min) { ------------------ | Branch (353:9): [True: 13.9k, False: 64.9k] ------------------ 354| | // For unsigned types return max to distinguish from 355| | // "no conversion can be performed" when 0 is returned. 356| 13.9k| *val = static_cast(flatbuffers::is_unsigned::value ? max : min); ------------------ | Branch (356:29): [True: 13.9k, Folded] ------------------ 357| 13.9k| return false; 358| 13.9k| } 359| 64.9k| *val = static_cast(i64); 360| 64.9k| return true; 361| 78.8k| } 362| 6.15k| *val = 0; 363| 6.15k| return false; 364| 88.6k|} _ZN11flatbuffers11NumToStringIjEENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEET_: 131| 74.9k|std::string NumToString(T t) { 132| | // clang-format off 133| | 134| 74.9k| #ifndef FLATBUFFERS_PREFER_PRINTF 135| 74.9k| std::stringstream ss; 136| 74.9k| ss << t; 137| 74.9k| return ss.str(); 138| | #else // FLATBUFFERS_PREFER_PRINTF 139| | auto v = static_cast(t); 140| | return NumToStringImplWrapper(v, "%.*lld"); 141| | #endif // FLATBUFFERS_PREFER_PRINTF 142| | // clang-format on 143| 74.9k|} _ZN11flatbuffers14StringToNumberIjEEbPKcPT_: 339| 100k|inline bool StringToNumber(const char* s, T* val) { 340| | // Assert on `unsigned long` and `signed long` on LP64. 341| | // If it is necessary, it could be solved with flatbuffers::enable_if. 342| 100k| static_assert(sizeof(T) < sizeof(int64_t), "unexpected type T"); 343| 100k| FLATBUFFERS_ASSERT(s && val); 344| 100k| int64_t i64; 345| | // The errno check isn't needed, will return MAX/MIN on overflow. 346| 100k| if (StringToIntegerImpl(&i64, s, 0, false)) { ------------------ | Branch (346:7): [True: 93.2k, False: 7.67k] ------------------ 347| 93.2k| const int64_t max = (flatbuffers::numeric_limits::max)(); 348| 93.2k| const int64_t min = flatbuffers::numeric_limits::lowest(); 349| 93.2k| if (i64 > max) { ------------------ | Branch (349:9): [True: 4.23k, False: 88.9k] ------------------ 350| 4.23k| *val = static_cast(max); 351| 4.23k| return false; 352| 4.23k| } 353| 88.9k| if (i64 < min) { ------------------ | Branch (353:9): [True: 11.5k, False: 77.4k] ------------------ 354| | // For unsigned types return max to distinguish from 355| | // "no conversion can be performed" when 0 is returned. 356| 11.5k| *val = static_cast(flatbuffers::is_unsigned::value ? max : min); ------------------ | Branch (356:29): [True: 11.5k, Folded] ------------------ 357| 11.5k| return false; 358| 11.5k| } 359| 77.4k| *val = static_cast(i64); 360| 77.4k| return true; 361| 88.9k| } 362| 7.67k| *val = 0; 363| 7.67k| return false; 364| 100k|} _ZN11flatbuffers14StringToNumberIaEEbPKcPT_: 339| 77.6k|inline bool StringToNumber(const char* s, T* val) { 340| | // Assert on `unsigned long` and `signed long` on LP64. 341| | // If it is necessary, it could be solved with flatbuffers::enable_if. 342| 77.6k| static_assert(sizeof(T) < sizeof(int64_t), "unexpected type T"); 343| 77.6k| FLATBUFFERS_ASSERT(s && val); 344| 77.6k| int64_t i64; 345| | // The errno check isn't needed, will return MAX/MIN on overflow. 346| 77.6k| if (StringToIntegerImpl(&i64, s, 0, false)) { ------------------ | Branch (346:7): [True: 71.4k, False: 6.15k] ------------------ 347| 71.4k| const int64_t max = (flatbuffers::numeric_limits::max)(); 348| 71.4k| const int64_t min = flatbuffers::numeric_limits::lowest(); 349| 71.4k| if (i64 > max) { ------------------ | Branch (349:9): [True: 7.64k, False: 63.8k] ------------------ 350| 7.64k| *val = static_cast(max); 351| 7.64k| return false; 352| 7.64k| } 353| 63.8k| if (i64 < min) { ------------------ | Branch (353:9): [True: 13.9k, False: 49.8k] ------------------ 354| | // For unsigned types return max to distinguish from 355| | // "no conversion can be performed" when 0 is returned. 356| 13.9k| *val = static_cast(flatbuffers::is_unsigned::value ? max : min); ------------------ | Branch (356:29): [Folded, False: 13.9k] ------------------ 357| 13.9k| return false; 358| 13.9k| } 359| 49.8k| *val = static_cast(i64); 360| 49.8k| return true; 361| 63.8k| } 362| 6.15k| *val = 0; 363| 6.15k| return false; 364| 77.6k|} _ZN11flatbuffers14StringToNumberIsEEbPKcPT_: 339| 84.8k|inline bool StringToNumber(const char* s, T* val) { 340| | // Assert on `unsigned long` and `signed long` on LP64. 341| | // If it is necessary, it could be solved with flatbuffers::enable_if. 342| 84.8k| static_assert(sizeof(T) < sizeof(int64_t), "unexpected type T"); 343| 84.8k| FLATBUFFERS_ASSERT(s && val); 344| 84.8k| int64_t i64; 345| | // The errno check isn't needed, will return MAX/MIN on overflow. 346| 84.8k| if (StringToIntegerImpl(&i64, s, 0, false)) { ------------------ | Branch (346:7): [True: 76.8k, False: 7.94k] ------------------ 347| 76.8k| const int64_t max = (flatbuffers::numeric_limits::max)(); 348| 76.8k| const int64_t min = flatbuffers::numeric_limits::lowest(); 349| 76.8k| if (i64 > max) { ------------------ | Branch (349:9): [True: 2.64k, False: 74.2k] ------------------ 350| 2.64k| *val = static_cast(max); 351| 2.64k| return false; 352| 2.64k| } 353| 74.2k| if (i64 < min) { ------------------ | Branch (353:9): [True: 10.7k, False: 63.5k] ------------------ 354| | // For unsigned types return max to distinguish from 355| | // "no conversion can be performed" when 0 is returned. 356| 10.7k| *val = static_cast(flatbuffers::is_unsigned::value ? max : min); ------------------ | Branch (356:29): [Folded, False: 10.7k] ------------------ 357| 10.7k| return false; 358| 10.7k| } 359| 63.5k| *val = static_cast(i64); 360| 63.5k| return true; 361| 74.2k| } 362| 7.94k| *val = 0; 363| 7.94k| return false; 364| 84.8k|} _ZN11flatbuffers14StringToNumberIiEEbPKcPT_: 339| 131k|inline bool StringToNumber(const char* s, T* val) { 340| | // Assert on `unsigned long` and `signed long` on LP64. 341| | // If it is necessary, it could be solved with flatbuffers::enable_if. 342| 131k| static_assert(sizeof(T) < sizeof(int64_t), "unexpected type T"); 343| 131k| FLATBUFFERS_ASSERT(s && val); 344| 131k| int64_t i64; 345| | // The errno check isn't needed, will return MAX/MIN on overflow. 346| 131k| if (StringToIntegerImpl(&i64, s, 0, false)) { ------------------ | Branch (346:7): [True: 123k, False: 8.58k] ------------------ 347| 123k| const int64_t max = (flatbuffers::numeric_limits::max)(); 348| 123k| const int64_t min = flatbuffers::numeric_limits::lowest(); 349| 123k| if (i64 > max) { ------------------ | Branch (349:9): [True: 3.07k, False: 120k] ------------------ 350| 3.07k| *val = static_cast(max); 351| 3.07k| return false; 352| 3.07k| } 353| 120k| if (i64 < min) { ------------------ | Branch (353:9): [True: 8.48k, False: 111k] ------------------ 354| | // For unsigned types return max to distinguish from 355| | // "no conversion can be performed" when 0 is returned. 356| 8.48k| *val = static_cast(flatbuffers::is_unsigned::value ? max : min); ------------------ | Branch (356:29): [Folded, False: 8.48k] ------------------ 357| 8.48k| return false; 358| 8.48k| } 359| 111k| *val = static_cast(i64); 360| 111k| return true; 361| 120k| } 362| 8.58k| *val = 0; 363| 8.58k| return false; 364| 131k|} _ZN11flatbuffers11NumToStringIsEENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEET_: 131| 61.8k|std::string NumToString(T t) { 132| | // clang-format off 133| | 134| 61.8k| #ifndef FLATBUFFERS_PREFER_PRINTF 135| 61.8k| std::stringstream ss; 136| 61.8k| ss << t; 137| 61.8k| return ss.str(); 138| | #else // FLATBUFFERS_PREFER_PRINTF 139| | auto v = static_cast(t); 140| | return NumToStringImplWrapper(v, "%.*lld"); 141| | #endif // FLATBUFFERS_PREFER_PRINTF 142| | // clang-format on 143| 61.8k|} _ZN11flatbuffers11NumToStringItEENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEET_: 131| 71.2k|std::string NumToString(T t) { 132| | // clang-format off 133| | 134| 71.2k| #ifndef FLATBUFFERS_PREFER_PRINTF 135| 71.2k| std::stringstream ss; 136| 71.2k| ss << t; 137| 71.2k| return ss.str(); 138| | #else // FLATBUFFERS_PREFER_PRINTF 139| | auto v = static_cast(t); 140| | return NumToStringImplWrapper(v, "%.*lld"); 141| | #endif // FLATBUFFERS_PREFER_PRINTF 142| | // clang-format on 143| 71.2k|} _ZN11flatbuffers15vector_downwardIjEC2EmPNS_9AllocatorEbmj: 41| 103k| : allocator_(allocator), 42| 103k| own_allocator_(own_allocator), 43| 103k| initial_size_(initial_size), 44| 103k| max_size_(max_size), 45| 103k| buffer_minalign_(buffer_minalign), 46| 103k| reserved_(0), 47| 103k| size_(0), 48| 103k| buf_(nullptr), 49| 103k| cur_(nullptr), 50| 103k| scratch_(nullptr) {} _ZN11flatbuffers15vector_downwardIjED2Ev: 81| 103k| ~vector_downward() { 82| 103k| clear_buffer(); 83| 103k| clear_allocator(); 84| 103k| } _ZN11flatbuffers15vector_downwardIjE12clear_bufferEv: 112| 103k| void clear_buffer() { 113| 103k| if (buf_) Deallocate(allocator_, buf_, reserved_); ------------------ | Branch (113:9): [True: 99.6k, False: 3.74k] ------------------ 114| 103k| buf_ = nullptr; 115| 103k| } _ZN11flatbuffers15vector_downwardIjE15clear_allocatorEv: 104| 103k| void clear_allocator() { 105| 103k| if (own_allocator_ && allocator_) { ------------------ | Branch (105:9): [True: 0, False: 103k] | Branch (105:27): [True: 0, False: 0] ------------------ 106| 0| delete allocator_; 107| 0| } 108| 103k| allocator_ = nullptr; 109| 103k| own_allocator_ = false; 110| 103k| } _ZNK11flatbuffers15vector_downwardIjE4dataEv: 183| 1.64M| uint8_t* data() const { 184| 1.64M| FLATBUFFERS_ASSERT(cur_); 185| 1.64M| return cur_; 186| 1.64M| } _ZN11flatbuffers15vector_downwardIjE18scratch_push_smallINS_21FlatBufferBuilderImplILb0EE8FieldLocEEEvRKT_: 214| 192k| void scratch_push_small(const T& t) { 215| 192k| ensure_space(sizeof(T)); 216| 192k| *reinterpret_cast(scratch_) = t; 217| 192k| scratch_ += sizeof(T); 218| 192k| } _ZN11flatbuffers15vector_downwardIjE12ensure_spaceEm: 144| 1.79M| size_t ensure_space(size_t len) { 145| 1.79M| FLATBUFFERS_ASSERT(cur_ >= scratch_ && scratch_ >= buf_); 146| | // If the length is larger than the unused part of the buffer, we need to 147| | // grow. 148| 1.79M| if (len > unused_buffer_size()) { ------------------ | Branch (148:9): [True: 99.6k, False: 1.69M] ------------------ 149| 99.6k| reallocate(len); 150| 99.6k| } 151| 1.79M| FLATBUFFERS_ASSERT(size() < max_size_); 152| 1.79M| return len; 153| 1.79M| } _ZNK11flatbuffers15vector_downwardIjE18unused_buffer_sizeEv: 174| 1.79M| SizeT unused_buffer_size() const { 175| 1.79M| return static_cast(cur_ - scratch_); 176| 1.79M| } _ZN11flatbuffers15vector_downwardIjE10reallocateEm: 278| 99.6k| void reallocate(size_t len) { 279| 99.6k| auto old_reserved = reserved_; 280| 99.6k| auto old_size = size(); 281| 99.6k| auto old_scratch_size = scratch_size(); 282| 99.6k| reserved_ += 283| 99.6k| (std::max)(len, old_reserved ? old_reserved / 2 : initial_size_); ------------------ | Branch (283:25): [True: 0, False: 99.6k] ------------------ 284| 99.6k| reserved_ = (reserved_ + buffer_minalign_ - 1) & ~(buffer_minalign_ - 1); 285| 99.6k| if (buf_) { ------------------ | Branch (285:9): [True: 0, False: 99.6k] ------------------ 286| 0| buf_ = ReallocateDownward(allocator_, buf_, old_reserved, reserved_, 287| 0| old_size, old_scratch_size); 288| 99.6k| } else { 289| 99.6k| buf_ = Allocate(allocator_, reserved_); 290| 99.6k| } 291| 99.6k| cur_ = buf_ + reserved_ - old_size; 292| 99.6k| scratch_ = buf_ + old_scratch_size; 293| 99.6k| } _ZNK11flatbuffers15vector_downwardIjE12scratch_sizeEv: 179| 99.6k| SizeT scratch_size() const { return static_cast(scratch_ - buf_); } _ZNK11flatbuffers15vector_downwardIjE4sizeEv: 171| 6.16M| inline SizeT size() const { return size_; } _ZN11flatbuffers15vector_downwardIjE4fillEm: 222| 1.76M| void fill(size_t zero_pad_bytes) { 223| 1.76M| make_space(zero_pad_bytes); 224| 2.29M| for (size_t i = 0; i < zero_pad_bytes; i++) cur_[i] = 0; ------------------ | Branch (224:24): [True: 526k, False: 1.76M] ------------------ 225| 1.76M| } _ZN11flatbuffers15vector_downwardIjE10make_spaceEm: 155| 2.82M| inline uint8_t* make_space(size_t len) { 156| 2.82M| if (len) { ------------------ | Branch (156:9): [True: 1.31M, False: 1.51M] ------------------ 157| 1.31M| ensure_space(len); 158| 1.31M| cur_ -= len; 159| 1.31M| size_ += static_cast(len); 160| 1.31M| } 161| 2.82M| return cur_; 162| 2.82M| } _ZN11flatbuffers15vector_downwardIjE10push_smallIaEEvRKT_: 208| 11.0k| void push_small(const T& little_endian_t) { 209| 11.0k| make_space(sizeof(T)); 210| 11.0k| *reinterpret_cast(cur_) = little_endian_t; 211| 11.0k| } _ZN11flatbuffers15vector_downwardIjE10push_smallIiEEvRKT_: 208| 315k| void push_small(const T& little_endian_t) { 209| 315k| make_space(sizeof(T)); 210| 315k| *reinterpret_cast(cur_) = little_endian_t; 211| 315k| } _ZN11flatbuffers15vector_downwardIjE10push_smallItEEvRKT_: 208| 14.3k| void push_small(const T& little_endian_t) { 209| 14.3k| make_space(sizeof(T)); 210| 14.3k| *reinterpret_cast(cur_) = little_endian_t; 211| 14.3k| } _ZN11flatbuffers15vector_downwardIjE10push_smallIjEEvRKT_: 208| 307k| void push_small(const T& little_endian_t) { 209| 307k| make_space(sizeof(T)); 210| 307k| *reinterpret_cast(cur_) = little_endian_t; 211| 307k| } _ZN11flatbuffers15vector_downwardIjE8fill_bigEm: 229| 290k| void fill_big(size_t zero_pad_bytes) { 230| 290k| memset(make_space(zero_pad_bytes), 0, zero_pad_bytes); 231| 290k| } _ZNK11flatbuffers15vector_downwardIjE11scratch_endEv: 193| 1.06M| uint8_t* scratch_end() const { 194| 1.06M| FLATBUFFERS_ASSERT(scratch_); 195| 1.06M| return scratch_; 196| 1.06M| } _ZN11flatbuffers15vector_downwardIjE11scratch_popEm: 238| 1.06M| void scratch_pop(size_t bytes_to_remove) { scratch_ -= bytes_to_remove; } _ZNK11flatbuffers15vector_downwardIjE12scratch_dataEv: 188| 290k| uint8_t* scratch_data() const { 189| 290k| FLATBUFFERS_ASSERT(buf_); 190| 290k| return buf_; 191| 290k| } _ZNK11flatbuffers15vector_downwardIjE7data_atEm: 198| 290k| uint8_t* data_at(size_t offset) const { return buf_ + reserved_ - offset; } _ZN11flatbuffers15vector_downwardIjE18scratch_push_smallIjEEvRKT_: 214| 290k| void scratch_push_small(const T& t) { 215| 290k| ensure_space(sizeof(T)); 216| 290k| *reinterpret_cast(scratch_) = t; 217| 290k| scratch_ += sizeof(T); 218| 290k| } _ZN11flatbuffers15vector_downwardIjE10push_smallIlEEvRKT_: 208| 19.9k| void push_small(const T& little_endian_t) { 209| 19.9k| make_space(sizeof(T)); 210| 19.9k| *reinterpret_cast(cur_) = little_endian_t; 211| 19.9k| } _ZN11flatbuffers15vector_downwardIjE10push_smallIhEEvRKT_: 208| 17.2k| void push_small(const T& little_endian_t) { 209| 17.2k| make_space(sizeof(T)); 210| 17.2k| *reinterpret_cast(cur_) = little_endian_t; 211| 17.2k| } _ZN11flatbuffers15vector_downwardIjE10push_smallIdEEvRKT_: 208| 20.5k| void push_small(const T& little_endian_t) { 209| 20.5k| make_space(sizeof(T)); 210| 20.5k| *reinterpret_cast(cur_) = little_endian_t; 211| 20.5k| } _ZN11flatbuffers15vector_downwardIjE10push_smallImEEvRKT_: 208| 30.3k| void push_small(const T& little_endian_t) { 209| 30.3k| make_space(sizeof(T)); 210| 30.3k| *reinterpret_cast(cur_) = little_endian_t; 211| 30.3k| } _ZN11flatbuffers15vector_downwardIjE13clear_scratchEv: 102| 1.06M| void clear_scratch() { scratch_ = buf_; } _ZN11flatbuffers15vector_downwardIjE10push_smallIsEEvRKT_: 208| 14.1k| void push_small(const T& little_endian_t) { 209| 14.1k| make_space(sizeof(T)); 210| 14.1k| *reinterpret_cast(cur_) = little_endian_t; 211| 14.1k| } _ZN11flatbuffers15vector_downwardIjE10push_smallIfEEvRKT_: 208| 22.6k| void push_small(const T& little_endian_t) { 209| 22.6k| make_space(sizeof(T)); 210| 22.6k| *reinterpret_cast(cur_) = little_endian_t; 211| 22.6k| } _ZN11flatbuffers15vector_downwardIjE5clearEv: 91| 769k| void clear() { 92| 769k| if (buf_) { ------------------ | Branch (92:9): [True: 192k, False: 576k] ------------------ 93| 192k| cur_ = buf_ + reserved_; 94| 576k| } else { 95| 576k| reserved_ = 0; 96| 576k| cur_ = nullptr; 97| 576k| } 98| 769k| size_ = 0; 99| 769k| clear_scratch(); 100| 769k| } _ZN11flatbuffers7GenTextERKNS_6ParserEPKvPNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEE: 420| 387k| std::string* _text) { 421| 387k| FLATBUFFERS_ASSERT(parser.root_struct_def_); // call SetRootType() 422| 387k| auto root = parser.opts.size_prefixed ? GetSizePrefixedRoot(flatbuffer) ------------------ | Branch (422:15): [True: 0, False: 387k] ------------------ 423| 387k| : GetRoot
(flatbuffer); 424| 387k| return GenerateTextImpl(parser, root, *parser.root_struct_def_, _text); 425| 387k|} idl_gen_text.cpp:_ZN11flatbuffersL16GenerateTextImplERKNS_6ParserEPKNS_5TableERKNS_9StructDefEPNSt3__112basic_stringIcNS9_11char_traitsIcEENS9_9allocatorIcEEEE: 385| 387k| std::string* _text) { 386| 387k| JsonPrinter printer(parser, *_text); 387| 387k| auto err = printer.GenStruct(struct_def, table, 0); 388| 387k| if (err) return err; ------------------ | Branch (388:7): [True: 0, False: 387k] ------------------ 389| 387k| printer.AddNewLine(); 390| 387k| return nullptr; 391| 387k|} _ZN11flatbuffers11JsonPrinterC2ERKNS_6ParserERNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEE: 375| 387k| : opts(parser.opts), text(dest) { 376| 387k| text.reserve(1024); // Reduce amount of inevitable reallocs. 377| 387k| } _ZN11flatbuffers11JsonPrinter9GenStructERKNS_9StructDefEPKNS_5TableEi: 316| 387k| int indent) { 317| 387k| text += '{'; 318| 387k| int fieldout = 0; 319| 387k| const uint8_t* prev_val = nullptr; 320| 387k| const auto elem_indent = indent + Indent(); 321| 387k| for (auto it = struct_def.fields.vec.begin(); 322| 774k| it != struct_def.fields.vec.end(); ++it) { ------------------ | Branch (322:10): [True: 387k, False: 387k] ------------------ 323| 387k| FieldDef& fd = **it; 324| 387k| auto is_present = struct_def.fixed || table->CheckField(fd.value.offset); ------------------ | Branch (324:25): [True: 0, False: 387k] | Branch (324:45): [True: 288k, False: 98.3k] ------------------ 325| 387k| auto output_anyway = (opts.output_default_scalars_in_json || fd.key) && ------------------ | Branch (325:29): [True: 387k, False: 0] | Branch (325:68): [True: 0, False: 0] ------------------ 326| 387k| IsScalar(fd.value.type.base_type) && !fd.deprecated; ------------------ | Branch (326:28): [True: 387k, False: 0] | Branch (326:65): [True: 387k, False: 0] ------------------ 327| 387k| if (is_present || output_anyway) { ------------------ | Branch (327:11): [True: 288k, False: 98.3k] | Branch (327:25): [True: 98.3k, False: 0] ------------------ 328| 387k| if (fieldout++) { ------------------ | Branch (328:13): [True: 0, False: 387k] ------------------ 329| 0| AddComma(); 330| 0| } 331| 387k| AddNewLine(); 332| 387k| AddIndent(elem_indent); 333| 387k| OutputIdentifier(fd.name); 334| 387k| if (!opts.protobuf_ascii_alike || ------------------ | Branch (334:13): [True: 387k, False: 0] ------------------ 335| 0| (fd.value.type.base_type != BASE_TYPE_STRUCT && ------------------ | Branch (335:14): [True: 0, False: 0] ------------------ 336| 0| fd.value.type.base_type != BASE_TYPE_VECTOR)) ------------------ | Branch (336:14): [True: 0, False: 0] ------------------ 337| 387k| text += ':'; 338| 387k| text += ' '; 339| | // clang-format off 340| 387k| switch (fd.value.type.base_type) { ------------------ | Branch (340:17): [True: 387k, False: 0] ------------------ 341| 0| #define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE, ...) \ 342| 0| case BASE_TYPE_ ## ENUM: { \ 343| 0| GenField(fd, table, struct_def.fixed, elem_indent); \ 344| 0| break; } 345| 0| FLATBUFFERS_GEN_TYPES_SCALAR(FLATBUFFERS_TD) ------------------ | | 50| 0| TD(NONE, "", uint8_t, byte, byte, byte, uint8, u8, UByte, UInt8, 0) \ | | ------------------ | | | | 345| 0| FLATBUFFERS_GEN_TYPES_SCALAR(FLATBUFFERS_TD) | | | | ------------------ | | | | | | 342| 0| case BASE_TYPE_ ## ENUM: { \ | | | | | | ------------------ | | | | | | | Branch (342:11): [True: 0, False: 387k] | | | | | | ------------------ | | | | | | 343| 0| GenField(fd, table, struct_def.fixed, elem_indent); \ | | | | | | 344| 0| break; } | | | | ------------------ | | ------------------ | | 51| 0| TD(UTYPE, "", uint8_t, byte, byte, byte, uint8, u8, UByte, UInt8, 1) /* begin scalar/int */ \ | | ------------------ | | | | 345| 0| FLATBUFFERS_GEN_TYPES_SCALAR(FLATBUFFERS_TD) | | | | ------------------ | | | | | | 342| 0| case BASE_TYPE_ ## ENUM: { \ | | | | | | ------------------ | | | | | | | Branch (342:11): [True: 0, False: 387k] | | | | | | ------------------ | | | | | | 343| 0| GenField(fd, table, struct_def.fixed, elem_indent); \ | | | | | | 344| 0| break; } | | | | ------------------ | | ------------------ | | 52| 22.0k| TD(BOOL, "bool", uint8_t, boolean,bool, bool, bool, bool, Boolean, Bool, 2) \ | | ------------------ | | | | 345| 22.0k| FLATBUFFERS_GEN_TYPES_SCALAR(FLATBUFFERS_TD) | | | | ------------------ | | | | | | 342| 22.0k| case BASE_TYPE_ ## ENUM: { \ | | | | | | ------------------ | | | | | | | Branch (342:11): [True: 22.0k, False: 365k] | | | | | | ------------------ | | | | | | 343| 22.0k| GenField(fd, table, struct_def.fixed, elem_indent); \ | | | | | | 344| 22.0k| break; } | | | | ------------------ | | ------------------ | | 53| 22.1k| TD(CHAR, "byte", int8_t, byte, int8, sbyte, int8, i8, Byte, Int8, 3) \ | | ------------------ | | | | 345| 22.1k| FLATBUFFERS_GEN_TYPES_SCALAR(FLATBUFFERS_TD) | | | | ------------------ | | | | | | 342| 22.1k| case BASE_TYPE_ ## ENUM: { \ | | | | | | ------------------ | | | | | | | Branch (342:11): [True: 22.1k, False: 365k] | | | | | | ------------------ | | | | | | 343| 22.1k| GenField(fd, table, struct_def.fixed, elem_indent); \ | | | | | | 344| 22.1k| break; } | | | | ------------------ | | ------------------ | | 54| 22.1k| TD(UCHAR, "ubyte", uint8_t, byte, byte, byte, uint8, u8, UByte, UInt8, 4) \ | | ------------------ | | | | 345| 12.8k| FLATBUFFERS_GEN_TYPES_SCALAR(FLATBUFFERS_TD) | | | | ------------------ | | | | | | 342| 12.8k| case BASE_TYPE_ ## ENUM: { \ | | | | | | ------------------ | | | | | | | Branch (342:11): [True: 12.8k, False: 374k] | | | | | | ------------------ | | | | | | 343| 12.8k| GenField(fd, table, struct_def.fixed, elem_indent); \ | | | | | | 344| 12.8k| break; } | | | | ------------------ | | ------------------ | | 55| 28.0k| TD(SHORT, "short", int16_t, short, int16, short, int16, i16, Short, Int16, 5) \ | | ------------------ | | | | 345| 28.0k| FLATBUFFERS_GEN_TYPES_SCALAR(FLATBUFFERS_TD) | | | | ------------------ | | | | | | 342| 28.0k| case BASE_TYPE_ ## ENUM: { \ | | | | | | ------------------ | | | | | | | Branch (342:11): [True: 28.0k, False: 359k] | | | | | | ------------------ | | | | | | 343| 28.0k| GenField(fd, table, struct_def.fixed, elem_indent); \ | | | | | | 344| 28.0k| break; } | | | | ------------------ | | ------------------ | | 56| 28.8k| TD(USHORT, "ushort", uint16_t, short, uint16, ushort, uint16, u16, UShort, UInt16, 6) \ | | ------------------ | | | | 345| 28.8k| FLATBUFFERS_GEN_TYPES_SCALAR(FLATBUFFERS_TD) | | | | ------------------ | | | | | | 342| 28.8k| case BASE_TYPE_ ## ENUM: { \ | | | | | | ------------------ | | | | | | | Branch (342:11): [True: 28.8k, False: 358k] | | | | | | ------------------ | | | | | | 343| 28.8k| GenField(fd, table, struct_def.fixed, elem_indent); \ | | | | | | 344| 28.8k| break; } | | | | ------------------ | | ------------------ | | 57| 49.4k| TD(INT, "int", int32_t, int, int32, int, int32, i32, Int, Int32, 7) \ | | ------------------ | | | | 345| 49.4k| FLATBUFFERS_GEN_TYPES_SCALAR(FLATBUFFERS_TD) | | | | ------------------ | | | | | | 342| 49.4k| case BASE_TYPE_ ## ENUM: { \ | | | | | | ------------------ | | | | | | | Branch (342:11): [True: 49.4k, False: 337k] | | | | | | ------------------ | | | | | | 343| 49.4k| GenField(fd, table, struct_def.fixed, elem_indent); \ | | | | | | 344| 49.4k| break; } | | | | ------------------ | | ------------------ | | 58| 49.4k| TD(UINT, "uint", uint32_t, int, uint32, uint, uint32, u32, UInt, UInt32, 8) \ | | ------------------ | | | | 345| 34.5k| FLATBUFFERS_GEN_TYPES_SCALAR(FLATBUFFERS_TD) | | | | ------------------ | | | | | | 342| 34.5k| case BASE_TYPE_ ## ENUM: { \ | | | | | | ------------------ | | | | | | | Branch (342:11): [True: 34.5k, False: 352k] | | | | | | ------------------ | | | | | | 343| 34.5k| GenField(fd, table, struct_def.fixed, elem_indent); \ | | | | | | 344| 34.5k| break; } | | | | ------------------ | | ------------------ | | 59| 39.7k| TD(LONG, "long", int64_t, long, int64, long, int64, i64, Long, Int64, 9) \ | | ------------------ | | | | 345| 39.7k| FLATBUFFERS_GEN_TYPES_SCALAR(FLATBUFFERS_TD) | | | | ------------------ | | | | | | 342| 39.7k| case BASE_TYPE_ ## ENUM: { \ | | | | | | ------------------ | | | | | | | Branch (342:11): [True: 39.7k, False: 347k] | | | | | | ------------------ | | | | | | 343| 39.7k| GenField(fd, table, struct_def.fixed, elem_indent); \ | | | | | | 344| 39.7k| break; } | | | | ------------------ | | ------------------ | | 60| 60.9k| TD(ULONG, "ulong", uint64_t, long, uint64, ulong, uint64, u64, ULong, UInt64, 10) /* end int */ \ | | ------------------ | | | | 345| 60.9k| FLATBUFFERS_GEN_TYPES_SCALAR(FLATBUFFERS_TD) | | | | ------------------ | | | | | | 342| 60.9k| case BASE_TYPE_ ## ENUM: { \ | | | | | | ------------------ | | | | | | | Branch (342:11): [True: 60.9k, False: 326k] | | | | | | ------------------ | | | | | | 343| 60.9k| GenField(fd, table, struct_def.fixed, elem_indent); \ | | | | | | 344| 60.9k| break; } | | | | ------------------ | | ------------------ | | 61| 60.9k| TD(FLOAT, "float", float, float, float32, float, float32, f32, Float, Float32, 11) /* begin float */ \ | | ------------------ | | | | 345| 46.6k| FLATBUFFERS_GEN_TYPES_SCALAR(FLATBUFFERS_TD) | | | | ------------------ | | | | | | 342| 46.6k| case BASE_TYPE_ ## ENUM: { \ | | | | | | ------------------ | | | | | | | Branch (342:11): [True: 46.6k, False: 340k] | | | | | | ------------------ | | | | | | 343| 46.6k| GenField(fd, table, struct_def.fixed, elem_indent); \ | | | | | | 344| 46.6k| break; } | | | | ------------------ | | ------------------ | | 62| 46.6k| TD(DOUBLE, "double", double, double, float64, double, float64, f64, Double, Double, 12) /* end float/scalar */ | | ------------------ | | | | 345| 41.8k| FLATBUFFERS_GEN_TYPES_SCALAR(FLATBUFFERS_TD) | | | | ------------------ | | | | | | 342| 41.8k| case BASE_TYPE_ ## ENUM: { \ | | | | | | ------------------ | | | | | | | Branch (342:11): [True: 41.8k, False: 345k] | | | | | | ------------------ | | | | | | 343| 41.8k| GenField(fd, table, struct_def.fixed, elem_indent); \ | | | | | | 344| 41.8k| break; } | | | | ------------------ | | ------------------ ------------------ 346| 0| #undef FLATBUFFERS_TD 347| | // Generate drop-thru case statements for all pointer types: 348| 0| #define FLATBUFFERS_TD(ENUM, ...) \ 349| 0| case BASE_TYPE_ ## ENUM: 350| 41.8k| FLATBUFFERS_GEN_TYPES_POINTER(FLATBUFFERS_TD) ------------------ | | 64| 0| TD(STRING, "string", Offset, int, int, StringOffset, int, unused, Int, Offset, 13) \ | | ------------------ | | | | 350| 0| FLATBUFFERS_GEN_TYPES_POINTER(FLATBUFFERS_TD) | | | | ------------------ | | | | | | 349| 41.8k| case BASE_TYPE_ ## ENUM: | | | | | | ------------------ | | | | | | | Branch (349:11): [True: 0, False: 387k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 65| 0| TD(VECTOR, "", Offset, int, int, VectorOffset, int, unused, Int, Offset, 14) \ | | ------------------ | | | | 350| 0| FLATBUFFERS_GEN_TYPES_POINTER(FLATBUFFERS_TD) | | | | ------------------ | | | | | | 349| 0| case BASE_TYPE_ ## ENUM: | | | | | | ------------------ | | | | | | | Branch (349:11): [True: 0, False: 387k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 66| 0| TD(VECTOR64, "", Offset64, int, int, VectorOffset, int, unused, Int, Offset, 18) \ | | ------------------ | | | | 350| 0| FLATBUFFERS_GEN_TYPES_POINTER(FLATBUFFERS_TD) | | | | ------------------ | | | | | | 349| 0| case BASE_TYPE_ ## ENUM: | | | | | | ------------------ | | | | | | | Branch (349:11): [True: 0, False: 387k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 67| 0| TD(STRUCT, "", Offset, int, int, int, int, unused, Int, Offset, 15) \ | | ------------------ | | | | 350| 0| FLATBUFFERS_GEN_TYPES_POINTER(FLATBUFFERS_TD) | | | | ------------------ | | | | | | 349| 0| case BASE_TYPE_ ## ENUM: | | | | | | ------------------ | | | | | | | Branch (349:11): [True: 0, False: 387k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 68| 0| TD(UNION, "", Offset, int, int, int, int, unused, Int, Offset, 16) | | ------------------ | | | | 350| 0| FLATBUFFERS_GEN_TYPES_POINTER(FLATBUFFERS_TD) | | | | ------------------ | | | | | | 349| 41.8k| case BASE_TYPE_ ## ENUM: | | | | | | ------------------ | | | | | | | Branch (349:11): [True: 0, False: 387k] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 351| 0| FLATBUFFERS_GEN_TYPE_ARRAY(FLATBUFFERS_TD) ------------------ | | 70| 0| TD(ARRAY, "", int, int, int, int, int, unused, Int, Offset, 17) | | ------------------ | | | | 351| 0| FLATBUFFERS_GEN_TYPE_ARRAY(FLATBUFFERS_TD) | | | | ------------------ | | | | | | 349| 0| case BASE_TYPE_ ## ENUM: | | | | | | ------------------ | | | | | | | Branch (349:11): [True: 0, False: 387k] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 352| 0| #undef FLATBUFFERS_TD 353| 0| { 354| 0| auto err = GenFieldOffset(fd, table, struct_def.fixed, elem_indent, prev_val); 355| 0| if (err) return err; ------------------ | Branch (355:19): [True: 0, False: 0] ------------------ 356| 0| break; 357| 0| } 358| 387k| } 359| | // clang-format on 360| | // Track prev val for use with union types. 361| 387k| if (struct_def.fixed) { ------------------ | Branch (361:13): [True: 0, False: 387k] ------------------ 362| 0| prev_val = reinterpret_cast(table) + fd.value.offset; 363| 387k| } else { 364| 387k| prev_val = table->GetAddressOf(fd.value.offset); 365| 387k| } 366| 387k| } 367| 387k| } 368| 387k| AddNewLine(); 369| 387k| AddIndent(indent); 370| 387k| text += '}'; 371| 387k| return nullptr; 372| 387k| } _ZNK11flatbuffers11JsonPrinter6IndentEv: 51| 387k| int Indent() const { return std::max(opts.indent_step, 0); } _ZN11flatbuffers11JsonPrinter9AddIndentEi: 49| 774k| void AddIndent(int ident) { text.append(ident, ' '); } _ZN11flatbuffers11JsonPrinter16OutputIdentifierERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE: 54| 387k| void OutputIdentifier(const std::string& name) { 55| 387k| if (opts.strict_json) text += '\"'; ------------------ | Branch (55:9): [True: 387k, False: 0] ------------------ 56| 387k| text += name; 57| 387k| if (opts.strict_json) text += '\"'; ------------------ | Branch (57:9): [True: 387k, False: 0] ------------------ 58| 387k| } _ZN11flatbuffers11JsonPrinter8GenFieldIhEEvRKNS_8FieldDefEPKNS_5TableEbi: 263| 34.9k| int indent) { 264| 34.9k| if (fixed) { ------------------ | Branch (264:9): [True: 0, False: 34.9k] ------------------ 265| 0| PrintScalar( 266| 0| reinterpret_cast(table)->GetField(fd.value.offset), 267| 0| fd.value.type, indent); 268| 34.9k| } else if (fd.IsOptional()) { ------------------ | Branch (268:16): [True: 0, False: 34.9k] ------------------ 269| 0| auto opt = table->GetOptional(fd.value.offset); 270| 0| if (opt) { ------------------ | Branch (270:11): [True: 0, False: 0] ------------------ 271| 0| PrintScalar(*opt, fd.value.type, indent); 272| 0| } else { 273| 0| text += "null"; 274| 0| } 275| 34.9k| } else { 276| 34.9k| PrintScalar(table->GetField(fd.value.offset, GetFieldDefault(fd)), 277| 34.9k| fd.value.type, indent); 278| 34.9k| } 279| 34.9k| } _ZN11flatbuffers11JsonPrinter11PrintScalarIhEEvT_RKNS_4TypeEi: 64| 34.9k| void PrintScalar(T val, const Type& type, int /*indent*/) { 65| 34.9k| if (IsBool(type.base_type)) { ------------------ | Branch (65:9): [True: 22.0k, False: 12.8k] ------------------ 66| 22.0k| text += val != 0 ? "true" : "false"; ------------------ | Branch (66:15): [True: 14.2k, False: 7.82k] ------------------ 67| 22.0k| return; // done 68| 22.0k| } 69| | 70| 12.8k| if (opts.output_enum_identifiers && type.enum_def) { ------------------ | Branch (70:9): [True: 12.8k, False: 0] | Branch (70:41): [True: 0, False: 12.8k] ------------------ 71| 0| const auto& enum_def = *type.enum_def; 72| 0| if (auto ev = enum_def.ReverseLookup(static_cast(val))) { ------------------ | Branch (72:16): [True: 0, False: 0] ------------------ 73| 0| text += '\"'; 74| 0| text += ev->name; 75| 0| text += '\"'; 76| 0| return; // done 77| 0| } else if (val && enum_def.attributes.Lookup("bit_flags")) { ------------------ | Branch (77:18): [True: 0, False: 0] | Branch (77:18): [True: 0, False: 0] | Branch (77:25): [True: 0, False: 0] ------------------ 78| 0| const auto entry_len = text.length(); 79| 0| const auto u64 = static_cast(val); 80| 0| uint64_t mask = 0; 81| 0| text += '\"'; 82| 0| for (auto it = enum_def.Vals().begin(), e = enum_def.Vals().end(); 83| 0| it != e; ++it) { ------------------ | Branch (83:14): [True: 0, False: 0] ------------------ 84| 0| auto f = (*it)->GetAsUInt64(); 85| 0| if (f & u64) { ------------------ | Branch (85:15): [True: 0, False: 0] ------------------ 86| 0| mask |= f; 87| 0| text += (*it)->name; 88| 0| text += ' '; 89| 0| } 90| 0| } 91| | // Don't slice if (u64 != mask) 92| 0| if (mask && (u64 == mask)) { ------------------ | Branch (92:13): [True: 0, False: 0] | Branch (92:21): [True: 0, False: 0] ------------------ 93| 0| text[text.length() - 1] = '\"'; 94| 0| return; // done 95| 0| } 96| 0| text.resize(entry_len); // restore 97| 0| } 98| | // print as numeric value 99| 0| } 100| | 101| 12.8k| text += NumToString(val); 102| 12.8k| return; 103| 12.8k| } _ZN11flatbuffers11JsonPrinter15GetFieldDefaultIhEET_RKNS_8FieldDefE: 252| 34.9k| static T GetFieldDefault(const FieldDef& fd) { 253| 34.9k| T val{}; 254| 34.9k| auto check = StringToNumber(fd.value.constant.c_str(), &val); 255| 34.9k| (void)check; 256| 34.9k| FLATBUFFERS_ASSERT(check); 257| 34.9k| return val; 258| 34.9k| } _ZN11flatbuffers11JsonPrinter8GenFieldIaEEvRKNS_8FieldDefEPKNS_5TableEbi: 263| 22.1k| int indent) { 264| 22.1k| if (fixed) { ------------------ | Branch (264:9): [True: 0, False: 22.1k] ------------------ 265| 0| PrintScalar( 266| 0| reinterpret_cast(table)->GetField(fd.value.offset), 267| 0| fd.value.type, indent); 268| 22.1k| } else if (fd.IsOptional()) { ------------------ | Branch (268:16): [True: 0, False: 22.1k] ------------------ 269| 0| auto opt = table->GetOptional(fd.value.offset); 270| 0| if (opt) { ------------------ | Branch (270:11): [True: 0, False: 0] ------------------ 271| 0| PrintScalar(*opt, fd.value.type, indent); 272| 0| } else { 273| 0| text += "null"; 274| 0| } 275| 22.1k| } else { 276| 22.1k| PrintScalar(table->GetField(fd.value.offset, GetFieldDefault(fd)), 277| 22.1k| fd.value.type, indent); 278| 22.1k| } 279| 22.1k| } _ZN11flatbuffers11JsonPrinter11PrintScalarIaEEvT_RKNS_4TypeEi: 64| 22.1k| void PrintScalar(T val, const Type& type, int /*indent*/) { 65| 22.1k| if (IsBool(type.base_type)) { ------------------ | Branch (65:9): [True: 0, False: 22.1k] ------------------ 66| 0| text += val != 0 ? "true" : "false"; ------------------ | Branch (66:15): [True: 0, False: 0] ------------------ 67| 0| return; // done 68| 0| } 69| | 70| 22.1k| if (opts.output_enum_identifiers && type.enum_def) { ------------------ | Branch (70:9): [True: 22.1k, False: 0] | Branch (70:41): [True: 0, False: 22.1k] ------------------ 71| 0| const auto& enum_def = *type.enum_def; 72| 0| if (auto ev = enum_def.ReverseLookup(static_cast(val))) { ------------------ | Branch (72:16): [True: 0, False: 0] ------------------ 73| 0| text += '\"'; 74| 0| text += ev->name; 75| 0| text += '\"'; 76| 0| return; // done 77| 0| } else if (val && enum_def.attributes.Lookup("bit_flags")) { ------------------ | Branch (77:18): [True: 0, False: 0] | Branch (77:18): [True: 0, False: 0] | Branch (77:25): [True: 0, False: 0] ------------------ 78| 0| const auto entry_len = text.length(); 79| 0| const auto u64 = static_cast(val); 80| 0| uint64_t mask = 0; 81| 0| text += '\"'; 82| 0| for (auto it = enum_def.Vals().begin(), e = enum_def.Vals().end(); 83| 0| it != e; ++it) { ------------------ | Branch (83:14): [True: 0, False: 0] ------------------ 84| 0| auto f = (*it)->GetAsUInt64(); 85| 0| if (f & u64) { ------------------ | Branch (85:15): [True: 0, False: 0] ------------------ 86| 0| mask |= f; 87| 0| text += (*it)->name; 88| 0| text += ' '; 89| 0| } 90| 0| } 91| | // Don't slice if (u64 != mask) 92| 0| if (mask && (u64 == mask)) { ------------------ | Branch (92:13): [True: 0, False: 0] | Branch (92:21): [True: 0, False: 0] ------------------ 93| 0| text[text.length() - 1] = '\"'; 94| 0| return; // done 95| 0| } 96| 0| text.resize(entry_len); // restore 97| 0| } 98| | // print as numeric value 99| 0| } 100| | 101| 22.1k| text += NumToString(val); 102| 22.1k| return; 103| 22.1k| } _ZN11flatbuffers11JsonPrinter15GetFieldDefaultIaEET_RKNS_8FieldDefE: 252| 22.1k| static T GetFieldDefault(const FieldDef& fd) { 253| 22.1k| T val{}; 254| 22.1k| auto check = StringToNumber(fd.value.constant.c_str(), &val); 255| 22.1k| (void)check; 256| 22.1k| FLATBUFFERS_ASSERT(check); 257| 22.1k| return val; 258| 22.1k| } _ZN11flatbuffers11JsonPrinter8GenFieldIsEEvRKNS_8FieldDefEPKNS_5TableEbi: 263| 28.0k| int indent) { 264| 28.0k| if (fixed) { ------------------ | Branch (264:9): [True: 0, False: 28.0k] ------------------ 265| 0| PrintScalar( 266| 0| reinterpret_cast(table)->GetField(fd.value.offset), 267| 0| fd.value.type, indent); 268| 28.0k| } else if (fd.IsOptional()) { ------------------ | Branch (268:16): [True: 0, False: 28.0k] ------------------ 269| 0| auto opt = table->GetOptional(fd.value.offset); 270| 0| if (opt) { ------------------ | Branch (270:11): [True: 0, False: 0] ------------------ 271| 0| PrintScalar(*opt, fd.value.type, indent); 272| 0| } else { 273| 0| text += "null"; 274| 0| } 275| 28.0k| } else { 276| 28.0k| PrintScalar(table->GetField(fd.value.offset, GetFieldDefault(fd)), 277| 28.0k| fd.value.type, indent); 278| 28.0k| } 279| 28.0k| } _ZN11flatbuffers11JsonPrinter11PrintScalarIsEEvT_RKNS_4TypeEi: 64| 28.0k| void PrintScalar(T val, const Type& type, int /*indent*/) { 65| 28.0k| if (IsBool(type.base_type)) { ------------------ | Branch (65:9): [True: 0, False: 28.0k] ------------------ 66| 0| text += val != 0 ? "true" : "false"; ------------------ | Branch (66:15): [True: 0, False: 0] ------------------ 67| 0| return; // done 68| 0| } 69| | 70| 28.0k| if (opts.output_enum_identifiers && type.enum_def) { ------------------ | Branch (70:9): [True: 28.0k, False: 0] | Branch (70:41): [True: 0, False: 28.0k] ------------------ 71| 0| const auto& enum_def = *type.enum_def; 72| 0| if (auto ev = enum_def.ReverseLookup(static_cast(val))) { ------------------ | Branch (72:16): [True: 0, False: 0] ------------------ 73| 0| text += '\"'; 74| 0| text += ev->name; 75| 0| text += '\"'; 76| 0| return; // done 77| 0| } else if (val && enum_def.attributes.Lookup("bit_flags")) { ------------------ | Branch (77:18): [True: 0, False: 0] | Branch (77:18): [True: 0, False: 0] | Branch (77:25): [True: 0, False: 0] ------------------ 78| 0| const auto entry_len = text.length(); 79| 0| const auto u64 = static_cast(val); 80| 0| uint64_t mask = 0; 81| 0| text += '\"'; 82| 0| for (auto it = enum_def.Vals().begin(), e = enum_def.Vals().end(); 83| 0| it != e; ++it) { ------------------ | Branch (83:14): [True: 0, False: 0] ------------------ 84| 0| auto f = (*it)->GetAsUInt64(); 85| 0| if (f & u64) { ------------------ | Branch (85:15): [True: 0, False: 0] ------------------ 86| 0| mask |= f; 87| 0| text += (*it)->name; 88| 0| text += ' '; 89| 0| } 90| 0| } 91| | // Don't slice if (u64 != mask) 92| 0| if (mask && (u64 == mask)) { ------------------ | Branch (92:13): [True: 0, False: 0] | Branch (92:21): [True: 0, False: 0] ------------------ 93| 0| text[text.length() - 1] = '\"'; 94| 0| return; // done 95| 0| } 96| 0| text.resize(entry_len); // restore 97| 0| } 98| | // print as numeric value 99| 0| } 100| | 101| 28.0k| text += NumToString(val); 102| 28.0k| return; 103| 28.0k| } _ZN11flatbuffers11JsonPrinter15GetFieldDefaultIsEET_RKNS_8FieldDefE: 252| 28.0k| static T GetFieldDefault(const FieldDef& fd) { 253| 28.0k| T val{}; 254| 28.0k| auto check = StringToNumber(fd.value.constant.c_str(), &val); 255| 28.0k| (void)check; 256| 28.0k| FLATBUFFERS_ASSERT(check); 257| 28.0k| return val; 258| 28.0k| } _ZN11flatbuffers11JsonPrinter8GenFieldItEEvRKNS_8FieldDefEPKNS_5TableEbi: 263| 28.8k| int indent) { 264| 28.8k| if (fixed) { ------------------ | Branch (264:9): [True: 0, False: 28.8k] ------------------ 265| 0| PrintScalar( 266| 0| reinterpret_cast(table)->GetField(fd.value.offset), 267| 0| fd.value.type, indent); 268| 28.8k| } else if (fd.IsOptional()) { ------------------ | Branch (268:16): [True: 0, False: 28.8k] ------------------ 269| 0| auto opt = table->GetOptional(fd.value.offset); 270| 0| if (opt) { ------------------ | Branch (270:11): [True: 0, False: 0] ------------------ 271| 0| PrintScalar(*opt, fd.value.type, indent); 272| 0| } else { 273| 0| text += "null"; 274| 0| } 275| 28.8k| } else { 276| 28.8k| PrintScalar(table->GetField(fd.value.offset, GetFieldDefault(fd)), 277| 28.8k| fd.value.type, indent); 278| 28.8k| } 279| 28.8k| } _ZN11flatbuffers11JsonPrinter11PrintScalarItEEvT_RKNS_4TypeEi: 64| 28.8k| void PrintScalar(T val, const Type& type, int /*indent*/) { 65| 28.8k| if (IsBool(type.base_type)) { ------------------ | Branch (65:9): [True: 0, False: 28.8k] ------------------ 66| 0| text += val != 0 ? "true" : "false"; ------------------ | Branch (66:15): [True: 0, False: 0] ------------------ 67| 0| return; // done 68| 0| } 69| | 70| 28.8k| if (opts.output_enum_identifiers && type.enum_def) { ------------------ | Branch (70:9): [True: 28.8k, False: 0] | Branch (70:41): [True: 0, False: 28.8k] ------------------ 71| 0| const auto& enum_def = *type.enum_def; 72| 0| if (auto ev = enum_def.ReverseLookup(static_cast(val))) { ------------------ | Branch (72:16): [True: 0, False: 0] ------------------ 73| 0| text += '\"'; 74| 0| text += ev->name; 75| 0| text += '\"'; 76| 0| return; // done 77| 0| } else if (val && enum_def.attributes.Lookup("bit_flags")) { ------------------ | Branch (77:18): [True: 0, False: 0] | Branch (77:18): [True: 0, False: 0] | Branch (77:25): [True: 0, False: 0] ------------------ 78| 0| const auto entry_len = text.length(); 79| 0| const auto u64 = static_cast(val); 80| 0| uint64_t mask = 0; 81| 0| text += '\"'; 82| 0| for (auto it = enum_def.Vals().begin(), e = enum_def.Vals().end(); 83| 0| it != e; ++it) { ------------------ | Branch (83:14): [True: 0, False: 0] ------------------ 84| 0| auto f = (*it)->GetAsUInt64(); 85| 0| if (f & u64) { ------------------ | Branch (85:15): [True: 0, False: 0] ------------------ 86| 0| mask |= f; 87| 0| text += (*it)->name; 88| 0| text += ' '; 89| 0| } 90| 0| } 91| | // Don't slice if (u64 != mask) 92| 0| if (mask && (u64 == mask)) { ------------------ | Branch (92:13): [True: 0, False: 0] | Branch (92:21): [True: 0, False: 0] ------------------ 93| 0| text[text.length() - 1] = '\"'; 94| 0| return; // done 95| 0| } 96| 0| text.resize(entry_len); // restore 97| 0| } 98| | // print as numeric value 99| 0| } 100| | 101| 28.8k| text += NumToString(val); 102| 28.8k| return; 103| 28.8k| } _ZN11flatbuffers11JsonPrinter15GetFieldDefaultItEET_RKNS_8FieldDefE: 252| 28.8k| static T GetFieldDefault(const FieldDef& fd) { 253| 28.8k| T val{}; 254| 28.8k| auto check = StringToNumber(fd.value.constant.c_str(), &val); 255| 28.8k| (void)check; 256| 28.8k| FLATBUFFERS_ASSERT(check); 257| 28.8k| return val; 258| 28.8k| } _ZN11flatbuffers11JsonPrinter8GenFieldIiEEvRKNS_8FieldDefEPKNS_5TableEbi: 263| 49.4k| int indent) { 264| 49.4k| if (fixed) { ------------------ | Branch (264:9): [True: 0, False: 49.4k] ------------------ 265| 0| PrintScalar( 266| 0| reinterpret_cast(table)->GetField(fd.value.offset), 267| 0| fd.value.type, indent); 268| 49.4k| } else if (fd.IsOptional()) { ------------------ | Branch (268:16): [True: 0, False: 49.4k] ------------------ 269| 0| auto opt = table->GetOptional(fd.value.offset); 270| 0| if (opt) { ------------------ | Branch (270:11): [True: 0, False: 0] ------------------ 271| 0| PrintScalar(*opt, fd.value.type, indent); 272| 0| } else { 273| 0| text += "null"; 274| 0| } 275| 49.4k| } else { 276| 49.4k| PrintScalar(table->GetField(fd.value.offset, GetFieldDefault(fd)), 277| 49.4k| fd.value.type, indent); 278| 49.4k| } 279| 49.4k| } _ZN11flatbuffers11JsonPrinter11PrintScalarIiEEvT_RKNS_4TypeEi: 64| 49.4k| void PrintScalar(T val, const Type& type, int /*indent*/) { 65| 49.4k| if (IsBool(type.base_type)) { ------------------ | Branch (65:9): [True: 0, False: 49.4k] ------------------ 66| 0| text += val != 0 ? "true" : "false"; ------------------ | Branch (66:15): [True: 0, False: 0] ------------------ 67| 0| return; // done 68| 0| } 69| | 70| 49.4k| if (opts.output_enum_identifiers && type.enum_def) { ------------------ | Branch (70:9): [True: 49.4k, False: 0] | Branch (70:41): [True: 0, False: 49.4k] ------------------ 71| 0| const auto& enum_def = *type.enum_def; 72| 0| if (auto ev = enum_def.ReverseLookup(static_cast(val))) { ------------------ | Branch (72:16): [True: 0, False: 0] ------------------ 73| 0| text += '\"'; 74| 0| text += ev->name; 75| 0| text += '\"'; 76| 0| return; // done 77| 0| } else if (val && enum_def.attributes.Lookup("bit_flags")) { ------------------ | Branch (77:18): [True: 0, False: 0] | Branch (77:18): [True: 0, False: 0] | Branch (77:25): [True: 0, False: 0] ------------------ 78| 0| const auto entry_len = text.length(); 79| 0| const auto u64 = static_cast(val); 80| 0| uint64_t mask = 0; 81| 0| text += '\"'; 82| 0| for (auto it = enum_def.Vals().begin(), e = enum_def.Vals().end(); 83| 0| it != e; ++it) { ------------------ | Branch (83:14): [True: 0, False: 0] ------------------ 84| 0| auto f = (*it)->GetAsUInt64(); 85| 0| if (f & u64) { ------------------ | Branch (85:15): [True: 0, False: 0] ------------------ 86| 0| mask |= f; 87| 0| text += (*it)->name; 88| 0| text += ' '; 89| 0| } 90| 0| } 91| | // Don't slice if (u64 != mask) 92| 0| if (mask && (u64 == mask)) { ------------------ | Branch (92:13): [True: 0, False: 0] | Branch (92:21): [True: 0, False: 0] ------------------ 93| 0| text[text.length() - 1] = '\"'; 94| 0| return; // done 95| 0| } 96| 0| text.resize(entry_len); // restore 97| 0| } 98| | // print as numeric value 99| 0| } 100| | 101| 49.4k| text += NumToString(val); 102| 49.4k| return; 103| 49.4k| } _ZN11flatbuffers11JsonPrinter15GetFieldDefaultIiEET_RKNS_8FieldDefE: 252| 49.4k| static T GetFieldDefault(const FieldDef& fd) { 253| 49.4k| T val{}; 254| 49.4k| auto check = StringToNumber(fd.value.constant.c_str(), &val); 255| 49.4k| (void)check; 256| 49.4k| FLATBUFFERS_ASSERT(check); 257| 49.4k| return val; 258| 49.4k| } _ZN11flatbuffers11JsonPrinter8GenFieldIjEEvRKNS_8FieldDefEPKNS_5TableEbi: 263| 34.5k| int indent) { 264| 34.5k| if (fixed) { ------------------ | Branch (264:9): [True: 0, False: 34.5k] ------------------ 265| 0| PrintScalar( 266| 0| reinterpret_cast(table)->GetField(fd.value.offset), 267| 0| fd.value.type, indent); 268| 34.5k| } else if (fd.IsOptional()) { ------------------ | Branch (268:16): [True: 0, False: 34.5k] ------------------ 269| 0| auto opt = table->GetOptional(fd.value.offset); 270| 0| if (opt) { ------------------ | Branch (270:11): [True: 0, False: 0] ------------------ 271| 0| PrintScalar(*opt, fd.value.type, indent); 272| 0| } else { 273| 0| text += "null"; 274| 0| } 275| 34.5k| } else { 276| 34.5k| PrintScalar(table->GetField(fd.value.offset, GetFieldDefault(fd)), 277| 34.5k| fd.value.type, indent); 278| 34.5k| } 279| 34.5k| } _ZN11flatbuffers11JsonPrinter11PrintScalarIjEEvT_RKNS_4TypeEi: 64| 34.5k| void PrintScalar(T val, const Type& type, int /*indent*/) { 65| 34.5k| if (IsBool(type.base_type)) { ------------------ | Branch (65:9): [True: 0, False: 34.5k] ------------------ 66| 0| text += val != 0 ? "true" : "false"; ------------------ | Branch (66:15): [True: 0, False: 0] ------------------ 67| 0| return; // done 68| 0| } 69| | 70| 34.5k| if (opts.output_enum_identifiers && type.enum_def) { ------------------ | Branch (70:9): [True: 34.5k, False: 0] | Branch (70:41): [True: 0, False: 34.5k] ------------------ 71| 0| const auto& enum_def = *type.enum_def; 72| 0| if (auto ev = enum_def.ReverseLookup(static_cast(val))) { ------------------ | Branch (72:16): [True: 0, False: 0] ------------------ 73| 0| text += '\"'; 74| 0| text += ev->name; 75| 0| text += '\"'; 76| 0| return; // done 77| 0| } else if (val && enum_def.attributes.Lookup("bit_flags")) { ------------------ | Branch (77:18): [True: 0, False: 0] | Branch (77:18): [True: 0, False: 0] | Branch (77:25): [True: 0, False: 0] ------------------ 78| 0| const auto entry_len = text.length(); 79| 0| const auto u64 = static_cast(val); 80| 0| uint64_t mask = 0; 81| 0| text += '\"'; 82| 0| for (auto it = enum_def.Vals().begin(), e = enum_def.Vals().end(); 83| 0| it != e; ++it) { ------------------ | Branch (83:14): [True: 0, False: 0] ------------------ 84| 0| auto f = (*it)->GetAsUInt64(); 85| 0| if (f & u64) { ------------------ | Branch (85:15): [True: 0, False: 0] ------------------ 86| 0| mask |= f; 87| 0| text += (*it)->name; 88| 0| text += ' '; 89| 0| } 90| 0| } 91| | // Don't slice if (u64 != mask) 92| 0| if (mask && (u64 == mask)) { ------------------ | Branch (92:13): [True: 0, False: 0] | Branch (92:21): [True: 0, False: 0] ------------------ 93| 0| text[text.length() - 1] = '\"'; 94| 0| return; // done 95| 0| } 96| 0| text.resize(entry_len); // restore 97| 0| } 98| | // print as numeric value 99| 0| } 100| | 101| 34.5k| text += NumToString(val); 102| 34.5k| return; 103| 34.5k| } _ZN11flatbuffers11JsonPrinter15GetFieldDefaultIjEET_RKNS_8FieldDefE: 252| 34.5k| static T GetFieldDefault(const FieldDef& fd) { 253| 34.5k| T val{}; 254| 34.5k| auto check = StringToNumber(fd.value.constant.c_str(), &val); 255| 34.5k| (void)check; 256| 34.5k| FLATBUFFERS_ASSERT(check); 257| 34.5k| return val; 258| 34.5k| } _ZN11flatbuffers11JsonPrinter8GenFieldIlEEvRKNS_8FieldDefEPKNS_5TableEbi: 263| 39.7k| int indent) { 264| 39.7k| if (fixed) { ------------------ | Branch (264:9): [True: 0, False: 39.7k] ------------------ 265| 0| PrintScalar( 266| 0| reinterpret_cast(table)->GetField(fd.value.offset), 267| 0| fd.value.type, indent); 268| 39.7k| } else if (fd.IsOptional()) { ------------------ | Branch (268:16): [True: 0, False: 39.7k] ------------------ 269| 0| auto opt = table->GetOptional(fd.value.offset); 270| 0| if (opt) { ------------------ | Branch (270:11): [True: 0, False: 0] ------------------ 271| 0| PrintScalar(*opt, fd.value.type, indent); 272| 0| } else { 273| 0| text += "null"; 274| 0| } 275| 39.7k| } else { 276| 39.7k| PrintScalar(table->GetField(fd.value.offset, GetFieldDefault(fd)), 277| 39.7k| fd.value.type, indent); 278| 39.7k| } 279| 39.7k| } _ZN11flatbuffers11JsonPrinter11PrintScalarIlEEvT_RKNS_4TypeEi: 64| 39.7k| void PrintScalar(T val, const Type& type, int /*indent*/) { 65| 39.7k| if (IsBool(type.base_type)) { ------------------ | Branch (65:9): [True: 0, False: 39.7k] ------------------ 66| 0| text += val != 0 ? "true" : "false"; ------------------ | Branch (66:15): [True: 0, False: 0] ------------------ 67| 0| return; // done 68| 0| } 69| | 70| 39.7k| if (opts.output_enum_identifiers && type.enum_def) { ------------------ | Branch (70:9): [True: 39.7k, False: 0] | Branch (70:41): [True: 0, False: 39.7k] ------------------ 71| 0| const auto& enum_def = *type.enum_def; 72| 0| if (auto ev = enum_def.ReverseLookup(static_cast(val))) { ------------------ | Branch (72:16): [True: 0, False: 0] ------------------ 73| 0| text += '\"'; 74| 0| text += ev->name; 75| 0| text += '\"'; 76| 0| return; // done 77| 0| } else if (val && enum_def.attributes.Lookup("bit_flags")) { ------------------ | Branch (77:18): [True: 0, False: 0] | Branch (77:18): [True: 0, False: 0] | Branch (77:25): [True: 0, False: 0] ------------------ 78| 0| const auto entry_len = text.length(); 79| 0| const auto u64 = static_cast(val); 80| 0| uint64_t mask = 0; 81| 0| text += '\"'; 82| 0| for (auto it = enum_def.Vals().begin(), e = enum_def.Vals().end(); 83| 0| it != e; ++it) { ------------------ | Branch (83:14): [True: 0, False: 0] ------------------ 84| 0| auto f = (*it)->GetAsUInt64(); 85| 0| if (f & u64) { ------------------ | Branch (85:15): [True: 0, False: 0] ------------------ 86| 0| mask |= f; 87| 0| text += (*it)->name; 88| 0| text += ' '; 89| 0| } 90| 0| } 91| | // Don't slice if (u64 != mask) 92| 0| if (mask && (u64 == mask)) { ------------------ | Branch (92:13): [True: 0, False: 0] | Branch (92:21): [True: 0, False: 0] ------------------ 93| 0| text[text.length() - 1] = '\"'; 94| 0| return; // done 95| 0| } 96| 0| text.resize(entry_len); // restore 97| 0| } 98| | // print as numeric value 99| 0| } 100| | 101| 39.7k| text += NumToString(val); 102| 39.7k| return; 103| 39.7k| } _ZN11flatbuffers11JsonPrinter15GetFieldDefaultIlEET_RKNS_8FieldDefE: 252| 39.7k| static T GetFieldDefault(const FieldDef& fd) { 253| 39.7k| T val{}; 254| 39.7k| auto check = StringToNumber(fd.value.constant.c_str(), &val); 255| 39.7k| (void)check; 256| 39.7k| FLATBUFFERS_ASSERT(check); 257| 39.7k| return val; 258| 39.7k| } _ZN11flatbuffers11JsonPrinter8GenFieldImEEvRKNS_8FieldDefEPKNS_5TableEbi: 263| 60.9k| int indent) { 264| 60.9k| if (fixed) { ------------------ | Branch (264:9): [True: 0, False: 60.9k] ------------------ 265| 0| PrintScalar( 266| 0| reinterpret_cast(table)->GetField(fd.value.offset), 267| 0| fd.value.type, indent); 268| 60.9k| } else if (fd.IsOptional()) { ------------------ | Branch (268:16): [True: 0, False: 60.9k] ------------------ 269| 0| auto opt = table->GetOptional(fd.value.offset); 270| 0| if (opt) { ------------------ | Branch (270:11): [True: 0, False: 0] ------------------ 271| 0| PrintScalar(*opt, fd.value.type, indent); 272| 0| } else { 273| 0| text += "null"; 274| 0| } 275| 60.9k| } else { 276| 60.9k| PrintScalar(table->GetField(fd.value.offset, GetFieldDefault(fd)), 277| 60.9k| fd.value.type, indent); 278| 60.9k| } 279| 60.9k| } _ZN11flatbuffers11JsonPrinter11PrintScalarImEEvT_RKNS_4TypeEi: 64| 60.9k| void PrintScalar(T val, const Type& type, int /*indent*/) { 65| 60.9k| if (IsBool(type.base_type)) { ------------------ | Branch (65:9): [True: 0, False: 60.9k] ------------------ 66| 0| text += val != 0 ? "true" : "false"; ------------------ | Branch (66:15): [True: 0, False: 0] ------------------ 67| 0| return; // done 68| 0| } 69| | 70| 60.9k| if (opts.output_enum_identifiers && type.enum_def) { ------------------ | Branch (70:9): [True: 60.9k, False: 0] | Branch (70:41): [True: 0, False: 60.9k] ------------------ 71| 0| const auto& enum_def = *type.enum_def; 72| 0| if (auto ev = enum_def.ReverseLookup(static_cast(val))) { ------------------ | Branch (72:16): [True: 0, False: 0] ------------------ 73| 0| text += '\"'; 74| 0| text += ev->name; 75| 0| text += '\"'; 76| 0| return; // done 77| 0| } else if (val && enum_def.attributes.Lookup("bit_flags")) { ------------------ | Branch (77:18): [True: 0, False: 0] | Branch (77:18): [True: 0, False: 0] | Branch (77:25): [True: 0, False: 0] ------------------ 78| 0| const auto entry_len = text.length(); 79| 0| const auto u64 = static_cast(val); 80| 0| uint64_t mask = 0; 81| 0| text += '\"'; 82| 0| for (auto it = enum_def.Vals().begin(), e = enum_def.Vals().end(); 83| 0| it != e; ++it) { ------------------ | Branch (83:14): [True: 0, False: 0] ------------------ 84| 0| auto f = (*it)->GetAsUInt64(); 85| 0| if (f & u64) { ------------------ | Branch (85:15): [True: 0, False: 0] ------------------ 86| 0| mask |= f; 87| 0| text += (*it)->name; 88| 0| text += ' '; 89| 0| } 90| 0| } 91| | // Don't slice if (u64 != mask) 92| 0| if (mask && (u64 == mask)) { ------------------ | Branch (92:13): [True: 0, False: 0] | Branch (92:21): [True: 0, False: 0] ------------------ 93| 0| text[text.length() - 1] = '\"'; 94| 0| return; // done 95| 0| } 96| 0| text.resize(entry_len); // restore 97| 0| } 98| | // print as numeric value 99| 0| } 100| | 101| 60.9k| text += NumToString(val); 102| 60.9k| return; 103| 60.9k| } _ZN11flatbuffers11JsonPrinter15GetFieldDefaultImEET_RKNS_8FieldDefE: 252| 60.9k| static T GetFieldDefault(const FieldDef& fd) { 253| 60.9k| T val{}; 254| 60.9k| auto check = StringToNumber(fd.value.constant.c_str(), &val); 255| 60.9k| (void)check; 256| 60.9k| FLATBUFFERS_ASSERT(check); 257| 60.9k| return val; 258| 60.9k| } _ZN11flatbuffers11JsonPrinter8GenFieldIfEEvRKNS_8FieldDefEPKNS_5TableEbi: 263| 46.6k| int indent) { 264| 46.6k| if (fixed) { ------------------ | Branch (264:9): [True: 0, False: 46.6k] ------------------ 265| 0| PrintScalar( 266| 0| reinterpret_cast(table)->GetField(fd.value.offset), 267| 0| fd.value.type, indent); 268| 46.6k| } else if (fd.IsOptional()) { ------------------ | Branch (268:16): [True: 0, False: 46.6k] ------------------ 269| 0| auto opt = table->GetOptional(fd.value.offset); 270| 0| if (opt) { ------------------ | Branch (270:11): [True: 0, False: 0] ------------------ 271| 0| PrintScalar(*opt, fd.value.type, indent); 272| 0| } else { 273| 0| text += "null"; 274| 0| } 275| 46.6k| } else { 276| 46.6k| PrintScalar(table->GetField(fd.value.offset, GetFieldDefault(fd)), 277| 46.6k| fd.value.type, indent); 278| 46.6k| } 279| 46.6k| } _ZN11flatbuffers11JsonPrinter11PrintScalarIfEEvT_RKNS_4TypeEi: 64| 46.6k| void PrintScalar(T val, const Type& type, int /*indent*/) { 65| 46.6k| if (IsBool(type.base_type)) { ------------------ | Branch (65:9): [True: 0, False: 46.6k] ------------------ 66| 0| text += val != 0 ? "true" : "false"; ------------------ | Branch (66:15): [True: 0, False: 0] ------------------ 67| 0| return; // done 68| 0| } 69| | 70| 46.6k| if (opts.output_enum_identifiers && type.enum_def) { ------------------ | Branch (70:9): [True: 46.6k, False: 0] | Branch (70:41): [True: 0, False: 46.6k] ------------------ 71| 0| const auto& enum_def = *type.enum_def; 72| 0| if (auto ev = enum_def.ReverseLookup(static_cast(val))) { ------------------ | Branch (72:16): [True: 0, False: 0] ------------------ 73| 0| text += '\"'; 74| 0| text += ev->name; 75| 0| text += '\"'; 76| 0| return; // done 77| 0| } else if (val && enum_def.attributes.Lookup("bit_flags")) { ------------------ | Branch (77:18): [True: 0, False: 0] | Branch (77:18): [True: 0, False: 0] | Branch (77:25): [True: 0, False: 0] ------------------ 78| 0| const auto entry_len = text.length(); 79| 0| const auto u64 = static_cast(val); 80| 0| uint64_t mask = 0; 81| 0| text += '\"'; 82| 0| for (auto it = enum_def.Vals().begin(), e = enum_def.Vals().end(); 83| 0| it != e; ++it) { ------------------ | Branch (83:14): [True: 0, False: 0] ------------------ 84| 0| auto f = (*it)->GetAsUInt64(); 85| 0| if (f & u64) { ------------------ | Branch (85:15): [True: 0, False: 0] ------------------ 86| 0| mask |= f; 87| 0| text += (*it)->name; 88| 0| text += ' '; 89| 0| } 90| 0| } 91| | // Don't slice if (u64 != mask) 92| 0| if (mask && (u64 == mask)) { ------------------ | Branch (92:13): [True: 0, False: 0] | Branch (92:21): [True: 0, False: 0] ------------------ 93| 0| text[text.length() - 1] = '\"'; 94| 0| return; // done 95| 0| } 96| 0| text.resize(entry_len); // restore 97| 0| } 98| | // print as numeric value 99| 0| } 100| | 101| 46.6k| text += NumToString(val); 102| 46.6k| return; 103| 46.6k| } _ZN11flatbuffers11JsonPrinter15GetFieldDefaultIfEET_RKNS_8FieldDefE: 252| 46.6k| static T GetFieldDefault(const FieldDef& fd) { 253| 46.6k| T val{}; 254| 46.6k| auto check = StringToNumber(fd.value.constant.c_str(), &val); 255| 46.6k| (void)check; 256| 46.6k| FLATBUFFERS_ASSERT(check); 257| 46.6k| return val; 258| 46.6k| } _ZN11flatbuffers11JsonPrinter8GenFieldIdEEvRKNS_8FieldDefEPKNS_5TableEbi: 263| 41.8k| int indent) { 264| 41.8k| if (fixed) { ------------------ | Branch (264:9): [True: 0, False: 41.8k] ------------------ 265| 0| PrintScalar( 266| 0| reinterpret_cast(table)->GetField(fd.value.offset), 267| 0| fd.value.type, indent); 268| 41.8k| } else if (fd.IsOptional()) { ------------------ | Branch (268:16): [True: 0, False: 41.8k] ------------------ 269| 0| auto opt = table->GetOptional(fd.value.offset); 270| 0| if (opt) { ------------------ | Branch (270:11): [True: 0, False: 0] ------------------ 271| 0| PrintScalar(*opt, fd.value.type, indent); 272| 0| } else { 273| 0| text += "null"; 274| 0| } 275| 41.8k| } else { 276| 41.8k| PrintScalar(table->GetField(fd.value.offset, GetFieldDefault(fd)), 277| 41.8k| fd.value.type, indent); 278| 41.8k| } 279| 41.8k| } _ZN11flatbuffers11JsonPrinter11PrintScalarIdEEvT_RKNS_4TypeEi: 64| 41.8k| void PrintScalar(T val, const Type& type, int /*indent*/) { 65| 41.8k| if (IsBool(type.base_type)) { ------------------ | Branch (65:9): [True: 0, False: 41.8k] ------------------ 66| 0| text += val != 0 ? "true" : "false"; ------------------ | Branch (66:15): [True: 0, False: 0] ------------------ 67| 0| return; // done 68| 0| } 69| | 70| 41.8k| if (opts.output_enum_identifiers && type.enum_def) { ------------------ | Branch (70:9): [True: 41.8k, False: 0] | Branch (70:41): [True: 0, False: 41.8k] ------------------ 71| 0| const auto& enum_def = *type.enum_def; 72| 0| if (auto ev = enum_def.ReverseLookup(static_cast(val))) { ------------------ | Branch (72:16): [True: 0, False: 0] ------------------ 73| 0| text += '\"'; 74| 0| text += ev->name; 75| 0| text += '\"'; 76| 0| return; // done 77| 0| } else if (val && enum_def.attributes.Lookup("bit_flags")) { ------------------ | Branch (77:18): [True: 0, False: 0] | Branch (77:18): [True: 0, False: 0] | Branch (77:25): [True: 0, False: 0] ------------------ 78| 0| const auto entry_len = text.length(); 79| 0| const auto u64 = static_cast(val); 80| 0| uint64_t mask = 0; 81| 0| text += '\"'; 82| 0| for (auto it = enum_def.Vals().begin(), e = enum_def.Vals().end(); 83| 0| it != e; ++it) { ------------------ | Branch (83:14): [True: 0, False: 0] ------------------ 84| 0| auto f = (*it)->GetAsUInt64(); 85| 0| if (f & u64) { ------------------ | Branch (85:15): [True: 0, False: 0] ------------------ 86| 0| mask |= f; 87| 0| text += (*it)->name; 88| 0| text += ' '; 89| 0| } 90| 0| } 91| | // Don't slice if (u64 != mask) 92| 0| if (mask && (u64 == mask)) { ------------------ | Branch (92:13): [True: 0, False: 0] | Branch (92:21): [True: 0, False: 0] ------------------ 93| 0| text[text.length() - 1] = '\"'; 94| 0| return; // done 95| 0| } 96| 0| text.resize(entry_len); // restore 97| 0| } 98| | // print as numeric value 99| 0| } 100| | 101| 41.8k| text += NumToString(val); 102| 41.8k| return; 103| 41.8k| } _ZN11flatbuffers11JsonPrinter15GetFieldDefaultIdEET_RKNS_8FieldDefE: 252| 41.8k| static T GetFieldDefault(const FieldDef& fd) { 253| 41.8k| T val{}; 254| 41.8k| auto check = StringToNumber(fd.value.constant.c_str(), &val); 255| 41.8k| (void)check; 256| 41.8k| FLATBUFFERS_ASSERT(check); 257| 41.8k| return val; 258| 41.8k| } _ZN11flatbuffers11JsonPrinter10AddNewLineEv: 45| 1.16M| void AddNewLine() { 46| 1.16M| if (opts.indent_step >= 0) text += '\n'; ------------------ | Branch (46:9): [True: 0, False: 1.16M] ------------------ 47| 1.16M| } _ZN11flatbuffers6Parser7MessageERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE: 386| 578k|void Parser::Message(const std::string& msg) { 387| 578k| if (!error_.empty()) error_ += "\n"; // log all warnings and errors ------------------ | Branch (387:7): [True: 0, False: 578k] ------------------ 388| 578k| error_ += file_being_parsed_.length() ? AbsolutePath(file_being_parsed_) : ""; ------------------ | Branch (388:13): [True: 0, False: 578k] ------------------ 389| | // clang-format off 390| | 391| | #ifdef _WIN32 // MSVC alike 392| | error_ += 393| | "(" + NumToString(line_) + ", " + NumToString(CursorPosition()) + ")"; 394| | #else // gcc alike 395| 578k| if (file_being_parsed_.length()) error_ += ":"; ------------------ | Branch (395:9): [True: 0, False: 578k] ------------------ 396| 578k| error_ += NumToString(line_) + ": " + NumToString(CursorPosition()); 397| 578k| #endif 398| | // clang-format on 399| 578k| error_ += ": " + msg; 400| 578k|} _ZN11flatbuffers6Parser7WarningERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE: 402| 103k|void Parser::Warning(const std::string& msg) { 403| 103k| if (!opts.no_warnings) { ------------------ | Branch (403:7): [True: 103k, False: 0] ------------------ 404| 103k| Message("warning: " + msg); 405| 103k| has_warning_ = true; // for opts.warnings_as_errors 406| 103k| } 407| 103k|} _ZN11flatbuffers6Parser5ErrorERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE: 409| 475k|CheckedError Parser::Error(const std::string& msg) { 410| 475k| Message("error: " + msg); 411| 475k| return CheckedError(true); 412| 475k|} _ZN11flatbuffers6Parser12RecurseErrorEv: 414| 426|CheckedError Parser::RecurseError() { 415| 426| return Error("maximum parsing depth " + NumToString(parse_depth_counter_) + 416| 426| " reached"); 417| 426|} _ZNK11flatbuffers9Namespace21GetFullyQualifiedNameERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEm: 449| 310k| size_t max_components) const { 450| | // Early exit if we don't have a defined namespace. 451| 310k| if (components.empty() || !max_components) { ------------------ | Branch (451:7): [True: 310k, False: 0] | Branch (451:29): [True: 0, False: 0] ------------------ 452| 310k| return name; 453| 310k| } 454| 0| std::string stream_str; 455| 0| for (size_t i = 0; i < std::min(components.size(), max_components); i++) { ------------------ | Branch (455:22): [True: 0, False: 0] ------------------ 456| 0| stream_str += components[i]; 457| 0| stream_str += '.'; 458| 0| } 459| 0| if (!stream_str.empty()) stream_str.pop_back(); ------------------ | Branch (459:7): [True: 0, False: 0] ------------------ 460| 0| if (name.length()) { ------------------ | Branch (460:7): [True: 0, False: 0] ------------------ 461| 0| stream_str += '.'; 462| 0| stream_str += name; 463| 0| } 464| 0| return stream_str; 465| 310k|} _ZNK11flatbuffers6Parser15TokenToStringIdEi: 467| 54.6k|std::string Parser::TokenToStringId(int t) const { 468| 54.6k| return t == kTokenIdentifier ? attribute_ : TokenToString(t); ------------------ | Branch (468:10): [True: 12.7k, False: 41.8k] ------------------ 469| 54.6k|} _ZN11flatbuffers6Parser11ParseHexNumEiPm: 472| 32.4k|CheckedError Parser::ParseHexNum(int nibbles, uint64_t* val) { 473| 32.4k| FLATBUFFERS_ASSERT(nibbles > 0); 474| 134k| for (int i = 0; i < nibbles; i++) ------------------ | Branch (474:19): [True: 106k, False: 27.9k] ------------------ 475| 106k| if (!is_xdigit(cursor_[i])) ------------------ | Branch (475:9): [True: 4.42k, False: 101k] ------------------ 476| 4.42k| return Error("escape code must be followed by " + NumToString(nibbles) + 477| 4.42k| " hex digits"); 478| 27.9k| std::string target(cursor_, cursor_ + nibbles); 479| 27.9k| *val = StringToUInt(target.c_str(), 16); 480| 27.9k| cursor_ += nibbles; 481| 27.9k| return NoError(); 482| 32.4k|} _ZN11flatbuffers6Parser17SkipByteOrderMarkEv: 484| 769k|CheckedError Parser::SkipByteOrderMark() { 485| 769k| if (static_cast(*cursor_) != 0xef) return NoError(); ------------------ | Branch (485:7): [True: 769k, False: 0] ------------------ 486| 0| cursor_++; 487| 0| if (static_cast(*cursor_) != 0xbb) ------------------ | Branch (487:7): [True: 0, False: 0] ------------------ 488| 0| return Error("invalid utf-8 byte order mark"); 489| 0| cursor_++; 490| 0| if (static_cast(*cursor_) != 0xbf) ------------------ | Branch (490:7): [True: 0, False: 0] ------------------ 491| 0| return Error("invalid utf-8 byte order mark"); 492| 0| cursor_++; 493| 0| return NoError(); 494| 0|} _ZN11flatbuffers6Parser4NextEv: 496| 5.72M|CheckedError Parser::Next() { 497| 5.72M| doc_comment_.clear(); 498| 5.72M| prev_cursor_ = cursor_; 499| 5.72M| bool seen_newline = cursor_ == source_; 500| 5.72M| attribute_.clear(); 501| 5.72M| attr_is_trivial_ascii_string_ = true; 502| 8.94M| for (;;) { 503| 8.94M| char c = *cursor_++; 504| 8.94M| token_ = c; 505| 8.94M| switch (c) { 506| 803k| case '\0': ------------------ | Branch (506:7): [True: 803k, False: 8.13M] ------------------ 507| 803k| cursor_--; 508| 803k| token_ = kTokenEof; 509| 803k| return NoError(); 510| 3.13M| case ' ': ------------------ | Branch (510:7): [True: 3.13M, False: 5.81M] ------------------ 511| 3.13M| case '\r': ------------------ | Branch (511:7): [True: 5.21k, False: 8.93M] ------------------ 512| 3.14M| case '\t': ------------------ | Branch (512:7): [True: 7.03k, False: 8.93M] ------------------ 513| 3.14M| break; 514| 73.3k| case '\n': ------------------ | Branch (514:7): [True: 73.3k, False: 8.87M] ------------------ 515| 73.3k| MarkNewLine(); 516| 73.3k| seen_newline = true; 517| 73.3k| break; 518| 868k| case '{': ------------------ | Branch (518:7): [True: 868k, False: 8.07M] ------------------ 519| 1.50M| case '}': ------------------ | Branch (519:7): [True: 634k, False: 8.30M] ------------------ 520| 1.56M| case '(': ------------------ | Branch (520:7): [True: 67.1k, False: 8.87M] ------------------ 521| 1.57M| case ')': ------------------ | Branch (521:7): [True: 4.72k, False: 8.93M] ------------------ 522| 1.57M| case '[': ------------------ | Branch (522:7): [True: 1.42k, False: 8.94M] ------------------ 523| 1.57M| case ']': ------------------ | Branch (523:7): [True: 1.40k, False: 8.94M] ------------------ 524| 1.57M| case '<': ------------------ | Branch (524:7): [True: 998, False: 8.94M] ------------------ 525| 1.57M| case '>': ------------------ | Branch (525:7): [True: 800, False: 8.94M] ------------------ 526| 1.60M| case ',': ------------------ | Branch (526:7): [True: 27.2k, False: 8.91M] ------------------ 527| 2.39M| case ':': ------------------ | Branch (527:7): [True: 790k, False: 8.15M] ------------------ 528| 2.60M| case ';': ------------------ | Branch (528:7): [True: 207k, False: 8.73M] ------------------ 529| 2.70M| case '=': ------------------ | Branch (529:7): [True: 99.1k, False: 8.84M] ------------------ 530| 2.70M| return NoError(); 531| 860k| case '\"': ------------------ | Branch (531:7): [True: 860k, False: 8.08M] ------------------ 532| 1.06M| case '\'': { ------------------ | Branch (532:7): [True: 207k, False: 8.73M] ------------------ 533| 1.06M| int unicode_high_surrogate = -1; 534| | 535| 25.6M| while (*cursor_ != c) { ------------------ | Branch (535:16): [True: 24.5M, False: 1.03M] ------------------ 536| 24.5M| if (*cursor_ < ' ' && static_cast(*cursor_) >= 0) ------------------ | Branch (536:15): [True: 385k, False: 24.2M] | Branch (536:33): [True: 21.8k, False: 363k] ------------------ 537| 21.8k| return Error("illegal character in string constant"); 538| 24.5M| if (*cursor_ == '\\') { ------------------ | Branch (538:15): [True: 57.1k, False: 24.5M] ------------------ 539| 57.1k| attr_is_trivial_ascii_string_ = false; // has escape sequence 540| 57.1k| cursor_++; 541| 57.1k| if (unicode_high_surrogate != -1 && *cursor_ != 'u') { ------------------ | Branch (541:17): [True: 7.06k, False: 50.1k] | Branch (541:49): [True: 1.10k, False: 5.95k] ------------------ 542| 1.10k| return Error( 543| 1.10k| "illegal Unicode sequence (unpaired high surrogate)"); 544| 1.10k| } 545| 56.0k| switch (*cursor_) { 546| 1.49k| case 'n': ------------------ | Branch (546:15): [True: 1.49k, False: 54.6k] ------------------ 547| 1.49k| attribute_ += '\n'; 548| 1.49k| cursor_++; 549| 1.49k| break; 550| 1.54k| case 't': ------------------ | Branch (550:15): [True: 1.54k, False: 54.5k] ------------------ 551| 1.54k| attribute_ += '\t'; 552| 1.54k| cursor_++; 553| 1.54k| break; 554| 1.54k| case 'r': ------------------ | Branch (554:15): [True: 1.54k, False: 54.5k] ------------------ 555| 1.54k| attribute_ += '\r'; 556| 1.54k| cursor_++; 557| 1.54k| break; 558| 1.98k| case 'b': ------------------ | Branch (558:15): [True: 1.98k, False: 54.1k] ------------------ 559| 1.98k| attribute_ += '\b'; 560| 1.98k| cursor_++; 561| 1.98k| break; 562| 1.97k| case 'f': ------------------ | Branch (562:15): [True: 1.97k, False: 54.1k] ------------------ 563| 1.97k| attribute_ += '\f'; 564| 1.97k| cursor_++; 565| 1.97k| break; 566| 4.18k| case '\"': ------------------ | Branch (566:15): [True: 4.18k, False: 51.9k] ------------------ 567| 4.18k| attribute_ += '\"'; 568| 4.18k| cursor_++; 569| 4.18k| break; 570| 3.50k| case '\'': ------------------ | Branch (570:15): [True: 3.50k, False: 52.5k] ------------------ 571| 3.50k| attribute_ += '\''; 572| 3.50k| cursor_++; 573| 3.50k| break; 574| 2.60k| case '\\': ------------------ | Branch (574:15): [True: 2.60k, False: 53.4k] ------------------ 575| 2.60k| attribute_ += '\\'; 576| 2.60k| cursor_++; 577| 2.60k| break; 578| 3.13k| case '/': ------------------ | Branch (578:15): [True: 3.13k, False: 52.9k] ------------------ 579| 3.13k| attribute_ += '/'; 580| 3.13k| cursor_++; 581| 3.13k| break; 582| 7.48k| case 'x': { // Not in the JSON standard ------------------ | Branch (582:15): [True: 7.48k, False: 48.6k] ------------------ 583| 7.48k| cursor_++; 584| 7.48k| uint64_t val; 585| 7.48k| ECHECK(ParseHexNum(2, &val)); ------------------ | | 56| 7.48k| { \ | | 57| 7.48k| auto ce = (call); \ | | 58| 7.48k| if (ce.Check()) return ce; \ | | ------------------ | | | Branch (58:9): [True: 816, False: 6.66k] | | ------------------ | | 59| 7.48k| } ------------------ 586| 6.66k| attribute_ += static_cast(val); 587| 6.66k| break; 588| 7.48k| } 589| 24.9k| case 'u': { ------------------ | Branch (589:15): [True: 24.9k, False: 31.1k] ------------------ 590| 24.9k| cursor_++; 591| 24.9k| uint64_t val; 592| 24.9k| ECHECK(ParseHexNum(4, &val)); ------------------ | | 56| 24.9k| { \ | | 57| 24.9k| auto ce = (call); \ | | 58| 24.9k| if (ce.Check()) return ce; \ | | ------------------ | | | Branch (58:9): [True: 3.60k, False: 21.3k] | | ------------------ | | 59| 24.9k| } ------------------ 593| 21.3k| if (val >= 0xD800 && val <= 0xDBFF) { ------------------ | Branch (593:21): [True: 17.3k, False: 4.00k] | Branch (593:38): [True: 9.87k, False: 7.42k] ------------------ 594| 9.87k| if (unicode_high_surrogate != -1) { ------------------ | Branch (594:23): [True: 731, False: 9.14k] ------------------ 595| 731| return Error( 596| 731| "illegal Unicode sequence (multiple high surrogates)"); 597| 9.14k| } else { 598| 9.14k| unicode_high_surrogate = static_cast(val); 599| 9.14k| } 600| 11.4k| } else if (val >= 0xDC00 && val <= 0xDFFF) { ------------------ | Branch (600:28): [True: 7.42k, False: 4.00k] | Branch (600:45): [True: 5.24k, False: 2.18k] ------------------ 601| 5.24k| if (unicode_high_surrogate == -1) { ------------------ | Branch (601:23): [True: 1.31k, False: 3.93k] ------------------ 602| 1.31k| return Error( 603| 1.31k| "illegal Unicode sequence (unpaired low surrogate)"); 604| 3.93k| } else { 605| 3.93k| int code_point = 0x10000 + 606| 3.93k| ((unicode_high_surrogate & 0x03FF) << 10) + 607| 3.93k| (val & 0x03FF); 608| 3.93k| ToUTF8(code_point, &attribute_); 609| 3.93k| unicode_high_surrogate = -1; 610| 3.93k| } 611| 6.18k| } else { 612| 6.18k| if (unicode_high_surrogate != -1) { ------------------ | Branch (612:23): [True: 479, False: 5.70k] ------------------ 613| 479| return Error( 614| 479| "illegal Unicode sequence (unpaired high surrogate)"); 615| 479| } 616| 5.70k| ToUTF8(static_cast(val), &attribute_); 617| 5.70k| } 618| 18.7k| break; 619| 21.3k| } 620| 18.7k| default: ------------------ | Branch (620:15): [True: 1.71k, False: 54.3k] ------------------ 621| 1.71k| return Error("unknown escape code in string constant"); 622| 56.0k| } 623| 24.5M| } else { // printable chars + UTF-8 bytes 624| 24.5M| if (unicode_high_surrogate != -1) { ------------------ | Branch (624:17): [True: 1.13k, False: 24.5M] ------------------ 625| 1.13k| return Error( 626| 1.13k| "illegal Unicode sequence (unpaired high surrogate)"); 627| 1.13k| } 628| | // reset if non-printable 629| 24.5M| attr_is_trivial_ascii_string_ &= 630| 24.5M| check_ascii_range(*cursor_, ' ', '~'); 631| | 632| 24.5M| attribute_ += *cursor_++; 633| 24.5M| } 634| 24.5M| } 635| 1.03M| if (unicode_high_surrogate != -1) { ------------------ | Branch (635:13): [True: 956, False: 1.03M] ------------------ 636| 956| return Error("illegal Unicode sequence (unpaired high surrogate)"); 637| 956| } 638| 1.03M| cursor_++; 639| 1.03M| if (!attr_is_trivial_ascii_string_ && !opts.allow_non_utf8 && ------------------ | Branch (639:13): [True: 51.6k, False: 982k] | Branch (639:47): [True: 51.6k, False: 0] ------------------ 640| 51.6k| !ValidateUTF8(attribute_)) { ------------------ | Branch (640:13): [True: 24.6k, False: 26.9k] ------------------ 641| 24.6k| return Error("illegal UTF-8 sequence"); 642| 24.6k| } 643| 1.00M| token_ = kTokenStringConstant; 644| 1.00M| return NoError(); 645| 1.03M| } 646| 3.69k| case '/': ------------------ | Branch (646:7): [True: 3.69k, False: 8.93M] ------------------ 647| 3.69k| if (*cursor_ == '/') { ------------------ | Branch (647:13): [True: 0, False: 3.69k] ------------------ 648| 0| const char* start = ++cursor_; 649| 0| while (*cursor_ && *cursor_ != '\n' && *cursor_ != '\r') cursor_++; ------------------ | Branch (649:18): [True: 0, False: 0] | Branch (649:30): [True: 0, False: 0] | Branch (649:50): [True: 0, False: 0] ------------------ 650| 0| if (*start == '/') { // documentation comment ------------------ | Branch (650:15): [True: 0, False: 0] ------------------ 651| 0| if (!seen_newline) ------------------ | Branch (651:17): [True: 0, False: 0] ------------------ 652| 0| return Error( 653| 0| "a documentation comment should be on a line on its own"); 654| 0| doc_comment_.push_back(std::string(start + 1, cursor_)); 655| 0| } 656| 0| break; 657| 3.69k| } else if (*cursor_ == '*') { ------------------ | Branch (657:20): [True: 0, False: 3.69k] ------------------ 658| 0| cursor_++; 659| | // TODO: make nested. 660| 0| while (*cursor_ != '*' || cursor_[1] != '/') { ------------------ | Branch (660:18): [True: 0, False: 0] | Branch (660:37): [True: 0, False: 0] ------------------ 661| 0| if (*cursor_ == '\n') MarkNewLine(); ------------------ | Branch (661:17): [True: 0, False: 0] ------------------ 662| 0| if (!*cursor_) return Error("end of file in comment"); ------------------ | Branch (662:17): [True: 0, False: 0] ------------------ 663| 0| cursor_++; 664| 0| } 665| 0| cursor_ += 2; 666| 0| break; 667| 0| } 668| 3.69k| FLATBUFFERS_FALLTHROUGH(); // else fall thru ------------------ | | 306| 3.69k| #define FLATBUFFERS_FALLTHROUGH() [[fallthrough]] ------------------ 669| 1.15M| default: ------------------ | Branch (669:7): [True: 1.14M, False: 7.79M] ------------------ 670| 1.15M| if (IsIdentifierStart(c)) { ------------------ | Branch (670:13): [True: 758k, False: 393k] ------------------ 671| | // Collect all chars of an identifier: 672| 758k| const char* start = cursor_ - 1; 673| 4.19M| while (IsIdentifierStart(*cursor_) || is_digit(*cursor_)) cursor_++; ------------------ | Branch (673:18): [True: 2.57M, False: 1.62M] | Branch (673:49): [True: 862k, False: 758k] ------------------ 674| 758k| attribute_.append(start, cursor_); 675| 758k| token_ = kTokenIdentifier; 676| 758k| return NoError(); 677| 758k| } 678| | 679| 393k| const auto has_sign = (c == '+') || (c == '-'); ------------------ | Branch (679:31): [True: 21.7k, False: 371k] | Branch (679:45): [True: 92.6k, False: 279k] ------------------ 680| 393k| if (has_sign) { ------------------ | Branch (680:13): [True: 114k, False: 279k] ------------------ 681| | // Check for +/-inf which is considered a float constant. 682| 114k| if (strncmp(cursor_, "inf", 3) == 0 && ------------------ | Branch (682:15): [True: 12.8k, False: 101k] ------------------ 683| 12.8k| !(IsIdentifierStart(cursor_[3]) || is_digit(cursor_[3]))) { ------------------ | Branch (683:17): [True: 4.28k, False: 8.60k] | Branch (683:50): [True: 3.62k, False: 4.97k] ------------------ 684| 4.97k| attribute_.assign(cursor_ - 1, cursor_ + 3); 685| 4.97k| token_ = kTokenFloatConstant; 686| 4.97k| cursor_ += 3; 687| 4.97k| return NoError(); 688| 4.97k| } 689| | 690| 109k| if (IsIdentifierStart(*cursor_)) { ------------------ | Branch (690:15): [True: 29.7k, False: 79.6k] ------------------ 691| | // '-'/'+' and following identifier - it could be a predefined 692| | // constant. Return the sign in token_, see ParseSingleValue. 693| 29.7k| return NoError(); 694| 29.7k| } 695| 109k| } 696| | 697| 358k| auto dot_lvl = 698| 358k| (c == '.') ? 0 : 1; // dot_lvl==0 <=> exactly one '.' seen ------------------ | Branch (698:13): [True: 6.44k, False: 352k] ------------------ 699| 358k| if (!dot_lvl && !is_digit(*cursor_)) return NoError(); // enum? ------------------ | Branch (699:13): [True: 6.44k, False: 352k] | Branch (699:25): [True: 2.48k, False: 3.96k] ------------------ 700| | // Parser accepts hexadecimal-floating-literal (see C++ 5.13.4). 701| 356k| if (is_digit(c) || has_sign || !dot_lvl) { ------------------ | Branch (701:13): [True: 216k, False: 139k] | Branch (701:28): [True: 79.6k, False: 60.2k] | Branch (701:40): [True: 3.96k, False: 56.3k] ------------------ 702| 300k| const auto start = cursor_ - 1; 703| 300k| auto start_digits = !is_digit(c) ? cursor_ : cursor_ - 1; ------------------ | Branch (703:31): [True: 83.6k, False: 216k] ------------------ 704| 300k| if (!is_digit(c) && is_digit(*cursor_)) { ------------------ | Branch (704:15): [True: 83.6k, False: 216k] | Branch (704:31): [True: 74.8k, False: 8.72k] ------------------ 705| 74.8k| start_digits = cursor_; // see digit in cursor_ position 706| 74.8k| c = *cursor_++; 707| 74.8k| } 708| | // hex-float can't begind with '.' 709| 300k| auto use_hex = dot_lvl && (c == '0') && is_alpha_char(*cursor_, 'X'); ------------------ | Branch (709:26): [True: 296k, False: 3.96k] | Branch (709:37): [True: 116k, False: 179k] | Branch (709:51): [True: 61.8k, False: 54.6k] ------------------ 710| 300k| if (use_hex) start_digits = ++cursor_; // '0x' is the prefix, skip it ------------------ | Branch (710:15): [True: 61.8k, False: 238k] ------------------ 711| | // Read an integer number or mantisa of float-point number. 712| 308k| do { 713| 308k| if (use_hex) { ------------------ | Branch (713:17): [True: 63.6k, False: 245k] ------------------ 714| 2.17M| while (is_xdigit(*cursor_)) cursor_++; ------------------ | Branch (714:22): [True: 2.11M, False: 63.6k] ------------------ 715| 245k| } else { 716| 8.27M| while (is_digit(*cursor_)) cursor_++; ------------------ | Branch (716:22): [True: 8.02M, False: 245k] ------------------ 717| 245k| } 718| 308k| } while ((*cursor_ == '.') && (++cursor_) && (--dot_lvl >= 0)); ------------------ | Branch (718:20): [True: 9.90k, False: 299k] | Branch (718:41): [True: 9.90k, False: 0] | Branch (718:56): [True: 8.81k, False: 1.08k] ------------------ 719| | // Exponent of float-point number. 720| 300k| if ((dot_lvl >= 0) && (cursor_ > start_digits)) { ------------------ | Branch (720:15): [True: 299k, False: 1.08k] | Branch (720:33): [True: 287k, False: 11.4k] ------------------ 721| | // The exponent suffix of hexadecimal float number is mandatory. 722| 287k| if (use_hex && !dot_lvl) start_digits = cursor_; ------------------ | Branch (722:17): [True: 56.6k, False: 230k] | Branch (722:28): [True: 1.79k, False: 54.8k] ------------------ 723| 287k| if ((use_hex && is_alpha_char(*cursor_, 'P')) || ------------------ | Branch (723:18): [True: 56.6k, False: 230k] | Branch (723:29): [True: 1.28k, False: 55.3k] ------------------ 724| 286k| is_alpha_char(*cursor_, 'E')) { ------------------ | Branch (724:17): [True: 12.8k, False: 273k] ------------------ 725| 14.1k| dot_lvl = 0; // Emulate dot to signal about float-point number. 726| 14.1k| cursor_++; 727| 14.1k| if (*cursor_ == '+' || *cursor_ == '-') cursor_++; ------------------ | Branch (727:19): [True: 1.42k, False: 12.7k] | Branch (727:38): [True: 2.32k, False: 10.4k] ------------------ 728| 14.1k| start_digits = cursor_; // the exponent-part has to have digits 729| | // Exponent is decimal integer number 730| 104k| while (is_digit(*cursor_)) cursor_++; ------------------ | Branch (730:22): [True: 90.6k, False: 14.1k] ------------------ 731| 14.1k| if (*cursor_ == '.') { ------------------ | Branch (731:19): [True: 904, False: 13.2k] ------------------ 732| 904| cursor_++; // If see a dot treat it as part of invalid number. 733| 904| dot_lvl = -1; // Fall thru to Error(). 734| 904| } 735| 14.1k| } 736| 287k| } 737| | // Finalize. 738| 300k| if ((dot_lvl >= 0) && (cursor_ > start_digits)) { ------------------ | Branch (738:15): [True: 298k, False: 1.98k] | Branch (738:33): [True: 278k, False: 19.2k] ------------------ 739| 278k| attribute_.append(start, cursor_); 740| 278k| token_ = dot_lvl ? kTokenIntegerConstant : kTokenFloatConstant; ------------------ | Branch (740:22): [True: 263k, False: 15.7k] ------------------ 741| 278k| return NoError(); 742| 278k| } else { 743| 21.2k| return Error("invalid number: " + std::string(start, cursor_)); 744| 21.2k| } 745| 300k| } 746| 56.3k| std::string ch; 747| 56.3k| ch = c; 748| 56.3k| if (false == check_ascii_range(c, ' ', '~')) ------------------ | Branch (748:13): [True: 24.6k, False: 31.6k] ------------------ 749| 24.6k| ch = "code: " + NumToString(c); 750| 56.3k| return Error("illegal character: " + ch); 751| 8.94M| } 752| 8.94M| } 753| 5.72M|} _ZNK11flatbuffers6Parser2IsEi: 756| 3.76M|bool Parser::Is(int t) const { return t == token_; } _ZNK11flatbuffers6Parser7IsIdentEPKc: 758| 3.73M|bool Parser::IsIdent(const char* id) const { 759| 3.73M| return token_ == kTokenIdentifier && attribute_ == id; ------------------ | Branch (759:10): [True: 3.11M, False: 617k] | Branch (759:40): [True: 312k, False: 2.80M] ------------------ 760| 3.73M|} _ZN11flatbuffers6Parser6ExpectEi: 763| 2.70M|CheckedError Parser::Expect(int t) { 764| 2.70M| if (t != token_) { ------------------ | Branch (764:7): [True: 36.1k, False: 2.66M] ------------------ 765| 36.1k| return Error("expecting: " + TokenToString(t) + 766| 36.1k| " instead got: " + TokenToStringId(token_)); 767| 36.1k| } 768| 2.66M| NEXT(); ------------------ | | 63| 2.66M|#define NEXT() ECHECK(Next()) | | ------------------ | | | | 56| 2.66M| { \ | | | | 57| 2.66M| auto ce = (call); \ | | | | 58| 2.66M| if (ce.Check()) return ce; \ | | | | ------------------ | | | | | Branch (58:9): [True: 108k, False: 2.56M] | | | | ------------------ | | | | 59| 2.66M| } | | ------------------ ------------------ 769| 2.56M| return NoError(); 770| 2.66M|} _ZN11flatbuffers6Parser16ParseNamespacingEPNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES8_: 772| 103k|CheckedError Parser::ParseNamespacing(std::string* id, std::string* last) { 773| 103k| while (Is('.')) { ------------------ | Branch (773:10): [True: 0, False: 103k] ------------------ 774| 0| NEXT(); ------------------ | | 63| 0|#define NEXT() ECHECK(Next()) | | ------------------ | | | | 56| 0| { \ | | | | 57| 0| auto ce = (call); \ | | | | 58| 0| if (ce.Check()) return ce; \ | | | | ------------------ | | | | | Branch (58:9): [True: 0, False: 0] | | | | ------------------ | | | | 59| 0| } | | ------------------ ------------------ 775| 0| *id += "."; 776| 0| *id += attribute_; 777| 0| if (last) *last = attribute_; ------------------ | Branch (777:9): [True: 0, False: 0] ------------------ 778| 0| EXPECT(kTokenIdentifier); ------------------ | | 64| 0|#define EXPECT(tok) ECHECK(Expect(tok)) | | ------------------ | | | | 56| 0| { \ | | | | 57| 0| auto ce = (call); \ | | | | 58| 0| if (ce.Check()) return ce; \ | | | | ------------------ | | | | | Branch (58:9): [True: 0, False: 0] | | | | ------------------ | | | | 59| 0| } | | ------------------ ------------------ 779| 0| } 780| 103k| return NoError(); 781| 103k|} _ZN11flatbuffers6Parser10LookupEnumERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE: 783| 3.24k|EnumDef* Parser::LookupEnum(const std::string& id) { 784| | // Search thru parent namespaces. 785| 3.24k| return LookupTableByName(enums_, id, *current_namespace_, 0); 786| 3.24k|} _ZNK11flatbuffers6Parser12LookupStructERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE: 788| 517k|StructDef* Parser::LookupStruct(const std::string& id) const { 789| 517k| auto sd = structs_.Lookup(id); 790| 517k| if (sd) sd->refcount++; ------------------ | Branch (790:7): [True: 103k, False: 413k] ------------------ 791| 517k| return sd; 792| 517k|} _ZNK11flatbuffers6Parser32LookupStructThruParentNamespacesERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE: 795| 103k| const std::string& id) const { 796| 103k| auto sd = LookupTableByName(structs_, id, *current_namespace_, 1); 797| 103k| if (sd) sd->refcount++; ------------------ | Branch (797:7): [True: 0, False: 103k] ------------------ 798| 103k| return sd; 799| 103k|} _ZN11flatbuffers6Parser9ParseTypeERNS_4TypeE: 817| 103k|CheckedError Parser::ParseType(Type& type) { 818| 103k| if (token_ == kTokenIdentifier) { ------------------ | Branch (818:7): [True: 103k, False: 0] ------------------ 819| 103k| if (IsIdent("bool")) { ------------------ | Branch (819:9): [True: 5.95k, False: 97.4k] ------------------ 820| 5.95k| type.base_type = BASE_TYPE_BOOL; 821| 5.95k| NEXT(); ------------------ | | 63| 5.95k|#define NEXT() ECHECK(Next()) | | ------------------ | | | | 56| 5.95k| { \ | | | | 57| 5.95k| auto ce = (call); \ | | | | 58| 5.95k| if (ce.Check()) return ce; \ | | | | ------------------ | | | | | Branch (58:9): [True: 0, False: 5.95k] | | | | ------------------ | | | | 59| 5.95k| } | | ------------------ ------------------ 822| 97.4k| } else if (IsIdent("byte") || IsIdent("int8")) { ------------------ | Branch (822:16): [True: 0, False: 97.4k] | Branch (822:35): [True: 6.00k, False: 91.4k] ------------------ 823| 6.00k| type.base_type = BASE_TYPE_CHAR; 824| 6.00k| NEXT(); ------------------ | | 63| 6.00k|#define NEXT() ECHECK(Next()) | | ------------------ | | | | 56| 6.00k| { \ | | | | 57| 6.00k| auto ce = (call); \ | | | | 58| 6.00k| if (ce.Check()) return ce; \ | | | | ------------------ | | | | | Branch (58:9): [True: 0, False: 6.00k] | | | | ------------------ | | | | 59| 6.00k| } | | ------------------ ------------------ 825| 91.4k| } else if (IsIdent("ubyte") || IsIdent("uint8")) { ------------------ | Branch (825:16): [True: 0, False: 91.4k] | Branch (825:36): [True: 3.55k, False: 87.8k] ------------------ 826| 3.55k| type.base_type = BASE_TYPE_UCHAR; 827| 3.55k| NEXT(); ------------------ | | 63| 3.55k|#define NEXT() ECHECK(Next()) | | ------------------ | | | | 56| 3.55k| { \ | | | | 57| 3.55k| auto ce = (call); \ | | | | 58| 3.55k| if (ce.Check()) return ce; \ | | | | ------------------ | | | | | Branch (58:9): [True: 0, False: 3.55k] | | | | ------------------ | | | | 59| 3.55k| } | | ------------------ ------------------ 828| 87.8k| } else if (IsIdent("short") || IsIdent("int16")) { ------------------ | Branch (828:16): [True: 0, False: 87.8k] | Branch (828:36): [True: 7.50k, False: 80.3k] ------------------ 829| 7.50k| type.base_type = BASE_TYPE_SHORT; 830| 7.50k| NEXT(); ------------------ | | 63| 7.50k|#define NEXT() ECHECK(Next()) | | ------------------ | | | | 56| 7.50k| { \ | | | | 57| 7.50k| auto ce = (call); \ | | | | 58| 7.50k| if (ce.Check()) return ce; \ | | | | ------------------ | | | | | Branch (58:9): [True: 0, False: 7.50k] | | | | ------------------ | | | | 59| 7.50k| } | | ------------------ ------------------ 831| 80.3k| } else if (IsIdent("ushort") || IsIdent("uint16")) { ------------------ | Branch (831:16): [True: 0, False: 80.3k] | Branch (831:37): [True: 7.69k, False: 72.7k] ------------------ 832| 7.69k| type.base_type = BASE_TYPE_USHORT; 833| 7.69k| NEXT(); ------------------ | | 63| 7.69k|#define NEXT() ECHECK(Next()) | | ------------------ | | | | 56| 7.69k| { \ | | | | 57| 7.69k| auto ce = (call); \ | | | | 58| 7.69k| if (ce.Check()) return ce; \ | | | | ------------------ | | | | | Branch (58:9): [True: 0, False: 7.69k] | | | | ------------------ | | | | 59| 7.69k| } | | ------------------ ------------------ 834| 72.7k| } else if (IsIdent("int") || IsIdent("int32")) { ------------------ | Branch (834:16): [True: 0, False: 72.7k] | Branch (834:34): [True: 12.8k, False: 59.8k] ------------------ 835| 12.8k| type.base_type = BASE_TYPE_INT; 836| 12.8k| NEXT(); ------------------ | | 63| 12.8k|#define NEXT() ECHECK(Next()) | | ------------------ | | | | 56| 12.8k| { \ | | | | 57| 12.8k| auto ce = (call); \ | | | | 58| 12.8k| if (ce.Check()) return ce; \ | | | | ------------------ | | | | | Branch (58:9): [True: 0, False: 12.8k] | | | | ------------------ | | | | 59| 12.8k| } | | ------------------ ------------------ 837| 59.8k| } else if (IsIdent("uint") || IsIdent("uint32")) { ------------------ | Branch (837:16): [True: 0, False: 59.8k] | Branch (837:35): [True: 9.19k, False: 50.6k] ------------------ 838| 9.19k| type.base_type = BASE_TYPE_UINT; 839| 9.19k| NEXT(); ------------------ | | 63| 9.19k|#define NEXT() ECHECK(Next()) | | ------------------ | | | | 56| 9.19k| { \ | | | | 57| 9.19k| auto ce = (call); \ | | | | 58| 9.19k| if (ce.Check()) return ce; \ | | | | ------------------ | | | | | Branch (58:9): [True: 0, False: 9.19k] | | | | ------------------ | | | | 59| 9.19k| } | | ------------------ ------------------ 840| 50.6k| } else if (IsIdent("long") || IsIdent("int64")) { ------------------ | Branch (840:16): [True: 0, False: 50.6k] | Branch (840:35): [True: 10.4k, False: 40.1k] ------------------ 841| 10.4k| type.base_type = BASE_TYPE_LONG; 842| 10.4k| NEXT(); ------------------ | | 63| 10.4k|#define NEXT() ECHECK(Next()) | | ------------------ | | | | 56| 10.4k| { \ | | | | 57| 10.4k| auto ce = (call); \ | | | | 58| 10.4k| if (ce.Check()) return ce; \ | | | | ------------------ | | | | | Branch (58:9): [True: 0, False: 10.4k] | | | | ------------------ | | | | 59| 10.4k| } | | ------------------ ------------------ 843| 40.1k| } else if (IsIdent("ulong") || IsIdent("uint64")) { ------------------ | Branch (843:16): [True: 0, False: 40.1k] | Branch (843:36): [True: 15.8k, False: 24.2k] ------------------ 844| 15.8k| type.base_type = BASE_TYPE_ULONG; 845| 15.8k| NEXT(); ------------------ | | 63| 15.8k|#define NEXT() ECHECK(Next()) | | ------------------ | | | | 56| 15.8k| { \ | | | | 57| 15.8k| auto ce = (call); \ | | | | 58| 15.8k| if (ce.Check()) return ce; \ | | | | ------------------ | | | | | Branch (58:9): [True: 0, False: 15.8k] | | | | ------------------ | | | | 59| 15.8k| } | | ------------------ ------------------ 846| 24.2k| } else if (IsIdent("float") || IsIdent("float32")) { ------------------ | Branch (846:16): [True: 13.0k, False: 11.2k] | Branch (846:36): [True: 0, False: 11.2k] ------------------ 847| 13.0k| type.base_type = BASE_TYPE_FLOAT; 848| 13.0k| NEXT(); ------------------ | | 63| 13.0k|#define NEXT() ECHECK(Next()) | | ------------------ | | | | 56| 13.0k| { \ | | | | 57| 13.0k| auto ce = (call); \ | | | | 58| 13.0k| if (ce.Check()) return ce; \ | | | | ------------------ | | | | | Branch (58:9): [True: 0, False: 13.0k] | | | | ------------------ | | | | 59| 13.0k| } | | ------------------ ------------------ 849| 13.0k| } else if (IsIdent("double") || IsIdent("float64")) { ------------------ | Branch (849:16): [True: 11.2k, False: 0] | Branch (849:37): [True: 0, False: 0] ------------------ 850| 11.2k| type.base_type = BASE_TYPE_DOUBLE; 851| 11.2k| NEXT(); ------------------ | | 63| 11.2k|#define NEXT() ECHECK(Next()) | | ------------------ | | | | 56| 11.2k| { \ | | | | 57| 11.2k| auto ce = (call); \ | | | | 58| 11.2k| if (ce.Check()) return ce; \ | | | | ------------------ | | | | | Branch (58:9): [True: 0, False: 11.2k] | | | | ------------------ | | | | 59| 11.2k| } | | ------------------ ------------------ 852| 11.2k| } else if (IsIdent("string")) { ------------------ | Branch (852:16): [True: 0, False: 0] ------------------ 853| 0| type.base_type = BASE_TYPE_STRING; 854| 0| NEXT(); ------------------ | | 63| 0|#define NEXT() ECHECK(Next()) | | ------------------ | | | | 56| 0| { \ | | | | 57| 0| auto ce = (call); \ | | | | 58| 0| if (ce.Check()) return ce; \ | | | | ------------------ | | | | | Branch (58:9): [True: 0, False: 0] | | | | ------------------ | | | | 59| 0| } | | ------------------ ------------------ 855| 0| } else { 856| 0| ECHECK(ParseTypeIdent(type)); ------------------ | | 56| 0| { \ | | 57| 0| auto ce = (call); \ | | 58| 0| if (ce.Check()) return ce; \ | | ------------------ | | | Branch (58:9): [True: 0, False: 0] | | ------------------ | | 59| 0| } ------------------ 857| 0| } 858| 103k| } else if (token_ == '[') { ------------------ | Branch (858:14): [True: 0, False: 0] ------------------ 859| 0| ParseDepthGuard depth_guard(this); 860| 0| ECHECK(depth_guard.Check()); ------------------ | | 56| 0| { \ | | 57| 0| auto ce = (call); \ | | 58| 0| if (ce.Check()) return ce; \ | | ------------------ | | | Branch (58:9): [True: 0, False: 0] | | ------------------ | | 59| 0| } ------------------ 861| 0| NEXT(); ------------------ | | 63| 0|#define NEXT() ECHECK(Next()) | | ------------------ | | | | 56| 0| { \ | | | | 57| 0| auto ce = (call); \ | | | | 58| 0| if (ce.Check()) return ce; \ | | | | ------------------ | | | | | Branch (58:9): [True: 0, False: 0] | | | | ------------------ | | | | 59| 0| } | | ------------------ ------------------ 862| 0| Type subtype; 863| 0| ECHECK(ParseType(subtype)); ------------------ | | 56| 0| { \ | | 57| 0| auto ce = (call); \ | | 58| 0| if (ce.Check()) return ce; \ | | ------------------ | | | Branch (58:9): [True: 0, False: 0] | | ------------------ | | 59| 0| } ------------------ 864| 0| if (IsSeries(subtype)) { ------------------ | Branch (864:9): [True: 0, False: 0] ------------------ 865| | // We could support this, but it will complicate things, and it's 866| | // easier to work around with a struct around the inner vector. 867| 0| return Error("nested vector types not supported (wrap in table first)"); 868| 0| } 869| 0| if (token_ == ':') { ------------------ | Branch (869:9): [True: 0, False: 0] ------------------ 870| 0| NEXT(); ------------------ | | 63| 0|#define NEXT() ECHECK(Next()) | | ------------------ | | | | 56| 0| { \ | | | | 57| 0| auto ce = (call); \ | | | | 58| 0| if (ce.Check()) return ce; \ | | | | ------------------ | | | | | Branch (58:9): [True: 0, False: 0] | | | | ------------------ | | | | 59| 0| } | | ------------------ ------------------ 871| 0| if (token_ != kTokenIntegerConstant) { ------------------ | Branch (871:11): [True: 0, False: 0] ------------------ 872| 0| return Error("length of fixed-length array must be an integer value"); 873| 0| } 874| 0| uint16_t fixed_length = 0; 875| 0| bool check = StringToNumber(attribute_.c_str(), &fixed_length); 876| 0| if (!check || fixed_length < 1) { ------------------ | Branch (876:11): [True: 0, False: 0] | Branch (876:21): [True: 0, False: 0] ------------------ 877| 0| return Error( 878| 0| "length of fixed-length array must be positive and fit to " 879| 0| "uint16_t type"); 880| 0| } 881| 0| type = Type(BASE_TYPE_ARRAY, subtype.struct_def, subtype.enum_def, 882| 0| fixed_length); 883| 0| NEXT(); ------------------ | | 63| 0|#define NEXT() ECHECK(Next()) | | ------------------ | | | | 56| 0| { \ | | | | 57| 0| auto ce = (call); \ | | | | 58| 0| if (ce.Check()) return ce; \ | | | | ------------------ | | | | | Branch (58:9): [True: 0, False: 0] | | | | ------------------ | | | | 59| 0| } | | ------------------ ------------------ 884| 0| } else { 885| 0| type = Type(BASE_TYPE_VECTOR, subtype.struct_def, subtype.enum_def); 886| 0| } 887| 0| type.element = subtype.base_type; 888| 0| EXPECT(']'); ------------------ | | 64| 0|#define EXPECT(tok) ECHECK(Expect(tok)) | | ------------------ | | | | 56| 0| { \ | | | | 57| 0| auto ce = (call); \ | | | | 58| 0| if (ce.Check()) return ce; \ | | | | ------------------ | | | | | Branch (58:9): [True: 0, False: 0] | | | | ------------------ | | | | 59| 0| } | | ------------------ ------------------ 889| 0| } else { 890| 0| return Error("illegal type syntax"); 891| 0| } 892| 103k| return NoError(); 893| 103k|} _ZN11flatbuffers6Parser8AddFieldERNS_9StructDefERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEERKNS_4TypeEPPNS_8FieldDefE: 896| 103k| const Type& type, FieldDef** dest) { 897| 103k| auto& field = *new FieldDef(); 898| 103k| field.value.offset = 899| 103k| FieldIndexToOffset(static_cast(struct_def.fields.vec.size())); 900| 103k| field.name = name; 901| 103k| field.file = struct_def.file; 902| 103k| field.value.type = type; 903| 103k| if (struct_def.fixed) { // statically compute the field offset ------------------ | Branch (903:7): [True: 0, False: 103k] ------------------ 904| 0| auto size = InlineSize(type); 905| 0| auto alignment = InlineAlignment(type); 906| | // structs_ need to have a predictable format, so we need to align to 907| | // the largest scalar 908| 0| struct_def.minalign = std::max(struct_def.minalign, alignment); 909| 0| struct_def.PadLastField(alignment); 910| 0| field.value.offset = static_cast(struct_def.bytesize); 911| 0| struct_def.bytesize += size; 912| 0| } 913| 103k| if (struct_def.fields.Add(name, &field)) ------------------ | Branch (913:7): [True: 0, False: 103k] ------------------ 914| 0| return Error("field already exists: " + name); 915| 103k| *dest = &field; 916| 103k| return NoError(); 917| 103k|} _ZN11flatbuffers6Parser10ParseFieldERNS_9StructDefE: 919| 103k|CheckedError Parser::ParseField(StructDef& struct_def) { 920| 103k| std::string name = attribute_; 921| | 922| 103k| if (LookupCreateStruct(name, false, false)) ------------------ | Branch (922:7): [True: 0, False: 103k] ------------------ 923| 0| return Error("field name can not be the same as table/struct name"); 924| | 925| 103k| if (!IsLowerSnakeCase(name)) { ------------------ | Branch (925:7): [True: 103k, False: 0] ------------------ 926| 103k| Warning("field names should be lowercase snake_case, got: " + name); 927| 103k| } 928| | 929| 103k| std::vector dc = doc_comment_; 930| 103k| EXPECT(kTokenIdentifier); ------------------ | | 64| 103k|#define EXPECT(tok) ECHECK(Expect(tok)) | | ------------------ | | | | 56| 103k| { \ | | | | 57| 103k| auto ce = (call); \ | | | | 58| 103k| if (ce.Check()) return ce; \ | | | | ------------------ | | | | | Branch (58:9): [True: 0, False: 103k] | | | | ------------------ | | | | 59| 103k| } | | ------------------ ------------------ 931| 103k| EXPECT(':'); ------------------ | | 64| 103k|#define EXPECT(tok) ECHECK(Expect(tok)) | | ------------------ | | | | 56| 103k| { \ | | | | 57| 103k| auto ce = (call); \ | | | | 58| 103k| if (ce.Check()) return ce; \ | | | | ------------------ | | | | | Branch (58:9): [True: 0, False: 103k] | | | | ------------------ | | | | 59| 103k| } | | ------------------ ------------------ 932| 103k| Type type; 933| 103k| ECHECK(ParseType(type)); ------------------ | | 56| 103k| { \ | | 57| 103k| auto ce = (call); \ | | 58| 103k| if (ce.Check()) return ce; \ | | ------------------ | | | Branch (58:9): [True: 0, False: 103k] | | ------------------ | | 59| 103k| } ------------------ 934| | 935| 103k| if (struct_def.fixed) { ------------------ | Branch (935:7): [True: 0, False: 103k] ------------------ 936| 0| if (IsIncompleteStruct(type) || ------------------ | Branch (936:9): [True: 0, False: 0] | Branch (936:9): [True: 0, False: 0] ------------------ 937| 0| (IsArray(type) && IsIncompleteStruct(type.VectorType()))) { ------------------ | Branch (937:10): [True: 0, False: 0] | Branch (937:27): [True: 0, False: 0] ------------------ 938| 0| std::string type_name = IsArray(type) ? type.VectorType().struct_def->name ------------------ | Branch (938:31): [True: 0, False: 0] ------------------ 939| 0| : type.struct_def->name; 940| 0| return Error( 941| 0| std::string("Incomplete type in struct is not allowed, type name: ") + 942| 0| type_name); 943| 0| } 944| | 945| 0| auto valid = IsScalar(type.base_type) || IsStruct(type); ------------------ | Branch (945:18): [True: 0, False: 0] | Branch (945:46): [True: 0, False: 0] ------------------ 946| 0| if (!valid && IsArray(type)) { ------------------ | Branch (946:9): [True: 0, False: 0] | Branch (946:19): [True: 0, False: 0] ------------------ 947| 0| const auto& elem_type = type.VectorType(); 948| 0| valid |= IsScalar(elem_type.base_type) || IsStruct(elem_type); ------------------ | Branch (948:16): [True: 0, False: 0] | Branch (948:49): [True: 0, False: 0] ------------------ 949| 0| } 950| 0| if (!valid) ------------------ | Branch (950:9): [True: 0, False: 0] ------------------ 951| 0| return Error("structs may contain only scalar or struct fields"); 952| 0| } 953| | 954| 103k| if (!struct_def.fixed && IsArray(type)) ------------------ | Branch (954:7): [True: 103k, False: 0] | Branch (954:28): [True: 0, False: 103k] ------------------ 955| 0| return Error("fixed-length array in table must be wrapped in struct"); 956| | 957| 103k| if (IsArray(type)) { ------------------ | Branch (957:7): [True: 0, False: 103k] ------------------ 958| 0| advanced_features_ |= reflection::AdvancedArrayFeatures; 959| 0| if (!SupportsAdvancedArrayFeatures()) { ------------------ | Branch (959:9): [True: 0, False: 0] ------------------ 960| 0| return Error( 961| 0| "Arrays are not yet supported in all " 962| 0| "the specified programming languages."); 963| 0| } 964| 0| } 965| | 966| 103k| FieldDef* typefield = nullptr; 967| 103k| if (type.base_type == BASE_TYPE_UNION) { ------------------ | Branch (967:7): [True: 0, False: 103k] ------------------ 968| | // For union fields, add a second auto-generated field to hold the type, 969| | // with a special suffix. 970| | 971| | // To ensure compatibility with many codes that rely on the BASE_TYPE_UTYPE 972| | // value to identify union type fields. 973| 0| Type union_type(type.enum_def->underlying_type); 974| 0| union_type.base_type = BASE_TYPE_UTYPE; 975| 0| ECHECK(AddField(struct_def, name + UnionTypeFieldSuffix(), union_type, ------------------ | | 56| 0| { \ | | 57| 0| auto ce = (call); \ | | 58| 0| if (ce.Check()) return ce; \ | | ------------------ | | | Branch (58:9): [True: 0, False: 0] | | ------------------ | | 59| 0| } ------------------ 976| 0| &typefield)); 977| | 978| 103k| } else if (IsVector(type) && type.element == BASE_TYPE_UNION) { ------------------ | Branch (978:14): [True: 0, False: 103k] | Branch (978:32): [True: 0, False: 0] ------------------ 979| 0| advanced_features_ |= reflection::AdvancedUnionFeatures; 980| | // Only cpp, js and ts supports the union vector feature so far. 981| 0| if (!SupportsAdvancedUnionFeatures()) { ------------------ | Branch (981:9): [True: 0, False: 0] ------------------ 982| 0| return Error( 983| 0| "Vectors of unions are not yet supported in at least one of " 984| 0| "the specified programming languages."); 985| 0| } 986| | // For vector of union fields, add a second auto-generated vector field to 987| | // hold the types, with a special suffix. 988| 0| Type union_vector(BASE_TYPE_VECTOR, nullptr, type.enum_def); 989| 0| union_vector.element = BASE_TYPE_UTYPE; 990| 0| ECHECK(AddField(struct_def, name + UnionTypeFieldSuffix(), union_vector, ------------------ | | 56| 0| { \ | | 57| 0| auto ce = (call); \ | | 58| 0| if (ce.Check()) return ce; \ | | ------------------ | | | Branch (58:9): [True: 0, False: 0] | | ------------------ | | 59| 0| } ------------------ 991| 0| &typefield)); 992| 0| } 993| | 994| 103k| FieldDef* field; 995| 103k| ECHECK(AddField(struct_def, name, type, &field)); ------------------ | | 56| 103k| { \ | | 57| 103k| auto ce = (call); \ | | 58| 103k| if (ce.Check()) return ce; \ | | ------------------ | | | Branch (58:9): [True: 0, False: 103k] | | ------------------ | | 59| 103k| } ------------------ 996| | 997| 103k| if (typefield) { ------------------ | Branch (997:7): [True: 0, False: 103k] ------------------ 998| | // We preserve the relation between the typefield 999| | // and field, so we can easily map it in the code 1000| | // generators. 1001| 0| typefield->sibling_union_field = field; 1002| 0| field->sibling_union_field = typefield; 1003| 0| } 1004| | 1005| 103k| if (token_ == '=') { ------------------ | Branch (1005:7): [True: 98.3k, False: 5.06k] ------------------ 1006| 98.3k| NEXT(); ------------------ | | 63| 98.3k|#define NEXT() ECHECK(Next()) | | ------------------ | | | | 56| 98.3k| { \ | | | | 57| 98.3k| auto ce = (call); \ | | | | 58| 98.3k| if (ce.Check()) return ce; \ | | | | ------------------ | | | | | Branch (58:9): [True: 0, False: 98.3k] | | | | ------------------ | | | | 59| 98.3k| } | | ------------------ ------------------ 1007| 98.3k| ECHECK(ParseSingleValue(&field->name, field->value, true)); ------------------ | | 56| 98.3k| { \ | | 57| 98.3k| auto ce = (call); \ | | 58| 98.3k| if (ce.Check()) return ce; \ | | ------------------ | | | Branch (58:9): [True: 0, False: 98.3k] | | ------------------ | | 59| 98.3k| } ------------------ 1008| 98.3k| if (IsStruct(type) || (struct_def.fixed && field->value.constant != "0")) ------------------ | Branch (1008:9): [True: 0, False: 98.3k] | Branch (1008:28): [True: 0, False: 98.3k] | Branch (1008:48): [True: 0, False: 0] ------------------ 1009| 0| return Error( 1010| 0| "default values are not supported for struct fields, table fields, " 1011| 0| "or in structs."); 1012| 98.3k| if (IsString(type) || IsVector(type)) { ------------------ | Branch (1012:9): [True: 0, False: 98.3k] | Branch (1012:27): [True: 0, False: 98.3k] ------------------ 1013| 0| advanced_features_ |= reflection::DefaultVectorsAndStrings; 1014| 0| if (field->value.constant != "0" && !SupportsDefaultVectorsAndStrings()) { ------------------ | Branch (1014:11): [True: 0, False: 0] | Branch (1014:43): [True: 0, False: 0] ------------------ 1015| 0| return Error( 1016| 0| "Default values for strings and vectors are not supported in one " 1017| 0| "of the specified programming languages"); 1018| 0| } 1019| 0| } 1020| | 1021| 98.3k| if (IsVector(type) && field->value.constant != "0" && ------------------ | Branch (1021:9): [True: 0, False: 98.3k] | Branch (1021:27): [True: 0, False: 0] ------------------ 1022| 0| field->value.constant != "[]") { ------------------ | Branch (1022:9): [True: 0, False: 0] ------------------ 1023| 0| return Error("The only supported default for vectors is `[]`."); 1024| 0| } 1025| 98.3k| } 1026| | 1027| | // Append .0 if the value has not it (skip hex and scientific floats). 1028| | // This suffix needed for generated C++ code. 1029| 103k| if (IsFloat(type.base_type)) { ------------------ | Branch (1029:7): [True: 24.2k, False: 79.1k] ------------------ 1030| 24.2k| auto& text = field->value.constant; 1031| 24.2k| FLATBUFFERS_ASSERT(false == text.empty()); 1032| 24.2k| auto s = text.c_str(); 1033| 25.8k| while (*s == ' ') s++; ------------------ | Branch (1033:12): [True: 1.54k, False: 24.2k] ------------------ 1034| 24.2k| if (*s == '-' || *s == '+') s++; ------------------ | Branch (1034:9): [True: 792, False: 23.4k] | Branch (1034:22): [True: 1.22k, False: 22.2k] ------------------ 1035| | // 1) A float constants (nan, inf, pi, etc) is a kind of identifier. 1036| | // 2) A float number needn't ".0" at the end if it has exponent. 1037| 24.2k| if ((false == IsIdentifierStart(*s)) && ------------------ | Branch (1037:9): [True: 21.0k, False: 3.25k] ------------------ 1038| 21.0k| (std::string::npos == field->value.constant.find_first_of(".eEpP"))) { ------------------ | Branch (1038:9): [True: 15.1k, False: 5.85k] ------------------ 1039| 15.1k| field->value.constant += ".0"; 1040| 15.1k| } 1041| 24.2k| } 1042| | 1043| 103k| field->doc_comment = dc; 1044| 103k| ECHECK(ParseMetaData(&field->attributes)); ------------------ | | 56| 103k| { \ | | 57| 103k| auto ce = (call); \ | | 58| 103k| if (ce.Check()) return ce; \ | | ------------------ | | | Branch (58:9): [True: 0, False: 103k] | | ------------------ | | 59| 103k| } ------------------ 1045| 103k| field->deprecated = field->attributes.Lookup("deprecated") != nullptr; 1046| 103k| auto hash_name = field->attributes.Lookup("hash"); 1047| 103k| if (hash_name) { ------------------ | Branch (1047:7): [True: 0, False: 103k] ------------------ 1048| 0| switch ((IsVector(type)) ? type.element : type.base_type) { ------------------ | Branch (1048:13): [True: 0, False: 0] ------------------ 1049| 0| case BASE_TYPE_SHORT: ------------------ | Branch (1049:7): [True: 0, False: 0] ------------------ 1050| 0| case BASE_TYPE_USHORT: { ------------------ | Branch (1050:7): [True: 0, False: 0] ------------------ 1051| 0| if (FindHashFunction16(hash_name->constant.c_str()) == nullptr) ------------------ | Branch (1051:13): [True: 0, False: 0] ------------------ 1052| 0| return Error("Unknown hashing algorithm for 16 bit types: " + 1053| 0| hash_name->constant); 1054| 0| break; 1055| 0| } 1056| 0| case BASE_TYPE_INT: ------------------ | Branch (1056:7): [True: 0, False: 0] ------------------ 1057| 0| case BASE_TYPE_UINT: { ------------------ | Branch (1057:7): [True: 0, False: 0] ------------------ 1058| 0| if (FindHashFunction32(hash_name->constant.c_str()) == nullptr) ------------------ | Branch (1058:13): [True: 0, False: 0] ------------------ 1059| 0| return Error("Unknown hashing algorithm for 32 bit types: " + 1060| 0| hash_name->constant); 1061| 0| break; 1062| 0| } 1063| 0| case BASE_TYPE_LONG: ------------------ | Branch (1063:7): [True: 0, False: 0] ------------------ 1064| 0| case BASE_TYPE_ULONG: { ------------------ | Branch (1064:7): [True: 0, False: 0] ------------------ 1065| 0| if (FindHashFunction64(hash_name->constant.c_str()) == nullptr) ------------------ | Branch (1065:13): [True: 0, False: 0] ------------------ 1066| 0| return Error("Unknown hashing algorithm for 64 bit types: " + 1067| 0| hash_name->constant); 1068| 0| break; 1069| 0| } 1070| 0| default: ------------------ | Branch (1070:7): [True: 0, False: 0] ------------------ 1071| 0| return Error( 1072| 0| "only short, ushort, int, uint, long and ulong data types support " 1073| 0| "hashing."); 1074| 0| } 1075| 0| } 1076| | 1077| 103k| if (field->attributes.Lookup("vector64") != nullptr) { ------------------ | Branch (1077:7): [True: 0, False: 103k] ------------------ 1078| 0| if (!IsVector(type)) { ------------------ | Branch (1078:9): [True: 0, False: 0] ------------------ 1079| 0| return Error("`vector64` attribute can only be applied on vectors."); 1080| 0| } 1081| | 1082| | // Upgrade the type to be a BASE_TYPE_VECTOR64, since the attributes are 1083| | // parsed after the type. 1084| 0| const BaseType element_base_type = type.element; 1085| 0| type = Type(BASE_TYPE_VECTOR64, type.struct_def, type.enum_def); 1086| 0| type.element = element_base_type; 1087| | 1088| | // Since the field was already added to the parent object, update the type 1089| | // in place. 1090| 0| field->value.type = type; 1091| | 1092| | // 64-bit vectors imply the offset64 attribute. 1093| 0| field->offset64 = true; 1094| 0| } 1095| | 1096| | // Record that this field uses 64-bit offsets. 1097| 103k| if (field->attributes.Lookup("offset64") != nullptr) { ------------------ | Branch (1097:7): [True: 0, False: 103k] ------------------ 1098| | // TODO(derekbailey): would be nice to have this be a recommendation or hint 1099| | // instead of a warning. 1100| 0| if (type.base_type == BASE_TYPE_VECTOR64) { ------------------ | Branch (1100:9): [True: 0, False: 0] ------------------ 1101| 0| Warning("attribute `vector64` implies `offset64` and isn't required."); 1102| 0| } 1103| | 1104| 0| field->offset64 = true; 1105| 0| } 1106| | 1107| | // Check for common conditions with Offset64 fields. 1108| 103k| if (field->offset64) { ------------------ | Branch (1108:7): [True: 0, False: 103k] ------------------ 1109| | // TODO(derekbailey): this is where we can disable string support for 1110| | // offset64, as that is not a hard requirement to have. 1111| 0| if (!IsString(type) && !IsVector(type)) { ------------------ | Branch (1111:9): [True: 0, False: 0] | Branch (1111:28): [True: 0, False: 0] ------------------ 1112| 0| return Error( 1113| 0| "only string and vectors can have `offset64` attribute applied"); 1114| 0| } 1115| | 1116| | // If this is a Vector, only scalar and scalar-like (structs) items are 1117| | // allowed. 1118| | // TODO(derekbailey): allow vector of strings, just require that the strings 1119| | // are Offset64. 1120| 0| if (IsVector(type) && ------------------ | Branch (1120:9): [True: 0, False: 0] | Branch (1120:9): [True: 0, False: 0] ------------------ 1121| 0| !((IsScalar(type.element) && !IsEnum(type.VectorType())) || ------------------ | Branch (1121:12): [True: 0, False: 0] | Branch (1121:38): [True: 0, False: 0] ------------------ 1122| 0| IsStruct(type.VectorType()))) { ------------------ | Branch (1122:11): [True: 0, False: 0] ------------------ 1123| 0| return Error("only vectors of scalars are allowed to be 64-bit."); 1124| 0| } 1125| | 1126| | // Lastly, check if it is supported by the specified generated languages. Do 1127| | // this last so the above checks can inform the user of schema errors to fix 1128| | // first. 1129| 0| if (!Supports64BitOffsets()) { ------------------ | Branch (1129:9): [True: 0, False: 0] ------------------ 1130| 0| return Error( 1131| 0| "fields using 64-bit offsets are not yet supported in at least one " 1132| 0| "of the specified programming languages."); 1133| 0| } 1134| 0| } 1135| | 1136| 103k| field->key = field->attributes.Lookup("key") != nullptr; 1137| | 1138| 103k| if (!struct_def.fixed) { ------------------ | Branch (1138:7): [True: 103k, False: 0] ------------------ 1139| | // For historical convenience reasons, string keys are assumed required. 1140| | // Scalars are kDefault unless otherwise specified. 1141| | // Nonscalars are kOptional unless required; 1142| 103k| const bool required = field->attributes.Lookup("required") != nullptr || ------------------ | Branch (1142:27): [True: 0, False: 103k] ------------------ 1143| 103k| (IsString(type) && field->key); ------------------ | Branch (1143:28): [True: 0, False: 103k] | Branch (1143:46): [True: 0, False: 0] ------------------ 1144| 103k| const bool default_str_or_vec = 1145| 103k| ((IsString(type) || IsVector(type)) && field->value.constant != "0"); ------------------ | Branch (1145:11): [True: 0, False: 103k] | Branch (1145:29): [True: 0, False: 103k] | Branch (1145:48): [True: 0, False: 0] ------------------ 1146| 103k| const bool optional = IsScalar(type.base_type) ------------------ | Branch (1146:27): [True: 103k, False: 0] ------------------ 1147| 103k| ? (field->value.constant == "null") 1148| 103k| : !(required || default_str_or_vec); ------------------ | Branch (1148:35): [True: 0, False: 0] | Branch (1148:47): [True: 0, False: 0] ------------------ 1149| 103k| if (required && optional) { ------------------ | Branch (1149:9): [True: 0, False: 103k] | Branch (1149:21): [True: 0, False: 0] ------------------ 1150| 0| return Error("Fields cannot be both optional and required."); 1151| 0| } 1152| 103k| field->presence = FieldDef::MakeFieldPresence(optional, required); 1153| | 1154| 103k| if (required && IsScalar(type.base_type)) { ------------------ | Branch (1154:9): [True: 0, False: 103k] | Branch (1154:21): [True: 0, False: 0] ------------------ 1155| 0| return Error("only non-scalar fields in tables may be 'required'"); 1156| 0| } 1157| 103k| } else { 1158| | // all struct fields are required 1159| 0| field->presence = FieldDef::kDefault; 1160| | 1161| | // setting required or optional on a struct field is meaningless 1162| 0| if (field->attributes.Lookup("required") != nullptr || ------------------ | Branch (1162:9): [True: 0, False: 0] | Branch (1162:9): [True: 0, False: 0] ------------------ 1163| 0| field->attributes.Lookup("optional") != nullptr) { ------------------ | Branch (1163:9): [True: 0, False: 0] ------------------ 1164| 0| return Error("struct fields are always required"); 1165| 0| } 1166| 0| } 1167| | 1168| 103k| if (field->key) { ------------------ | Branch (1168:7): [True: 0, False: 103k] ------------------ 1169| 0| if (struct_def.has_key) return Error("only one field may be set as 'key'"); ------------------ | Branch (1169:9): [True: 0, False: 0] ------------------ 1170| 0| struct_def.has_key = true; 1171| 0| auto is_valid = 1172| 0| IsScalar(type.base_type) || IsString(type) || IsStruct(type); ------------------ | Branch (1172:9): [True: 0, False: 0] | Branch (1172:37): [True: 0, False: 0] | Branch (1172:55): [True: 0, False: 0] ------------------ 1173| 0| if (IsArray(type)) { ------------------ | Branch (1173:9): [True: 0, False: 0] ------------------ 1174| 0| is_valid |= 1175| 0| IsScalar(type.VectorType().base_type) || IsStruct(type.VectorType()); ------------------ | Branch (1175:11): [True: 0, False: 0] | Branch (1175:52): [True: 0, False: 0] ------------------ 1176| 0| } 1177| 0| if (!is_valid) { ------------------ | Branch (1177:9): [True: 0, False: 0] ------------------ 1178| 0| return Error( 1179| 0| "'key' field must be string, scalar type or fixed size array of " 1180| 0| "scalars"); 1181| 0| } 1182| 0| } 1183| | 1184| 103k| if (field->IsScalarOptional()) { ------------------ | Branch (1184:7): [True: 0, False: 103k] ------------------ 1185| 0| advanced_features_ |= reflection::OptionalScalars; 1186| 0| if (type.enum_def && type.enum_def->Lookup("null")) { ------------------ | Branch (1186:9): [True: 0, False: 0] | Branch (1186:9): [True: 0, False: 0] | Branch (1186:26): [True: 0, False: 0] ------------------ 1187| 0| FLATBUFFERS_ASSERT(IsInteger(type.base_type)); 1188| 0| return Error( 1189| 0| "the default 'null' is reserved for declaring optional scalar " 1190| 0| "fields, it conflicts with declaration of enum '" + 1191| 0| type.enum_def->name + "'."); 1192| 0| } 1193| 0| if (field->attributes.Lookup("key")) { ------------------ | Branch (1193:9): [True: 0, False: 0] ------------------ 1194| 0| return Error( 1195| 0| "only a non-optional scalar field can be used as a 'key' field"); 1196| 0| } 1197| 0| if (!SupportsOptionalScalars()) { ------------------ | Branch (1197:9): [True: 0, False: 0] ------------------ 1198| 0| return Error( 1199| 0| "Optional scalars are not yet supported in at least one of " 1200| 0| "the specified programming languages."); 1201| 0| } 1202| 0| } 1203| | 1204| 103k| auto check_enum = [this](const FieldDef* field, const Type& type, 1205| 103k| const std::string& name, 1206| 103k| const std::string& constant) -> CheckedError { 1207| | // Optional and bitflags enums may have default constants that are not 1208| | // their specified variants. 1209| 103k| if (!field->IsOptional() && 1210| 103k| type.enum_def->attributes.Lookup("bit_flags") == nullptr) { 1211| 103k| if (type.enum_def->FindByValue(constant) == nullptr) { 1212| 103k| return Error("default value of `" + constant + "` for " + "field `" + 1213| 103k| name + "` is not part of enum `" + type.enum_def->name + 1214| 103k| "`."); 1215| 103k| } 1216| 103k| } 1217| | 1218| 103k| return NoError(); 1219| 103k| }; 1220| | 1221| 103k| if (type.enum_def) { ------------------ | Branch (1221:7): [True: 0, False: 103k] ------------------ 1222| | // Verify the enum's type and default value. 1223| 0| const std::string& constant = field->value.constant; 1224| 0| if (type.base_type == BASE_TYPE_UNION) { ------------------ | Branch (1224:9): [True: 0, False: 0] ------------------ 1225| 0| if (constant != "0") { ------------------ | Branch (1225:11): [True: 0, False: 0] ------------------ 1226| 0| return Error("Union defaults must be NONE"); 1227| 0| } 1228| 0| } else if (IsVector(type)) { ------------------ | Branch (1228:16): [True: 0, False: 0] ------------------ 1229| 0| if (constant != "0" && constant != "[]") { ------------------ | Branch (1229:11): [True: 0, False: 0] | Branch (1229:30): [True: 0, False: 0] ------------------ 1230| 0| return Error("Vector defaults may only be `[]`."); 1231| 0| } 1232| 0| } else if (IsArray(type)) { ------------------ | Branch (1232:16): [True: 0, False: 0] ------------------ 1233| 0| if (constant != "0") { ------------------ | Branch (1233:11): [True: 0, False: 0] ------------------ 1234| 0| return Error("Array defaults are not supported yet."); 1235| 0| } 1236| 0| CheckedError err = check_enum(field, type.VectorType(), name, constant); 1237| 0| if (err.Check()) { ------------------ | Branch (1237:11): [True: 0, False: 0] ------------------ 1238| | // reset the check state of the error 1239| 0| return CheckedError{err}; 1240| 0| } 1241| 0| } else { 1242| 0| if (!IsInteger(type.base_type)) { ------------------ | Branch (1242:11): [True: 0, False: 0] ------------------ 1243| 0| return Error("Enums must have integer base types"); 1244| 0| } 1245| 0| CheckedError err = check_enum(field, type, name, constant); 1246| 0| if (err.Check()) { ------------------ | Branch (1246:11): [True: 0, False: 0] ------------------ 1247| | // reset the check state of the error 1248| 0| return CheckedError{err}; 1249| 0| } 1250| 0| } 1251| 0| } 1252| | 1253| 103k| if (field->deprecated && struct_def.fixed) ------------------ | Branch (1253:7): [True: 0, False: 103k] | Branch (1253:28): [True: 0, False: 0] ------------------ 1254| 0| return Error("can't deprecate fields in a struct"); 1255| | 1256| 103k| auto cpp_type = field->attributes.Lookup("cpp_type"); 1257| 103k| if (cpp_type) { ------------------ | Branch (1257:7): [True: 0, False: 103k] ------------------ 1258| 0| if (!hash_name) ------------------ | Branch (1258:9): [True: 0, False: 0] ------------------ 1259| 0| return Error("cpp_type can only be used with a hashed field"); 1260| | /// forcing cpp_ptr_type to 'naked' if unset 1261| 0| auto cpp_ptr_type = field->attributes.Lookup("cpp_ptr_type"); 1262| 0| if (!cpp_ptr_type) { ------------------ | Branch (1262:9): [True: 0, False: 0] ------------------ 1263| 0| auto val = new Value(); 1264| 0| val->type = cpp_type->type; 1265| 0| val->constant = "naked"; 1266| 0| field->attributes.Add("cpp_ptr_type", val); 1267| 0| } 1268| 0| } 1269| | 1270| 103k| field->shared = field->attributes.Lookup("shared") != nullptr; 1271| 103k| if (field->shared && field->value.type.base_type != BASE_TYPE_STRING) ------------------ | Branch (1271:7): [True: 0, False: 103k] | Branch (1271:24): [True: 0, False: 0] ------------------ 1272| 0| return Error("shared can only be defined on strings"); 1273| | 1274| 103k| auto field_native_custom_alloc = 1275| 103k| field->attributes.Lookup("native_custom_alloc"); 1276| 103k| if (field_native_custom_alloc) ------------------ | Branch (1276:7): [True: 0, False: 103k] ------------------ 1277| 0| return Error( 1278| 0| "native_custom_alloc can only be used with a table or struct " 1279| 0| "definition"); 1280| | 1281| 103k| field->native_inline = field->attributes.Lookup("native_inline") != nullptr; 1282| 103k| if (field->native_inline && !IsStruct(field->value.type) && ------------------ | Branch (1282:7): [True: 0, False: 103k] | Branch (1282:31): [True: 0, False: 0] ------------------ 1283| 0| !IsVectorOfStruct(field->value.type) && ------------------ | Branch (1283:7): [True: 0, False: 0] ------------------ 1284| 0| !IsVectorOfTable(field->value.type)) ------------------ | Branch (1284:7): [True: 0, False: 0] ------------------ 1285| 0| return Error( 1286| 0| "'native_inline' can only be defined on structs, vector of structs or " 1287| 0| "vector of tables"); 1288| | 1289| 103k| auto nested = field->attributes.Lookup("nested_flatbuffer"); 1290| 103k| if (nested) { ------------------ | Branch (1290:7): [True: 0, False: 103k] ------------------ 1291| 0| if (nested->type.base_type != BASE_TYPE_STRING) ------------------ | Branch (1291:9): [True: 0, False: 0] ------------------ 1292| 0| return Error( 1293| 0| "nested_flatbuffer attribute must be a string (the root type)"); 1294| 0| if (!IsVector(type.base_type) || type.element != BASE_TYPE_UCHAR) ------------------ | Branch (1294:9): [True: 0, False: 0] | Branch (1294:38): [True: 0, False: 0] ------------------ 1295| 0| return Error( 1296| 0| "nested_flatbuffer attribute may only apply to a vector of ubyte"); 1297| | // This will cause an error if the root type of the nested flatbuffer 1298| | // wasn't defined elsewhere. 1299| 0| field->nested_flatbuffer = LookupCreateStruct(nested->constant); 1300| 0| } 1301| | 1302| 103k| if (field->attributes.Lookup("flexbuffer")) { ------------------ | Branch (1302:7): [True: 0, False: 103k] ------------------ 1303| 0| field->flexbuffer = true; 1304| 0| uses_flexbuffers_ = true; 1305| 0| if (type.base_type != BASE_TYPE_VECTOR || type.element != BASE_TYPE_UCHAR) ------------------ | Branch (1305:9): [True: 0, False: 0] | Branch (1305:47): [True: 0, False: 0] ------------------ 1306| 0| return Error("flexbuffer attribute may only apply to a vector of ubyte"); 1307| 0| } 1308| | 1309| 103k| if (typefield) { ------------------ | Branch (1309:7): [True: 0, False: 103k] ------------------ 1310| 0| if (!IsScalar(typefield->value.type.base_type)) { ------------------ | Branch (1310:9): [True: 0, False: 0] ------------------ 1311| | // this is a union vector field 1312| 0| typefield->presence = field->presence; 1313| 0| } 1314| | // If this field is a union, and it has a manually assigned id, 1315| | // the automatically added type field should have an id as well (of N - 1). 1316| 0| auto attr = field->attributes.Lookup("id"); 1317| 0| if (attr) { ------------------ | Branch (1317:9): [True: 0, False: 0] ------------------ 1318| 0| const auto& id_str = attr->constant; 1319| 0| voffset_t id = 0; 1320| 0| const auto done = !atot(id_str.c_str(), *this, &id).Check(); 1321| 0| if (done && id > 0) { ------------------ | Branch (1321:11): [True: 0, False: 0] | Branch (1321:19): [True: 0, False: 0] ------------------ 1322| 0| auto val = new Value(); 1323| 0| val->type = attr->type; 1324| 0| val->constant = NumToString(id - 1); 1325| 0| typefield->attributes.Add("id", val); 1326| 0| } else { 1327| 0| return Error( 1328| 0| "a union type effectively adds two fields with non-negative ids, " 1329| 0| "its id must be that of the second field (the first field is " 1330| 0| "the type field and not explicitly declared in the schema);\n" 1331| 0| "field: " + 1332| 0| field->name + ", id: " + id_str); 1333| 0| } 1334| 0| } 1335| | // if this field is a union that is deprecated, 1336| | // the automatically added type field should be deprecated as well 1337| 0| if (field->deprecated) { ------------------ | Branch (1337:9): [True: 0, False: 0] ------------------ 1338| 0| typefield->deprecated = true; 1339| 0| } 1340| 0| } 1341| | 1342| 103k| EXPECT(';'); ------------------ | | 64| 103k|#define EXPECT(tok) ECHECK(Expect(tok)) | | ------------------ | | | | 56| 103k| { \ | | | | 57| 103k| auto ce = (call); \ | | | | 58| 103k| if (ce.Check()) return ce; \ | | | | ------------------ | | | | | Branch (58:9): [True: 0, False: 103k] | | | | ------------------ | | | | 59| 103k| } | | ------------------ ------------------ 1343| 103k| return NoError(); 1344| 103k|} _ZN11flatbuffers6Parser10ParseCommaEv: 1357| 51.3k|CheckedError Parser::ParseComma() { 1358| 51.3k| if (!opts.protobuf_ascii_alike) EXPECT(','); ------------------ | | 64| 51.3k|#define EXPECT(tok) ECHECK(Expect(tok)) | | ------------------ | | | | 56| 51.3k| { \ | | | | 57| 51.3k| auto ce = (call); \ | | | | 58| 51.3k| if (ce.Check()) return ce; \ | | | | ------------------ | | | | | Branch (58:9): [True: 25.9k, False: 25.3k] | | | | ------------------ | | | | 59| 51.3k| } | | ------------------ ------------------ | Branch (1358:7): [True: 51.3k, False: 0] ------------------ 1359| 25.3k| return NoError(); 1360| 51.3k|} _ZN11flatbuffers6Parser13ParseAnyValueERNS_5ValueEPNS_8FieldDefEmPKNS_9StructDefEmb: 1365| 567k| size_t count, bool inside_vector) { 1366| 567k| switch (val.type.base_type) { 1367| 0| case BASE_TYPE_UNION: { ------------------ | Branch (1367:5): [True: 0, False: 567k] ------------------ 1368| 0| FLATBUFFERS_ASSERT(field); 1369| 0| std::string constant; 1370| 0| Vector* vector_of_union_types = nullptr; 1371| | // Find corresponding type field we may have already parsed. 1372| 0| for (auto elem = field_stack_.rbegin() + count; 1373| 0| elem != field_stack_.rbegin() + parent_fieldn + count; ++elem) { ------------------ | Branch (1373:12): [True: 0, False: 0] ------------------ 1374| 0| auto& type = elem->second->value.type; 1375| 0| if (type.enum_def == val.type.enum_def) { ------------------ | Branch (1375:13): [True: 0, False: 0] ------------------ 1376| 0| if (inside_vector) { ------------------ | Branch (1376:15): [True: 0, False: 0] ------------------ 1377| 0| if (IsVector(type) && type.element == BASE_TYPE_UTYPE) { ------------------ | Branch (1377:17): [True: 0, False: 0] | Branch (1377:35): [True: 0, False: 0] ------------------ 1378| | // Vector of union type field. 1379| 0| uoffset_t offset; 1380| 0| ECHECK(atot(elem->first.constant.c_str(), *this, &offset)); ------------------ | | 56| 0| { \ | | 57| 0| auto ce = (call); \ | | 58| 0| if (ce.Check()) return ce; \ | | ------------------ | | | Branch (58:9): [True: 0, False: 0] | | ------------------ | | 59| 0| } ------------------ 1381| 0| vector_of_union_types = reinterpret_cast*>( 1382| 0| builder_.GetCurrentBufferPointer() + builder_.GetSize() - 1383| 0| offset); 1384| 0| break; 1385| 0| } 1386| 0| } else { 1387| 0| if (type.base_type == BASE_TYPE_UTYPE) { ------------------ | Branch (1387:17): [True: 0, False: 0] ------------------ 1388| | // Union type field. 1389| 0| constant = elem->first.constant; 1390| 0| break; 1391| 0| } 1392| 0| } 1393| 0| } 1394| 0| } 1395| 0| if (constant.empty() && !inside_vector) { ------------------ | Branch (1395:11): [True: 0, False: 0] | Branch (1395:31): [True: 0, False: 0] ------------------ 1396| | // We haven't seen the type field yet. Sadly a lot of JSON writers 1397| | // output these in alphabetical order, meaning it comes after this 1398| | // value. So we scan past the value to find it, then come back here. 1399| | // We currently don't do this for vectors of unions because the 1400| | // scanning/serialization logic would get very complicated. 1401| 0| auto type_name = field->name + UnionTypeFieldSuffix(); 1402| 0| FLATBUFFERS_ASSERT(parent_struct_def); 1403| 0| auto type_field = parent_struct_def->fields.Lookup(type_name); 1404| 0| FLATBUFFERS_ASSERT(type_field); // Guaranteed by ParseField(). 1405| | // Remember where we are in the source file, so we can come back here. 1406| 0| auto backup = *static_cast(this); 1407| 0| ECHECK(SkipAnyJsonValue()); // The table. ------------------ | | 56| 0| { \ | | 57| 0| auto ce = (call); \ | | 58| 0| if (ce.Check()) return ce; \ | | ------------------ | | | Branch (58:9): [True: 0, False: 0] | | ------------------ | | 59| 0| } ------------------ 1408| 0| ECHECK(ParseComma()); ------------------ | | 56| 0| { \ | | 57| 0| auto ce = (call); \ | | 58| 0| if (ce.Check()) return ce; \ | | ------------------ | | | Branch (58:9): [True: 0, False: 0] | | ------------------ | | 59| 0| } ------------------ 1409| 0| auto next_name = attribute_; 1410| 0| if (Is(kTokenStringConstant)) { ------------------ | Branch (1410:13): [True: 0, False: 0] ------------------ 1411| 0| NEXT(); ------------------ | | 63| 0|#define NEXT() ECHECK(Next()) | | ------------------ | | | | 56| 0| { \ | | | | 57| 0| auto ce = (call); \ | | | | 58| 0| if (ce.Check()) return ce; \ | | | | ------------------ | | | | | Branch (58:9): [True: 0, False: 0] | | | | ------------------ | | | | 59| 0| } | | ------------------ ------------------ 1412| 0| } else { 1413| 0| EXPECT(kTokenIdentifier); ------------------ | | 64| 0|#define EXPECT(tok) ECHECK(Expect(tok)) | | ------------------ | | | | 56| 0| { \ | | | | 57| 0| auto ce = (call); \ | | | | 58| 0| if (ce.Check()) return ce; \ | | | | ------------------ | | | | | Branch (58:9): [True: 0, False: 0] | | | | ------------------ | | | | 59| 0| } | | ------------------ ------------------ 1414| 0| } 1415| 0| if (next_name == type_name) { ------------------ | Branch (1415:13): [True: 0, False: 0] ------------------ 1416| 0| EXPECT(':'); ------------------ | | 64| 0|#define EXPECT(tok) ECHECK(Expect(tok)) | | ------------------ | | | | 56| 0| { \ | | | | 57| 0| auto ce = (call); \ | | | | 58| 0| if (ce.Check()) return ce; \ | | | | ------------------ | | | | | Branch (58:9): [True: 0, False: 0] | | | | ------------------ | | | | 59| 0| } | | ------------------ ------------------ 1417| 0| ParseDepthGuard depth_guard(this); 1418| 0| ECHECK(depth_guard.Check()); ------------------ | | 56| 0| { \ | | 57| 0| auto ce = (call); \ | | 58| 0| if (ce.Check()) return ce; \ | | ------------------ | | | Branch (58:9): [True: 0, False: 0] | | ------------------ | | 59| 0| } ------------------ 1419| 0| Value type_val = type_field->value; 1420| 0| ECHECK(ParseAnyValue(type_val, type_field, 0, nullptr, 0)); ------------------ | | 56| 0| { \ | | 57| 0| auto ce = (call); \ | | 58| 0| if (ce.Check()) return ce; \ | | ------------------ | | | Branch (58:9): [True: 0, False: 0] | | ------------------ | | 59| 0| } ------------------ 1421| 0| constant = type_val.constant; 1422| | // Got the information we needed, now rewind: 1423| 0| *static_cast(this) = backup; 1424| 0| } 1425| 0| } 1426| 0| if (constant.empty() && !vector_of_union_types) { ------------------ | Branch (1426:11): [True: 0, False: 0] | Branch (1426:31): [True: 0, False: 0] ------------------ 1427| 0| return Error("missing type field for this union value: " + field->name); 1428| 0| } 1429| 0| uint8_t enum_idx; 1430| 0| if (vector_of_union_types) { ------------------ | Branch (1430:11): [True: 0, False: 0] ------------------ 1431| 0| if (vector_of_union_types->size() <= count) ------------------ | Branch (1431:13): [True: 0, False: 0] ------------------ 1432| 0| return Error( 1433| 0| "union types vector smaller than union values vector for: " + 1434| 0| field->name); 1435| 0| enum_idx = vector_of_union_types->Get(static_cast(count)); 1436| 0| } else { 1437| 0| ECHECK(atot(constant.c_str(), *this, &enum_idx)); ------------------ | | 56| 0| { \ | | 57| 0| auto ce = (call); \ | | 58| 0| if (ce.Check()) return ce; \ | | ------------------ | | | Branch (58:9): [True: 0, False: 0] | | ------------------ | | 59| 0| } ------------------ 1438| 0| } 1439| 0| auto enum_val = val.type.enum_def->ReverseLookup(enum_idx, true); 1440| 0| if (!enum_val) return Error("illegal type id for: " + field->name); ------------------ | Branch (1440:11): [True: 0, False: 0] ------------------ 1441| 0| if (enum_val->union_type.base_type == BASE_TYPE_STRUCT) { ------------------ | Branch (1441:11): [True: 0, False: 0] ------------------ 1442| 0| ECHECK(ParseTable(*enum_val->union_type.struct_def, &val.constant, ------------------ | | 56| 0| { \ | | 57| 0| auto ce = (call); \ | | 58| 0| if (ce.Check()) return ce; \ | | ------------------ | | | Branch (58:9): [True: 0, False: 0] | | ------------------ | | 59| 0| } ------------------ 1443| 0| nullptr)); 1444| 0| if (enum_val->union_type.struct_def->fixed) { ------------------ | Branch (1444:13): [True: 0, False: 0] ------------------ 1445| | // All BASE_TYPE_UNION values are offsets, so turn this into one. 1446| 0| SerializeStruct(*enum_val->union_type.struct_def, val); 1447| 0| builder_.ClearOffsets(); 1448| 0| val.constant = NumToString(builder_.GetSize()); 1449| 0| } 1450| 0| } else if (IsString(enum_val->union_type)) { ------------------ | Branch (1450:18): [True: 0, False: 0] ------------------ 1451| 0| ECHECK(ParseString(val, field->shared)); ------------------ | | 56| 0| { \ | | 57| 0| auto ce = (call); \ | | 58| 0| if (ce.Check()) return ce; \ | | ------------------ | | | Branch (58:9): [True: 0, False: 0] | | ------------------ | | 59| 0| } ------------------ 1452| 0| } else { 1453| 0| FLATBUFFERS_ASSERT(false); 1454| 0| } 1455| 0| break; 1456| 0| } 1457| 0| case BASE_TYPE_STRUCT: ------------------ | Branch (1457:5): [True: 0, False: 567k] ------------------ 1458| 0| ECHECK(ParseTable(*val.type.struct_def, &val.constant, nullptr)); ------------------ | | 56| 0| { \ | | 57| 0| auto ce = (call); \ | | 58| 0| if (ce.Check()) return ce; \ | | ------------------ | | | Branch (58:9): [True: 0, False: 0] | | ------------------ | | 59| 0| } ------------------ 1459| 0| break; 1460| 0| case BASE_TYPE_STRING: { ------------------ | Branch (1460:5): [True: 0, False: 567k] ------------------ 1461| 0| ECHECK(ParseString(val, field->shared)); ------------------ | | 56| 0| { \ | | 57| 0| auto ce = (call); \ | | 58| 0| if (ce.Check()) return ce; \ | | ------------------ | | | Branch (58:9): [True: 0, False: 0] | | ------------------ | | 59| 0| } ------------------ 1462| 0| break; 1463| 0| } 1464| 0| case BASE_TYPE_VECTOR64: ------------------ | Branch (1464:5): [True: 0, False: 567k] ------------------ 1465| 0| case BASE_TYPE_VECTOR: { ------------------ | Branch (1465:5): [True: 0, False: 567k] ------------------ 1466| 0| uoffset_t off; 1467| 0| ECHECK(ParseVector(val.type, &off, field, parent_fieldn)); ------------------ | | 56| 0| { \ | | 57| 0| auto ce = (call); \ | | 58| 0| if (ce.Check()) return ce; \ | | ------------------ | | | Branch (58:9): [True: 0, False: 0] | | ------------------ | | 59| 0| } ------------------ 1468| 0| val.constant = NumToString(off); 1469| 0| break; 1470| 0| } 1471| 0| case BASE_TYPE_ARRAY: { ------------------ | Branch (1471:5): [True: 0, False: 567k] ------------------ 1472| 0| ECHECK(ParseArray(val)); ------------------ | | 56| 0| { \ | | 57| 0| auto ce = (call); \ | | 58| 0| if (ce.Check()) return ce; \ | | ------------------ | | | Branch (58:9): [True: 0, False: 0] | | ------------------ | | 59| 0| } ------------------ 1473| 0| break; 1474| 0| } 1475| 56.4k| case BASE_TYPE_INT: ------------------ | Branch (1475:5): [True: 56.4k, False: 510k] ------------------ 1476| 106k| case BASE_TYPE_UINT: ------------------ | Branch (1476:5): [True: 50.0k, False: 517k] ------------------ 1477| 149k| case BASE_TYPE_LONG: ------------------ | Branch (1477:5): [True: 42.8k, False: 524k] ------------------ 1478| 205k| case BASE_TYPE_ULONG: { ------------------ | Branch (1478:5): [True: 56.1k, False: 511k] ------------------ 1479| 205k| if (field && field->attributes.Lookup("hash") && ------------------ | Branch (1479:11): [True: 205k, False: 0] | Branch (1479:11): [True: 0, False: 205k] | Branch (1479:20): [True: 0, False: 205k] ------------------ 1480| 0| (token_ == kTokenIdentifier || token_ == kTokenStringConstant)) { ------------------ | Branch (1480:12): [True: 0, False: 0] | Branch (1480:42): [True: 0, False: 0] ------------------ 1481| 0| ECHECK(ParseHash(val, field)); ------------------ | | 56| 0| { \ | | 57| 0| auto ce = (call); \ | | 58| 0| if (ce.Check()) return ce; \ | | ------------------ | | | Branch (58:9): [True: 0, False: 0] | | ------------------ | | 59| 0| } ------------------ 1482| 205k| } else { 1483| 205k| ECHECK(ParseSingleValue(field ? &field->name : nullptr, val, false)); ------------------ | | 56| 205k| { \ | | 57| 410k| auto ce = (call); \ | | ------------------ | | | Branch (57:16): [True: 205k, False: 0] | | ------------------ | | 58| 205k| if (ce.Check()) return ce; \ | | ------------------ | | | Branch (58:9): [True: 27.2k, False: 178k] | | ------------------ | | 59| 205k| } ------------------ 1484| 178k| } 1485| 178k| break; 1486| 205k| } 1487| 361k| default: ------------------ | Branch (1487:5): [True: 361k, False: 205k] ------------------ 1488| 361k| ECHECK(ParseSingleValue(field ? &field->name : nullptr, val, false)); ------------------ | | 56| 361k| { \ | | 57| 723k| auto ce = (call); \ | | ------------------ | | | Branch (57:16): [True: 361k, False: 0] | | ------------------ | | 58| 361k| if (ce.Check()) return ce; \ | | ------------------ | | | Branch (58:9): [True: 79.1k, False: 282k] | | ------------------ | | 59| 361k| } ------------------ 1489| 282k| break; 1490| 567k| } 1491| 460k| return NoError(); 1492| 567k|} _ZN11flatbuffers6Parser10ParseTableERKNS_9StructDefEPNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEPj: 1549| 764k| uoffset_t* ovalue) { 1550| 764k| ParseDepthGuard depth_guard(this); 1551| 764k| ECHECK(depth_guard.Check()); ------------------ | | 56| 764k| { \ | | 57| 764k| auto ce = (call); \ | | 58| 764k| if (ce.Check()) return ce; \ | | ------------------ | | | Branch (58:9): [True: 0, False: 764k] | | ------------------ | | 59| 764k| } ------------------ 1552| | 1553| 764k| size_t fieldn_outer = 0; 1554| 764k| auto err = ParseTableDelimiters( 1555| 764k| fieldn_outer, &struct_def, 1556| 764k| [&](const std::string& name, size_t& fieldn, 1557| 764k| const StructDef* struct_def_inner) -> CheckedError { 1558| 764k| if (name == "$schema") { 1559| 764k| ECHECK(Expect(kTokenStringConstant)); 1560| 764k| return NoError(); 1561| 764k| } 1562| 764k| auto field = struct_def_inner->fields.Lookup(name); 1563| 764k| if (!field) { 1564| 764k| if (!opts.skip_unexpected_fields_in_json) { 1565| 764k| return Error("unknown field: " + name); 1566| 764k| } else { 1567| 764k| ECHECK(SkipAnyJsonValue()); 1568| 764k| } 1569| 764k| } else { 1570| 764k| if (IsIdent("null") && !IsScalar(field->value.type.base_type)) { 1571| 764k| ECHECK(Next()); // Ignore this field. 1572| 764k| } else { 1573| 764k| Value val = field->value; 1574| 764k| if (field->flexbuffer) { 1575| 764k| flexbuffers::Builder builder(1024, 1576| 764k| flexbuffers::BUILDER_FLAG_SHARE_ALL); 1577| 764k| ECHECK(ParseFlexBufferValue(&builder)); 1578| 764k| builder.Finish(); 1579| | // Force alignment for nested flexbuffer 1580| 764k| builder_.ForceVectorAlignment(builder.GetSize(), sizeof(uint8_t), 1581| 764k| sizeof(largest_scalar_t)); 1582| 764k| auto off = builder_.CreateVector(builder.GetBuffer()); 1583| 764k| val.constant = NumToString(off.o); 1584| 764k| } else if (field->nested_flatbuffer) { 1585| 764k| ECHECK( 1586| 764k| ParseNestedFlatbuffer(val, field, fieldn, struct_def_inner)); 1587| 764k| } else { 1588| 764k| ECHECK(ParseAnyValue(val, field, fieldn, struct_def_inner, 0)); 1589| 764k| } 1590| | // Hardcoded insertion-sort with error-check. 1591| | // If fields are specified in order, then this loop exits 1592| | // immediately. 1593| 764k| auto elem = field_stack_.rbegin(); 1594| 764k| for (; elem != field_stack_.rbegin() + fieldn; ++elem) { 1595| 764k| auto existing_field = elem->second; 1596| 764k| if (existing_field == field) 1597| 764k| return Error("field set more than once: " + field->name); 1598| 764k| if (existing_field->value.offset < field->value.offset) break; 1599| 764k| } 1600| | // Note: elem points to before the insertion point, thus .base() 1601| | // points to the correct spot. 1602| 764k| field_stack_.insert(elem.base(), std::make_pair(val, field)); 1603| 764k| fieldn++; 1604| 764k| } 1605| 764k| } 1606| 764k| return NoError(); 1607| 764k| }); 1608| 764k| ECHECK(err); ------------------ | | 56| 764k| { \ | | 57| 764k| auto ce = (call); \ | | 58| 764k| if (ce.Check()) return ce; \ | | ------------------ | | | Branch (58:9): [True: 257k, False: 507k] | | ------------------ | | 59| 764k| } ------------------ 1609| | 1610| | // Check if all required fields are parsed. 1611| 507k| for (auto field_it = struct_def.fields.vec.begin(); 1612| 1.01M| field_it != struct_def.fields.vec.end(); ++field_it) { ------------------ | Branch (1612:8): [True: 507k, False: 507k] ------------------ 1613| 507k| auto required_field = *field_it; 1614| 507k| if (!required_field->IsRequired()) { ------------------ | Branch (1614:9): [True: 507k, False: 0] ------------------ 1615| 507k| continue; 1616| 507k| } 1617| 0| bool found = false; 1618| 0| for (auto pf_it = field_stack_.end() - fieldn_outer; 1619| 0| pf_it != field_stack_.end(); ++pf_it) { ------------------ | Branch (1619:10): [True: 0, False: 0] ------------------ 1620| 0| auto parsed_field = pf_it->second; 1621| 0| if (parsed_field == required_field) { ------------------ | Branch (1621:11): [True: 0, False: 0] ------------------ 1622| 0| found = true; 1623| 0| break; 1624| 0| } 1625| 0| } 1626| 0| if (!found) { ------------------ | Branch (1626:9): [True: 0, False: 0] ------------------ 1627| 0| return Error("required field is missing: " + required_field->name + 1628| 0| " in " + struct_def.name); 1629| 0| } 1630| 0| } 1631| | 1632| 507k| if (struct_def.fixed && fieldn_outer != struct_def.fields.vec.size()) ------------------ | Branch (1632:7): [True: 0, False: 507k] | Branch (1632:27): [True: 0, False: 0] ------------------ 1633| 0| return Error("struct: wrong number of initializers: " + struct_def.name); 1634| | 1635| 507k| auto start = struct_def.fixed ? builder_.StartStruct(struct_def.minalign) ------------------ | Branch (1635:16): [True: 0, False: 507k] ------------------ 1636| 507k| : builder_.StartTable(); 1637| | 1638| 2.01M| for (size_t size = struct_def.sortbysize ? sizeof(largest_scalar_t) : 1; size; ------------------ | Branch (1638:22): [True: 507k, False: 0] | Branch (1638:76): [True: 1.72M, False: 290k] ------------------ 1639| 1.72M| size /= 2) { 1640| | // Go through elements in reverse, since we're building the data backwards. 1641| | // TODO(derekbailey): this doesn't work when there are Offset64 fields, as 1642| | // those have to be built first. So this needs to be changed to iterate over 1643| | // Offset64 then Offset32 fields. 1644| 1.72M| for (auto it = field_stack_.rbegin(); 1645| 2.84M| it != field_stack_.rbegin() + fieldn_outer; ++it) { ------------------ | Branch (1645:10): [True: 1.33M, False: 1.50M] ------------------ 1646| 1.33M| auto& field_value = it->first; 1647| 1.33M| auto field = it->second; 1648| 1.33M| if (!struct_def.sortbysize || ------------------ | Branch (1648:11): [True: 0, False: 1.33M] ------------------ 1649| 1.33M| size == SizeOf(field_value.type.base_type)) { ------------------ | Branch (1649:11): [True: 408k, False: 923k] ------------------ 1650| 408k| switch (field_value.type.base_type) { ------------------ | Branch (1650:17): [True: 408k, False: 0] ------------------ 1651| | // clang-format off 1652| 0| #define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE, ...) \ 1653| 0| case BASE_TYPE_ ## ENUM: \ 1654| 0| builder_.Pad(field->padding); \ 1655| 0| if (struct_def.fixed) { \ 1656| 0| CTYPE val; \ 1657| 0| ECHECK(atot(field_value.constant.c_str(), *this, &val)); \ 1658| 0| builder_.PushElement(val); \ 1659| 0| } else { \ 1660| 0| if (field->IsScalarOptional()) { \ 1661| 0| if (field_value.constant != "null") { \ 1662| 0| CTYPE val; \ 1663| 0| ECHECK(atot(field_value.constant.c_str(), *this, &val)); \ 1664| 0| builder_.AddElement(field_value.offset, val); \ 1665| 0| } \ 1666| 0| } else { \ 1667| 0| CTYPE val, valdef; \ 1668| 0| ECHECK(atot(field_value.constant.c_str(), *this, &val)); \ 1669| 0| ECHECK(atot(field->value.constant.c_str(), *this, &valdef)); \ 1670| 0| builder_.AddElement(field_value.offset, val, valdef); \ 1671| 0| } \ 1672| 0| } \ 1673| 0| break; 1674| 408k| FLATBUFFERS_GEN_TYPES_SCALAR(FLATBUFFERS_TD) ------------------ | | 50| 0| TD(NONE, "", uint8_t, byte, byte, byte, uint8, u8, UByte, UInt8, 0) \ | | ------------------ | | | | 1674| 0| FLATBUFFERS_GEN_TYPES_SCALAR(FLATBUFFERS_TD) | | | | ------------------ | | | | | | 1653| 0| case BASE_TYPE_ ## ENUM: \ | | | | | | ------------------ | | | | | | | Branch (1653:13): [True: 0, False: 408k] | | | | | | ------------------ | | | | | | 1654| 0| builder_.Pad(field->padding); \ | | | | | | 1655| 0| if (struct_def.fixed) { \ | | | | | | ------------------ | | | | | | | Branch (1655:19): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 1656| 0| CTYPE val; \ | | | | | | 1657| 0| ECHECK(atot(field_value.constant.c_str(), *this, &val)); \ | | | | | | ------------------ | | | | | | | | 56| 0| { \ | | | | | | | | 57| 0| auto ce = (call); \ | | | | | | | | 58| 0| if (ce.Check()) return ce; \ | | | | | | | | ------------------ | | | | | | | | | Branch (58:9): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 59| 0| } | | | | | | ------------------ | | | | | | 1658| 0| builder_.PushElement(val); \ | | | | | | 1659| 0| } else { \ | | | | | | 1660| 0| if (field->IsScalarOptional()) { \ | | | | | | ------------------ | | | | | | | Branch (1660:21): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 1661| 0| if (field_value.constant != "null") { \ | | | | | | ------------------ | | | | | | | Branch (1661:23): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 1662| 0| CTYPE val; \ | | | | | | 1663| 0| ECHECK(atot(field_value.constant.c_str(), *this, &val)); \ | | | | | | ------------------ | | | | | | | | 56| 0| { \ | | | | | | | | 57| 0| auto ce = (call); \ | | | | | | | | 58| 0| if (ce.Check()) return ce; \ | | | | | | | | ------------------ | | | | | | | | | Branch (58:9): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 59| 0| } | | | | | | ------------------ | | | | | | 1664| 0| builder_.AddElement(field_value.offset, val); \ | | | | | | 1665| 0| } \ | | | | | | 1666| 0| } else { \ | | | | | | 1667| 0| CTYPE val, valdef; \ | | | | | | 1668| 0| ECHECK(atot(field_value.constant.c_str(), *this, &val)); \ | | | | | | ------------------ | | | | | | | | 56| 0| { \ | | | | | | | | 57| 0| auto ce = (call); \ | | | | | | | | 58| 0| if (ce.Check()) return ce; \ | | | | | | | | ------------------ | | | | | | | | | Branch (58:9): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 59| 0| } | | | | | | ------------------ | | | | | | 1669| 0| ECHECK(atot(field->value.constant.c_str(), *this, &valdef)); \ | | | | | | ------------------ | | | | | | | | 56| 0| { \ | | | | | | | | 57| 0| auto ce = (call); \ | | | | | | | | 58| 0| if (ce.Check()) return ce; \ | | | | | | | | ------------------ | | | | | | | | | Branch (58:9): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 59| 0| } | | | | | | ------------------ | | | | | | 1670| 0| builder_.AddElement(field_value.offset, val, valdef); \ | | | | | | 1671| 0| } \ | | | | | | 1672| 0| } \ | | | | | | 1673| 0| break; | | | | ------------------ | | ------------------ | | 51| 0| TD(UTYPE, "", uint8_t, byte, byte, byte, uint8, u8, UByte, UInt8, 1) /* begin scalar/int */ \ | | ------------------ | | | | 1674| 0| FLATBUFFERS_GEN_TYPES_SCALAR(FLATBUFFERS_TD) | | | | ------------------ | | | | | | 1653| 0| case BASE_TYPE_ ## ENUM: \ | | | | | | ------------------ | | | | | | | Branch (1653:13): [True: 0, False: 408k] | | | | | | ------------------ | | | | | | 1654| 0| builder_.Pad(field->padding); \ | | | | | | 1655| 0| if (struct_def.fixed) { \ | | | | | | ------------------ | | | | | | | Branch (1655:19): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 1656| 0| CTYPE val; \ | | | | | | 1657| 0| ECHECK(atot(field_value.constant.c_str(), *this, &val)); \ | | | | | | ------------------ | | | | | | | | 56| 0| { \ | | | | | | | | 57| 0| auto ce = (call); \ | | | | | | | | 58| 0| if (ce.Check()) return ce; \ | | | | | | | | ------------------ | | | | | | | | | Branch (58:9): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 59| 0| } | | | | | | ------------------ | | | | | | 1658| 0| builder_.PushElement(val); \ | | | | | | 1659| 0| } else { \ | | | | | | 1660| 0| if (field->IsScalarOptional()) { \ | | | | | | ------------------ | | | | | | | Branch (1660:21): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 1661| 0| if (field_value.constant != "null") { \ | | | | | | ------------------ | | | | | | | Branch (1661:23): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 1662| 0| CTYPE val; \ | | | | | | 1663| 0| ECHECK(atot(field_value.constant.c_str(), *this, &val)); \ | | | | | | ------------------ | | | | | | | | 56| 0| { \ | | | | | | | | 57| 0| auto ce = (call); \ | | | | | | | | 58| 0| if (ce.Check()) return ce; \ | | | | | | | | ------------------ | | | | | | | | | Branch (58:9): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 59| 0| } | | | | | | ------------------ | | | | | | 1664| 0| builder_.AddElement(field_value.offset, val); \ | | | | | | 1665| 0| } \ | | | | | | 1666| 0| } else { \ | | | | | | 1667| 0| CTYPE val, valdef; \ | | | | | | 1668| 0| ECHECK(atot(field_value.constant.c_str(), *this, &val)); \ | | | | | | ------------------ | | | | | | | | 56| 0| { \ | | | | | | | | 57| 0| auto ce = (call); \ | | | | | | | | 58| 0| if (ce.Check()) return ce; \ | | | | | | | | ------------------ | | | | | | | | | Branch (58:9): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 59| 0| } | | | | | | ------------------ | | | | | | 1669| 0| ECHECK(atot(field->value.constant.c_str(), *this, &valdef)); \ | | | | | | ------------------ | | | | | | | | 56| 0| { \ | | | | | | | | 57| 0| auto ce = (call); \ | | | | | | | | 58| 0| if (ce.Check()) return ce; \ | | | | | | | | ------------------ | | | | | | | | | Branch (58:9): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 59| 0| } | | | | | | ------------------ | | | | | | 1670| 0| builder_.AddElement(field_value.offset, val, valdef); \ | | | | | | 1671| 0| } \ | | | | | | 1672| 0| } \ | | | | | | 1673| 0| break; | | | | ------------------ | | ------------------ | | 52| 29.7k| TD(BOOL, "bool", uint8_t, boolean,bool, bool, bool, bool, Boolean, Bool, 2) \ | | ------------------ | | | | 1674| 29.7k| FLATBUFFERS_GEN_TYPES_SCALAR(FLATBUFFERS_TD) | | | | ------------------ | | | | | | 1653| 29.7k| case BASE_TYPE_ ## ENUM: \ | | | | | | ------------------ | | | | | | | Branch (1653:13): [True: 29.7k, False: 379k] | | | | | | ------------------ | | | | | | 1654| 10.9k| builder_.Pad(field->padding); \ | | | | | | 1655| 29.7k| if (struct_def.fixed) { \ | | | | | | ------------------ | | | | | | | Branch (1655:19): [True: 0, False: 29.7k] | | | | | | ------------------ | | | | | | 1656| 0| CTYPE val; \ | | | | | | 1657| 0| ECHECK(atot(field_value.constant.c_str(), *this, &val)); \ | | | | | | ------------------ | | | | | | | | 56| 0| { \ | | | | | | | | 57| 0| auto ce = (call); \ | | | | | | | | 58| 0| if (ce.Check()) return ce; \ | | | | | | | | ------------------ | | | | | | | | | Branch (58:9): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 59| 0| } | | | | | | ------------------ | | | | | | 1658| 0| builder_.PushElement(val); \ | | | | | | 1659| 29.7k| } else { \ | | | | | | 1660| 29.7k| if (field->IsScalarOptional()) { \ | | | | | | ------------------ | | | | | | | Branch (1660:21): [True: 0, False: 29.7k] | | | | | | ------------------ | | | | | | 1661| 0| if (field_value.constant != "null") { \ | | | | | | ------------------ | | | | | | | Branch (1661:23): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 1662| 0| CTYPE val; \ | | | | | | 1663| 0| ECHECK(atot(field_value.constant.c_str(), *this, &val)); \ | | | | | | ------------------ | | | | | | | | 56| 0| { \ | | | | | | | | 57| 0| auto ce = (call); \ | | | | | | | | 58| 0| if (ce.Check()) return ce; \ | | | | | | | | ------------------ | | | | | | | | | Branch (58:9): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 59| 0| } | | | | | | ------------------ | | | | | | 1664| 0| builder_.AddElement(field_value.offset, val); \ | | | | | | 1665| 0| } \ | | | | | | 1666| 29.7k| } else { \ | | | | | | 1667| 29.7k| CTYPE val, valdef; \ | | | | | | 1668| 29.7k| ECHECK(atot(field_value.constant.c_str(), *this, &val)); \ | | | | | | ------------------ | | | | | | | | 56| 29.7k| { \ | | | | | | | | 57| 29.7k| auto ce = (call); \ | | | | | | | | 58| 29.7k| if (ce.Check()) return ce; \ | | | | | | | | ------------------ | | | | | | | | | Branch (58:9): [True: 18.8k, False: 10.9k] | | | | | | | | ------------------ | | | | | | | | 59| 29.7k| } | | | | | | ------------------ | | | | | | 1669| 10.9k| ECHECK(atot(field->value.constant.c_str(), *this, &valdef)); \ | | | | | | ------------------ | | | | | | | | 56| 10.9k| { \ | | | | | | | | 57| 10.9k| auto ce = (call); \ | | | | | | | | 58| 10.9k| if (ce.Check()) return ce; \ | | | | | | | | ------------------ | | | | | | | | | Branch (58:9): [True: 0, False: 10.9k] | | | | | | | | ------------------ | | | | | | | | 59| 10.9k| } | | | | | | ------------------ | | | | | | 1670| 10.9k| builder_.AddElement(field_value.offset, val, valdef); \ | | | | | | 1671| 10.9k| } \ | | | | | | 1672| 29.7k| } \ | | | | | | 1673| 10.9k| break; | | | | ------------------ | | ------------------ | | 53| 38.8k| TD(CHAR, "byte", int8_t, byte, int8, sbyte, int8, i8, Byte, Int8, 3) \ | | ------------------ | | | | 1674| 38.8k| FLATBUFFERS_GEN_TYPES_SCALAR(FLATBUFFERS_TD) | | | | ------------------ | | | | | | 1653| 38.8k| case BASE_TYPE_ ## ENUM: \ | | | | | | ------------------ | | | | | | | Branch (1653:13): [True: 38.8k, False: 369k] | | | | | | ------------------ | | | | | | 1654| 11.0k| builder_.Pad(field->padding); \ | | | | | | 1655| 38.8k| if (struct_def.fixed) { \ | | | | | | ------------------ | | | | | | | Branch (1655:19): [True: 0, False: 38.8k] | | | | | | ------------------ | | | | | | 1656| 0| CTYPE val; \ | | | | | | 1657| 0| ECHECK(atot(field_value.constant.c_str(), *this, &val)); \ | | | | | | ------------------ | | | | | | | | 56| 0| { \ | | | | | | | | 57| 0| auto ce = (call); \ | | | | | | | | 58| 0| if (ce.Check()) return ce; \ | | | | | | | | ------------------ | | | | | | | | | Branch (58:9): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 59| 0| } | | | | | | ------------------ | | | | | | 1658| 0| builder_.PushElement(val); \ | | | | | | 1659| 38.8k| } else { \ | | | | | | 1660| 38.8k| if (field->IsScalarOptional()) { \ | | | | | | ------------------ | | | | | | | Branch (1660:21): [True: 0, False: 38.8k] | | | | | | ------------------ | | | | | | 1661| 0| if (field_value.constant != "null") { \ | | | | | | ------------------ | | | | | | | Branch (1661:23): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 1662| 0| CTYPE val; \ | | | | | | 1663| 0| ECHECK(atot(field_value.constant.c_str(), *this, &val)); \ | | | | | | ------------------ | | | | | | | | 56| 0| { \ | | | | | | | | 57| 0| auto ce = (call); \ | | | | | | | | 58| 0| if (ce.Check()) return ce; \ | | | | | | | | ------------------ | | | | | | | | | Branch (58:9): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 59| 0| } | | | | | | ------------------ | | | | | | 1664| 0| builder_.AddElement(field_value.offset, val); \ | | | | | | 1665| 0| } \ | | | | | | 1666| 38.8k| } else { \ | | | | | | 1667| 38.8k| CTYPE val, valdef; \ | | | | | | 1668| 38.8k| ECHECK(atot(field_value.constant.c_str(), *this, &val)); \ | | | | | | ------------------ | | | | | | | | 56| 38.8k| { \ | | | | | | | | 57| 38.8k| auto ce = (call); \ | | | | | | | | 58| 38.8k| if (ce.Check()) return ce; \ | | | | | | | | ------------------ | | | | | | | | | Branch (58:9): [True: 27.8k, False: 11.0k] | | | | | | | | ------------------ | | | | | | | | 59| 38.8k| } | | | | | | ------------------ | | | | | | 1669| 11.0k| ECHECK(atot(field->value.constant.c_str(), *this, &valdef)); \ | | | | | | ------------------ | | | | | | | | 56| 11.0k| { \ | | | | | | | | 57| 11.0k| auto ce = (call); \ | | | | | | | | 58| 11.0k| if (ce.Check()) return ce; \ | | | | | | | | ------------------ | | | | | | | | | Branch (58:9): [True: 0, False: 11.0k] | | | | | | | | ------------------ | | | | | | | | 59| 11.0k| } | | | | | | ------------------ | | | | | | 1670| 11.0k| builder_.AddElement(field_value.offset, val, valdef); \ | | | | | | 1671| 11.0k| } \ | | | | | | 1672| 38.8k| } \ | | | | | | 1673| 11.0k| break; | | | | ------------------ | | ------------------ | | 54| 23.7k| TD(UCHAR, "ubyte", uint8_t, byte, byte, byte, uint8, u8, UByte, UInt8, 4) \ | | ------------------ | | | | 1674| 23.7k| FLATBUFFERS_GEN_TYPES_SCALAR(FLATBUFFERS_TD) | | | | ------------------ | | | | | | 1653| 23.7k| case BASE_TYPE_ ## ENUM: \ | | | | | | ------------------ | | | | | | | Branch (1653:13): [True: 23.7k, False: 385k] | | | | | | ------------------ | | | | | | 1654| 6.29k| builder_.Pad(field->padding); \ | | | | | | 1655| 23.7k| if (struct_def.fixed) { \ | | | | | | ------------------ | | | | | | | Branch (1655:19): [True: 0, False: 23.7k] | | | | | | ------------------ | | | | | | 1656| 0| CTYPE val; \ | | | | | | 1657| 0| ECHECK(atot(field_value.constant.c_str(), *this, &val)); \ | | | | | | ------------------ | | | | | | | | 56| 0| { \ | | | | | | | | 57| 0| auto ce = (call); \ | | | | | | | | 58| 0| if (ce.Check()) return ce; \ | | | | | | | | ------------------ | | | | | | | | | Branch (58:9): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 59| 0| } | | | | | | ------------------ | | | | | | 1658| 0| builder_.PushElement(val); \ | | | | | | 1659| 23.7k| } else { \ | | | | | | 1660| 23.7k| if (field->IsScalarOptional()) { \ | | | | | | ------------------ | | | | | | | Branch (1660:21): [True: 0, False: 23.7k] | | | | | | ------------------ | | | | | | 1661| 0| if (field_value.constant != "null") { \ | | | | | | ------------------ | | | | | | | Branch (1661:23): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 1662| 0| CTYPE val; \ | | | | | | 1663| 0| ECHECK(atot(field_value.constant.c_str(), *this, &val)); \ | | | | | | ------------------ | | | | | | | | 56| 0| { \ | | | | | | | | 57| 0| auto ce = (call); \ | | | | | | | | 58| 0| if (ce.Check()) return ce; \ | | | | | | | | ------------------ | | | | | | | | | Branch (58:9): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 59| 0| } | | | | | | ------------------ | | | | | | 1664| 0| builder_.AddElement(field_value.offset, val); \ | | | | | | 1665| 0| } \ | | | | | | 1666| 23.7k| } else { \ | | | | | | 1667| 23.7k| CTYPE val, valdef; \ | | | | | | 1668| 23.7k| ECHECK(atot(field_value.constant.c_str(), *this, &val)); \ | | | | | | ------------------ | | | | | | | | 56| 23.7k| { \ | | | | | | | | 57| 23.7k| auto ce = (call); \ | | | | | | | | 58| 23.7k| if (ce.Check()) return ce; \ | | | | | | | | ------------------ | | | | | | | | | Branch (58:9): [True: 17.4k, False: 6.29k] | | | | | | | | ------------------ | | | | | | | | 59| 23.7k| } | | | | | | ------------------ | | | | | | 1669| 6.29k| ECHECK(atot(field->value.constant.c_str(), *this, &valdef)); \ | | | | | | ------------------ | | | | | | | | 56| 6.29k| { \ | | | | | | | | 57| 6.29k| auto ce = (call); \ | | | | | | | | 58| 6.29k| if (ce.Check()) return ce; \ | | | | | | | | ------------------ | | | | | | | | | Branch (58:9): [True: 0, False: 6.29k] | | | | | | | | ------------------ | | | | | | | | 59| 6.29k| } | | | | | | ------------------ | | | | | | 1670| 6.29k| builder_.AddElement(field_value.offset, val, valdef); \ | | | | | | 1671| 6.29k| } \ | | | | | | 1672| 23.7k| } \ | | | | | | 1673| 6.29k| break; | | | | ------------------ | | ------------------ | | 55| 35.4k| TD(SHORT, "short", int16_t, short, int16, short, int16, i16, Short, Int16, 5) \ | | ------------------ | | | | 1674| 35.4k| FLATBUFFERS_GEN_TYPES_SCALAR(FLATBUFFERS_TD) | | | | ------------------ | | | | | | 1653| 35.4k| case BASE_TYPE_ ## ENUM: \ | | | | | | ------------------ | | | | | | | Branch (1653:13): [True: 35.4k, False: 373k] | | | | | | ------------------ | | | | | | 1654| 14.1k| builder_.Pad(field->padding); \ | | | | | | 1655| 35.4k| if (struct_def.fixed) { \ | | | | | | ------------------ | | | | | | | Branch (1655:19): [True: 0, False: 35.4k] | | | | | | ------------------ | | | | | | 1656| 0| CTYPE val; \ | | | | | | 1657| 0| ECHECK(atot(field_value.constant.c_str(), *this, &val)); \ | | | | | | ------------------ | | | | | | | | 56| 0| { \ | | | | | | | | 57| 0| auto ce = (call); \ | | | | | | | | 58| 0| if (ce.Check()) return ce; \ | | | | | | | | ------------------ | | | | | | | | | Branch (58:9): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 59| 0| } | | | | | | ------------------ | | | | | | 1658| 0| builder_.PushElement(val); \ | | | | | | 1659| 35.4k| } else { \ | | | | | | 1660| 35.4k| if (field->IsScalarOptional()) { \ | | | | | | ------------------ | | | | | | | Branch (1660:21): [True: 0, False: 35.4k] | | | | | | ------------------ | | | | | | 1661| 0| if (field_value.constant != "null") { \ | | | | | | ------------------ | | | | | | | Branch (1661:23): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 1662| 0| CTYPE val; \ | | | | | | 1663| 0| ECHECK(atot(field_value.constant.c_str(), *this, &val)); \ | | | | | | ------------------ | | | | | | | | 56| 0| { \ | | | | | | | | 57| 0| auto ce = (call); \ | | | | | | | | 58| 0| if (ce.Check()) return ce; \ | | | | | | | | ------------------ | | | | | | | | | Branch (58:9): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 59| 0| } | | | | | | ------------------ | | | | | | 1664| 0| builder_.AddElement(field_value.offset, val); \ | | | | | | 1665| 0| } \ | | | | | | 1666| 35.4k| } else { \ | | | | | | 1667| 35.4k| CTYPE val, valdef; \ | | | | | | 1668| 35.4k| ECHECK(atot(field_value.constant.c_str(), *this, &val)); \ | | | | | | ------------------ | | | | | | | | 56| 35.4k| { \ | | | | | | | | 57| 35.4k| auto ce = (call); \ | | | | | | | | 58| 35.4k| if (ce.Check()) return ce; \ | | | | | | | | ------------------ | | | | | | | | | Branch (58:9): [True: 21.3k, False: 14.1k] | | | | | | | | ------------------ | | | | | | | | 59| 35.4k| } | | | | | | ------------------ | | | | | | 1669| 14.1k| ECHECK(atot(field->value.constant.c_str(), *this, &valdef)); \ | | | | | | ------------------ | | | | | | | | 56| 14.1k| { \ | | | | | | | | 57| 14.1k| auto ce = (call); \ | | | | | | | | 58| 14.1k| if (ce.Check()) return ce; \ | | | | | | | | ------------------ | | | | | | | | | Branch (58:9): [True: 0, False: 14.1k] | | | | | | | | ------------------ | | | | | | | | 59| 14.1k| } | | | | | | ------------------ | | | | | | 1670| 14.1k| builder_.AddElement(field_value.offset, val, valdef); \ | | | | | | 1671| 14.1k| } \ | | | | | | 1672| 35.4k| } \ | | | | | | 1673| 14.1k| break; | | | | ------------------ | | ------------------ | | 56| 38.1k| TD(USHORT, "ushort", uint16_t, short, uint16, ushort, uint16, u16, UShort, UInt16, 6) \ | | ------------------ | | | | 1674| 38.1k| FLATBUFFERS_GEN_TYPES_SCALAR(FLATBUFFERS_TD) | | | | ------------------ | | | | | | 1653| 38.1k| case BASE_TYPE_ ## ENUM: \ | | | | | | ------------------ | | | | | | | Branch (1653:13): [True: 38.1k, False: 370k] | | | | | | ------------------ | | | | | | 1654| 14.3k| builder_.Pad(field->padding); \ | | | | | | 1655| 38.1k| if (struct_def.fixed) { \ | | | | | | ------------------ | | | | | | | Branch (1655:19): [True: 0, False: 38.1k] | | | | | | ------------------ | | | | | | 1656| 0| CTYPE val; \ | | | | | | 1657| 0| ECHECK(atot(field_value.constant.c_str(), *this, &val)); \ | | | | | | ------------------ | | | | | | | | 56| 0| { \ | | | | | | | | 57| 0| auto ce = (call); \ | | | | | | | | 58| 0| if (ce.Check()) return ce; \ | | | | | | | | ------------------ | | | | | | | | | Branch (58:9): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 59| 0| } | | | | | | ------------------ | | | | | | 1658| 0| builder_.PushElement(val); \ | | | | | | 1659| 38.1k| } else { \ | | | | | | 1660| 38.1k| if (field->IsScalarOptional()) { \ | | | | | | ------------------ | | | | | | | Branch (1660:21): [True: 0, False: 38.1k] | | | | | | ------------------ | | | | | | 1661| 0| if (field_value.constant != "null") { \ | | | | | | ------------------ | | | | | | | Branch (1661:23): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 1662| 0| CTYPE val; \ | | | | | | 1663| 0| ECHECK(atot(field_value.constant.c_str(), *this, &val)); \ | | | | | | ------------------ | | | | | | | | 56| 0| { \ | | | | | | | | 57| 0| auto ce = (call); \ | | | | | | | | 58| 0| if (ce.Check()) return ce; \ | | | | | | | | ------------------ | | | | | | | | | Branch (58:9): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 59| 0| } | | | | | | ------------------ | | | | | | 1664| 0| builder_.AddElement(field_value.offset, val); \ | | | | | | 1665| 0| } \ | | | | | | 1666| 38.1k| } else { \ | | | | | | 1667| 38.1k| CTYPE val, valdef; \ | | | | | | 1668| 38.1k| ECHECK(atot(field_value.constant.c_str(), *this, &val)); \ | | | | | | ------------------ | | | | | | | | 56| 38.1k| { \ | | | | | | | | 57| 38.1k| auto ce = (call); \ | | | | | | | | 58| 38.1k| if (ce.Check()) return ce; \ | | | | | | | | ------------------ | | | | | | | | | Branch (58:9): [True: 23.7k, False: 14.3k] | | | | | | | | ------------------ | | | | | | | | 59| 38.1k| } | | | | | | ------------------ | | | | | | 1669| 14.3k| ECHECK(atot(field->value.constant.c_str(), *this, &valdef)); \ | | | | | | ------------------ | | | | | | | | 56| 14.3k| { \ | | | | | | | | 57| 14.3k| auto ce = (call); \ | | | | | | | | 58| 14.3k| if (ce.Check()) return ce; \ | | | | | | | | ------------------ | | | | | | | | | Branch (58:9): [True: 0, False: 14.3k] | | | | | | | | ------------------ | | | | | | | | 59| 14.3k| } | | | | | | ------------------ | | | | | | 1670| 14.3k| builder_.AddElement(field_value.offset, val, valdef); \ | | | | | | 1671| 14.3k| } \ | | | | | | 1672| 38.1k| } \ | | | | | | 1673| 14.3k| break; | | | | ------------------ | | ------------------ | | 57| 45.0k| TD(INT, "int", int32_t, int, int32, int, int32, i32, Int, Int32, 7) \ | | ------------------ | | | | 1674| 45.0k| FLATBUFFERS_GEN_TYPES_SCALAR(FLATBUFFERS_TD) | | | | ------------------ | | | | | | 1653| 45.0k| case BASE_TYPE_ ## ENUM: \ | | | | | | ------------------ | | | | | | | Branch (1653:13): [True: 45.0k, False: 363k] | | | | | | ------------------ | | | | | | 1654| 24.8k| builder_.Pad(field->padding); \ | | | | | | 1655| 45.0k| if (struct_def.fixed) { \ | | | | | | ------------------ | | | | | | | Branch (1655:19): [True: 0, False: 45.0k] | | | | | | ------------------ | | | | | | 1656| 0| CTYPE val; \ | | | | | | 1657| 0| ECHECK(atot(field_value.constant.c_str(), *this, &val)); \ | | | | | | ------------------ | | | | | | | | 56| 0| { \ | | | | | | | | 57| 0| auto ce = (call); \ | | | | | | | | 58| 0| if (ce.Check()) return ce; \ | | | | | | | | ------------------ | | | | | | | | | Branch (58:9): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 59| 0| } | | | | | | ------------------ | | | | | | 1658| 0| builder_.PushElement(val); \ | | | | | | 1659| 45.0k| } else { \ | | | | | | 1660| 45.0k| if (field->IsScalarOptional()) { \ | | | | | | ------------------ | | | | | | | Branch (1660:21): [True: 0, False: 45.0k] | | | | | | ------------------ | | | | | | 1661| 0| if (field_value.constant != "null") { \ | | | | | | ------------------ | | | | | | | Branch (1661:23): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 1662| 0| CTYPE val; \ | | | | | | 1663| 0| ECHECK(atot(field_value.constant.c_str(), *this, &val)); \ | | | | | | ------------------ | | | | | | | | 56| 0| { \ | | | | | | | | 57| 0| auto ce = (call); \ | | | | | | | | 58| 0| if (ce.Check()) return ce; \ | | | | | | | | ------------------ | | | | | | | | | Branch (58:9): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 59| 0| } | | | | | | ------------------ | | | | | | 1664| 0| builder_.AddElement(field_value.offset, val); \ | | | | | | 1665| 0| } \ | | | | | | 1666| 45.0k| } else { \ | | | | | | 1667| 45.0k| CTYPE val, valdef; \ | | | | | | 1668| 45.0k| ECHECK(atot(field_value.constant.c_str(), *this, &val)); \ | | | | | | ------------------ | | | | | | | | 56| 45.0k| { \ | | | | | | | | 57| 45.0k| auto ce = (call); \ | | | | | | | | 58| 45.0k| if (ce.Check()) return ce; \ | | | | | | | | ------------------ | | | | | | | | | Branch (58:9): [True: 20.1k, False: 24.8k] | | | | | | | | ------------------ | | | | | | | | 59| 45.0k| } | | | | | | ------------------ | | | | | | 1669| 24.8k| ECHECK(atot(field->value.constant.c_str(), *this, &valdef)); \ | | | | | | ------------------ | | | | | | | | 56| 24.8k| { \ | | | | | | | | 57| 24.8k| auto ce = (call); \ | | | | | | | | 58| 24.8k| if (ce.Check()) return ce; \ | | | | | | | | ------------------ | | | | | | | | | Branch (58:9): [True: 0, False: 24.8k] | | | | | | | | ------------------ | | | | | | | | 59| 24.8k| } | | | | | | ------------------ | | | | | | 1670| 24.8k| builder_.AddElement(field_value.offset, val, valdef); \ | | | | | | 1671| 24.8k| } \ | | | | | | 1672| 45.0k| } \ | | | | | | 1673| 24.8k| break; | | | | ------------------ | | ------------------ | | 58| 40.5k| TD(UINT, "uint", uint32_t, int, uint32, uint, uint32, u32, UInt, UInt32, 8) \ | | ------------------ | | | | 1674| 40.5k| FLATBUFFERS_GEN_TYPES_SCALAR(FLATBUFFERS_TD) | | | | ------------------ | | | | | | 1653| 40.5k| case BASE_TYPE_ ## ENUM: \ | | | | | | ------------------ | | | | | | | Branch (1653:13): [True: 40.5k, False: 368k] | | | | | | ------------------ | | | | | | 1654| 17.0k| builder_.Pad(field->padding); \ | | | | | | 1655| 40.5k| if (struct_def.fixed) { \ | | | | | | ------------------ | | | | | | | Branch (1655:19): [True: 0, False: 40.5k] | | | | | | ------------------ | | | | | | 1656| 0| CTYPE val; \ | | | | | | 1657| 0| ECHECK(atot(field_value.constant.c_str(), *this, &val)); \ | | | | | | ------------------ | | | | | | | | 56| 0| { \ | | | | | | | | 57| 0| auto ce = (call); \ | | | | | | | | 58| 0| if (ce.Check()) return ce; \ | | | | | | | | ------------------ | | | | | | | | | Branch (58:9): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 59| 0| } | | | | | | ------------------ | | | | | | 1658| 0| builder_.PushElement(val); \ | | | | | | 1659| 40.5k| } else { \ | | | | | | 1660| 40.5k| if (field->IsScalarOptional()) { \ | | | | | | ------------------ | | | | | | | Branch (1660:21): [True: 0, False: 40.5k] | | | | | | ------------------ | | | | | | 1661| 0| if (field_value.constant != "null") { \ | | | | | | ------------------ | | | | | | | Branch (1661:23): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 1662| 0| CTYPE val; \ | | | | | | 1663| 0| ECHECK(atot(field_value.constant.c_str(), *this, &val)); \ | | | | | | ------------------ | | | | | | | | 56| 0| { \ | | | | | | | | 57| 0| auto ce = (call); \ | | | | | | | | 58| 0| if (ce.Check()) return ce; \ | | | | | | | | ------------------ | | | | | | | | | Branch (58:9): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 59| 0| } | | | | | | ------------------ | | | | | | 1664| 0| builder_.AddElement(field_value.offset, val); \ | | | | | | 1665| 0| } \ | | | | | | 1666| 40.5k| } else { \ | | | | | | 1667| 40.5k| CTYPE val, valdef; \ | | | | | | 1668| 40.5k| ECHECK(atot(field_value.constant.c_str(), *this, &val)); \ | | | | | | ------------------ | | | | | | | | 56| 40.5k| { \ | | | | | | | | 57| 40.5k| auto ce = (call); \ | | | | | | | | 58| 40.5k| if (ce.Check()) return ce; \ | | | | | | | | ------------------ | | | | | | | | | Branch (58:9): [True: 23.4k, False: 17.0k] | | | | | | | | ------------------ | | | | | | | | 59| 40.5k| } | | | | | | ------------------ | | | | | | 1669| 17.0k| ECHECK(atot(field->value.constant.c_str(), *this, &valdef)); \ | | | | | | ------------------ | | | | | | | | 56| 17.0k| { \ | | | | | | | | 57| 17.0k| auto ce = (call); \ | | | | | | | | 58| 17.0k| if (ce.Check()) return ce; \ | | | | | | | | ------------------ | | | | | | | | | Branch (58:9): [True: 0, False: 17.0k] | | | | | | | | ------------------ | | | | | | | | 59| 17.0k| } | | | | | | ------------------ | | | | | | 1670| 17.0k| builder_.AddElement(field_value.offset, val, valdef); \ | | | | | | 1671| 17.0k| } \ | | | | | | 1672| 40.5k| } \ | | | | | | 1673| 17.0k| break; | | | | ------------------ | | ------------------ | | 59| 33.3k| TD(LONG, "long", int64_t, long, int64, long, int64, i64, Long, Int64, 9) \ | | ------------------ | | | | 1674| 33.3k| FLATBUFFERS_GEN_TYPES_SCALAR(FLATBUFFERS_TD) | | | | ------------------ | | | | | | 1653| 33.3k| case BASE_TYPE_ ## ENUM: \ | | | | | | ------------------ | | | | | | | Branch (1653:13): [True: 33.3k, False: 375k] | | | | | | ------------------ | | | | | | 1654| 19.9k| builder_.Pad(field->padding); \ | | | | | | 1655| 33.3k| if (struct_def.fixed) { \ | | | | | | ------------------ | | | | | | | Branch (1655:19): [True: 0, False: 33.3k] | | | | | | ------------------ | | | | | | 1656| 0| CTYPE val; \ | | | | | | 1657| 0| ECHECK(atot(field_value.constant.c_str(), *this, &val)); \ | | | | | | ------------------ | | | | | | | | 56| 0| { \ | | | | | | | | 57| 0| auto ce = (call); \ | | | | | | | | 58| 0| if (ce.Check()) return ce; \ | | | | | | | | ------------------ | | | | | | | | | Branch (58:9): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 59| 0| } | | | | | | ------------------ | | | | | | 1658| 0| builder_.PushElement(val); \ | | | | | | 1659| 33.3k| } else { \ | | | | | | 1660| 33.3k| if (field->IsScalarOptional()) { \ | | | | | | ------------------ | | | | | | | Branch (1660:21): [True: 0, False: 33.3k] | | | | | | ------------------ | | | | | | 1661| 0| if (field_value.constant != "null") { \ | | | | | | ------------------ | | | | | | | Branch (1661:23): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 1662| 0| CTYPE val; \ | | | | | | 1663| 0| ECHECK(atot(field_value.constant.c_str(), *this, &val)); \ | | | | | | ------------------ | | | | | | | | 56| 0| { \ | | | | | | | | 57| 0| auto ce = (call); \ | | | | | | | | 58| 0| if (ce.Check()) return ce; \ | | | | | | | | ------------------ | | | | | | | | | Branch (58:9): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 59| 0| } | | | | | | ------------------ | | | | | | 1664| 0| builder_.AddElement(field_value.offset, val); \ | | | | | | 1665| 0| } \ | | | | | | 1666| 33.3k| } else { \ | | | | | | 1667| 33.3k| CTYPE val, valdef; \ | | | | | | 1668| 33.3k| ECHECK(atot(field_value.constant.c_str(), *this, &val)); \ | | | | | | ------------------ | | | | | | | | 56| 33.3k| { \ | | | | | | | | 57| 33.3k| auto ce = (call); \ | | | | | | | | 58| 33.3k| if (ce.Check()) return ce; \ | | | | | | | | ------------------ | | | | | | | | | Branch (58:9): [True: 13.4k, False: 19.9k] | | | | | | | | ------------------ | | | | | | | | 59| 33.3k| } | | | | | | ------------------ | | | | | | 1669| 19.9k| ECHECK(atot(field->value.constant.c_str(), *this, &valdef)); \ | | | | | | ------------------ | | | | | | | | 56| 19.9k| { \ | | | | | | | | 57| 19.9k| auto ce = (call); \ | | | | | | | | 58| 19.9k| if (ce.Check()) return ce; \ | | | | | | | | ------------------ | | | | | | | | | Branch (58:9): [True: 0, False: 19.9k] | | | | | | | | ------------------ | | | | | | | | 59| 19.9k| } | | | | | | ------------------ | | | | | | 1670| 19.9k| builder_.AddElement(field_value.offset, val, valdef); \ | | | | | | 1671| 19.9k| } \ | | | | | | 1672| 33.3k| } \ | | | | | | 1673| 19.9k| break; | | | | ------------------ | | ------------------ | | 60| 46.8k| TD(ULONG, "ulong", uint64_t, long, uint64, ulong, uint64, u64, ULong, UInt64, 10) /* end int */ \ | | ------------------ | | | | 1674| 46.8k| FLATBUFFERS_GEN_TYPES_SCALAR(FLATBUFFERS_TD) | | | | ------------------ | | | | | | 1653| 46.8k| case BASE_TYPE_ ## ENUM: \ | | | | | | ------------------ | | | | | | | Branch (1653:13): [True: 46.8k, False: 361k] | | | | | | ------------------ | | | | | | 1654| 30.3k| builder_.Pad(field->padding); \ | | | | | | 1655| 46.8k| if (struct_def.fixed) { \ | | | | | | ------------------ | | | | | | | Branch (1655:19): [True: 0, False: 46.8k] | | | | | | ------------------ | | | | | | 1656| 0| CTYPE val; \ | | | | | | 1657| 0| ECHECK(atot(field_value.constant.c_str(), *this, &val)); \ | | | | | | ------------------ | | | | | | | | 56| 0| { \ | | | | | | | | 57| 0| auto ce = (call); \ | | | | | | | | 58| 0| if (ce.Check()) return ce; \ | | | | | | | | ------------------ | | | | | | | | | Branch (58:9): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 59| 0| } | | | | | | ------------------ | | | | | | 1658| 0| builder_.PushElement(val); \ | | | | | | 1659| 46.8k| } else { \ | | | | | | 1660| 46.8k| if (field->IsScalarOptional()) { \ | | | | | | ------------------ | | | | | | | Branch (1660:21): [True: 0, False: 46.8k] | | | | | | ------------------ | | | | | | 1661| 0| if (field_value.constant != "null") { \ | | | | | | ------------------ | | | | | | | Branch (1661:23): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 1662| 0| CTYPE val; \ | | | | | | 1663| 0| ECHECK(atot(field_value.constant.c_str(), *this, &val)); \ | | | | | | ------------------ | | | | | | | | 56| 0| { \ | | | | | | | | 57| 0| auto ce = (call); \ | | | | | | | | 58| 0| if (ce.Check()) return ce; \ | | | | | | | | ------------------ | | | | | | | | | Branch (58:9): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 59| 0| } | | | | | | ------------------ | | | | | | 1664| 0| builder_.AddElement(field_value.offset, val); \ | | | | | | 1665| 0| } \ | | | | | | 1666| 46.8k| } else { \ | | | | | | 1667| 46.8k| CTYPE val, valdef; \ | | | | | | 1668| 46.8k| ECHECK(atot(field_value.constant.c_str(), *this, &val)); \ | | | | | | ------------------ | | | | | | | | 56| 46.8k| { \ | | | | | | | | 57| 46.8k| auto ce = (call); \ | | | | | | | | 58| 46.8k| if (ce.Check()) return ce; \ | | | | | | | | ------------------ | | | | | | | | | Branch (58:9): [True: 16.5k, False: 30.3k] | | | | | | | | ------------------ | | | | | | | | 59| 46.8k| } | | | | | | ------------------ | | | | | | 1669| 30.3k| ECHECK(atot(field->value.constant.c_str(), *this, &valdef)); \ | | | | | | ------------------ | | | | | | | | 56| 30.3k| { \ | | | | | | | | 57| 30.3k| auto ce = (call); \ | | | | | | | | 58| 30.3k| if (ce.Check()) return ce; \ | | | | | | | | ------------------ | | | | | | | | | Branch (58:9): [True: 0, False: 30.3k] | | | | | | | | ------------------ | | | | | | | | 59| 30.3k| } | | | | | | ------------------ | | | | | | 1670| 30.3k| builder_.AddElement(field_value.offset, val, valdef); \ | | | | | | 1671| 30.3k| } \ | | | | | | 1672| 46.8k| } \ | | | | | | 1673| 30.3k| break; | | | | ------------------ | | ------------------ | | 61| 43.5k| TD(FLOAT, "float", float, float, float32, float, float32, f32, Float, Float32, 11) /* begin float */ \ | | ------------------ | | | | 1674| 43.5k| FLATBUFFERS_GEN_TYPES_SCALAR(FLATBUFFERS_TD) | | | | ------------------ | | | | | | 1653| 43.5k| case BASE_TYPE_ ## ENUM: \ | | | | | | ------------------ | | | | | | | Branch (1653:13): [True: 43.5k, False: 365k] | | | | | | ------------------ | | | | | | 1654| 22.6k| builder_.Pad(field->padding); \ | | | | | | 1655| 43.5k| if (struct_def.fixed) { \ | | | | | | ------------------ | | | | | | | Branch (1655:19): [True: 0, False: 43.5k] | | | | | | ------------------ | | | | | | 1656| 0| CTYPE val; \ | | | | | | 1657| 0| ECHECK(atot(field_value.constant.c_str(), *this, &val)); \ | | | | | | ------------------ | | | | | | | | 56| 0| { \ | | | | | | | | 57| 0| auto ce = (call); \ | | | | | | | | 58| 0| if (ce.Check()) return ce; \ | | | | | | | | ------------------ | | | | | | | | | Branch (58:9): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 59| 0| } | | | | | | ------------------ | | | | | | 1658| 0| builder_.PushElement(val); \ | | | | | | 1659| 43.5k| } else { \ | | | | | | 1660| 43.5k| if (field->IsScalarOptional()) { \ | | | | | | ------------------ | | | | | | | Branch (1660:21): [True: 0, False: 43.5k] | | | | | | ------------------ | | | | | | 1661| 0| if (field_value.constant != "null") { \ | | | | | | ------------------ | | | | | | | Branch (1661:23): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 1662| 0| CTYPE val; \ | | | | | | 1663| 0| ECHECK(atot(field_value.constant.c_str(), *this, &val)); \ | | | | | | ------------------ | | | | | | | | 56| 0| { \ | | | | | | | | 57| 0| auto ce = (call); \ | | | | | | | | 58| 0| if (ce.Check()) return ce; \ | | | | | | | | ------------------ | | | | | | | | | Branch (58:9): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 59| 0| } | | | | | | ------------------ | | | | | | 1664| 0| builder_.AddElement(field_value.offset, val); \ | | | | | | 1665| 0| } \ | | | | | | 1666| 43.5k| } else { \ | | | | | | 1667| 43.5k| CTYPE val, valdef; \ | | | | | | 1668| 43.5k| ECHECK(atot(field_value.constant.c_str(), *this, &val)); \ | | | | | | ------------------ | | | | | | | | 56| 43.5k| { \ | | | | | | | | 57| 43.5k| auto ce = (call); \ | | | | | | | | 58| 43.5k| if (ce.Check()) return ce; \ | | | | | | | | ------------------ | | | | | | | | | Branch (58:9): [True: 20.8k, False: 22.6k] | | | | | | | | ------------------ | | | | | | | | 59| 43.5k| } | | | | | | ------------------ | | | | | | 1669| 22.6k| ECHECK(atot(field->value.constant.c_str(), *this, &valdef)); \ | | | | | | ------------------ | | | | | | | | 56| 22.6k| { \ | | | | | | | | 57| 22.6k| auto ce = (call); \ | | | | | | | | 58| 22.6k| if (ce.Check()) return ce; \ | | | | | | | | ------------------ | | | | | | | | | Branch (58:9): [True: 0, False: 22.6k] | | | | | | | | ------------------ | | | | | | | | 59| 22.6k| } | | | | | | ------------------ | | | | | | 1670| 22.6k| builder_.AddElement(field_value.offset, val, valdef); \ | | | | | | 1671| 22.6k| } \ | | | | | | 1672| 43.5k| } \ | | | | | | 1673| 22.6k| break; | | | | ------------------ | | ------------------ | | 62| 33.4k| TD(DOUBLE, "double", double, double, float64, double, float64, f64, Double, Double, 12) /* end float/scalar */ | | ------------------ | | | | 1674| 33.4k| FLATBUFFERS_GEN_TYPES_SCALAR(FLATBUFFERS_TD) | | | | ------------------ | | | | | | 1653| 33.4k| case BASE_TYPE_ ## ENUM: \ | | | | | | ------------------ | | | | | | | Branch (1653:13): [True: 33.4k, False: 375k] | | | | | | ------------------ | | | | | | 1654| 20.5k| builder_.Pad(field->padding); \ | | | | | | 1655| 33.4k| if (struct_def.fixed) { \ | | | | | | ------------------ | | | | | | | Branch (1655:19): [True: 0, False: 33.4k] | | | | | | ------------------ | | | | | | 1656| 0| CTYPE val; \ | | | | | | 1657| 0| ECHECK(atot(field_value.constant.c_str(), *this, &val)); \ | | | | | | ------------------ | | | | | | | | 56| 0| { \ | | | | | | | | 57| 0| auto ce = (call); \ | | | | | | | | 58| 0| if (ce.Check()) return ce; \ | | | | | | | | ------------------ | | | | | | | | | Branch (58:9): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 59| 0| } | | | | | | ------------------ | | | | | | 1658| 0| builder_.PushElement(val); \ | | | | | | 1659| 33.4k| } else { \ | | | | | | 1660| 33.4k| if (field->IsScalarOptional()) { \ | | | | | | ------------------ | | | | | | | Branch (1660:21): [True: 0, False: 33.4k] | | | | | | ------------------ | | | | | | 1661| 0| if (field_value.constant != "null") { \ | | | | | | ------------------ | | | | | | | Branch (1661:23): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 1662| 0| CTYPE val; \ | | | | | | 1663| 0| ECHECK(atot(field_value.constant.c_str(), *this, &val)); \ | | | | | | ------------------ | | | | | | | | 56| 0| { \ | | | | | | | | 57| 0| auto ce = (call); \ | | | | | | | | 58| 0| if (ce.Check()) return ce; \ | | | | | | | | ------------------ | | | | | | | | | Branch (58:9): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 59| 0| } | | | | | | ------------------ | | | | | | 1664| 0| builder_.AddElement(field_value.offset, val); \ | | | | | | 1665| 0| } \ | | | | | | 1666| 33.4k| } else { \ | | | | | | 1667| 33.4k| CTYPE val, valdef; \ | | | | | | 1668| 33.4k| ECHECK(atot(field_value.constant.c_str(), *this, &val)); \ | | | | | | ------------------ | | | | | | | | 56| 33.4k| { \ | | | | | | | | 57| 33.4k| auto ce = (call); \ | | | | | | | | 58| 33.4k| if (ce.Check()) return ce; \ | | | | | | | | ------------------ | | | | | | | | | Branch (58:9): [True: 12.9k, False: 20.5k] | | | | | | | | ------------------ | | | | | | | | 59| 33.4k| } | | | | | | ------------------ | | | | | | 1669| 20.5k| ECHECK(atot(field->value.constant.c_str(), *this, &valdef)); \ | | | | | | ------------------ | | | | | | | | 56| 20.5k| { \ | | | | | | | | 57| 20.5k| auto ce = (call); \ | | | | | | | | 58| 20.5k| if (ce.Check()) return ce; \ | | | | | | | | ------------------ | | | | | | | | | Branch (58:9): [True: 0, False: 20.5k] | | | | | | | | ------------------ | | | | | | | | 59| 20.5k| } | | | | | | ------------------ | | | | | | 1670| 20.5k| builder_.AddElement(field_value.offset, val, valdef); \ | | | | | | 1671| 20.5k| } \ | | | | | | 1672| 33.4k| } \ | | | | | | 1673| 20.5k| break; | | | | ------------------ | | ------------------ ------------------ 1675| 20.5k| #undef FLATBUFFERS_TD 1676| 20.5k| #define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE, ...) \ 1677| 20.5k| case BASE_TYPE_ ## ENUM: \ 1678| 20.5k| builder_.Pad(field->padding); \ 1679| 20.5k| if (IsStruct(field->value.type)) { \ 1680| 20.5k| SerializeStruct(*field->value.type.struct_def, field_value); \ 1681| 20.5k| } else { \ 1682| | /* Special case for fields that use 64-bit addressing */ \ 1683| 20.5k| if(field->offset64) { \ 1684| 20.5k| Offset64 offset; \ 1685| 20.5k| ECHECK(atot(field_value.constant.c_str(), *this, &offset)); \ 1686| 20.5k| builder_.AddOffset(field_value.offset, offset); \ 1687| 20.5k| } else { \ 1688| 20.5k| CTYPE val; \ 1689| 20.5k| ECHECK(atot(field_value.constant.c_str(), *this, &val)); \ 1690| 20.5k| builder_.AddOffset(field_value.offset, val); \ 1691| 20.5k| } \ 1692| 20.5k| } \ 1693| 20.5k| break; 1694| 20.5k| FLATBUFFERS_GEN_TYPES_POINTER(FLATBUFFERS_TD) ------------------ | | 64| 0| TD(STRING, "string", Offset, int, int, StringOffset, int, unused, Int, Offset, 13) \ | | ------------------ | | | | 1694| 0| FLATBUFFERS_GEN_TYPES_POINTER(FLATBUFFERS_TD) | | | | ------------------ | | | | | | 1677| 0| case BASE_TYPE_ ## ENUM: \ | | | | | | ------------------ | | | | | | | Branch (1677:13): [True: 0, False: 408k] | | | | | | ------------------ | | | | | | 1678| 0| builder_.Pad(field->padding); \ | | | | | | 1679| 0| if (IsStruct(field->value.type)) { \ | | | | | | ------------------ | | | | | | | Branch (1679:19): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 1680| 0| SerializeStruct(*field->value.type.struct_def, field_value); \ | | | | | | 1681| 0| } else { \ | | | | | | 1682| 0| /* Special case for fields that use 64-bit addressing */ \ | | | | | | 1683| 0| if(field->offset64) { \ | | | | | | ------------------ | | | | | | | Branch (1683:20): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 1684| 0| Offset64 offset; \ | | | | | | 1685| 0| ECHECK(atot(field_value.constant.c_str(), *this, &offset)); \ | | | | | | ------------------ | | | | | | | | 56| 0| { \ | | | | | | | | 57| 0| auto ce = (call); \ | | | | | | | | 58| 0| if (ce.Check()) return ce; \ | | | | | | | | ------------------ | | | | | | | | | Branch (58:9): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 59| 0| } | | | | | | ------------------ | | | | | | 1686| 0| builder_.AddOffset(field_value.offset, offset); \ | | | | | | 1687| 0| } else { \ | | | | | | 1688| 0| CTYPE val; \ | | | | | | 1689| 0| ECHECK(atot(field_value.constant.c_str(), *this, &val)); \ | | | | | | ------------------ | | | | | | | | 56| 0| { \ | | | | | | | | 57| 0| auto ce = (call); \ | | | | | | | | 58| 0| if (ce.Check()) return ce; \ | | | | | | | | ------------------ | | | | | | | | | Branch (58:9): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 59| 0| } | | | | | | ------------------ | | | | | | 1690| 0| builder_.AddOffset(field_value.offset, val); \ | | | | | | 1691| 0| } \ | | | | | | 1692| 0| } \ | | | | | | 1693| 0| break; | | | | ------------------ | | ------------------ | | 65| 0| TD(VECTOR, "", Offset, int, int, VectorOffset, int, unused, Int, Offset, 14) \ | | ------------------ | | | | 1694| 0| FLATBUFFERS_GEN_TYPES_POINTER(FLATBUFFERS_TD) | | | | ------------------ | | | | | | 1677| 0| case BASE_TYPE_ ## ENUM: \ | | | | | | ------------------ | | | | | | | Branch (1677:13): [True: 0, False: 408k] | | | | | | ------------------ | | | | | | 1678| 0| builder_.Pad(field->padding); \ | | | | | | 1679| 0| if (IsStruct(field->value.type)) { \ | | | | | | ------------------ | | | | | | | Branch (1679:19): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 1680| 0| SerializeStruct(*field->value.type.struct_def, field_value); \ | | | | | | 1681| 0| } else { \ | | | | | | 1682| 0| /* Special case for fields that use 64-bit addressing */ \ | | | | | | 1683| 0| if(field->offset64) { \ | | | | | | ------------------ | | | | | | | Branch (1683:20): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 1684| 0| Offset64 offset; \ | | | | | | 1685| 0| ECHECK(atot(field_value.constant.c_str(), *this, &offset)); \ | | | | | | ------------------ | | | | | | | | 56| 0| { \ | | | | | | | | 57| 0| auto ce = (call); \ | | | | | | | | 58| 0| if (ce.Check()) return ce; \ | | | | | | | | ------------------ | | | | | | | | | Branch (58:9): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 59| 0| } | | | | | | ------------------ | | | | | | 1686| 0| builder_.AddOffset(field_value.offset, offset); \ | | | | | | 1687| 0| } else { \ | | | | | | 1688| 0| CTYPE val; \ | | | | | | 1689| 0| ECHECK(atot(field_value.constant.c_str(), *this, &val)); \ | | | | | | ------------------ | | | | | | | | 56| 0| { \ | | | | | | | | 57| 0| auto ce = (call); \ | | | | | | | | 58| 0| if (ce.Check()) return ce; \ | | | | | | | | ------------------ | | | | | | | | | Branch (58:9): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 59| 0| } | | | | | | ------------------ | | | | | | 1690| 0| builder_.AddOffset(field_value.offset, val); \ | | | | | | 1691| 0| } \ | | | | | | 1692| 0| } \ | | | | | | 1693| 0| break; | | | | ------------------ | | ------------------ | | 66| 0| TD(VECTOR64, "", Offset64, int, int, VectorOffset, int, unused, Int, Offset, 18) \ | | ------------------ | | | | 1694| 0| FLATBUFFERS_GEN_TYPES_POINTER(FLATBUFFERS_TD) | | | | ------------------ | | | | | | 1677| 0| case BASE_TYPE_ ## ENUM: \ | | | | | | ------------------ | | | | | | | Branch (1677:13): [True: 0, False: 408k] | | | | | | ------------------ | | | | | | 1678| 0| builder_.Pad(field->padding); \ | | | | | | 1679| 0| if (IsStruct(field->value.type)) { \ | | | | | | ------------------ | | | | | | | Branch (1679:19): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 1680| 0| SerializeStruct(*field->value.type.struct_def, field_value); \ | | | | | | 1681| 0| } else { \ | | | | | | 1682| 0| /* Special case for fields that use 64-bit addressing */ \ | | | | | | 1683| 0| if(field->offset64) { \ | | | | | | ------------------ | | | | | | | Branch (1683:20): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 1684| 0| Offset64 offset; \ | | | | | | 1685| 0| ECHECK(atot(field_value.constant.c_str(), *this, &offset)); \ | | | | | | ------------------ | | | | | | | | 56| 0| { \ | | | | | | | | 57| 0| auto ce = (call); \ | | | | | | | | 58| 0| if (ce.Check()) return ce; \ | | | | | | | | ------------------ | | | | | | | | | Branch (58:9): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 59| 0| } | | | | | | ------------------ | | | | | | 1686| 0| builder_.AddOffset(field_value.offset, offset); \ | | | | | | 1687| 0| } else { \ | | | | | | 1688| 0| CTYPE val; \ | | | | | | 1689| 0| ECHECK(atot(field_value.constant.c_str(), *this, &val)); \ | | | | | | ------------------ | | | | | | | | 56| 0| { \ | | | | | | | | 57| 0| auto ce = (call); \ | | | | | | | | 58| 0| if (ce.Check()) return ce; \ | | | | | | | | ------------------ | | | | | | | | | Branch (58:9): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 59| 0| } | | | | | | ------------------ | | | | | | 1690| 0| builder_.AddOffset(field_value.offset, val); \ | | | | | | 1691| 0| } \ | | | | | | 1692| 0| } \ | | | | | | 1693| 0| break; | | | | ------------------ | | ------------------ | | 67| 0| TD(STRUCT, "", Offset, int, int, int, int, unused, Int, Offset, 15) \ | | ------------------ | | | | 1694| 0| FLATBUFFERS_GEN_TYPES_POINTER(FLATBUFFERS_TD) | | | | ------------------ | | | | | | 1677| 0| case BASE_TYPE_ ## ENUM: \ | | | | | | ------------------ | | | | | | | Branch (1677:13): [True: 0, False: 408k] | | | | | | ------------------ | | | | | | 1678| 0| builder_.Pad(field->padding); \ | | | | | | 1679| 0| if (IsStruct(field->value.type)) { \ | | | | | | ------------------ | | | | | | | Branch (1679:19): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 1680| 0| SerializeStruct(*field->value.type.struct_def, field_value); \ | | | | | | 1681| 0| } else { \ | | | | | | 1682| 0| /* Special case for fields that use 64-bit addressing */ \ | | | | | | 1683| 0| if(field->offset64) { \ | | | | | | ------------------ | | | | | | | Branch (1683:20): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 1684| 0| Offset64 offset; \ | | | | | | 1685| 0| ECHECK(atot(field_value.constant.c_str(), *this, &offset)); \ | | | | | | ------------------ | | | | | | | | 56| 0| { \ | | | | | | | | 57| 0| auto ce = (call); \ | | | | | | | | 58| 0| if (ce.Check()) return ce; \ | | | | | | | | ------------------ | | | | | | | | | Branch (58:9): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 59| 0| } | | | | | | ------------------ | | | | | | 1686| 0| builder_.AddOffset(field_value.offset, offset); \ | | | | | | 1687| 0| } else { \ | | | | | | 1688| 0| CTYPE val; \ | | | | | | 1689| 0| ECHECK(atot(field_value.constant.c_str(), *this, &val)); \ | | | | | | ------------------ | | | | | | | | 56| 0| { \ | | | | | | | | 57| 0| auto ce = (call); \ | | | | | | | | 58| 0| if (ce.Check()) return ce; \ | | | | | | | | ------------------ | | | | | | | | | Branch (58:9): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 59| 0| } | | | | | | ------------------ | | | | | | 1690| 0| builder_.AddOffset(field_value.offset, val); \ | | | | | | 1691| 0| } \ | | | | | | 1692| 0| } \ | | | | | | 1693| 0| break; | | | | ------------------ | | ------------------ | | 68| 0| TD(UNION, "", Offset, int, int, int, int, unused, Int, Offset, 16) | | ------------------ | | | | 1694| 0| FLATBUFFERS_GEN_TYPES_POINTER(FLATBUFFERS_TD) | | | | ------------------ | | | | | | 1677| 0| case BASE_TYPE_ ## ENUM: \ | | | | | | ------------------ | | | | | | | Branch (1677:13): [True: 0, False: 408k] | | | | | | ------------------ | | | | | | 1678| 0| builder_.Pad(field->padding); \ | | | | | | 1679| 0| if (IsStruct(field->value.type)) { \ | | | | | | ------------------ | | | | | | | Branch (1679:19): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 1680| 0| SerializeStruct(*field->value.type.struct_def, field_value); \ | | | | | | 1681| 0| } else { \ | | | | | | 1682| 0| /* Special case for fields that use 64-bit addressing */ \ | | | | | | 1683| 0| if(field->offset64) { \ | | | | | | ------------------ | | | | | | | Branch (1683:20): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 1684| 0| Offset64 offset; \ | | | | | | 1685| 0| ECHECK(atot(field_value.constant.c_str(), *this, &offset)); \ | | | | | | ------------------ | | | | | | | | 56| 0| { \ | | | | | | | | 57| 0| auto ce = (call); \ | | | | | | | | 58| 0| if (ce.Check()) return ce; \ | | | | | | | | ------------------ | | | | | | | | | Branch (58:9): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 59| 0| } | | | | | | ------------------ | | | | | | 1686| 0| builder_.AddOffset(field_value.offset, offset); \ | | | | | | 1687| 0| } else { \ | | | | | | 1688| 0| CTYPE val; \ | | | | | | 1689| 0| ECHECK(atot(field_value.constant.c_str(), *this, &val)); \ | | | | | | ------------------ | | | | | | | | 56| 0| { \ | | | | | | | | 57| 0| auto ce = (call); \ | | | | | | | | 58| 0| if (ce.Check()) return ce; \ | | | | | | | | ------------------ | | | | | | | | | Branch (58:9): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 59| 0| } | | | | | | ------------------ | | | | | | 1690| 0| builder_.AddOffset(field_value.offset, val); \ | | | | | | 1691| 0| } \ | | | | | | 1692| 0| } \ | | | | | | 1693| 0| break; | | | | ------------------ | | ------------------ ------------------ 1695| 0| #undef FLATBUFFERS_TD 1696| 0| case BASE_TYPE_ARRAY: ------------------ | Branch (1696:13): [True: 0, False: 408k] ------------------ 1697| 0| builder_.Pad(field->padding); 1698| 0| builder_.PushBytes( 1699| 0| reinterpret_cast(field_value.constant.c_str()), 1700| 0| InlineSize(field_value.type)); 1701| 0| break; 1702| | // clang-format on 1703| 408k| } 1704| 408k| } 1705| 1.33M| } 1706| 1.72M| } 1707| 482k| for (size_t i = 0; i < fieldn_outer; i++) field_stack_.pop_back(); ------------------ | Branch (1707:22): [True: 192k, False: 290k] ------------------ 1708| | 1709| 290k| if (struct_def.fixed) { ------------------ | Branch (1709:7): [True: 0, False: 290k] ------------------ 1710| 0| builder_.ClearOffsets(); 1711| 0| builder_.EndStruct(); 1712| 0| FLATBUFFERS_ASSERT(value); 1713| | // Temporarily store this struct in the value string, since it is to 1714| | // be serialized in-place elsewhere. 1715| 0| value->assign( 1716| 0| reinterpret_cast(builder_.GetCurrentBufferPointer()), 1717| 0| struct_def.bytesize); 1718| 0| builder_.PopBytes(struct_def.bytesize); 1719| 0| FLATBUFFERS_ASSERT(!ovalue); 1720| 290k| } else { 1721| 290k| auto val = builder_.EndTable(start); 1722| 290k| if (ovalue) *ovalue = val; ------------------ | Branch (1722:9): [True: 290k, False: 0] ------------------ 1723| 290k| if (value) *value = NumToString(val); ------------------ | Branch (1723:9): [True: 0, False: 290k] ------------------ 1724| 290k| } 1725| 290k| return NoError(); 1726| 290k|} _ZN11flatbuffers6Parser13ParseMetaDataEPNS_11SymbolTableINS_5ValueEEE: 1977| 206k|CheckedError Parser::ParseMetaData(SymbolTable* attributes) { 1978| 206k| if (Is('(')) { ------------------ | Branch (1978:7): [True: 0, False: 206k] ------------------ 1979| 0| NEXT(); ------------------ | | 63| 0|#define NEXT() ECHECK(Next()) | | ------------------ | | | | 56| 0| { \ | | | | 57| 0| auto ce = (call); \ | | | | 58| 0| if (ce.Check()) return ce; \ | | | | ------------------ | | | | | Branch (58:9): [True: 0, False: 0] | | | | ------------------ | | | | 59| 0| } | | ------------------ ------------------ 1980| 0| for (;;) { 1981| 0| auto name = attribute_; 1982| 0| if (false == (Is(kTokenIdentifier) || Is(kTokenStringConstant))) ------------------ | Branch (1982:11): [True: 0, False: 0] | Branch (1982:21): [True: 0, False: 0] | Branch (1982:45): [True: 0, False: 0] ------------------ 1983| 0| return Error("attribute name must be either identifier or string: " + 1984| 0| name); 1985| 0| if (known_attributes_.find(name) == known_attributes_.end()) ------------------ | Branch (1985:11): [True: 0, False: 0] ------------------ 1986| 0| return Error("user define attributes must be declared before use: " + 1987| 0| name); 1988| 0| NEXT(); ------------------ | | 63| 0|#define NEXT() ECHECK(Next()) | | ------------------ | | | | 56| 0| { \ | | | | 57| 0| auto ce = (call); \ | | | | 58| 0| if (ce.Check()) return ce; \ | | | | ------------------ | | | | | Branch (58:9): [True: 0, False: 0] | | | | ------------------ | | | | 59| 0| } | | ------------------ ------------------ 1989| 0| auto e = new Value(); 1990| 0| if (attributes->Add(name, e)) Warning("attribute already found: " + name); ------------------ | Branch (1990:11): [True: 0, False: 0] ------------------ 1991| 0| if (Is(':')) { ------------------ | Branch (1991:11): [True: 0, False: 0] ------------------ 1992| 0| NEXT(); ------------------ | | 63| 0|#define NEXT() ECHECK(Next()) | | ------------------ | | | | 56| 0| { \ | | | | 57| 0| auto ce = (call); \ | | | | 58| 0| if (ce.Check()) return ce; \ | | | | ------------------ | | | | | Branch (58:9): [True: 0, False: 0] | | | | ------------------ | | | | 59| 0| } | | ------------------ ------------------ 1993| 0| ECHECK(ParseSingleValue(&name, *e, true)); ------------------ | | 56| 0| { \ | | 57| 0| auto ce = (call); \ | | 58| 0| if (ce.Check()) return ce; \ | | ------------------ | | | Branch (58:9): [True: 0, False: 0] | | ------------------ | | 59| 0| } ------------------ 1994| 0| } 1995| 0| if (Is(')')) { ------------------ | Branch (1995:11): [True: 0, False: 0] ------------------ 1996| 0| NEXT(); ------------------ | | 63| 0|#define NEXT() ECHECK(Next()) | | ------------------ | | | | 56| 0| { \ | | | | 57| 0| auto ce = (call); \ | | | | 58| 0| if (ce.Check()) return ce; \ | | | | ------------------ | | | | | Branch (58:9): [True: 0, False: 0] | | | | ------------------ | | | | 59| 0| } | | ------------------ ------------------ 1997| 0| break; 1998| 0| } 1999| 0| EXPECT(','); ------------------ | | 64| 0|#define EXPECT(tok) ECHECK(Expect(tok)) | | ------------------ | | | | 56| 0| { \ | | | | 57| 0| auto ce = (call); \ | | | | 58| 0| if (ce.Check()) return ce; \ | | | | ------------------ | | | | | Branch (58:9): [True: 0, False: 0] | | | | ------------------ | | | | 59| 0| } | | ------------------ ------------------ 2000| 0| } 2001| 0| } 2002| 206k| return NoError(); 2003| 206k|} _ZN11flatbuffers6Parser19ParseEnumFromStringERKNS_4TypeEPNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEE: 2006| 20.4k| std::string* result) { 2007| 20.4k| const auto base_type = 2008| 20.4k| type.enum_def ? type.enum_def->underlying_type.base_type : type.base_type; ------------------ | Branch (2008:7): [True: 0, False: 20.4k] ------------------ 2009| 20.4k| if (!IsInteger(base_type)) return Error("not a valid value for this field"); ------------------ | Branch (2009:7): [True: 0, False: 20.4k] ------------------ 2010| 20.4k| uint64_t u64 = 0; 2011| 20.4k| for (size_t pos = 0; pos != std::string::npos;) { ------------------ | Branch (2011:24): [True: 20.4k, False: 0] ------------------ 2012| 20.4k| const auto delim = attribute_.find_first_of(' ', pos); 2013| 20.4k| const auto last = (std::string::npos == delim); 2014| 20.4k| auto word = attribute_.substr(pos, !last ? delim - pos : std::string::npos); ------------------ | Branch (2014:40): [True: 1.48k, False: 19.0k] ------------------ 2015| 20.4k| pos = !last ? delim + 1 : std::string::npos; ------------------ | Branch (2015:11): [True: 1.48k, False: 19.0k] ------------------ 2016| 20.4k| const EnumVal* ev = nullptr; 2017| 20.4k| if (type.enum_def) { ------------------ | Branch (2017:9): [True: 0, False: 20.4k] ------------------ 2018| 0| ev = type.enum_def->Lookup(word); 2019| 20.4k| } else { 2020| 20.4k| auto dot = word.find_first_of('.'); 2021| 20.4k| if (std::string::npos == dot) ------------------ | Branch (2021:11): [True: 17.2k, False: 3.24k] ------------------ 2022| 17.2k| return Error("enum values need to be qualified by an enum type"); 2023| 3.24k| auto enum_def_str = word.substr(0, dot); 2024| 3.24k| const auto enum_def = LookupEnum(enum_def_str); 2025| 3.24k| if (!enum_def) return Error("unknown enum: " + enum_def_str); ------------------ | Branch (2025:11): [True: 3.24k, False: 0] ------------------ 2026| 0| auto enum_val_str = word.substr(dot + 1); 2027| 0| ev = enum_def->Lookup(enum_val_str); 2028| 0| } 2029| 0| if (!ev) return Error("unknown enum value: " + word); ------------------ | Branch (2029:9): [True: 0, False: 0] ------------------ 2030| 0| u64 |= ev->GetAsUInt64(); 2031| 0| } 2032| 0| *result = IsUnsigned(base_type) ? NumToString(u64) ------------------ | Branch (2032:13): [True: 0, False: 0] ------------------ 2033| 0| : NumToString(static_cast(u64)); 2034| 0| return NoError(); 2035| 20.4k|} _ZN11flatbuffers6Parser13ParseFunctionEPKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERNS_5ValueE: 2088| 67.9k|CheckedError Parser::ParseFunction(const std::string* name, Value& e) { 2089| 67.9k| ParseDepthGuard depth_guard(this); 2090| 67.9k| ECHECK(depth_guard.Check()); ------------------ | | 56| 67.9k| { \ | | 57| 67.9k| auto ce = (call); \ | | 58| 67.9k| if (ce.Check()) return ce; \ | | ------------------ | | | Branch (58:9): [True: 426, False: 67.5k] | | ------------------ | | 59| 67.9k| } ------------------ 2091| | 2092| | // Copy name, attribute will be changed on NEXT(). 2093| 67.5k| const auto functionname = attribute_; 2094| 67.5k| if (!IsFloat(e.type.base_type)) { ------------------ | Branch (2094:7): [True: 1.91k, False: 65.6k] ------------------ 2095| 1.91k| return Error(functionname + ": type of argument mismatch, expecting: " + 2096| 1.91k| TypeName(BASE_TYPE_DOUBLE) + 2097| 1.91k| ", found: " + TypeName(e.type.base_type) + 2098| 1.91k| ", name: " + (name ? *name : "") + ", value: " + e.constant); ------------------ | Branch (2098:32): [True: 1.91k, False: 0] ------------------ 2099| 1.91k| } 2100| 65.6k| NEXT(); ------------------ | | 63| 65.6k|#define NEXT() ECHECK(Next()) | | ------------------ | | | | 56| 65.6k| { \ | | | | 57| 65.6k| auto ce = (call); \ | | | | 58| 65.6k| if (ce.Check()) return ce; \ | | | | ------------------ | | | | | Branch (58:9): [True: 0, False: 65.6k] | | | | ------------------ | | | | 59| 65.6k| } | | ------------------ ------------------ 2101| 65.6k| EXPECT('('); ------------------ | | 64| 65.6k|#define EXPECT(tok) ECHECK(Expect(tok)) | | ------------------ | | | | 56| 65.6k| { \ | | | | 57| 65.6k| auto ce = (call); \ | | | | 58| 65.6k| if (ce.Check()) return ce; \ | | | | ------------------ | | | | | Branch (58:9): [True: 2.40k, False: 63.2k] | | | | ------------------ | | | | 59| 65.6k| } | | ------------------ ------------------ 2102| 63.2k| ECHECK(ParseSingleValue(name, e, false)); ------------------ | | 56| 63.2k| { \ | | 57| 63.2k| auto ce = (call); \ | | 58| 63.2k| if (ce.Check()) return ce; \ | | ------------------ | | | Branch (58:9): [True: 56.0k, False: 7.18k] | | ------------------ | | 59| 63.2k| } ------------------ 2103| 7.18k| EXPECT(')'); ------------------ | | 64| 7.18k|#define EXPECT(tok) ECHECK(Expect(tok)) | | ------------------ | | | | 56| 7.18k| { \ | | | | 57| 7.18k| auto ce = (call); \ | | | | 58| 7.18k| if (ce.Check()) return ce; \ | | | | ------------------ | | | | | Branch (58:9): [True: 3.88k, False: 3.30k] | | | | ------------------ | | | | 59| 7.18k| } | | ------------------ ------------------ 2104| | // calculate with double precision 2105| 3.30k| double x, y = 0.0; 2106| 3.30k| ECHECK(atot(e.constant.c_str(), *this, &x)); ------------------ | | 56| 3.30k| { \ | | 57| 3.30k| auto ce = (call); \ | | 58| 3.30k| if (ce.Check()) return ce; \ | | ------------------ | | | Branch (58:9): [True: 549, False: 2.75k] | | ------------------ | | 59| 3.30k| } ------------------ 2107| | // clang-format off 2108| 2.75k| auto func_match = false; 2109| 2.75k| #define FLATBUFFERS_FN_DOUBLE(name, op) \ 2110| 2.75k| if (!func_match && functionname == name) { y = op; func_match = true; } 2111| 2.75k| FLATBUFFERS_FN_DOUBLE("deg", x / kPi * 180); ------------------ | | 2110| 2.75k| if (!func_match && functionname == name) { y = op; func_match = true; } | | ------------------ | | | Branch (2110:9): [True: 2.75k, False: 0] | | | Branch (2110:24): [True: 0, False: 2.75k] | | ------------------ ------------------ 2112| 2.75k| FLATBUFFERS_FN_DOUBLE("rad", x * kPi / 180); ------------------ | | 2110| 2.75k| if (!func_match && functionname == name) { y = op; func_match = true; } | | ------------------ | | | Branch (2110:9): [True: 2.75k, False: 0] | | | Branch (2110:24): [True: 0, False: 2.75k] | | ------------------ ------------------ 2113| 2.75k| FLATBUFFERS_FN_DOUBLE("sin", sin(x)); ------------------ | | 2110| 2.75k| if (!func_match && functionname == name) { y = op; func_match = true; } | | ------------------ | | | Branch (2110:9): [True: 2.75k, False: 0] | | | Branch (2110:24): [True: 0, False: 2.75k] | | ------------------ ------------------ 2114| 2.75k| FLATBUFFERS_FN_DOUBLE("cos", cos(x)); ------------------ | | 2110| 2.75k| if (!func_match && functionname == name) { y = op; func_match = true; } | | ------------------ | | | Branch (2110:9): [True: 2.75k, False: 0] | | | Branch (2110:24): [True: 0, False: 2.75k] | | ------------------ ------------------ 2115| 2.75k| FLATBUFFERS_FN_DOUBLE("tan", tan(x)); ------------------ | | 2110| 2.75k| if (!func_match && functionname == name) { y = op; func_match = true; } | | ------------------ | | | Branch (2110:9): [True: 2.75k, False: 0] | | | Branch (2110:24): [True: 0, False: 2.75k] | | ------------------ ------------------ 2116| 2.75k| FLATBUFFERS_FN_DOUBLE("asin", asin(x)); ------------------ | | 2110| 2.75k| if (!func_match && functionname == name) { y = op; func_match = true; } | | ------------------ | | | Branch (2110:9): [True: 2.75k, False: 0] | | | Branch (2110:24): [True: 0, False: 2.75k] | | ------------------ ------------------ 2117| 2.75k| FLATBUFFERS_FN_DOUBLE("acos", acos(x)); ------------------ | | 2110| 2.75k| if (!func_match && functionname == name) { y = op; func_match = true; } | | ------------------ | | | Branch (2110:9): [True: 2.75k, False: 0] | | | Branch (2110:24): [True: 0, False: 2.75k] | | ------------------ ------------------ 2118| 2.75k| FLATBUFFERS_FN_DOUBLE("atan", atan(x)); ------------------ | | 2110| 2.75k| if (!func_match && functionname == name) { y = op; func_match = true; } | | ------------------ | | | Branch (2110:9): [True: 2.75k, False: 0] | | | Branch (2110:24): [True: 0, False: 2.75k] | | ------------------ ------------------ 2119| | // TODO(wvo): add more useful conversion functions here. 2120| 2.75k| #undef FLATBUFFERS_FN_DOUBLE 2121| | // clang-format on 2122| 2.75k| if (true != func_match) { ------------------ | Branch (2122:7): [True: 2.75k, False: 0] ------------------ 2123| 2.75k| return Error(std::string("Unknown conversion function: ") + functionname + 2124| 2.75k| ", field name: " + (name ? *name : "") + ------------------ | Branch (2124:38): [True: 2.75k, False: 0] ------------------ 2125| 2.75k| ", value: " + e.constant); 2126| 2.75k| } 2127| 0| e.constant = NumToString(y); 2128| 0| return NoError(); 2129| 2.75k|} _ZN11flatbuffers6Parser13TryTypedValueEPKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEibRNS_5ValueENS_8BaseTypeEPb: 2133| 593k| bool* destmatch) { 2134| 593k| FLATBUFFERS_ASSERT(*destmatch == false && dtoken == token_); 2135| 593k| *destmatch = true; 2136| 593k| e.constant = attribute_; 2137| | // Check token match 2138| 593k| if (!check) { ------------------ | Branch (2138:7): [True: 0, False: 593k] ------------------ 2139| 0| if (e.type.base_type == BASE_TYPE_NONE) { ------------------ | Branch (2139:9): [True: 0, False: 0] ------------------ 2140| 0| e.type.base_type = req; 2141| 0| } else { 2142| 0| return Error(std::string("type mismatch: expecting: ") + 2143| 0| TypeName(e.type.base_type) + ", found: " + TypeName(req) + 2144| 0| ", name: " + (name ? *name : "") + ", value: " + e.constant); ------------------ | Branch (2144:34): [True: 0, False: 0] ------------------ 2145| 0| } 2146| 0| } 2147| | // The exponent suffix of hexadecimal float-point number is mandatory. 2148| | // A hex-integer constant is forbidden as an initializer of float number. 2149| 593k| if ((kTokenFloatConstant != dtoken) && IsFloat(e.type.base_type)) { ------------------ | Branch (2149:7): [True: 579k, False: 14.7k] | Branch (2149:42): [True: 134k, False: 444k] ------------------ 2150| 134k| const auto& s = e.constant; 2151| 134k| const auto k = s.find_first_of("0123456789."); 2152| 134k| if ((std::string::npos != k) && (s.length() > (k + 1)) && ------------------ | Branch (2152:9): [True: 90.8k, False: 44.1k] | Branch (2152:37): [True: 53.7k, False: 37.0k] ------------------ 2153| 53.7k| (s[k] == '0' && is_alpha_char(s[k + 1], 'X')) && ------------------ | Branch (2153:10): [True: 18.6k, False: 35.1k] | Branch (2153:25): [True: 8.81k, False: 9.81k] ------------------ 2154| 8.81k| (std::string::npos == s.find_first_of("pP", k + 2))) { ------------------ | Branch (2154:9): [True: 5.33k, False: 3.48k] ------------------ 2155| 5.33k| return Error( 2156| 5.33k| "invalid number, the exponent suffix of hexadecimal " 2157| 5.33k| "floating-point literals is mandatory: \"" + 2158| 5.33k| s + "\""); 2159| 5.33k| } 2160| 134k| } 2161| 588k| NEXT(); ------------------ | | 63| 588k|#define NEXT() ECHECK(Next()) | | ------------------ | | | | 56| 588k| { \ | | | | 57| 588k| auto ce = (call); \ | | | | 58| 588k| if (ce.Check()) return ce; \ | | | | ------------------ | | | | | Branch (58:9): [True: 24.5k, False: 563k] | | | | ------------------ | | | | 59| 588k| } | | ------------------ ------------------ 2162| 563k| return NoError(); 2163| 588k|} _ZN11flatbuffers6Parser16ParseSingleValueEPKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERNS_5ValueEb: 2166| 728k| bool check_now) { 2167| 728k| if (token_ == '+' || token_ == '-') { ------------------ | Branch (2167:7): [True: 10.6k, False: 718k] | Branch (2167:24): [True: 16.0k, False: 702k] ------------------ 2168| 26.6k| const char sign = static_cast(token_); 2169| | // Get an indentifier: NAN, INF, or function name like cos/sin/deg. 2170| 26.6k| NEXT(); ------------------ | | 63| 26.6k|#define NEXT() ECHECK(Next()) | | ------------------ | | | | 56| 26.6k| { \ | | | | 57| 26.6k| auto ce = (call); \ | | | | 58| 26.6k| if (ce.Check()) return ce; \ | | | | ------------------ | | | | | Branch (58:9): [True: 0, False: 26.6k] | | | | ------------------ | | | | 59| 26.6k| } | | ------------------ ------------------ 2171| 26.6k| if (token_ != kTokenIdentifier) return Error("constant name expected"); ------------------ | Branch (2171:9): [True: 0, False: 26.6k] ------------------ 2172| 26.6k| attribute_.insert(size_t(0), size_t(1), sign); 2173| 26.6k| } 2174| | 2175| 728k| const auto in_type = e.type.base_type; 2176| 728k| const auto is_tok_ident = (token_ == kTokenIdentifier); 2177| 728k| const auto is_tok_string = (token_ == kTokenStringConstant); 2178| | 2179| | // First see if this could be a conversion function. 2180| 728k| if (is_tok_ident && *cursor_ == '(') { ------------------ | Branch (2180:7): [True: 124k, False: 604k] | Branch (2180:23): [True: 67.9k, False: 56.2k] ------------------ 2181| 67.9k| return ParseFunction(name, e); 2182| 67.9k| } 2183| | 2184| | // clang-format off 2185| 660k| auto match = false; 2186| | 2187| 660k| #define IF_ECHECK_(force, dtoken, check, req) \ 2188| 660k| if (!match && ((dtoken) == token_) && ((check) || flatbuffers::IsConstTrue(force))) \ 2189| 660k| ECHECK(TryTypedValue(name, dtoken, check, e, req, &match)) 2190| 660k| #define TRY_ECHECK(dtoken, check, req) IF_ECHECK_(false, dtoken, check, req) 2191| 660k| #define FORCE_ECHECK(dtoken, check, req) IF_ECHECK_(true, dtoken, check, req) 2192| | // clang-format on 2193| | 2194| 660k| if (is_tok_ident || is_tok_string) { ------------------ | Branch (2194:7): [True: 56.2k, False: 604k] | Branch (2194:23): [True: 312k, False: 292k] ------------------ 2195| 368k| const auto kTokenStringOrIdent = token_; 2196| | // The string type is a most probable type, check it first. 2197| 368k| TRY_ECHECK(kTokenStringConstant, in_type == BASE_TYPE_STRING, ------------------ | | 2190| 368k| #define TRY_ECHECK(dtoken, check, req) IF_ECHECK_(false, dtoken, check, req) | | ------------------ | | | | 2188| 368k| if (!match && ((dtoken) == token_) && ((check) || flatbuffers::IsConstTrue(force))) \ | | | | ------------------ | | | | | Branch (2188:9): [True: 368k, False: 0] | | | | | Branch (2188:19): [True: 312k, False: 56.2k] | | | | | Branch (2188:44): [True: 0, False: 312k] | | | | | Branch (2188:55): [Folded, False: 0] | | | | ------------------ | | | | 2189| 368k| ECHECK(TryTypedValue(name, dtoken, check, e, req, &match)) | | | | ------------------ | | | | | | 56| 0| { \ | | | | | | 57| 0| auto ce = (call); \ | | | | | | 58| 0| if (ce.Check()) return ce; \ | | | | | | ------------------ | | | | | | | Branch (58:9): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 59| 0| } | | | | ------------------ | | ------------------ ------------------ 2198| 368k| BASE_TYPE_STRING); 2199| | 2200| | // avoid escaped and non-ascii in the string 2201| 368k| if (!match && is_tok_string && IsScalar(in_type) && ------------------ | Branch (2201:9): [True: 368k, False: 0] | Branch (2201:19): [True: 312k, False: 56.2k] | Branch (2201:36): [True: 312k, False: 0] ------------------ 2202| 312k| !attr_is_trivial_ascii_string_) { ------------------ | Branch (2202:9): [True: 20.4k, False: 291k] ------------------ 2203| 20.4k| return Error( 2204| 20.4k| std::string("type mismatch or invalid value, an initializer of " 2205| 20.4k| "non-string field must be trivial ASCII string: type: ") + 2206| 20.4k| TypeName(in_type) + ", name: " + (name ? *name : "") + ------------------ | Branch (2206:45): [True: 20.4k, False: 0] ------------------ 2207| 20.4k| ", value: " + attribute_); 2208| 20.4k| } 2209| | 2210| | // A boolean as true/false. Boolean as Integer check below. 2211| 347k| if (!match && IsBool(in_type)) { ------------------ | Branch (2211:9): [True: 347k, False: 0] | Branch (2211:19): [True: 36.6k, False: 311k] ------------------ 2212| 36.6k| auto is_true = attribute_ == "true"; 2213| 36.6k| if (is_true || attribute_ == "false") { ------------------ | Branch (2213:11): [True: 2.72k, False: 33.9k] | Branch (2213:22): [True: 2.25k, False: 31.6k] ------------------ 2214| 4.98k| attribute_ = is_true ? "1" : "0"; ------------------ | Branch (2214:22): [True: 2.72k, False: 2.25k] ------------------ 2215| | // accepts both kTokenStringConstant and kTokenIdentifier 2216| 4.98k| TRY_ECHECK(kTokenStringOrIdent, IsBool(in_type), BASE_TYPE_BOOL); ------------------ | | 2190| 4.98k| #define TRY_ECHECK(dtoken, check, req) IF_ECHECK_(false, dtoken, check, req) | | ------------------ | | | | 2188| 4.98k| if (!match && ((dtoken) == token_) && ((check) || flatbuffers::IsConstTrue(force))) \ | | | | ------------------ | | | | | Branch (2188:9): [True: 4.98k, False: 0] | | | | | Branch (2188:19): [True: 4.98k, False: 0] | | | | | Branch (2188:44): [True: 4.98k, False: 0] | | | | | Branch (2188:55): [Folded, False: 0] | | | | ------------------ | | | | 2189| 4.98k| ECHECK(TryTypedValue(name, dtoken, check, e, req, &match)) | | | | ------------------ | | | | | | 56| 4.98k| { \ | | | | | | 57| 4.98k| auto ce = (call); \ | | | | | | 58| 4.98k| if (ce.Check()) return ce; \ | | | | | | ------------------ | | | | | | | Branch (58:9): [True: 552, False: 4.43k] | | | | | | ------------------ | | | | | | 59| 4.98k| } | | | | ------------------ | | ------------------ ------------------ 2217| 4.43k| } 2218| 36.6k| } 2219| | // Check for optional scalars. 2220| 347k| if (!match && IsScalar(in_type) && attribute_ == "null") { ------------------ | Branch (2220:9): [True: 342k, False: 4.43k] | Branch (2220:19): [True: 342k, False: 0] | Branch (2220:40): [True: 3.17k, False: 339k] ------------------ 2221| 3.17k| e.constant = "null"; 2222| 3.17k| NEXT(); ------------------ | | 63| 3.17k|#define NEXT() ECHECK(Next()) | | ------------------ | | | | 56| 3.17k| { \ | | | | 57| 3.17k| auto ce = (call); \ | | | | 58| 3.17k| if (ce.Check()) return ce; \ | | | | ------------------ | | | | | Branch (58:9): [True: 692, False: 2.48k] | | | | ------------------ | | | | 59| 3.17k| } | | ------------------ ------------------ 2223| 2.48k| match = true; 2224| 2.48k| } 2225| | // Check if this could be a string/identifier enum value. 2226| | // Enum can have only true integer base type. 2227| 346k| if (!match && IsInteger(in_type) && !IsBool(in_type) && ------------------ | Branch (2227:9): [True: 339k, False: 6.91k] | Branch (2227:19): [True: 240k, False: 99.5k] | Branch (2227:41): [True: 210k, False: 29.8k] ------------------ 2228| 210k| IsIdentifierStart(*attribute_.c_str())) { ------------------ | Branch (2228:9): [True: 20.4k, False: 189k] ------------------ 2229| 20.4k| ECHECK(ParseEnumFromString(e.type, &e.constant)); ------------------ | | 56| 20.4k| { \ | | 57| 20.4k| auto ce = (call); \ | | 58| 20.4k| if (ce.Check()) return ce; \ | | ------------------ | | | Branch (58:9): [True: 20.4k, False: 0] | | ------------------ | | 59| 20.4k| } ------------------ 2230| 0| NEXT(); ------------------ | | 63| 0|#define NEXT() ECHECK(Next()) | | ------------------ | | | | 56| 0| { \ | | | | 57| 0| auto ce = (call); \ | | | | 58| 0| if (ce.Check()) return ce; \ | | | | ------------------ | | | | | Branch (58:9): [True: 0, False: 0] | | | | ------------------ | | | | 59| 0| } | | ------------------ ------------------ 2231| 0| match = true; 2232| 0| } 2233| | // Parse a float/integer number from the string. 2234| | // A "scalar-in-string" value needs extra checks. 2235| 326k| if (!match && is_tok_string && IsScalar(in_type)) { ------------------ | Branch (2235:9): [True: 319k, False: 6.91k] | Branch (2235:19): [True: 279k, False: 40.0k] | Branch (2235:36): [True: 279k, False: 0] ------------------ 2236| | // Strip trailing whitespaces from attribute_. 2237| 279k| auto last_non_ws = attribute_.find_last_not_of(' '); 2238| 279k| if (std::string::npos != last_non_ws) attribute_.resize(last_non_ws + 1); ------------------ | Branch (2238:11): [True: 266k, False: 12.4k] ------------------ 2239| 279k| if (IsFloat(e.type.base_type)) { ------------------ | Branch (2239:11): [True: 77.2k, False: 201k] ------------------ 2240| | // The functions strtod() and strtof() accept both 'nan' and 2241| | // 'nan(number)' literals. While 'nan(number)' is rejected by the parser 2242| | // as an unsupported function if is_tok_ident is true. 2243| 77.2k| if (attribute_.find_last_of(')') != std::string::npos) { ------------------ | Branch (2243:13): [True: 4.49k, False: 72.8k] ------------------ 2244| 4.49k| return Error("invalid number: " + attribute_); 2245| 4.49k| } 2246| 77.2k| } 2247| 279k| } 2248| | // Float numbers or nan, inf, pi, etc. 2249| 321k| TRY_ECHECK(kTokenStringOrIdent, IsFloat(in_type), BASE_TYPE_FLOAT); ------------------ | | 2190| 321k| #define TRY_ECHECK(dtoken, check, req) IF_ECHECK_(false, dtoken, check, req) | | ------------------ | | | | 2188| 321k| if (!match && ((dtoken) == token_) && ((check) || flatbuffers::IsConstTrue(force))) \ | | | | ------------------ | | | | | Branch (2188:9): [True: 314k, False: 6.91k] | | | | | Branch (2188:19): [True: 314k, False: 0] | | | | | Branch (2188:44): [True: 95.0k, False: 219k] | | | | | Branch (2188:55): [Folded, False: 0] | | | | ------------------ | | | | 2189| 321k| ECHECK(TryTypedValue(name, dtoken, check, e, req, &match)) | | | | ------------------ | | | | | | 56| 95.0k| { \ | | | | | | 57| 95.0k| auto ce = (call); \ | | | | | | 58| 95.0k| if (ce.Check()) return ce; \ | | | | | | ------------------ | | | | | | | Branch (58:9): [True: 11.1k, False: 83.9k] | | | | | | ------------------ | | | | | | 59| 95.0k| } | | | | ------------------ | | ------------------ ------------------ 2250| | // An integer constant in string. 2251| 310k| TRY_ECHECK(kTokenStringOrIdent, IsInteger(in_type), BASE_TYPE_INT); ------------------ | | 2190| 310k| #define TRY_ECHECK(dtoken, check, req) IF_ECHECK_(false, dtoken, check, req) | | ------------------ | | | | 2188| 310k| if (!match && ((dtoken) == token_) && ((check) || flatbuffers::IsConstTrue(force))) \ | | | | ------------------ | | | | | Branch (2188:9): [True: 219k, False: 90.8k] | | | | | Branch (2188:19): [True: 219k, False: 0] | | | | | Branch (2188:44): [True: 219k, False: 0] | | | | | Branch (2188:55): [Folded, False: 0] | | | | ------------------ | | | | 2189| 310k| ECHECK(TryTypedValue(name, dtoken, check, e, req, &match)) | | | | ------------------ | | | | | | 56| 219k| { \ | | | | | | 57| 219k| auto ce = (call); \ | | | | | | 58| 219k| if (ce.Check()) return ce; \ | | | | | | ------------------ | | | | | | | Branch (58:9): [True: 8.33k, False: 211k] | | | | | | ------------------ | | | | | | 59| 219k| } | | | | ------------------ | | ------------------ ------------------ 2252| | // Unknown tokens will be interpreted as string type. 2253| | // An attribute value may be a scalar or string constant. 2254| 302k| FORCE_ECHECK(kTokenStringConstant, in_type == BASE_TYPE_STRING, ------------------ | | 2191| 302k| #define FORCE_ECHECK(dtoken, check, req) IF_ECHECK_(true, dtoken, check, req) | | ------------------ | | | | 2188| 302k| if (!match && ((dtoken) == token_) && ((check) || flatbuffers::IsConstTrue(force))) \ | | | | ------------------ | | | | | Branch (2188:9): [True: 0, False: 302k] | | | | | Branch (2188:19): [True: 0, False: 0] | | | | | Branch (2188:44): [True: 0, False: 0] | | | | | Branch (2188:55): [True: 0, Folded] | | | | ------------------ | | | | 2189| 302k| ECHECK(TryTypedValue(name, dtoken, check, e, req, &match)) | | | | ------------------ | | | | | | 56| 0| { \ | | | | | | 57| 0| auto ce = (call); \ | | | | | | 58| 0| if (ce.Check()) return ce; \ | | | | | | ------------------ | | | | | | | Branch (58:9): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 59| 0| } | | | | ------------------ | | ------------------ ------------------ 2255| 302k| BASE_TYPE_STRING); 2256| 302k| } else { 2257| | // Try a float number. 2258| 292k| TRY_ECHECK(kTokenFloatConstant, IsFloat(in_type), BASE_TYPE_FLOAT); ------------------ | | 2190| 292k| #define TRY_ECHECK(dtoken, check, req) IF_ECHECK_(false, dtoken, check, req) | | ------------------ | | | | 2188| 292k| if (!match && ((dtoken) == token_) && ((check) || flatbuffers::IsConstTrue(force))) \ | | | | ------------------ | | | | | Branch (2188:9): [True: 292k, False: 0] | | | | | Branch (2188:19): [True: 17.8k, False: 274k] | | | | | Branch (2188:44): [True: 14.7k, False: 3.05k] | | | | | Branch (2188:55): [Folded, False: 0] | | | | ------------------ | | | | 2189| 292k| ECHECK(TryTypedValue(name, dtoken, check, e, req, &match)) | | | | ------------------ | | | | | | 56| 14.7k| { \ | | | | | | 57| 14.7k| auto ce = (call); \ | | | | | | 58| 14.7k| if (ce.Check()) return ce; \ | | | | | | ------------------ | | | | | | | Branch (58:9): [True: 2.56k, False: 12.1k] | | | | | | ------------------ | | | | | | 59| 14.7k| } | | | | ------------------ | | ------------------ ------------------ 2259| | // Integer token can init any scalar (integer of float). 2260| 290k| FORCE_ECHECK(kTokenIntegerConstant, IsScalar(in_type), BASE_TYPE_INT); ------------------ | | 2191| 290k| #define FORCE_ECHECK(dtoken, check, req) IF_ECHECK_(true, dtoken, check, req) | | ------------------ | | | | 2188| 290k| if (!match && ((dtoken) == token_) && ((check) || flatbuffers::IsConstTrue(force))) \ | | | | ------------------ | | | | | Branch (2188:9): [True: 277k, False: 12.1k] | | | | | Branch (2188:19): [True: 259k, False: 18.5k] | | | | | Branch (2188:44): [True: 259k, False: 0] | | | | | Branch (2188:55): [True: 0, Folded] | | | | ------------------ | | | | 2189| 290k| ECHECK(TryTypedValue(name, dtoken, check, e, req, &match)) | | | | ------------------ | | | | | | 56| 259k| { \ | | | | | | 57| 259k| auto ce = (call); \ | | | | | | 58| 259k| if (ce.Check()) return ce; \ | | | | | | ------------------ | | | | | | | Branch (58:9): [True: 7.21k, False: 252k] | | | | | | ------------------ | | | | | | 59| 259k| } | | | | ------------------ | | ------------------ ------------------ 2261| 282k| } 2262| | // Match empty vectors for default-empty-vectors. 2263| 584k| if (!match && IsVector(e.type) && token_ == '[') { ------------------ | Branch (2263:7): [True: 18.5k, False: 566k] | Branch (2263:17): [True: 0, False: 18.5k] | Branch (2263:37): [True: 0, False: 0] ------------------ 2264| 0| NEXT(); ------------------ | | 63| 0|#define NEXT() ECHECK(Next()) | | ------------------ | | | | 56| 0| { \ | | | | 57| 0| auto ce = (call); \ | | | | 58| 0| if (ce.Check()) return ce; \ | | | | ------------------ | | | | | Branch (58:9): [True: 0, False: 0] | | | | ------------------ | | | | 59| 0| } | | ------------------ ------------------ 2265| 0| if (token_ != ']') { ------------------ | Branch (2265:9): [True: 0, False: 0] ------------------ 2266| 0| return Error("Expected `]` in vector default"); 2267| 0| } 2268| 0| NEXT(); ------------------ | | 63| 0|#define NEXT() ECHECK(Next()) | | ------------------ | | | | 56| 0| { \ | | | | 57| 0| auto ce = (call); \ | | | | 58| 0| if (ce.Check()) return ce; \ | | | | ------------------ | | | | | Branch (58:9): [True: 0, False: 0] | | | | ------------------ | | | | 59| 0| } | | ------------------ ------------------ 2269| 0| match = true; 2270| 0| e.constant = "[]"; 2271| 0| } 2272| | 2273| 584k|#undef FORCE_ECHECK 2274| 584k|#undef TRY_ECHECK 2275| 584k|#undef IF_ECHECK_ 2276| | 2277| 584k| if (!match) { ------------------ | Branch (2277:7): [True: 18.5k, False: 566k] ------------------ 2278| 18.5k| std::string msg; 2279| 18.5k| msg += "Cannot assign token starting with '" + TokenToStringId(token_) + 2280| 18.5k| "' to value of <" + std::string(TypeName(in_type)) + "> type."; 2281| 18.5k| return Error(msg); 2282| 18.5k| } 2283| 566k| const auto match_type = e.type.base_type; // may differ from in_type 2284| | // The check_now flag must be true when parse a fbs-schema. 2285| | // This flag forces to check default scalar values or metadata of field. 2286| | // For JSON parser the flag should be false. 2287| | // If it is set for JSON each value will be checked twice (see ParseTable). 2288| | // Special case 'null' since atot can't handle that. 2289| 566k| if (check_now && IsScalar(match_type) && e.constant != "null") { ------------------ | Branch (2289:7): [True: 98.3k, False: 468k] | Branch (2289:20): [True: 98.3k, False: 0] | Branch (2289:44): [True: 98.3k, False: 0] ------------------ 2290| | // clang-format off 2291| 98.3k| switch (match_type) { 2292| 0| #define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE, ...) \ 2293| 0| case BASE_TYPE_ ## ENUM: {\ 2294| 0| CTYPE val; \ 2295| 0| ECHECK(atot(e.constant.c_str(), *this, &val)); \ 2296| 0| SingleValueRepack(e, val); \ 2297| 0| break; } 2298| 98.3k| FLATBUFFERS_GEN_TYPES_SCALAR(FLATBUFFERS_TD) ------------------ | | 50| 0| TD(NONE, "", uint8_t, byte, byte, byte, uint8, u8, UByte, UInt8, 0) \ | | ------------------ | | | | 2298| 0| FLATBUFFERS_GEN_TYPES_SCALAR(FLATBUFFERS_TD) | | | | ------------------ | | | | | | 2293| 0| case BASE_TYPE_ ## ENUM: {\ | | | | | | ------------------ | | | | | | | Branch (2293:7): [True: 0, False: 98.3k] | | | | | | ------------------ | | | | | | 2294| 0| CTYPE val; \ | | | | | | 2295| 0| ECHECK(atot(e.constant.c_str(), *this, &val)); \ | | | | | | ------------------ | | | | | | | | 56| 0| { \ | | | | | | | | 57| 0| auto ce = (call); \ | | | | | | | | 58| 0| if (ce.Check()) return ce; \ | | | | | | | | ------------------ | | | | | | | | | Branch (58:9): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 59| 0| } | | | | | | ------------------ | | | | | | 2296| 0| SingleValueRepack(e, val); \ | | | | | | 2297| 0| break; } | | | | ------------------ | | ------------------ | | 51| 0| TD(UTYPE, "", uint8_t, byte, byte, byte, uint8, u8, UByte, UInt8, 1) /* begin scalar/int */ \ | | ------------------ | | | | 2298| 0| FLATBUFFERS_GEN_TYPES_SCALAR(FLATBUFFERS_TD) | | | | ------------------ | | | | | | 2293| 0| case BASE_TYPE_ ## ENUM: {\ | | | | | | ------------------ | | | | | | | Branch (2293:7): [True: 0, False: 98.3k] | | | | | | ------------------ | | | | | | 2294| 0| CTYPE val; \ | | | | | | 2295| 0| ECHECK(atot(e.constant.c_str(), *this, &val)); \ | | | | | | ------------------ | | | | | | | | 56| 0| { \ | | | | | | | | 57| 0| auto ce = (call); \ | | | | | | | | 58| 0| if (ce.Check()) return ce; \ | | | | | | | | ------------------ | | | | | | | | | Branch (58:9): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 59| 0| } | | | | | | ------------------ | | | | | | 2296| 0| SingleValueRepack(e, val); \ | | | | | | 2297| 0| break; } | | | | ------------------ | | ------------------ | | 52| 5.58k| TD(BOOL, "bool", uint8_t, boolean,bool, bool, bool, bool, Boolean, Bool, 2) \ | | ------------------ | | | | 2298| 5.58k| FLATBUFFERS_GEN_TYPES_SCALAR(FLATBUFFERS_TD) | | | | ------------------ | | | | | | 2293| 5.58k| case BASE_TYPE_ ## ENUM: {\ | | | | | | ------------------ | | | | | | | Branch (2293:7): [True: 5.58k, False: 92.7k] | | | | | | ------------------ | | | | | | 2294| 5.58k| CTYPE val; \ | | | | | | 2295| 5.58k| ECHECK(atot(e.constant.c_str(), *this, &val)); \ | | | | | | ------------------ | | | | | | | | 56| 5.58k| { \ | | | | | | | | 57| 5.58k| auto ce = (call); \ | | | | | | | | 58| 5.58k| if (ce.Check()) return ce; \ | | | | | | | | ------------------ | | | | | | | | | Branch (58:9): [True: 0, False: 5.58k] | | | | | | | | ------------------ | | | | | | | | 59| 5.58k| } | | | | | | ------------------ | | | | | | 2296| 5.58k| SingleValueRepack(e, val); \ | | | | | | 2297| 5.58k| break; } | | | | ------------------ | | ------------------ | | 53| 5.59k| TD(CHAR, "byte", int8_t, byte, int8, sbyte, int8, i8, Byte, Int8, 3) \ | | ------------------ | | | | 2298| 5.59k| FLATBUFFERS_GEN_TYPES_SCALAR(FLATBUFFERS_TD) | | | | ------------------ | | | | | | 2293| 5.59k| case BASE_TYPE_ ## ENUM: {\ | | | | | | ------------------ | | | | | | | Branch (2293:7): [True: 5.59k, False: 92.7k] | | | | | | ------------------ | | | | | | 2294| 5.59k| CTYPE val; \ | | | | | | 2295| 5.59k| ECHECK(atot(e.constant.c_str(), *this, &val)); \ | | | | | | ------------------ | | | | | | | | 56| 5.59k| { \ | | | | | | | | 57| 5.59k| auto ce = (call); \ | | | | | | | | 58| 5.59k| if (ce.Check()) return ce; \ | | | | | | | | ------------------ | | | | | | | | | Branch (58:9): [True: 0, False: 5.59k] | | | | | | | | ------------------ | | | | | | | | 59| 5.59k| } | | | | | | ------------------ | | | | | | 2296| 5.59k| SingleValueRepack(e, val); \ | | | | | | 2297| 5.59k| break; } | | | | ------------------ | | ------------------ | | 54| 5.59k| TD(UCHAR, "ubyte", uint8_t, byte, byte, byte, uint8, u8, UByte, UInt8, 4) \ | | ------------------ | | | | 2298| 3.27k| FLATBUFFERS_GEN_TYPES_SCALAR(FLATBUFFERS_TD) | | | | ------------------ | | | | | | 2293| 3.27k| case BASE_TYPE_ ## ENUM: {\ | | | | | | ------------------ | | | | | | | Branch (2293:7): [True: 3.27k, False: 95.0k] | | | | | | ------------------ | | | | | | 2294| 3.27k| CTYPE val; \ | | | | | | 2295| 3.27k| ECHECK(atot(e.constant.c_str(), *this, &val)); \ | | | | | | ------------------ | | | | | | | | 56| 3.27k| { \ | | | | | | | | 57| 3.27k| auto ce = (call); \ | | | | | | | | 58| 3.27k| if (ce.Check()) return ce; \ | | | | | | | | ------------------ | | | | | | | | | Branch (58:9): [True: 0, False: 3.27k] | | | | | | | | ------------------ | | | | | | | | 59| 3.27k| } | | | | | | ------------------ | | | | | | 2296| 3.27k| SingleValueRepack(e, val); \ | | | | | | 2297| 3.27k| break; } | | | | ------------------ | | ------------------ | | 55| 7.08k| TD(SHORT, "short", int16_t, short, int16, short, int16, i16, Short, Int16, 5) \ | | ------------------ | | | | 2298| 7.08k| FLATBUFFERS_GEN_TYPES_SCALAR(FLATBUFFERS_TD) | | | | ------------------ | | | | | | 2293| 7.08k| case BASE_TYPE_ ## ENUM: {\ | | | | | | ------------------ | | | | | | | Branch (2293:7): [True: 7.08k, False: 91.2k] | | | | | | ------------------ | | | | | | 2294| 7.08k| CTYPE val; \ | | | | | | 2295| 7.08k| ECHECK(atot(e.constant.c_str(), *this, &val)); \ | | | | | | ------------------ | | | | | | | | 56| 7.08k| { \ | | | | | | | | 57| 7.08k| auto ce = (call); \ | | | | | | | | 58| 7.08k| if (ce.Check()) return ce; \ | | | | | | | | ------------------ | | | | | | | | | Branch (58:9): [True: 0, False: 7.08k] | | | | | | | | ------------------ | | | | | | | | 59| 7.08k| } | | | | | | ------------------ | | | | | | 2296| 7.08k| SingleValueRepack(e, val); \ | | | | | | 2297| 7.08k| break; } | | | | ------------------ | | ------------------ | | 56| 7.30k| TD(USHORT, "ushort", uint16_t, short, uint16, ushort, uint16, u16, UShort, UInt16, 6) \ | | ------------------ | | | | 2298| 7.30k| FLATBUFFERS_GEN_TYPES_SCALAR(FLATBUFFERS_TD) | | | | ------------------ | | | | | | 2293| 7.30k| case BASE_TYPE_ ## ENUM: {\ | | | | | | ------------------ | | | | | | | Branch (2293:7): [True: 7.30k, False: 91.0k] | | | | | | ------------------ | | | | | | 2294| 7.30k| CTYPE val; \ | | | | | | 2295| 7.30k| ECHECK(atot(e.constant.c_str(), *this, &val)); \ | | | | | | ------------------ | | | | | | | | 56| 7.30k| { \ | | | | | | | | 57| 7.30k| auto ce = (call); \ | | | | | | | | 58| 7.30k| if (ce.Check()) return ce; \ | | | | | | | | ------------------ | | | | | | | | | Branch (58:9): [True: 0, False: 7.30k] | | | | | | | | ------------------ | | | | | | | | 59| 7.30k| } | | | | | | ------------------ | | | | | | 2296| 7.30k| SingleValueRepack(e, val); \ | | | | | | 2297| 7.30k| break; } | | | | ------------------ | | ------------------ | | 57| 12.4k| TD(INT, "int", int32_t, int, int32, int, int32, i32, Int, Int32, 7) \ | | ------------------ | | | | 2298| 12.4k| FLATBUFFERS_GEN_TYPES_SCALAR(FLATBUFFERS_TD) | | | | ------------------ | | | | | | 2293| 12.4k| case BASE_TYPE_ ## ENUM: {\ | | | | | | ------------------ | | | | | | | Branch (2293:7): [True: 12.4k, False: 85.9k] | | | | | | ------------------ | | | | | | 2294| 12.4k| CTYPE val; \ | | | | | | 2295| 12.4k| ECHECK(atot(e.constant.c_str(), *this, &val)); \ | | | | | | ------------------ | | | | | | | | 56| 12.4k| { \ | | | | | | | | 57| 12.4k| auto ce = (call); \ | | | | | | | | 58| 12.4k| if (ce.Check()) return ce; \ | | | | | | | | ------------------ | | | | | | | | | Branch (58:9): [True: 0, False: 12.4k] | | | | | | | | ------------------ | | | | | | | | 59| 12.4k| } | | | | | | ------------------ | | | | | | 2296| 12.4k| SingleValueRepack(e, val); \ | | | | | | 2297| 12.4k| break; } | | | | ------------------ | | ------------------ | | 58| 12.4k| TD(UINT, "uint", uint32_t, int, uint32, uint, uint32, u32, UInt, UInt32, 8) \ | | ------------------ | | | | 2298| 8.75k| FLATBUFFERS_GEN_TYPES_SCALAR(FLATBUFFERS_TD) | | | | ------------------ | | | | | | 2293| 8.75k| case BASE_TYPE_ ## ENUM: {\ | | | | | | ------------------ | | | | | | | Branch (2293:7): [True: 8.75k, False: 89.6k] | | | | | | ------------------ | | | | | | 2294| 8.75k| CTYPE val; \ | | | | | | 2295| 8.75k| ECHECK(atot(e.constant.c_str(), *this, &val)); \ | | | | | | ------------------ | | | | | | | | 56| 8.75k| { \ | | | | | | | | 57| 8.75k| auto ce = (call); \ | | | | | | | | 58| 8.75k| if (ce.Check()) return ce; \ | | | | | | | | ------------------ | | | | | | | | | Branch (58:9): [True: 0, False: 8.75k] | | | | | | | | ------------------ | | | | | | | | 59| 8.75k| } | | | | | | ------------------ | | | | | | 2296| 8.75k| SingleValueRepack(e, val); \ | | | | | | 2297| 8.75k| break; } | | | | ------------------ | | ------------------ | | 59| 10.0k| TD(LONG, "long", int64_t, long, int64, long, int64, i64, Long, Int64, 9) \ | | ------------------ | | | | 2298| 10.0k| FLATBUFFERS_GEN_TYPES_SCALAR(FLATBUFFERS_TD) | | | | ------------------ | | | | | | 2293| 10.0k| case BASE_TYPE_ ## ENUM: {\ | | | | | | ------------------ | | | | | | | Branch (2293:7): [True: 10.0k, False: 88.2k] | | | | | | ------------------ | | | | | | 2294| 10.0k| CTYPE val; \ | | | | | | 2295| 10.0k| ECHECK(atot(e.constant.c_str(), *this, &val)); \ | | | | | | ------------------ | | | | | | | | 56| 10.0k| { \ | | | | | | | | 57| 10.0k| auto ce = (call); \ | | | | | | | | 58| 10.0k| if (ce.Check()) return ce; \ | | | | | | | | ------------------ | | | | | | | | | Branch (58:9): [True: 0, False: 10.0k] | | | | | | | | ------------------ | | | | | | | | 59| 10.0k| } | | | | | | ------------------ | | | | | | 2296| 10.0k| SingleValueRepack(e, val); \ | | | | | | 2297| 10.0k| break; } | | | | ------------------ | | ------------------ | | 60| 15.3k| TD(ULONG, "ulong", uint64_t, long, uint64, ulong, uint64, u64, ULong, UInt64, 10) /* end int */ \ | | ------------------ | | | | 2298| 15.3k| FLATBUFFERS_GEN_TYPES_SCALAR(FLATBUFFERS_TD) | | | | ------------------ | | | | | | 2293| 15.3k| case BASE_TYPE_ ## ENUM: {\ | | | | | | ------------------ | | | | | | | Branch (2293:7): [True: 15.3k, False: 82.9k] | | | | | | ------------------ | | | | | | 2294| 15.3k| CTYPE val; \ | | | | | | 2295| 15.3k| ECHECK(atot(e.constant.c_str(), *this, &val)); \ | | | | | | ------------------ | | | | | | | | 56| 15.3k| { \ | | | | | | | | 57| 15.3k| auto ce = (call); \ | | | | | | | | 58| 15.3k| if (ce.Check()) return ce; \ | | | | | | | | ------------------ | | | | | | | | | Branch (58:9): [True: 0, False: 15.3k] | | | | | | | | ------------------ | | | | | | | | 59| 15.3k| } | | | | | | ------------------ | | | | | | 2296| 15.3k| SingleValueRepack(e, val); \ | | | | | | 2297| 15.3k| break; } | | | | ------------------ | | ------------------ | | 61| 15.3k| TD(FLOAT, "float", float, float, float32, float, float32, f32, Float, Float32, 11) /* begin float */ \ | | ------------------ | | | | 2298| 12.1k| FLATBUFFERS_GEN_TYPES_SCALAR(FLATBUFFERS_TD) | | | | ------------------ | | | | | | 2293| 12.1k| case BASE_TYPE_ ## ENUM: {\ | | | | | | ------------------ | | | | | | | Branch (2293:7): [True: 12.1k, False: 86.2k] | | | | | | ------------------ | | | | | | 2294| 12.1k| CTYPE val; \ | | | | | | 2295| 12.1k| ECHECK(atot(e.constant.c_str(), *this, &val)); \ | | | | | | ------------------ | | | | | | | | 56| 12.1k| { \ | | | | | | | | 57| 12.1k| auto ce = (call); \ | | | | | | | | 58| 12.1k| if (ce.Check()) return ce; \ | | | | | | | | ------------------ | | | | | | | | | Branch (58:9): [True: 0, False: 12.1k] | | | | | | | | ------------------ | | | | | | | | 59| 12.1k| } | | | | | | ------------------ | | | | | | 2296| 12.1k| SingleValueRepack(e, val); \ | | | | | | 2297| 12.1k| break; } | | | | ------------------ | | ------------------ | | 62| 12.1k| TD(DOUBLE, "double", double, double, float64, double, float64, f64, Double, Double, 12) /* end float/scalar */ | | ------------------ | | | | 2298| 10.7k| FLATBUFFERS_GEN_TYPES_SCALAR(FLATBUFFERS_TD) | | | | ------------------ | | | | | | 2293| 10.7k| case BASE_TYPE_ ## ENUM: {\ | | | | | | ------------------ | | | | | | | Branch (2293:7): [True: 10.7k, False: 87.5k] | | | | | | ------------------ | | | | | | 2294| 10.7k| CTYPE val; \ | | | | | | 2295| 10.7k| ECHECK(atot(e.constant.c_str(), *this, &val)); \ | | | | | | ------------------ | | | | | | | | 56| 10.7k| { \ | | | | | | | | 57| 10.7k| auto ce = (call); \ | | | | | | | | 58| 10.7k| if (ce.Check()) return ce; \ | | | | | | | | ------------------ | | | | | | | | | Branch (58:9): [True: 0, False: 10.7k] | | | | | | | | ------------------ | | | | | | | | 59| 10.7k| } | | | | | | ------------------ | | | | | | 2296| 10.7k| SingleValueRepack(e, val); \ | | | | | | 2297| 10.7k| break; } | | | | ------------------ | | ------------------ ------------------ 2299| 0| #undef FLATBUFFERS_TD 2300| 0| default: break; ------------------ | Branch (2300:5): [True: 0, False: 98.3k] ------------------ 2301| 98.3k| } 2302| | // clang-format on 2303| 98.3k| } 2304| 566k| return NoError(); 2305| 566k|} _ZN11flatbuffers6Parser18LookupCreateStructERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEbb: 2308| 206k| bool create_if_new, bool definition) { 2309| 206k| std::string qualified_name = current_namespace_->GetFullyQualifiedName(name); 2310| | // See if it exists pre-declared by an unqualified use. 2311| 206k| auto struct_def = LookupStruct(name); 2312| 206k| if (struct_def && struct_def->predecl) { ------------------ | Branch (2312:7): [True: 0, False: 206k] | Branch (2312:21): [True: 0, False: 0] ------------------ 2313| 0| if (definition) { ------------------ | Branch (2313:9): [True: 0, False: 0] ------------------ 2314| | // Make sure it has the current namespace, and is registered under its 2315| | // qualified name. 2316| 0| struct_def->defined_namespace = current_namespace_; 2317| 0| structs_.Move(name, qualified_name); 2318| 0| } 2319| 0| return struct_def; 2320| 0| } 2321| | // See if it exists pre-declared by an qualified use. 2322| 206k| struct_def = LookupStruct(qualified_name); 2323| 206k| if (struct_def && struct_def->predecl) { ------------------ | Branch (2323:7): [True: 0, False: 206k] | Branch (2323:21): [True: 0, False: 0] ------------------ 2324| 0| if (definition) { ------------------ | Branch (2324:9): [True: 0, False: 0] ------------------ 2325| | // Make sure it has the current namespace. 2326| 0| struct_def->defined_namespace = current_namespace_; 2327| 0| } 2328| 0| return struct_def; 2329| 0| } 2330| 206k| if (!definition && !struct_def) { ------------------ | Branch (2330:7): [True: 103k, False: 103k] | Branch (2330:22): [True: 103k, False: 0] ------------------ 2331| 103k| struct_def = LookupStructThruParentNamespaces(name); 2332| 103k| } 2333| 206k| if (!struct_def && create_if_new) { ------------------ | Branch (2333:7): [True: 206k, False: 0] | Branch (2333:22): [True: 103k, False: 103k] ------------------ 2334| 103k| struct_def = new StructDef(); 2335| 103k| if (definition) { ------------------ | Branch (2335:9): [True: 103k, False: 0] ------------------ 2336| 103k| structs_.Add(qualified_name, struct_def); 2337| 103k| struct_def->name = name; 2338| 103k| struct_def->defined_namespace = current_namespace_; 2339| 103k| } else { 2340| | // Not a definition. 2341| | // Rather than failing, we create a "pre declared" StructDef, due to 2342| | // circular references, and check for errors at the end of parsing. 2343| | // It is defined in the current namespace, as the best guess what the 2344| | // final namespace will be. 2345| 0| structs_.Add(name, struct_def); 2346| 0| struct_def->name = name; 2347| 0| struct_def->defined_namespace = current_namespace_; 2348| 0| struct_def->original_location.reset( 2349| 0| new std::string(file_being_parsed_ + ":" + NumToString(line_))); 2350| 0| } 2351| 103k| } 2352| 206k| return struct_def; 2353| 206k|} _ZN11flatbuffers6Parser11StartStructERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEPPNS_9StructDefE: 2713| 103k|CheckedError Parser::StartStruct(const std::string& name, StructDef** dest) { 2714| 103k| auto& struct_def = *LookupCreateStruct(name, true, true); 2715| 103k| if (!struct_def.predecl) ------------------ | Branch (2715:7): [True: 0, False: 103k] ------------------ 2716| 0| return Error("datatype already exists: " + 2717| 0| current_namespace_->GetFullyQualifiedName(name)); 2718| 103k| struct_def.predecl = false; 2719| 103k| struct_def.name = name; 2720| 103k| struct_def.file = file_being_parsed_; 2721| | // Move this struct to the back of the vector just in case it was predeclared, 2722| | // to preserve declaration order. 2723| 103k| *std::remove(structs_.vec.begin(), structs_.vec.end(), &struct_def) = 2724| 103k| &struct_def; 2725| 103k| *dest = &struct_def; 2726| 103k| return NoError(); 2727| 103k|} _ZN11flatbuffers6Parser10CheckClashERNSt3__16vectorIPNS_8FieldDefENS1_9allocatorIS4_EEEEPNS_9StructDefEPKcNS_8BaseTypeE: 2731| 620k| BaseType basetype) { 2732| 620k| auto len = strlen(suffix); 2733| 1.24M| for (auto it = fields.begin(); it != fields.end(); ++it) { ------------------ | Branch (2733:34): [True: 620k, False: 620k] ------------------ 2734| 620k| auto& fname = (*it)->name; 2735| 620k| if (fname.length() > len && ------------------ | Branch (2735:9): [True: 0, False: 620k] ------------------ 2736| 0| fname.compare(fname.length() - len, len, suffix) == 0 && ------------------ | Branch (2736:9): [True: 0, False: 0] ------------------ 2737| 0| (*it)->value.type.base_type != BASE_TYPE_UTYPE) { ------------------ | Branch (2737:9): [True: 0, False: 0] ------------------ 2738| 0| auto field = 2739| 0| struct_def->fields.Lookup(fname.substr(0, fname.length() - len)); 2740| 0| if (field && field->value.type.base_type == basetype) ------------------ | Branch (2740:11): [True: 0, False: 0] | Branch (2740:20): [True: 0, False: 0] ------------------ 2741| 0| return Error("Field " + fname + 2742| 0| " would clash with generated functions for field " + 2743| 0| field->name); 2744| 0| } 2745| 620k| } 2746| 620k| return NoError(); 2747| 620k|} _ZN11flatbuffers6Parser9ParseDeclEPKc: 2869| 103k|CheckedError Parser::ParseDecl(const char* filename) { 2870| 103k| std::vector dc = doc_comment_; 2871| 103k| bool fixed = IsIdent("struct"); 2872| 103k| if (!fixed && !IsIdent("table")) return Error("declaration expected"); ------------------ | Branch (2872:7): [True: 103k, False: 0] | Branch (2872:17): [True: 0, False: 103k] ------------------ 2873| 103k| NEXT(); ------------------ | | 63| 103k|#define NEXT() ECHECK(Next()) | | ------------------ | | | | 56| 103k| { \ | | | | 57| 103k| auto ce = (call); \ | | | | 58| 103k| if (ce.Check()) return ce; \ | | | | ------------------ | | | | | Branch (58:9): [True: 0, False: 103k] | | | | ------------------ | | | | 59| 103k| } | | ------------------ ------------------ 2874| 103k| std::string name = attribute_; 2875| 103k| EXPECT(kTokenIdentifier); ------------------ | | 64| 103k|#define EXPECT(tok) ECHECK(Expect(tok)) | | ------------------ | | | | 56| 103k| { \ | | | | 57| 103k| auto ce = (call); \ | | | | 58| 103k| if (ce.Check()) return ce; \ | | | | ------------------ | | | | | Branch (58:9): [True: 0, False: 103k] | | | | ------------------ | | | | 59| 103k| } | | ------------------ ------------------ 2876| 103k| StructDef* struct_def; 2877| 103k| ECHECK(StartStruct(name, &struct_def)); ------------------ | | 56| 103k| { \ | | 57| 103k| auto ce = (call); \ | | 58| 103k| if (ce.Check()) return ce; \ | | ------------------ | | | Branch (58:9): [True: 0, False: 103k] | | ------------------ | | 59| 103k| } ------------------ 2878| 103k| struct_def->doc_comment = dc; 2879| 103k| struct_def->fixed = fixed; 2880| 103k| if (filename && !opts.project_root.empty()) { ------------------ | Branch (2880:7): [True: 0, False: 103k] | Branch (2880:19): [True: 0, False: 0] ------------------ 2881| 0| struct_def->declaration_file = &GetPooledString(FilePath( 2882| 0| opts.project_root, filename, opts.binary_schema_absolute_paths)); 2883| 0| } 2884| 103k| ECHECK(ParseMetaData(&struct_def->attributes)); ------------------ | | 56| 103k| { \ | | 57| 103k| auto ce = (call); \ | | 58| 103k| if (ce.Check()) return ce; \ | | ------------------ | | | Branch (58:9): [True: 0, False: 103k] | | ------------------ | | 59| 103k| } ------------------ 2885| 103k| struct_def->sortbysize = 2886| 103k| struct_def->attributes.Lookup("original_order") == nullptr && !fixed; ------------------ | Branch (2886:7): [True: 103k, False: 0] | Branch (2886:69): [True: 103k, False: 0] ------------------ 2887| 103k| EXPECT('{'); ------------------ | | 64| 103k|#define EXPECT(tok) ECHECK(Expect(tok)) | | ------------------ | | | | 56| 103k| { \ | | | | 57| 103k| auto ce = (call); \ | | | | 58| 103k| if (ce.Check()) return ce; \ | | | | ------------------ | | | | | Branch (58:9): [True: 0, False: 103k] | | | | ------------------ | | | | 59| 103k| } | | ------------------ ------------------ 2888| 206k| while (token_ != '}') ECHECK(ParseField(*struct_def)); ------------------ | | 56| 206k| { \ | | 57| 206k| auto ce = (call); \ | | 58| 206k| if (ce.Check()) return ce; \ | | ------------------ | | | Branch (58:9): [True: 0, False: 103k] | | ------------------ | | 59| 206k| } ------------------ | Branch (2888:10): [True: 103k, False: 103k] ------------------ 2889| 103k| if (fixed) { ------------------ | Branch (2889:7): [True: 0, False: 103k] ------------------ 2890| 0| const auto force_align = struct_def->attributes.Lookup("force_align"); 2891| 0| if (force_align) { ------------------ | Branch (2891:9): [True: 0, False: 0] ------------------ 2892| 0| size_t align; 2893| 0| ECHECK(ParseAlignAttribute(force_align->constant, struct_def->minalign, ------------------ | | 56| 0| { \ | | 57| 0| auto ce = (call); \ | | 58| 0| if (ce.Check()) return ce; \ | | ------------------ | | | Branch (58:9): [True: 0, False: 0] | | ------------------ | | 59| 0| } ------------------ 2894| 0| &align)); 2895| 0| struct_def->minalign = align; 2896| 0| } 2897| 0| if (!struct_def->bytesize) return Error("size 0 structs not allowed"); ------------------ | Branch (2897:9): [True: 0, False: 0] ------------------ 2898| 0| } 2899| 103k| struct_def->PadLastField(struct_def->minalign); 2900| | // Check if this is a table that has manual id assignments 2901| 103k| auto& fields = struct_def->fields.vec; 2902| 103k| if (!fixed && fields.size()) { ------------------ | Branch (2902:7): [True: 103k, False: 0] | Branch (2902:17): [True: 103k, False: 0] ------------------ 2903| 103k| size_t num_id_fields = 0; 2904| 206k| for (auto it = fields.begin(); it != fields.end(); ++it) { ------------------ | Branch (2904:36): [True: 103k, False: 103k] ------------------ 2905| 103k| if ((*it)->attributes.Lookup("id")) num_id_fields++; ------------------ | Branch (2905:11): [True: 0, False: 103k] ------------------ 2906| 103k| } 2907| | // If any fields have ids.. 2908| 103k| if (num_id_fields || opts.require_explicit_ids) { ------------------ | Branch (2908:9): [True: 0, False: 103k] | Branch (2908:26): [True: 0, False: 103k] ------------------ 2909| | // Then all fields must have them. 2910| 0| if (num_id_fields != fields.size()) { ------------------ | Branch (2910:11): [True: 0, False: 0] ------------------ 2911| 0| if (opts.require_explicit_ids) { ------------------ | Branch (2911:13): [True: 0, False: 0] ------------------ 2912| 0| return Error( 2913| 0| "all fields must have an 'id' attribute when " 2914| 0| "--require-explicit-ids is used"); 2915| 0| } else { 2916| 0| return Error( 2917| 0| "either all fields or no fields must have an 'id' attribute"); 2918| 0| } 2919| 0| } 2920| | // Simply sort by id, then the fields are the same as if no ids had 2921| | // been specified. 2922| 0| std::sort(fields.begin(), fields.end(), compareFieldDefs); 2923| | // Verify we have a contiguous set, and reassign vtable offsets. 2924| 0| FLATBUFFERS_ASSERT(fields.size() <= 2925| 0| flatbuffers::numeric_limits::max()); 2926| 0| for (voffset_t i = 0; i < static_cast(fields.size()); i++) { ------------------ | Branch (2926:29): [True: 0, False: 0] ------------------ 2927| 0| auto& field = *fields[i]; 2928| 0| const auto& id_str = field.attributes.Lookup("id")->constant; 2929| | 2930| | // Metadata values have a dynamic type, they can be `float`, 'int', or 2931| | // 'string`. 2932| | // The FieldIndexToOffset(i) expects the voffset_t so `id` is limited by 2933| | // this type. 2934| 0| voffset_t id = 0; 2935| 0| const auto done = !atot(id_str.c_str(), *this, &id).Check(); 2936| 0| if (!done) ------------------ | Branch (2936:13): [True: 0, False: 0] ------------------ 2937| 0| return Error("field id\'s must be non-negative number, field: " + 2938| 0| field.name + ", id: " + id_str); 2939| 0| if (i != id) ------------------ | Branch (2939:13): [True: 0, False: 0] ------------------ 2940| 0| return Error("field id\'s must be consecutive from 0, id " + 2941| 0| NumToString(i) + " missing or set twice, field: " + 2942| 0| field.name + ", id: " + id_str); 2943| 0| field.value.offset = FieldIndexToOffset(i); 2944| 0| } 2945| 0| } 2946| 103k| } 2947| | 2948| 103k| ECHECK( ------------------ | | 56| 103k| { \ | | 57| 103k| auto ce = (call); \ | | 58| 103k| if (ce.Check()) return ce; \ | | ------------------ | | | Branch (58:9): [True: 0, False: 103k] | | ------------------ | | 59| 103k| } ------------------ 2949| 103k| CheckClash(fields, struct_def, UnionTypeFieldSuffix(), BASE_TYPE_UNION)); 2950| 103k| ECHECK(CheckClash(fields, struct_def, "Type", BASE_TYPE_UNION)); ------------------ | | 56| 103k| { \ | | 57| 103k| auto ce = (call); \ | | 58| 103k| if (ce.Check()) return ce; \ | | ------------------ | | | Branch (58:9): [True: 0, False: 103k] | | ------------------ | | 59| 103k| } ------------------ 2951| 103k| ECHECK(CheckClash(fields, struct_def, "_length", BASE_TYPE_VECTOR)); ------------------ | | 56| 103k| { \ | | 57| 103k| auto ce = (call); \ | | 58| 103k| if (ce.Check()) return ce; \ | | ------------------ | | | Branch (58:9): [True: 0, False: 103k] | | ------------------ | | 59| 103k| } ------------------ 2952| 103k| ECHECK(CheckClash(fields, struct_def, "Length", BASE_TYPE_VECTOR)); ------------------ | | 56| 103k| { \ | | 57| 103k| auto ce = (call); \ | | 58| 103k| if (ce.Check()) return ce; \ | | ------------------ | | | Branch (58:9): [True: 0, False: 103k] | | ------------------ | | 59| 103k| } ------------------ 2953| 103k| ECHECK(CheckClash(fields, struct_def, "_byte_vector", BASE_TYPE_STRING)); ------------------ | | 56| 103k| { \ | | 57| 103k| auto ce = (call); \ | | 58| 103k| if (ce.Check()) return ce; \ | | ------------------ | | | Branch (58:9): [True: 0, False: 103k] | | ------------------ | | 59| 103k| } ------------------ 2954| 103k| ECHECK(CheckClash(fields, struct_def, "ByteVector", BASE_TYPE_STRING)); ------------------ | | 56| 103k| { \ | | 57| 103k| auto ce = (call); \ | | 58| 103k| if (ce.Check()) return ce; \ | | ------------------ | | | Branch (58:9): [True: 0, False: 103k] | | ------------------ | | 59| 103k| } ------------------ 2955| 103k| EXPECT('}'); ------------------ | | 64| 103k|#define EXPECT(tok) ECHECK(Expect(tok)) | | ------------------ | | | | 56| 103k| { \ | | | | 57| 103k| auto ce = (call); \ | | | | 58| 103k| if (ce.Check()) return ce; \ | | | | ------------------ | | | | | Branch (58:9): [True: 0, False: 103k] | | | | ------------------ | | | | 59| 103k| } | | ------------------ ------------------ 2956| 103k| const auto qualified_name = 2957| 103k| current_namespace_->GetFullyQualifiedName(struct_def->name); 2958| 103k| if (types_.Add(qualified_name, ------------------ | Branch (2958:7): [True: 0, False: 103k] ------------------ 2959| 103k| new Type(BASE_TYPE_STRUCT, struct_def, nullptr))) 2960| 0| return Error("datatype already exists: " + qualified_name); 2961| 103k| return NoError(); 2962| 103k|} _ZN11flatbuffers6Parser11SetRootTypeEPKc: 3010| 103k|bool Parser::SetRootType(const char* name) { 3011| 103k| root_struct_def_ = LookupStruct(name); 3012| 103k| if (!root_struct_def_) ------------------ | Branch (3012:7): [True: 0, False: 103k] ------------------ 3013| 0| root_struct_def_ = 3014| 0| LookupStruct(current_namespace_->GetFullyQualifiedName(name)); 3015| 103k| return root_struct_def_ != nullptr; 3016| 103k|} _ZN11flatbuffers6Parser5ParseEPKcPS2_S2_: 3587| 103k| const char* source_filename) { 3588| 103k| const auto initial_depth = parse_depth_counter_; 3589| 103k| (void)initial_depth; 3590| 103k| bool r; 3591| | 3592| 103k| if (opts.use_flexbuffers) { ------------------ | Branch (3592:7): [True: 0, False: 103k] ------------------ 3593| 0| r = ParseFlexBuffer(source, source_filename, &flex_builder_); 3594| 103k| } else { 3595| 103k| r = !ParseRoot(source, include_paths, source_filename).Check(); 3596| 103k| } 3597| 103k| FLATBUFFERS_ASSERT(initial_depth == parse_depth_counter_); 3598| 103k| return r; 3599| 103k|} _ZN11flatbuffers6Parser9ParseJsonEPKcS2_: 3601| 665k|bool Parser::ParseJson(const char* json, const char* json_filename) { 3602| 665k| const auto initial_depth = parse_depth_counter_; 3603| 665k| (void)initial_depth; 3604| 665k| builder_.Clear(); 3605| 665k| const auto done = 3606| 665k| !StartParseFile(json, json_filename).Check() && !DoParseJson().Check(); ------------------ | Branch (3606:7): [True: 665k, False: 0] | Branch (3606:55): [True: 190k, False: 475k] ------------------ 3607| 665k| FLATBUFFERS_ASSERT(initial_depth == parse_depth_counter_); 3608| 665k| return done; 3609| 665k|} _ZN11flatbuffers6Parser14StartParseFileEPKcS2_: 3616| 769k| const char* source_filename) { 3617| 769k| file_being_parsed_ = source_filename ? source_filename : ""; ------------------ | Branch (3617:24): [True: 0, False: 769k] ------------------ 3618| 769k| source_ = source; 3619| 769k| ResetState(source_); 3620| 769k| error_.clear(); 3621| 769k| ECHECK(SkipByteOrderMark()); ------------------ | | 56| 769k| { \ | | 57| 769k| auto ce = (call); \ | | 58| 769k| if (ce.Check()) return ce; \ | | ------------------ | | | Branch (58:9): [True: 0, False: 769k] | | ------------------ | | 59| 769k| } ------------------ 3622| 769k| NEXT(); ------------------ | | 63| 769k|#define NEXT() ECHECK(Next()) | | ------------------ | | | | 56| 769k| { \ | | | | 57| 769k| auto ce = (call); \ | | | | 58| 769k| if (ce.Check()) return ce; \ | | | | ------------------ | | | | | Branch (58:9): [True: 0, False: 769k] | | | | ------------------ | | | | 59| 769k| } | | ------------------ ------------------ 3623| 769k| if (Is(kTokenEof)) return Error("input file is empty"); ------------------ | Branch (3623:7): [True: 0, False: 769k] ------------------ 3624| 769k| return NoError(); 3625| 769k|} _ZN11flatbuffers6Parser9ParseRootEPKcPS2_S2_: 3628| 103k| const char* source_filename) { 3629| 103k| ECHECK(DoParse(source, include_paths, source_filename, nullptr)); ------------------ | | 56| 103k| { \ | | 57| 103k| auto ce = (call); \ | | 58| 103k| if (ce.Check()) return ce; \ | | ------------------ | | | Branch (58:9): [True: 0, False: 103k] | | ------------------ | | 59| 103k| } ------------------ 3630| | 3631| | // Check that all types were defined. 3632| 206k| for (auto it = structs_.vec.begin(); it != structs_.vec.end();) { ------------------ | Branch (3632:40): [True: 103k, False: 103k] ------------------ 3633| 103k| auto& struct_def = **it; 3634| 103k| if (struct_def.predecl) { ------------------ | Branch (3634:9): [True: 0, False: 103k] ------------------ 3635| 0| if (opts.proto_mode) { ------------------ | Branch (3635:11): [True: 0, False: 0] ------------------ 3636| | // Protos allow enums to be used before declaration, so check if that 3637| | // is the case here. 3638| 0| EnumDef* enum_def = nullptr; 3639| 0| for (size_t components = 3640| 0| struct_def.defined_namespace->components.size() + 1; 3641| 0| components && !enum_def; components--) { ------------------ | Branch (3641:14): [True: 0, False: 0] | Branch (3641:28): [True: 0, False: 0] ------------------ 3642| 0| auto qualified_name = 3643| 0| struct_def.defined_namespace->GetFullyQualifiedName( 3644| 0| struct_def.name, components - 1); 3645| 0| enum_def = LookupEnum(qualified_name); 3646| 0| } 3647| 0| if (enum_def) { ------------------ | Branch (3647:13): [True: 0, False: 0] ------------------ 3648| | // This is pretty slow, but a simple solution for now. 3649| 0| auto initial_count = struct_def.refcount; 3650| 0| for (auto struct_it = structs_.vec.begin(); 3651| 0| struct_it != structs_.vec.end(); ++struct_it) { ------------------ | Branch (3651:16): [True: 0, False: 0] ------------------ 3652| 0| auto& sd = **struct_it; 3653| 0| for (auto field_it = sd.fields.vec.begin(); 3654| 0| field_it != sd.fields.vec.end(); ++field_it) { ------------------ | Branch (3654:18): [True: 0, False: 0] ------------------ 3655| 0| auto& field = **field_it; 3656| 0| if (field.value.type.struct_def == &struct_def) { ------------------ | Branch (3656:19): [True: 0, False: 0] ------------------ 3657| 0| field.value.type.struct_def = nullptr; 3658| 0| field.value.type.enum_def = enum_def; 3659| 0| auto& bt = IsVector(field.value.type) ------------------ | Branch (3659:28): [True: 0, False: 0] ------------------ 3660| 0| ? field.value.type.element 3661| 0| : field.value.type.base_type; 3662| 0| FLATBUFFERS_ASSERT(bt == BASE_TYPE_STRUCT); 3663| 0| bt = enum_def->underlying_type.base_type; 3664| 0| struct_def.refcount--; 3665| 0| enum_def->refcount++; 3666| 0| } 3667| 0| } 3668| 0| } 3669| 0| if (struct_def.refcount) ------------------ | Branch (3669:15): [True: 0, False: 0] ------------------ 3670| 0| return Error("internal: " + NumToString(struct_def.refcount) + "/" + 3671| 0| NumToString(initial_count) + 3672| 0| " use(s) of pre-declaration enum not accounted for: " + 3673| 0| enum_def->name); 3674| 0| structs_.dict.erase(structs_.dict.find(struct_def.name)); 3675| 0| it = structs_.vec.erase(it); 3676| 0| delete &struct_def; 3677| 0| continue; // Skip error. 3678| 0| } 3679| 0| } 3680| 0| auto err = "type referenced but not defined (check namespace): " + 3681| 0| struct_def.name; 3682| 0| if (struct_def.original_location) ------------------ | Branch (3682:11): [True: 0, False: 0] ------------------ 3683| 0| err += ", originally at: " + *struct_def.original_location; 3684| 0| return Error(err); 3685| 0| } 3686| 103k| ++it; 3687| 103k| } 3688| | 3689| | // This check has to happen here and not earlier, because only now do we 3690| | // know for sure what the type of these are. 3691| 103k| for (auto it = enums_.vec.begin(); it != enums_.vec.end(); ++it) { ------------------ | Branch (3691:38): [True: 0, False: 103k] ------------------ 3692| 0| auto& enum_def = **it; 3693| 0| if (enum_def.is_union) { ------------------ | Branch (3693:9): [True: 0, False: 0] ------------------ 3694| 0| for (auto val_it = enum_def.Vals().begin(); 3695| 0| val_it != enum_def.Vals().end(); ++val_it) { ------------------ | Branch (3695:12): [True: 0, False: 0] ------------------ 3696| 0| auto& val = **val_it; 3697| | 3698| 0| if (!(opts.lang_to_generate != 0 && SupportsAdvancedUnionFeatures()) && ------------------ | Branch (3698:15): [True: 0, False: 0] | Branch (3698:45): [True: 0, False: 0] ------------------ 3699| 0| (IsStruct(val.union_type) || IsString(val.union_type))) ------------------ | Branch (3699:14): [True: 0, False: 0] | Branch (3699:42): [True: 0, False: 0] ------------------ 3700| | 3701| 0| return Error( 3702| 0| "only tables can be union elements in the generated language: " + 3703| 0| val.name); 3704| 0| } 3705| 0| } 3706| 0| } 3707| | 3708| 103k| auto err = CheckPrivateLeak(); 3709| 103k| if (err.Check()) return err; ------------------ | Branch (3709:7): [True: 0, False: 103k] ------------------ 3710| | 3711| | // Parse JSON object only if the scheme has been parsed. 3712| 103k| if (token_ == '{') { ------------------ | Branch (3712:7): [True: 98.3k, False: 5.06k] ------------------ 3713| 98.3k| ECHECK(DoParseJson()); ------------------ | | 56| 98.3k| { \ | | 57| 98.3k| auto ce = (call); \ | | 58| 98.3k| if (ce.Check()) return ce; \ | | ------------------ | | | Branch (58:9): [True: 0, False: 98.3k] | | ------------------ | | 59| 98.3k| } ------------------ 3714| 98.3k| } 3715| 103k| return NoError(); 3716| 103k|} _ZN11flatbuffers6Parser16CheckPrivateLeakEv: 3718| 103k|CheckedError Parser::CheckPrivateLeak() { 3719| 103k| if (!opts.no_leak_private_annotations) return NoError(); ------------------ | Branch (3719:7): [True: 103k, False: 0] ------------------ 3720| | // Iterate over all structs/tables to validate we arent leaking 3721| | // any private (structs/tables/enums) 3722| 0| for (auto it = structs_.vec.begin(); it != structs_.vec.end(); it++) { ------------------ | Branch (3722:40): [True: 0, False: 0] ------------------ 3723| 0| auto& struct_def = **it; 3724| 0| for (auto fld_it = struct_def.fields.vec.begin(); 3725| 0| fld_it != struct_def.fields.vec.end(); ++fld_it) { ------------------ | Branch (3725:10): [True: 0, False: 0] ------------------ 3726| 0| auto& field = **fld_it; 3727| | 3728| 0| if (field.value.type.enum_def) { ------------------ | Branch (3728:11): [True: 0, False: 0] ------------------ 3729| 0| auto err = 3730| 0| CheckPrivatelyLeakedFields(struct_def, *field.value.type.enum_def); 3731| 0| if (err.Check()) { ------------------ | Branch (3731:13): [True: 0, False: 0] ------------------ 3732| 0| return err; 3733| 0| } 3734| 0| } else if (field.value.type.struct_def) { ------------------ | Branch (3734:18): [True: 0, False: 0] ------------------ 3735| 0| auto err = CheckPrivatelyLeakedFields(struct_def, 3736| 0| *field.value.type.struct_def); 3737| 0| if (err.Check()) { ------------------ | Branch (3737:13): [True: 0, False: 0] ------------------ 3738| 0| return err; 3739| 0| } 3740| 0| } 3741| 0| } 3742| 0| } 3743| | // Iterate over all enums to validate we arent leaking 3744| | // any private (structs/tables) 3745| 0| for (auto it = enums_.vec.begin(); it != enums_.vec.end(); ++it) { ------------------ | Branch (3745:38): [True: 0, False: 0] ------------------ 3746| 0| auto& enum_def = **it; 3747| 0| if (enum_def.is_union) { ------------------ | Branch (3747:9): [True: 0, False: 0] ------------------ 3748| 0| for (auto val_it = enum_def.Vals().begin(); 3749| 0| val_it != enum_def.Vals().end(); ++val_it) { ------------------ | Branch (3749:12): [True: 0, False: 0] ------------------ 3750| 0| auto& val = **val_it; 3751| 0| if (val.union_type.struct_def) { ------------------ | Branch (3751:13): [True: 0, False: 0] ------------------ 3752| 0| auto err = 3753| 0| CheckPrivatelyLeakedFields(enum_def, *val.union_type.struct_def); 3754| 0| if (err.Check()) { ------------------ | Branch (3754:15): [True: 0, False: 0] ------------------ 3755| 0| return err; 3756| 0| } 3757| 0| } 3758| 0| } 3759| 0| } 3760| 0| } 3761| 0| return NoError(); 3762| 0|} _ZN11flatbuffers6Parser7DoParseEPKcPS2_S2_S2_: 3779| 103k| const char* include_filename) { 3780| 103k| uint64_t source_hash = 0; 3781| 103k| if (source_filename) { ------------------ | Branch (3781:7): [True: 0, False: 103k] ------------------ 3782| | // If the file is in-memory, don't include its contents in the hash as we 3783| | // won't be able to load them later. 3784| 0| if (FileExists(source_filename)) ------------------ | Branch (3784:9): [True: 0, False: 0] ------------------ 3785| 0| source_hash = HashFile(source_filename, source); 3786| 0| else 3787| 0| source_hash = HashFile(source_filename, nullptr); 3788| | 3789| 0| if (included_files_.find(source_hash) == included_files_.end()) { ------------------ | Branch (3789:9): [True: 0, False: 0] ------------------ 3790| 0| included_files_[source_hash] = include_filename ? include_filename : ""; ------------------ | Branch (3790:38): [True: 0, False: 0] ------------------ 3791| 0| files_included_per_file_[source_filename] = std::set(); 3792| 0| } else { 3793| 0| return NoError(); 3794| 0| } 3795| 0| } 3796| 103k| if (!include_paths) { ------------------ | Branch (3796:7): [True: 103k, False: 0] ------------------ 3797| 103k| static const char* current_directory[] = {"", nullptr}; 3798| 103k| include_paths = current_directory; 3799| 103k| } 3800| 103k| field_stack_.clear(); 3801| 103k| builder_.Clear(); 3802| | // Start with a blank namespace just in case this file doesn't have one. 3803| 103k| current_namespace_ = empty_namespace_; 3804| | 3805| 103k| ECHECK(StartParseFile(source, source_filename)); ------------------ | | 56| 103k| { \ | | 57| 103k| auto ce = (call); \ | | 58| 103k| if (ce.Check()) return ce; \ | | ------------------ | | | Branch (58:9): [True: 0, False: 103k] | | ------------------ | | 59| 103k| } ------------------ 3806| | 3807| | // Includes must come before type declarations: 3808| 103k| for (;;) { 3809| | // Parse pre-include proto statements if any: 3810| 103k| if (opts.proto_mode && (attribute_ == "option" || attribute_ == "syntax" || ------------------ | Branch (3810:9): [True: 0, False: 103k] | Branch (3810:29): [True: 0, False: 0] | Branch (3810:55): [True: 0, False: 0] ------------------ 3811| 0| attribute_ == "package")) { ------------------ | Branch (3811:29): [True: 0, False: 0] ------------------ 3812| 0| ECHECK(ParseProtoDecl()); ------------------ | | 56| 0| { \ | | 57| 0| auto ce = (call); \ | | 58| 0| if (ce.Check()) return ce; \ | | ------------------ | | | Branch (58:9): [True: 0, False: 0] | | ------------------ | | 59| 0| } ------------------ 3813| 103k| } else if (IsIdent("native_include")) { ------------------ | Branch (3813:16): [True: 0, False: 103k] ------------------ 3814| 0| NEXT(); ------------------ | | 63| 0|#define NEXT() ECHECK(Next()) | | ------------------ | | | | 56| 0| { \ | | | | 57| 0| auto ce = (call); \ | | | | 58| 0| if (ce.Check()) return ce; \ | | | | ------------------ | | | | | Branch (58:9): [True: 0, False: 0] | | | | ------------------ | | | | 59| 0| } | | ------------------ ------------------ 3815| 0| native_included_files_.emplace_back(attribute_); 3816| 0| EXPECT(kTokenStringConstant); ------------------ | | 64| 0|#define EXPECT(tok) ECHECK(Expect(tok)) | | ------------------ | | | | 56| 0| { \ | | | | 57| 0| auto ce = (call); \ | | | | 58| 0| if (ce.Check()) return ce; \ | | | | ------------------ | | | | | Branch (58:9): [True: 0, False: 0] | | | | ------------------ | | | | 59| 0| } | | ------------------ ------------------ 3817| 0| EXPECT(';'); ------------------ | | 64| 0|#define EXPECT(tok) ECHECK(Expect(tok)) | | ------------------ | | | | 56| 0| { \ | | | | 57| 0| auto ce = (call); \ | | | | 58| 0| if (ce.Check()) return ce; \ | | | | ------------------ | | | | | Branch (58:9): [True: 0, False: 0] | | | | ------------------ | | | | 59| 0| } | | ------------------ ------------------ 3818| 103k| } else if (IsIdent("include") || (opts.proto_mode && IsIdent("import"))) { ------------------ | Branch (3818:16): [True: 0, False: 103k] | Branch (3818:39): [True: 0, False: 103k] | Branch (3818:58): [True: 0, False: 0] ------------------ 3819| 0| NEXT(); ------------------ | | 63| 0|#define NEXT() ECHECK(Next()) | | ------------------ | | | | 56| 0| { \ | | | | 57| 0| auto ce = (call); \ | | | | 58| 0| if (ce.Check()) return ce; \ | | | | ------------------ | | | | | Branch (58:9): [True: 0, False: 0] | | | | ------------------ | | | | 59| 0| } | | ------------------ ------------------ 3820| 0| if (opts.proto_mode && attribute_ == "public") NEXT(); ------------------ | | 63| 0|#define NEXT() ECHECK(Next()) | | ------------------ | | | | 56| 0| { \ | | | | 57| 0| auto ce = (call); \ | | | | 58| 0| if (ce.Check()) return ce; \ | | | | ------------------ | | | | | Branch (58:9): [True: 0, False: 0] | | | | ------------------ | | | | 59| 0| } | | ------------------ ------------------ | Branch (3820:11): [True: 0, False: 0] | Branch (3820:30): [True: 0, False: 0] ------------------ 3821| 0| auto name = flatbuffers::PosixPath(attribute_.c_str()); 3822| 0| EXPECT(kTokenStringConstant); ------------------ | | 64| 0|#define EXPECT(tok) ECHECK(Expect(tok)) | | ------------------ | | | | 56| 0| { \ | | | | 57| 0| auto ce = (call); \ | | | | 58| 0| if (ce.Check()) return ce; \ | | | | ------------------ | | | | | Branch (58:9): [True: 0, False: 0] | | | | ------------------ | | | | 59| 0| } | | ------------------ ------------------ 3823| | // Look for the file relative to the directory of the current file. 3824| 0| std::string filepath; 3825| 0| if (source_filename) { ------------------ | Branch (3825:11): [True: 0, False: 0] ------------------ 3826| 0| auto source_file_directory = 3827| 0| flatbuffers::StripFileName(source_filename); 3828| 0| filepath = flatbuffers::ConCatPathFileName(source_file_directory, name); 3829| 0| } 3830| 0| if (filepath.empty() || !FileExists(filepath.c_str())) { ------------------ | Branch (3830:11): [True: 0, False: 0] | Branch (3830:31): [True: 0, False: 0] ------------------ 3831| | // Look for the file in include_paths. 3832| 0| for (auto paths = include_paths; paths && *paths; paths++) { ------------------ | Branch (3832:42): [True: 0, False: 0] | Branch (3832:51): [True: 0, False: 0] ------------------ 3833| 0| filepath = flatbuffers::ConCatPathFileName(*paths, name); 3834| 0| if (FileExists(filepath.c_str())) break; ------------------ | Branch (3834:15): [True: 0, False: 0] ------------------ 3835| 0| } 3836| 0| } 3837| 0| if (filepath.empty()) ------------------ | Branch (3837:11): [True: 0, False: 0] ------------------ 3838| 0| return Error("unable to locate include file: " + name); 3839| 0| if (source_filename) { ------------------ | Branch (3839:11): [True: 0, False: 0] ------------------ 3840| 0| IncludedFile included_file; 3841| 0| included_file.filename = filepath; 3842| 0| included_file.schema_name = name; 3843| 0| files_included_per_file_[source_filename].insert(included_file); 3844| 0| } 3845| | 3846| 0| std::string contents; 3847| 0| bool file_loaded = LoadFile(filepath.c_str(), true, &contents); 3848| 0| if (included_files_.find(HashFile(filepath.c_str(), contents.c_str())) == ------------------ | Branch (3848:11): [True: 0, False: 0] ------------------ 3849| 0| included_files_.end()) { 3850| | // We found an include file that we have not parsed yet. 3851| | // Parse it. 3852| 0| if (!file_loaded) return Error("unable to load include file: " + name); ------------------ | Branch (3852:13): [True: 0, False: 0] ------------------ 3853| 0| ECHECK(DoParse(contents.c_str(), include_paths, filepath.c_str(), ------------------ | | 56| 0| { \ | | 57| 0| auto ce = (call); \ | | 58| 0| if (ce.Check()) return ce; \ | | ------------------ | | | Branch (58:9): [True: 0, False: 0] | | ------------------ | | 59| 0| } ------------------ 3854| 0| name.c_str())); 3855| | // We generally do not want to output code for any included files: 3856| 0| if (!opts.generate_all) MarkGenerated(); ------------------ | Branch (3856:13): [True: 0, False: 0] ------------------ 3857| | // Reset these just in case the included file had them, and the 3858| | // parent doesn't. 3859| 0| root_struct_def_ = nullptr; 3860| 0| file_identifier_.clear(); 3861| 0| file_extension_.clear(); 3862| | // This is the easiest way to continue this file after an include: 3863| | // instead of saving and restoring all the state, we simply start the 3864| | // file anew. This will cause it to encounter the same include 3865| | // statement again, but this time it will skip it, because it was 3866| | // entered into included_files_. 3867| | // This is recursive, but only go as deep as the number of include 3868| | // statements. 3869| 0| included_files_.erase(source_hash); 3870| 0| return DoParse(source, include_paths, source_filename, 3871| 0| include_filename); 3872| 0| } 3873| 0| EXPECT(';'); ------------------ | | 64| 0|#define EXPECT(tok) ECHECK(Expect(tok)) | | ------------------ | | | | 56| 0| { \ | | | | 57| 0| auto ce = (call); \ | | | | 58| 0| if (ce.Check()) return ce; \ | | | | ------------------ | | | | | Branch (58:9): [True: 0, False: 0] | | | | ------------------ | | | | 59| 0| } | | ------------------ ------------------ 3874| 103k| } else { 3875| 103k| break; 3876| 103k| } 3877| 103k| } 3878| | // Now parse all other kinds of declarations: 3879| 310k| while (token_ != kTokenEof) { ------------------ | Branch (3879:10): [True: 305k, False: 5.06k] ------------------ 3880| 305k| if (opts.proto_mode) { ------------------ | Branch (3880:9): [True: 0, False: 305k] ------------------ 3881| 0| ECHECK(ParseProtoDecl()); ------------------ | | 56| 0| { \ | | 57| 0| auto ce = (call); \ | | 58| 0| if (ce.Check()) return ce; \ | | ------------------ | | | Branch (58:9): [True: 0, False: 0] | | ------------------ | | 59| 0| } ------------------ 3882| 305k| } else if (IsIdent("namespace")) { ------------------ | Branch (3882:16): [True: 0, False: 305k] ------------------ 3883| 0| ECHECK(ParseNamespace()); ------------------ | | 56| 0| { \ | | 57| 0| auto ce = (call); \ | | 58| 0| if (ce.Check()) return ce; \ | | ------------------ | | | Branch (58:9): [True: 0, False: 0] | | ------------------ | | 59| 0| } ------------------ 3884| 305k| } else if (token_ == '{') { ------------------ | Branch (3884:16): [True: 98.3k, False: 206k] ------------------ 3885| 98.3k| return NoError(); 3886| 206k| } else if (IsIdent("enum")) { ------------------ | Branch (3886:16): [True: 0, False: 206k] ------------------ 3887| 0| ECHECK(ParseEnum(false, nullptr, source_filename)); ------------------ | | 56| 0| { \ | | 57| 0| auto ce = (call); \ | | 58| 0| if (ce.Check()) return ce; \ | | ------------------ | | | Branch (58:9): [True: 0, False: 0] | | ------------------ | | 59| 0| } ------------------ 3888| 206k| } else if (IsIdent("union")) { ------------------ | Branch (3888:16): [True: 0, False: 206k] ------------------ 3889| 0| ECHECK(ParseEnum(true, nullptr, source_filename)); ------------------ | | 56| 0| { \ | | 57| 0| auto ce = (call); \ | | 58| 0| if (ce.Check()) return ce; \ | | ------------------ | | | Branch (58:9): [True: 0, False: 0] | | ------------------ | | 59| 0| } ------------------ 3890| 206k| } else if (IsIdent("root_type")) { ------------------ | Branch (3890:16): [True: 103k, False: 103k] ------------------ 3891| 103k| NEXT(); ------------------ | | 63| 103k|#define NEXT() ECHECK(Next()) | | ------------------ | | | | 56| 103k| { \ | | | | 57| 103k| auto ce = (call); \ | | | | 58| 103k| if (ce.Check()) return ce; \ | | | | ------------------ | | | | | Branch (58:9): [True: 0, False: 103k] | | | | ------------------ | | | | 59| 103k| } | | ------------------ ------------------ 3892| 103k| auto root_type = attribute_; 3893| 103k| EXPECT(kTokenIdentifier); ------------------ | | 64| 103k|#define EXPECT(tok) ECHECK(Expect(tok)) | | ------------------ | | | | 56| 103k| { \ | | | | 57| 103k| auto ce = (call); \ | | | | 58| 103k| if (ce.Check()) return ce; \ | | | | ------------------ | | | | | Branch (58:9): [True: 0, False: 103k] | | | | ------------------ | | | | 59| 103k| } | | ------------------ ------------------ 3894| 103k| ECHECK(ParseNamespacing(&root_type, nullptr)); ------------------ | | 56| 103k| { \ | | 57| 103k| auto ce = (call); \ | | 58| 103k| if (ce.Check()) return ce; \ | | ------------------ | | | Branch (58:9): [True: 0, False: 103k] | | ------------------ | | 59| 103k| } ------------------ 3895| 103k| if (opts.root_type.empty()) { ------------------ | Branch (3895:11): [True: 103k, False: 0] ------------------ 3896| 103k| if (!SetRootType(root_type.c_str())) ------------------ | Branch (3896:13): [True: 0, False: 103k] ------------------ 3897| 0| return Error("unknown root type: " + root_type); 3898| 103k| if (root_struct_def_->fixed) return Error("root type must be a table"); ------------------ | Branch (3898:13): [True: 0, False: 103k] ------------------ 3899| 103k| } 3900| 103k| EXPECT(';'); ------------------ | | 64| 103k|#define EXPECT(tok) ECHECK(Expect(tok)) | | ------------------ | | | | 56| 103k| { \ | | | | 57| 103k| auto ce = (call); \ | | | | 58| 103k| if (ce.Check()) return ce; \ | | | | ------------------ | | | | | Branch (58:9): [True: 0, False: 103k] | | | | ------------------ | | | | 59| 103k| } | | ------------------ ------------------ 3901| 103k| } else if (IsIdent("file_identifier")) { ------------------ | Branch (3901:16): [True: 0, False: 103k] ------------------ 3902| 0| NEXT(); ------------------ | | 63| 0|#define NEXT() ECHECK(Next()) | | ------------------ | | | | 56| 0| { \ | | | | 57| 0| auto ce = (call); \ | | | | 58| 0| if (ce.Check()) return ce; \ | | | | ------------------ | | | | | Branch (58:9): [True: 0, False: 0] | | | | ------------------ | | | | 59| 0| } | | ------------------ ------------------ 3903| 0| file_identifier_ = attribute_; 3904| 0| EXPECT(kTokenStringConstant); ------------------ | | 64| 0|#define EXPECT(tok) ECHECK(Expect(tok)) | | ------------------ | | | | 56| 0| { \ | | | | 57| 0| auto ce = (call); \ | | | | 58| 0| if (ce.Check()) return ce; \ | | | | ------------------ | | | | | Branch (58:9): [True: 0, False: 0] | | | | ------------------ | | | | 59| 0| } | | ------------------ ------------------ 3905| 0| if (file_identifier_.length() != flatbuffers::kFileIdentifierLength) ------------------ | Branch (3905:11): [True: 0, False: 0] ------------------ 3906| 0| return Error("file_identifier must be exactly " + 3907| 0| NumToString(flatbuffers::kFileIdentifierLength) + 3908| 0| " characters"); 3909| 0| EXPECT(';'); ------------------ | | 64| 0|#define EXPECT(tok) ECHECK(Expect(tok)) | | ------------------ | | | | 56| 0| { \ | | | | 57| 0| auto ce = (call); \ | | | | 58| 0| if (ce.Check()) return ce; \ | | | | ------------------ | | | | | Branch (58:9): [True: 0, False: 0] | | | | ------------------ | | | | 59| 0| } | | ------------------ ------------------ 3910| 103k| } else if (IsIdent("file_extension")) { ------------------ | Branch (3910:16): [True: 0, False: 103k] ------------------ 3911| 0| NEXT(); ------------------ | | 63| 0|#define NEXT() ECHECK(Next()) | | ------------------ | | | | 56| 0| { \ | | | | 57| 0| auto ce = (call); \ | | | | 58| 0| if (ce.Check()) return ce; \ | | | | ------------------ | | | | | Branch (58:9): [True: 0, False: 0] | | | | ------------------ | | | | 59| 0| } | | ------------------ ------------------ 3912| 0| file_extension_ = attribute_; 3913| 0| EXPECT(kTokenStringConstant); ------------------ | | 64| 0|#define EXPECT(tok) ECHECK(Expect(tok)) | | ------------------ | | | | 56| 0| { \ | | | | 57| 0| auto ce = (call); \ | | | | 58| 0| if (ce.Check()) return ce; \ | | | | ------------------ | | | | | Branch (58:9): [True: 0, False: 0] | | | | ------------------ | | | | 59| 0| } | | ------------------ ------------------ 3914| 0| EXPECT(';'); ------------------ | | 64| 0|#define EXPECT(tok) ECHECK(Expect(tok)) | | ------------------ | | | | 56| 0| { \ | | | | 57| 0| auto ce = (call); \ | | | | 58| 0| if (ce.Check()) return ce; \ | | | | ------------------ | | | | | Branch (58:9): [True: 0, False: 0] | | | | ------------------ | | | | 59| 0| } | | ------------------ ------------------ 3915| 103k| } else if (IsIdent("include")) { ------------------ | Branch (3915:16): [True: 0, False: 103k] ------------------ 3916| 0| return Error("includes must come before declarations"); 3917| 103k| } else if (IsIdent("attribute")) { ------------------ | Branch (3917:16): [True: 0, False: 103k] ------------------ 3918| 0| NEXT(); ------------------ | | 63| 0|#define NEXT() ECHECK(Next()) | | ------------------ | | | | 56| 0| { \ | | | | 57| 0| auto ce = (call); \ | | | | 58| 0| if (ce.Check()) return ce; \ | | | | ------------------ | | | | | Branch (58:9): [True: 0, False: 0] | | | | ------------------ | | | | 59| 0| } | | ------------------ ------------------ 3919| 0| auto name = attribute_; 3920| 0| if (Is(kTokenIdentifier)) { ------------------ | Branch (3920:11): [True: 0, False: 0] ------------------ 3921| 0| NEXT(); ------------------ | | 63| 0|#define NEXT() ECHECK(Next()) | | ------------------ | | | | 56| 0| { \ | | | | 57| 0| auto ce = (call); \ | | | | 58| 0| if (ce.Check()) return ce; \ | | | | ------------------ | | | | | Branch (58:9): [True: 0, False: 0] | | | | ------------------ | | | | 59| 0| } | | ------------------ ------------------ 3922| 0| } else { 3923| 0| EXPECT(kTokenStringConstant); ------------------ | | 64| 0|#define EXPECT(tok) ECHECK(Expect(tok)) | | ------------------ | | | | 56| 0| { \ | | | | 57| 0| auto ce = (call); \ | | | | 58| 0| if (ce.Check()) return ce; \ | | | | ------------------ | | | | | Branch (58:9): [True: 0, False: 0] | | | | ------------------ | | | | 59| 0| } | | ------------------ ------------------ 3924| 0| } 3925| 0| EXPECT(';'); ------------------ | | 64| 0|#define EXPECT(tok) ECHECK(Expect(tok)) | | ------------------ | | | | 56| 0| { \ | | | | 57| 0| auto ce = (call); \ | | | | 58| 0| if (ce.Check()) return ce; \ | | | | ------------------ | | | | | Branch (58:9): [True: 0, False: 0] | | | | ------------------ | | | | 59| 0| } | | ------------------ ------------------ 3926| 0| known_attributes_[name] = false; 3927| 103k| } else if (IsIdent("rpc_service")) { ------------------ | Branch (3927:16): [True: 0, False: 103k] ------------------ 3928| 0| ECHECK(ParseService(source_filename)); ------------------ | | 56| 0| { \ | | 57| 0| auto ce = (call); \ | | 58| 0| if (ce.Check()) return ce; \ | | ------------------ | | | Branch (58:9): [True: 0, False: 0] | | ------------------ | | 59| 0| } ------------------ 3929| 103k| } else { 3930| 103k| ECHECK(ParseDecl(source_filename)); ------------------ | | 56| 103k| { \ | | 57| 103k| auto ce = (call); \ | | 58| 103k| if (ce.Check()) return ce; \ | | ------------------ | | | Branch (58:9): [True: 0, False: 103k] | | ------------------ | | 59| 103k| } ------------------ 3931| 103k| } 3932| 305k| } 3933| 5.06k| EXPECT(kTokenEof); ------------------ | | 64| 5.06k|#define EXPECT(tok) ECHECK(Expect(tok)) | | ------------------ | | | | 56| 5.06k| { \ | | | | 57| 5.06k| auto ce = (call); \ | | | | 58| 5.06k| if (ce.Check()) return ce; \ | | | | ------------------ | | | | | Branch (58:9): [True: 0, False: 5.06k] | | | | ------------------ | | | | 59| 5.06k| } | | ------------------ ------------------ 3934| 5.06k| if (opts.warnings_as_errors && has_warning_) { ------------------ | Branch (3934:7): [True: 0, False: 5.06k] | Branch (3934:34): [True: 0, False: 0] ------------------ 3935| 0| return Error("treating warnings as errors, failed due to above warnings"); 3936| 0| } 3937| 5.06k| return NoError(); 3938| 5.06k|} _ZN11flatbuffers6Parser11DoParseJsonEv: 3940| 764k|CheckedError Parser::DoParseJson() { 3941| 764k| if (token_ != '{') { ------------------ | Branch (3941:7): [True: 0, False: 764k] ------------------ 3942| 0| EXPECT('{'); ------------------ | | 64| 0|#define EXPECT(tok) ECHECK(Expect(tok)) | | ------------------ | | | | 56| 0| { \ | | | | 57| 0| auto ce = (call); \ | | | | 58| 0| if (ce.Check()) return ce; \ | | | | ------------------ | | | | | Branch (58:9): [True: 0, False: 0] | | | | ------------------ | | | | 59| 0| } | | ------------------ ------------------ 3943| 764k| } else { 3944| 764k| if (!root_struct_def_) return Error("no root type set to parse json with"); ------------------ | Branch (3944:9): [True: 0, False: 764k] ------------------ 3945| 764k| if (builder_.GetSize()) { ------------------ | Branch (3945:9): [True: 0, False: 764k] ------------------ 3946| 0| return Error("cannot have more than one json object in a file"); 3947| 0| } 3948| 764k| uoffset_t toff; 3949| 764k| ECHECK(ParseTable(*root_struct_def_, nullptr, &toff)); ------------------ | | 56| 764k| { \ | | 57| 764k| auto ce = (call); \ | | 58| 764k| if (ce.Check()) return ce; \ | | ------------------ | | | Branch (58:9): [True: 473k, False: 290k] | | ------------------ | | 59| 764k| } ------------------ 3950| 290k| if (opts.size_prefixed) { ------------------ | Branch (3950:9): [True: 0, False: 290k] ------------------ 3951| 0| builder_.FinishSizePrefixed( 3952| 0| Offset
(toff), 3953| 0| file_identifier_.length() ? file_identifier_.c_str() : nullptr); ------------------ | Branch (3953:11): [True: 0, False: 0] ------------------ 3954| 290k| } else { 3955| 290k| builder_.Finish(Offset
(toff), file_identifier_.length() ------------------ | Branch (3955:44): [True: 0, False: 290k] ------------------ 3956| 290k| ? file_identifier_.c_str() 3957| 290k| : nullptr); 3958| 290k| } 3959| 290k| } 3960| 290k| if (opts.require_json_eof) { ------------------ | Branch (3960:7): [True: 290k, False: 0] ------------------ 3961| | // Check that JSON file doesn't contain more objects or IDL directives. 3962| | // Comments after JSON are allowed. 3963| 290k| EXPECT(kTokenEof); ------------------ | | 64| 290k|#define EXPECT(tok) ECHECK(Expect(tok)) | | ------------------ | | | | 56| 290k| { \ | | | | 57| 290k| auto ce = (call); \ | | | | 58| 290k| if (ce.Check()) return ce; \ | | | | ------------------ | | | | | Branch (58:9): [True: 1.77k, False: 288k] | | | | ------------------ | | | | 59| 290k| } | | ------------------ ------------------ 3964| 288k| } 3965| 288k| return NoError(); 3966| 290k|} idl_parser.cpp:_ZN11flatbuffers12_GLOBAL__N_113TokenToStringEi: 185| 78.0k|static std::string TokenToString(int t) { 186| 78.0k| static const char * const tokens[] = { 187| 78.0k| #define FLATBUFFERS_TOKEN(NAME, VALUE, STRING) STRING, 188| 78.0k| FLATBUFFERS_GEN_TOKENS(FLATBUFFERS_TOKEN) ------------------ | | 171| 78.0k| TD(Eof, 256, "end of file") \ | | ------------------ | | | | 188| 78.0k| FLATBUFFERS_GEN_TOKENS(FLATBUFFERS_TOKEN) | | | | ------------------ | | | | | | 187| 78.0k| #define FLATBUFFERS_TOKEN(NAME, VALUE, STRING) STRING, | | | | ------------------ | | ------------------ | | 172| 78.0k| TD(StringConstant, 257, "string constant") \ | | ------------------ | | | | 188| 78.0k| FLATBUFFERS_GEN_TOKENS(FLATBUFFERS_TOKEN) | | | | ------------------ | | | | | | 187| 78.0k| #define FLATBUFFERS_TOKEN(NAME, VALUE, STRING) STRING, | | | | ------------------ | | ------------------ | | 173| 78.0k| TD(IntegerConstant, 258, "integer constant") \ | | ------------------ | | | | 188| 78.0k| FLATBUFFERS_GEN_TOKENS(FLATBUFFERS_TOKEN) | | | | ------------------ | | | | | | 187| 78.0k| #define FLATBUFFERS_TOKEN(NAME, VALUE, STRING) STRING, | | | | ------------------ | | ------------------ | | 174| 78.0k| TD(FloatConstant, 259, "float constant") \ | | ------------------ | | | | 188| 78.0k| FLATBUFFERS_GEN_TOKENS(FLATBUFFERS_TOKEN) | | | | ------------------ | | | | | | 187| 78.0k| #define FLATBUFFERS_TOKEN(NAME, VALUE, STRING) STRING, | | | | ------------------ | | ------------------ | | 175| 78.0k| TD(Identifier, 260, "identifier") | | ------------------ | | | | 188| 78.0k| FLATBUFFERS_GEN_TOKENS(FLATBUFFERS_TOKEN) | | | | ------------------ | | | | | | 187| 78.0k| #define FLATBUFFERS_TOKEN(NAME, VALUE, STRING) STRING, | | | | ------------------ | | ------------------ ------------------ 189| 78.0k| #undef FLATBUFFERS_TOKEN 190| 78.0k| #define FLATBUFFERS_TD(ENUM, IDLTYPE, ...) \ 191| 78.0k| IDLTYPE, 192| 78.0k| FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD) ------------------ | | 112| 78.0k| FLATBUFFERS_GEN_TYPES_SCALAR(TD) \ | | ------------------ | | | | 50| 78.0k| TD(NONE, "", uint8_t, byte, byte, byte, uint8, u8, UByte, UInt8, 0) \ | | | | ------------------ | | | | | | 192| 78.0k| FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD) | | | | | | ------------------ | | | | | | | | 191| 78.0k| IDLTYPE, | | | | | | ------------------ | | | | ------------------ | | | | 51| 78.0k| TD(UTYPE, "", uint8_t, byte, byte, byte, uint8, u8, UByte, UInt8, 1) /* begin scalar/int */ \ | | | | ------------------ | | | | | | 192| 78.0k| FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD) | | | | | | ------------------ | | | | | | | | 191| 78.0k| IDLTYPE, | | | | | | ------------------ | | | | ------------------ | | | | 52| 78.0k| TD(BOOL, "bool", uint8_t, boolean,bool, bool, bool, bool, Boolean, Bool, 2) \ | | | | ------------------ | | | | | | 192| 78.0k| FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD) | | | | | | ------------------ | | | | | | | | 191| 78.0k| IDLTYPE, | | | | | | ------------------ | | | | ------------------ | | | | 53| 78.0k| TD(CHAR, "byte", int8_t, byte, int8, sbyte, int8, i8, Byte, Int8, 3) \ | | | | ------------------ | | | | | | 192| 78.0k| FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD) | | | | | | ------------------ | | | | | | | | 191| 78.0k| IDLTYPE, | | | | | | ------------------ | | | | ------------------ | | | | 54| 78.0k| TD(UCHAR, "ubyte", uint8_t, byte, byte, byte, uint8, u8, UByte, UInt8, 4) \ | | | | ------------------ | | | | | | 192| 78.0k| FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD) | | | | | | ------------------ | | | | | | | | 191| 78.0k| IDLTYPE, | | | | | | ------------------ | | | | ------------------ | | | | 55| 78.0k| TD(SHORT, "short", int16_t, short, int16, short, int16, i16, Short, Int16, 5) \ | | | | ------------------ | | | | | | 192| 78.0k| FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD) | | | | | | ------------------ | | | | | | | | 191| 78.0k| IDLTYPE, | | | | | | ------------------ | | | | ------------------ | | | | 56| 78.0k| TD(USHORT, "ushort", uint16_t, short, uint16, ushort, uint16, u16, UShort, UInt16, 6) \ | | | | ------------------ | | | | | | 192| 78.0k| FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD) | | | | | | ------------------ | | | | | | | | 191| 78.0k| IDLTYPE, | | | | | | ------------------ | | | | ------------------ | | | | 57| 78.0k| TD(INT, "int", int32_t, int, int32, int, int32, i32, Int, Int32, 7) \ | | | | ------------------ | | | | | | 192| 78.0k| FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD) | | | | | | ------------------ | | | | | | | | 191| 78.0k| IDLTYPE, | | | | | | ------------------ | | | | ------------------ | | | | 58| 78.0k| TD(UINT, "uint", uint32_t, int, uint32, uint, uint32, u32, UInt, UInt32, 8) \ | | | | ------------------ | | | | | | 192| 78.0k| FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD) | | | | | | ------------------ | | | | | | | | 191| 78.0k| IDLTYPE, | | | | | | ------------------ | | | | ------------------ | | | | 59| 78.0k| TD(LONG, "long", int64_t, long, int64, long, int64, i64, Long, Int64, 9) \ | | | | ------------------ | | | | | | 192| 78.0k| FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD) | | | | | | ------------------ | | | | | | | | 191| 78.0k| IDLTYPE, | | | | | | ------------------ | | | | ------------------ | | | | 60| 78.0k| TD(ULONG, "ulong", uint64_t, long, uint64, ulong, uint64, u64, ULong, UInt64, 10) /* end int */ \ | | | | ------------------ | | | | | | 192| 78.0k| FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD) | | | | | | ------------------ | | | | | | | | 191| 78.0k| IDLTYPE, | | | | | | ------------------ | | | | ------------------ | | | | 61| 78.0k| TD(FLOAT, "float", float, float, float32, float, float32, f32, Float, Float32, 11) /* begin float */ \ | | | | ------------------ | | | | | | 192| 78.0k| FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD) | | | | | | ------------------ | | | | | | | | 191| 78.0k| IDLTYPE, | | | | | | ------------------ | | | | ------------------ | | | | 62| 78.0k| TD(DOUBLE, "double", double, double, float64, double, float64, f64, Double, Double, 12) /* end float/scalar */ | | | | ------------------ | | | | | | 192| 78.0k| FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD) | | | | | | ------------------ | | | | | | | | 191| 78.0k| IDLTYPE, | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 113| 78.0k| FLATBUFFERS_GEN_TYPES_POINTER(TD) \ | | ------------------ | | | | 64| 78.0k| TD(STRING, "string", Offset, int, int, StringOffset, int, unused, Int, Offset, 13) \ | | | | ------------------ | | | | | | 192| 78.0k| FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD) | | | | | | ------------------ | | | | | | | | 191| 78.0k| IDLTYPE, | | | | | | ------------------ | | | | ------------------ | | | | 65| 78.0k| TD(VECTOR, "", Offset, int, int, VectorOffset, int, unused, Int, Offset, 14) \ | | | | ------------------ | | | | | | 192| 78.0k| FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD) | | | | | | ------------------ | | | | | | | | 191| 78.0k| IDLTYPE, | | | | | | ------------------ | | | | ------------------ | | | | 66| 78.0k| TD(VECTOR64, "", Offset64, int, int, VectorOffset, int, unused, Int, Offset, 18) \ | | | | ------------------ | | | | | | 192| 78.0k| FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD) | | | | | | ------------------ | | | | | | | | 191| 78.0k| IDLTYPE, | | | | | | ------------------ | | | | ------------------ | | | | 67| 78.0k| TD(STRUCT, "", Offset, int, int, int, int, unused, Int, Offset, 15) \ | | | | ------------------ | | | | | | 192| 78.0k| FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD) | | | | | | ------------------ | | | | | | | | 191| 78.0k| IDLTYPE, | | | | | | ------------------ | | | | ------------------ | | | | 68| 78.0k| TD(UNION, "", Offset, int, int, int, int, unused, Int, Offset, 16) | | | | ------------------ | | | | | | 192| 78.0k| FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD) | | | | | | ------------------ | | | | | | | | 191| 78.0k| IDLTYPE, | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 114| 78.0k| FLATBUFFERS_GEN_TYPE_ARRAY(TD) | | ------------------ | | | | 70| 78.0k| TD(ARRAY, "", int, int, int, int, int, unused, Int, Offset, 17) | | | | ------------------ | | | | | | 192| 78.0k| FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD) | | | | | | ------------------ | | | | | | | | 191| 78.0k| IDLTYPE, | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 193| 78.0k| #undef FLATBUFFERS_TD 194| 78.0k| }; 195| 78.0k| if (t < 256) { // A single ascii char token. ------------------ | Branch (195:7): [True: 60.2k, False: 17.7k] ------------------ 196| 60.2k| std::string s; 197| 60.2k| s.append(1, static_cast(t)); 198| 60.2k| return s; 199| 60.2k| } else { // Other tokens. 200| 17.7k| return tokens[t - 256]; 201| 17.7k| } 202| 78.0k|} idl_parser.cpp:_ZN11flatbuffers12_GLOBAL__N_17NoErrorEv: 94| 15.1M|static CheckedError NoError() { return CheckedError(false); } idl_parser.cpp:_ZN11flatbuffers12_GLOBAL__N_112ValidateUTF8ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE: 66| 51.6k|static bool ValidateUTF8(const std::string& str) { 67| 51.6k| const char* s = &str[0]; 68| 51.6k| const char* const sEnd = s + str.length(); 69| 1.82M| while (s < sEnd) { ------------------ | Branch (69:10): [True: 1.80M, False: 26.9k] ------------------ 70| 1.80M| if (FromUTF8(&s) < 0) { ------------------ | Branch (70:9): [True: 24.6k, False: 1.77M] ------------------ 71| 24.6k| return false; 72| 24.6k| } 73| 1.80M| } 74| 26.9k| return true; 75| 51.6k|} idl_parser.cpp:_ZN11flatbuffers12_GLOBAL__N_117IsIdentifierStartEc: 205| 5.70M|static bool IsIdentifierStart(char c) { return is_alpha(c) || (c == '_'); } ------------------ | Branch (205:48): [True: 3.24M, False: 2.46M] | Branch (205:63): [True: 148k, False: 2.31M] ------------------ _ZN11flatbuffers6Parser15ParseDepthGuardC2EPS0_: 426| 832k| : parser_(*parser_not_null), caller_depth_(parser_.parse_depth_counter_) { 427| 832k| FLATBUFFERS_ASSERT(caller_depth_ <= (FLATBUFFERS_MAX_PARSING_DEPTH) && 428| 832k| "Check() must be called to prevent stack overflow"); 429| 832k| parser_.parse_depth_counter_ += 1; 430| 832k| } _ZN11flatbuffers6Parser15ParseDepthGuard5CheckEv: 434| 832k| CheckedError Check() { 435| 832k| return caller_depth_ >= (FLATBUFFERS_MAX_PARSING_DEPTH) ------------------ | Branch (435:12): [True: 426, False: 831k] ------------------ 436| 832k| ? parser_.RecurseError() 437| 832k| : CheckedError(false); 438| 832k| } _ZN11flatbuffers6Parser15ParseDepthGuardD2Ev: 432| 832k| ~ParseDepthGuard() { parser_.parse_depth_counter_ -= 1; } idl_parser.cpp:_ZN11flatbuffers12_GLOBAL__N_116IsLowerSnakeCaseERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE: 77| 103k|static bool IsLowerSnakeCase(const std::string& str) { 78| 103k| for (size_t i = 0; i < str.length(); i++) { ------------------ | Branch (78:22): [True: 103k, False: 0] ------------------ 79| 103k| char c = str[i]; 80| 103k| if (!check_ascii_range(c, 'a', 'z') && !is_digit(c) && c != '_') { ------------------ | Branch (80:9): [True: 103k, False: 0] | Branch (80:44): [True: 103k, False: 0] | Branch (80:60): [True: 103k, False: 0] ------------------ 81| 103k| return false; 82| 103k| } 83| 103k| } 84| 0| return true; 85| 103k|} idl_parser.cpp:_ZN11flatbuffers12_GLOBAL__N_117SingleValueRepackERNS_5ValueEf: 306| 12.1k|static void SingleValueRepack(Value& e, float val) { 307| 12.1k| if (val != val) e.constant = "nan"; ------------------ | Branch (307:7): [True: 1.23k, False: 10.9k] ------------------ 308| 12.1k|} idl_parser.cpp:_ZN11flatbuffers12_GLOBAL__N_117SingleValueRepackERNS_5ValueEd: 309| 10.7k|static void SingleValueRepack(Value& e, double val) { 310| 10.7k| if (val != val) e.constant = "nan"; ------------------ | Branch (310:7): [True: 1.21k, False: 9.55k] ------------------ 311| 10.7k|} idl_parser.cpp:_ZN11flatbuffers12_GLOBAL__N_120TypeToIntervalStringIhEENSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEv: 97| 22.6k|static std::string TypeToIntervalString() { 98| 22.6k| return "[" + NumToString((flatbuffers::numeric_limits::lowest)()) + "; " + 99| 22.6k| NumToString((flatbuffers::numeric_limits::max)()) + "]"; 100| 22.6k|} idl_parser.cpp:_ZN11flatbuffers12_GLOBAL__N_120TypeToIntervalStringIaEENSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEv: 97| 21.6k|static std::string TypeToIntervalString() { 98| 21.6k| return "[" + NumToString((flatbuffers::numeric_limits::lowest)()) + "; " + 99| 21.6k| NumToString((flatbuffers::numeric_limits::max)()) + "]"; 100| 21.6k|} idl_parser.cpp:_ZN11flatbuffers12_GLOBAL__N_120TypeToIntervalStringIsEENSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEv: 97| 13.3k|static std::string TypeToIntervalString() { 98| 13.3k| return "[" + NumToString((flatbuffers::numeric_limits::lowest)()) + "; " + 99| 13.3k| NumToString((flatbuffers::numeric_limits::max)()) + "]"; 100| 13.3k|} idl_parser.cpp:_ZN11flatbuffers12_GLOBAL__N_120TypeToIntervalStringItEENSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEv: 97| 17.5k|static std::string TypeToIntervalString() { 98| 17.5k| return "[" + NumToString((flatbuffers::numeric_limits::lowest)()) + "; " + 99| 17.5k| NumToString((flatbuffers::numeric_limits::max)()) + "]"; 100| 17.5k|} idl_parser.cpp:_ZN11flatbuffers12_GLOBAL__N_120TypeToIntervalStringIiEENSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEv: 97| 11.5k|static std::string TypeToIntervalString() { 98| 11.5k| return "[" + NumToString((flatbuffers::numeric_limits::lowest)()) + "; " + 99| 11.5k| NumToString((flatbuffers::numeric_limits::max)()) + "]"; 100| 11.5k|} idl_parser.cpp:_ZN11flatbuffers12_GLOBAL__N_120TypeToIntervalStringIjEENSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEv: 97| 15.7k|static std::string TypeToIntervalString() { 98| 15.7k| return "[" + NumToString((flatbuffers::numeric_limits::lowest)()) + "; " + 99| 15.7k| NumToString((flatbuffers::numeric_limits::max)()) + "]"; 100| 15.7k|} idl_parser.cpp:_ZN11flatbuffers12_GLOBAL__N_120TypeToIntervalStringIlEENSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEv: 97| 5.84k|static std::string TypeToIntervalString() { 98| 5.84k| return "[" + NumToString((flatbuffers::numeric_limits::lowest)()) + "; " + 99| 5.84k| NumToString((flatbuffers::numeric_limits::max)()) + "]"; 100| 5.84k|} idl_parser.cpp:_ZN11flatbuffers12_GLOBAL__N_120TypeToIntervalStringImEENSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEv: 97| 10.3k|static std::string TypeToIntervalString() { 98| 10.3k| return "[" + NumToString((flatbuffers::numeric_limits::lowest)()) + "; " + 99| 10.3k| NumToString((flatbuffers::numeric_limits::max)()) + "]"; 100| 10.3k|} idl_parser.cpp:_ZN11flatbuffers12_GLOBAL__N_117LookupTableByNameINS_7EnumDefEEEPT_RKNS_11SymbolTableIS3_EERKNSt3__112basic_stringIcNS9_11char_traitsIcEENS9_9allocatorIcEEEERKNS_9NamespaceEm: 146| 3.24k| size_t skip_top) { 147| 3.24k| const auto& components = current_namespace.components; 148| 3.24k| if (table.dict.empty()) return nullptr; ------------------ | Branch (148:7): [True: 3.24k, False: 0] ------------------ 149| 0| if (components.size() < skip_top) return nullptr; ------------------ | Branch (149:7): [True: 0, False: 0] ------------------ 150| 0| const auto N = components.size() - skip_top; 151| 0| std::string full_name; 152| 0| for (size_t i = 0; i < N; i++) { ------------------ | Branch (152:22): [True: 0, False: 0] ------------------ 153| 0| full_name += components[i]; 154| 0| full_name += '.'; 155| 0| } 156| 0| for (size_t i = N; i > 0; i--) { ------------------ | Branch (156:22): [True: 0, False: 0] ------------------ 157| 0| full_name += name; 158| 0| auto obj = table.Lookup(full_name); 159| 0| if (obj) return obj; ------------------ | Branch (159:9): [True: 0, False: 0] ------------------ 160| 0| auto len = full_name.size() - components[i - 1].size() - 1 - name.size(); 161| 0| full_name.resize(len); 162| 0| } 163| 0| FLATBUFFERS_ASSERT(full_name.empty()); 164| 0| return table.Lookup(name); // lookup in global namespace 165| 0|} idl_parser.cpp:_ZN11flatbuffers12_GLOBAL__N_117LookupTableByNameINS_9StructDefEEEPT_RKNS_11SymbolTableIS3_EERKNSt3__112basic_stringIcNS9_11char_traitsIcEENS9_9allocatorIcEEEERKNS_9NamespaceEm: 146| 103k| size_t skip_top) { 147| 103k| const auto& components = current_namespace.components; 148| 103k| if (table.dict.empty()) return nullptr; ------------------ | Branch (148:7): [True: 0, False: 103k] ------------------ 149| 103k| if (components.size() < skip_top) return nullptr; ------------------ | Branch (149:7): [True: 103k, False: 0] ------------------ 150| 0| const auto N = components.size() - skip_top; 151| 0| std::string full_name; 152| 0| for (size_t i = 0; i < N; i++) { ------------------ | Branch (152:22): [True: 0, False: 0] ------------------ 153| 0| full_name += components[i]; 154| 0| full_name += '.'; 155| 0| } 156| 0| for (size_t i = N; i > 0; i--) { ------------------ | Branch (156:22): [True: 0, False: 0] ------------------ 157| 0| full_name += name; 158| 0| auto obj = table.Lookup(full_name); 159| 0| if (obj) return obj; ------------------ | Branch (159:9): [True: 0, False: 0] ------------------ 160| 0| auto len = full_name.size() - components[i - 1].size() - 1 - name.size(); 161| 0| full_name.resize(len); 162| 0| } 163| 0| FLATBUFFERS_ASSERT(full_name.empty()); 164| 0| return table.Lookup(name); // lookup in global namespace 165| 0|} idl_parser.cpp:_ZN11flatbuffers12_GLOBAL__N_14atotItEENS_12CheckedErrorEPKcRNS_6ParserEPT_: 117| 59.8k|static CheckedError atot(const char* s, Parser& parser, T* val) { 118| 59.8k| auto done = atot_scalar(s, val, bool_constant::value>()); 119| 59.8k| if (done) return NoError(); ------------------ | Branch (119:7): [True: 36.0k, False: 23.7k] ------------------ 120| 23.7k| if (0 == *val) ------------------ | Branch (120:7): [True: 6.15k, False: 17.5k] ------------------ 121| 6.15k| return parser.Error("invalid number: \"" + std::string(s) + "\""); 122| 17.5k| else 123| 17.5k| return parser.Error("invalid number: \"" + std::string(s) + "\"" + 124| 17.5k| ", constant does not fit " + TypeToIntervalString()); 125| 23.7k|} idl_parser.cpp:_ZN11flatbuffers12_GLOBAL__N_111atot_scalarItEEbPKcPT_NSt3__117integral_constantIbLb0EEE: 104| 59.8k|static bool atot_scalar(const char* s, T* val, bool_constant) { 105| 59.8k| return StringToNumber(s, val); 106| 59.8k|} idl_parser.cpp:_ZN11flatbuffers12_GLOBAL__N_14atotIjEENS_12CheckedErrorEPKcRNS_6ParserEPT_: 117| 66.3k|static CheckedError atot(const char* s, Parser& parser, T* val) { 118| 66.3k| auto done = atot_scalar(s, val, bool_constant::value>()); 119| 66.3k| if (done) return NoError(); ------------------ | Branch (119:7): [True: 42.8k, False: 23.4k] ------------------ 120| 23.4k| if (0 == *val) ------------------ | Branch (120:7): [True: 7.67k, False: 15.7k] ------------------ 121| 7.67k| return parser.Error("invalid number: \"" + std::string(s) + "\""); 122| 15.7k| else 123| 15.7k| return parser.Error("invalid number: \"" + std::string(s) + "\"" + 124| 15.7k| ", constant does not fit " + TypeToIntervalString()); 125| 23.4k|} idl_parser.cpp:_ZN11flatbuffers12_GLOBAL__N_111atot_scalarIjEEbPKcPT_NSt3__117integral_constantIbLb0EEE: 104| 66.3k|static bool atot_scalar(const char* s, T* val, bool_constant) { 105| 66.3k| return StringToNumber(s, val); 106| 66.3k|} idl_parser.cpp:_ZN11flatbuffers12_GLOBAL__N_14atotIhEENS_12CheckedErrorEPKcRNS_6ParserEPT_: 117| 79.6k|static CheckedError atot(const char* s, Parser& parser, T* val) { 118| 79.6k| auto done = atot_scalar(s, val, bool_constant::value>()); 119| 79.6k| if (done) return NoError(); ------------------ | Branch (119:7): [True: 43.3k, False: 36.3k] ------------------ 120| 36.3k| if (0 == *val) ------------------ | Branch (120:7): [True: 13.6k, False: 22.6k] ------------------ 121| 13.6k| return parser.Error("invalid number: \"" + std::string(s) + "\""); 122| 22.6k| else 123| 22.6k| return parser.Error("invalid number: \"" + std::string(s) + "\"" + 124| 22.6k| ", constant does not fit " + TypeToIntervalString()); 125| 36.3k|} idl_parser.cpp:_ZN11flatbuffers12_GLOBAL__N_111atot_scalarIhEEbPKcPT_NSt3__117integral_constantIbLb0EEE: 104| 79.6k|static bool atot_scalar(const char* s, T* val, bool_constant) { 105| 79.6k| return StringToNumber(s, val); 106| 79.6k|} idl_parser.cpp:_ZN11flatbuffers6Parser20ParseTableDelimitersIZNS0_10ParseTableERKNS_9StructDefEPNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEPjE3$_0EENS_12CheckedErrorERmPS3_T_: 1509| 764k| const StructDef* struct_def, F body) { 1510| | // We allow tables both as JSON object{ .. } with field names 1511| | // or vector[..] with all fields in order 1512| 764k| char terminator = '}'; 1513| 764k| bool is_nested_vector = struct_def && Is('['); ------------------ | Branch (1513:27): [True: 764k, False: 0] | Branch (1513:41): [True: 0, False: 764k] ------------------ 1514| 764k| if (is_nested_vector) { ------------------ | Branch (1514:7): [True: 0, False: 764k] ------------------ 1515| 0| NEXT(); ------------------ | | 63| 0|#define NEXT() ECHECK(Next()) | | ------------------ | | | | 56| 0| { \ | | | | 57| 0| auto ce = (call); \ | | | | 58| 0| if (ce.Check()) return ce; \ | | | | ------------------ | | | | | Branch (58:9): [True: 0, False: 0] | | | | ------------------ | | | | 59| 0| } | | ------------------ ------------------ 1516| 0| terminator = ']'; 1517| 764k| } else { 1518| 764k| EXPECT('{'); ------------------ | | 64| 764k|#define EXPECT(tok) ECHECK(Expect(tok)) | | ------------------ | | | | 56| 764k| { \ | | | | 57| 764k| auto ce = (call); \ | | | | 58| 764k| if (ce.Check()) return ce; \ | | | | ------------------ | | | | | Branch (58:9): [True: 0, False: 764k] | | | | ------------------ | | | | 59| 764k| } | | ------------------ ------------------ 1519| 764k| } 1520| 789k| for (;;) { 1521| 789k| if ((!opts.strict_json || !fieldn) && Is(terminator)) break; ------------------ | Branch (1521:10): [True: 0, False: 789k] | Branch (1521:31): [True: 764k, False: 25.3k] | Branch (1521:43): [True: 98.3k, False: 665k] ------------------ 1522| 691k| std::string name; 1523| 691k| if (is_nested_vector) { ------------------ | Branch (1523:9): [True: 0, False: 691k] ------------------ 1524| 0| if (fieldn >= struct_def->fields.vec.size()) { ------------------ | Branch (1524:11): [True: 0, False: 0] ------------------ 1525| 0| return Error("too many unnamed fields in nested array"); 1526| 0| } 1527| 0| name = struct_def->fields.vec[fieldn]->name; 1528| 691k| } else { 1529| 691k| name = attribute_; 1530| 691k| if (Is(kTokenStringConstant)) { ------------------ | Branch (1530:11): [True: 688k, False: 2.94k] ------------------ 1531| 688k| NEXT(); ------------------ | | 63| 688k|#define NEXT() ECHECK(Next()) | | ------------------ | | | | 56| 688k| { \ | | | | 57| 688k| auto ce = (call); \ | | | | 58| 688k| if (ce.Check()) return ce; \ | | | | ------------------ | | | | | Branch (58:9): [True: 1.49k, False: 686k] | | | | ------------------ | | | | 59| 688k| } | | ------------------ ------------------ 1532| 686k| } else { 1533| 2.94k| EXPECT(opts.strict_json ? kTokenStringConstant : kTokenIdentifier); ------------------ | | 64| 2.94k|#define EXPECT(tok) ECHECK(Expect(tok)) | | ------------------ | | | | 56| 2.94k| { \ | | | | 57| 5.89k| auto ce = (call); \ | | | | ------------------ | | | | | Branch (57:16): [True: 2.94k, False: 0] | | | | ------------------ | | | | 58| 2.94k| if (ce.Check()) return ce; \ | | | | ------------------ | | | | | Branch (58:9): [True: 2.94k, False: 0] | | | | ------------------ | | | | 59| 2.94k| } | | ------------------ ------------------ 1534| 0| } 1535| 686k| if (!opts.protobuf_ascii_alike || !(Is('{') || Is('['))) EXPECT(':'); ------------------ | | 64| 686k|#define EXPECT(tok) ECHECK(Expect(tok)) | | ------------------ | | | | 56| 686k| { \ | | | | 57| 686k| auto ce = (call); \ | | | | 58| 686k| if (ce.Check()) return ce; \ | | | | ------------------ | | | | | Branch (58:9): [True: 107k, False: 579k] | | | | ------------------ | | | | 59| 686k| } | | ------------------ ------------------ | Branch (1535:11): [True: 686k, False: 0] | Branch (1535:43): [True: 0, False: 0] | Branch (1535:54): [True: 0, False: 0] ------------------ 1536| 579k| } 1537| 579k| ECHECK(body(name, fieldn, struct_def)); ------------------ | | 56| 579k| { \ | | 57| 579k| auto ce = (call); \ | | 58| 579k| if (ce.Check()) return ce; \ | | ------------------ | | | Branch (58:9): [True: 118k, False: 461k] | | ------------------ | | 59| 579k| } ------------------ 1538| 461k| if (Is(terminator)) break; ------------------ | Branch (1538:9): [True: 409k, False: 51.3k] ------------------ 1539| 51.3k| ECHECK(ParseComma()); ------------------ | | 56| 51.3k| { \ | | 57| 51.3k| auto ce = (call); \ | | 58| 51.3k| if (ce.Check()) return ce; \ | | ------------------ | | | Branch (58:9): [True: 25.9k, False: 25.3k] | | ------------------ | | 59| 51.3k| } ------------------ 1540| 25.3k| } 1541| 508k| NEXT(); ------------------ | | 63| 508k|#define NEXT() ECHECK(Next()) | | ------------------ | | | | 56| 508k| { \ | | | | 57| 508k| auto ce = (call); \ | | | | 58| 508k| if (ce.Check()) return ce; \ | | | | ------------------ | | | | | Branch (58:9): [True: 813, False: 507k] | | | | ------------------ | | | | 59| 508k| } | | ------------------ ------------------ 1542| 507k| if (is_nested_vector && fieldn != struct_def->fields.vec.size()) { ------------------ | Branch (1542:7): [True: 0, False: 507k] | Branch (1542:27): [True: 0, False: 0] ------------------ 1543| 0| return Error("wrong number of unnamed fields in table vector"); 1544| 0| } 1545| 507k| return NoError(); 1546| 507k|} idl_parser.cpp:_ZZN11flatbuffers6Parser10ParseTableERKNS_9StructDefEPNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEPjENK3$_0clERKSA_RmPS2_: 1557| 579k| const StructDef* struct_def_inner) -> CheckedError { 1558| 579k| if (name == "$schema") { ------------------ | Branch (1558:13): [True: 4.09k, False: 575k] ------------------ 1559| 4.09k| ECHECK(Expect(kTokenStringConstant)); ------------------ | | 56| 4.09k| { \ | | 57| 4.09k| auto ce = (call); \ | | 58| 4.09k| if (ce.Check()) return ce; \ | | ------------------ | | | Branch (58:9): [True: 263, False: 3.83k] | | ------------------ | | 59| 4.09k| } ------------------ 1560| 3.83k| return NoError(); 1561| 4.09k| } 1562| 575k| auto field = struct_def_inner->fields.Lookup(name); 1563| 575k| if (!field) { ------------------ | Branch (1563:13): [True: 8.12k, False: 567k] ------------------ 1564| 8.12k| if (!opts.skip_unexpected_fields_in_json) { ------------------ | Branch (1564:15): [True: 8.12k, False: 0] ------------------ 1565| 8.12k| return Error("unknown field: " + name); 1566| 8.12k| } else { 1567| 0| ECHECK(SkipAnyJsonValue()); ------------------ | | 56| 0| { \ | | 57| 0| auto ce = (call); \ | | 58| 0| if (ce.Check()) return ce; \ | | ------------------ | | | Branch (58:9): [True: 0, False: 0] | | ------------------ | | 59| 0| } ------------------ 1568| 0| } 1569| 567k| } else { 1570| 567k| if (IsIdent("null") && !IsScalar(field->value.type.base_type)) { ------------------ | Branch (1570:15): [True: 2.02k, False: 565k] | Branch (1570:34): [True: 0, False: 2.02k] ------------------ 1571| 0| ECHECK(Next()); // Ignore this field. ------------------ | | 56| 0| { \ | | 57| 0| auto ce = (call); \ | | 58| 0| if (ce.Check()) return ce; \ | | ------------------ | | | Branch (58:9): [True: 0, False: 0] | | ------------------ | | 59| 0| } ------------------ 1572| 567k| } else { 1573| 567k| Value val = field->value; 1574| 567k| if (field->flexbuffer) { ------------------ | Branch (1574:17): [True: 0, False: 567k] ------------------ 1575| 0| flexbuffers::Builder builder(1024, 1576| 0| flexbuffers::BUILDER_FLAG_SHARE_ALL); 1577| 0| ECHECK(ParseFlexBufferValue(&builder)); ------------------ | | 56| 0| { \ | | 57| 0| auto ce = (call); \ | | 58| 0| if (ce.Check()) return ce; \ | | ------------------ | | | Branch (58:9): [True: 0, False: 0] | | ------------------ | | 59| 0| } ------------------ 1578| 0| builder.Finish(); 1579| | // Force alignment for nested flexbuffer 1580| 0| builder_.ForceVectorAlignment(builder.GetSize(), sizeof(uint8_t), 1581| 0| sizeof(largest_scalar_t)); 1582| 0| auto off = builder_.CreateVector(builder.GetBuffer()); 1583| 0| val.constant = NumToString(off.o); 1584| 567k| } else if (field->nested_flatbuffer) { ------------------ | Branch (1584:24): [True: 0, False: 567k] ------------------ 1585| 0| ECHECK( ------------------ | | 56| 0| { \ | | 57| 0| auto ce = (call); \ | | 58| 0| if (ce.Check()) return ce; \ | | ------------------ | | | Branch (58:9): [True: 0, False: 0] | | ------------------ | | 59| 0| } ------------------ 1586| 0| ParseNestedFlatbuffer(val, field, fieldn, struct_def_inner)); 1587| 567k| } else { 1588| 567k| ECHECK(ParseAnyValue(val, field, fieldn, struct_def_inner, 0)); ------------------ | | 56| 567k| { \ | | 57| 567k| auto ce = (call); \ | | 58| 567k| if (ce.Check()) return ce; \ | | ------------------ | | | Branch (58:9): [True: 106k, False: 460k] | | ------------------ | | 59| 567k| } ------------------ 1589| 460k| } 1590| | // Hardcoded insertion-sort with error-check. 1591| | // If fields are specified in order, then this loop exits 1592| | // immediately. 1593| 460k| auto elem = field_stack_.rbegin(); 1594| 460k| for (; elem != field_stack_.rbegin() + fieldn; ++elem) { ------------------ | Branch (1594:20): [True: 3.66k, False: 457k] ------------------ 1595| 3.66k| auto existing_field = elem->second; 1596| 3.66k| if (existing_field == field) ------------------ | Branch (1596:19): [True: 3.66k, False: 0] ------------------ 1597| 3.66k| return Error("field set more than once: " + field->name); 1598| 0| if (existing_field->value.offset < field->value.offset) break; ------------------ | Branch (1598:19): [True: 0, False: 0] ------------------ 1599| 0| } 1600| | // Note: elem points to before the insertion point, thus .base() 1601| | // points to the correct spot. 1602| 457k| field_stack_.insert(elem.base(), std::make_pair(val, field)); 1603| 457k| fieldn++; 1604| 457k| } 1605| 567k| } 1606| 457k| return NoError(); 1607| 575k| }); idl_parser.cpp:_ZN11flatbuffers12_GLOBAL__N_14atotIaEENS_12CheckedErrorEPKcRNS_6ParserEPT_: 117| 55.5k|static CheckedError atot(const char* s, Parser& parser, T* val) { 118| 55.5k| auto done = atot_scalar(s, val, bool_constant::value>()); 119| 55.5k| if (done) return NoError(); ------------------ | Branch (119:7): [True: 27.7k, False: 27.8k] ------------------ 120| 27.8k| if (0 == *val) ------------------ | Branch (120:7): [True: 6.15k, False: 21.6k] ------------------ 121| 6.15k| return parser.Error("invalid number: \"" + std::string(s) + "\""); 122| 21.6k| else 123| 21.6k| return parser.Error("invalid number: \"" + std::string(s) + "\"" + 124| 21.6k| ", constant does not fit " + TypeToIntervalString()); 125| 27.8k|} idl_parser.cpp:_ZN11flatbuffers12_GLOBAL__N_111atot_scalarIaEEbPKcPT_NSt3__117integral_constantIbLb0EEE: 104| 55.5k|static bool atot_scalar(const char* s, T* val, bool_constant) { 105| 55.5k| return StringToNumber(s, val); 106| 55.5k|} idl_parser.cpp:_ZN11flatbuffers12_GLOBAL__N_14atotIsEENS_12CheckedErrorEPKcRNS_6ParserEPT_: 117| 56.7k|static CheckedError atot(const char* s, Parser& parser, T* val) { 118| 56.7k| auto done = atot_scalar(s, val, bool_constant::value>()); 119| 56.7k| if (done) return NoError(); ------------------ | Branch (119:7): [True: 35.4k, False: 21.3k] ------------------ 120| 21.3k| if (0 == *val) ------------------ | Branch (120:7): [True: 7.94k, False: 13.3k] ------------------ 121| 7.94k| return parser.Error("invalid number: \"" + std::string(s) + "\""); 122| 13.3k| else 123| 13.3k| return parser.Error("invalid number: \"" + std::string(s) + "\"" + 124| 13.3k| ", constant does not fit " + TypeToIntervalString()); 125| 21.3k|} idl_parser.cpp:_ZN11flatbuffers12_GLOBAL__N_111atot_scalarIsEEbPKcPT_NSt3__117integral_constantIbLb0EEE: 104| 56.7k|static bool atot_scalar(const char* s, T* val, bool_constant) { 105| 56.7k| return StringToNumber(s, val); 106| 56.7k|} idl_parser.cpp:_ZN11flatbuffers12_GLOBAL__N_14atotIiEENS_12CheckedErrorEPKcRNS_6ParserEPT_: 117| 82.3k|static CheckedError atot(const char* s, Parser& parser, T* val) { 118| 82.3k| auto done = atot_scalar(s, val, bool_constant::value>()); 119| 82.3k| if (done) return NoError(); ------------------ | Branch (119:7): [True: 62.2k, False: 20.1k] ------------------ 120| 20.1k| if (0 == *val) ------------------ | Branch (120:7): [True: 8.58k, False: 11.5k] ------------------ 121| 8.58k| return parser.Error("invalid number: \"" + std::string(s) + "\""); 122| 11.5k| else 123| 11.5k| return parser.Error("invalid number: \"" + std::string(s) + "\"" + 124| 11.5k| ", constant does not fit " + TypeToIntervalString()); 125| 20.1k|} idl_parser.cpp:_ZN11flatbuffers12_GLOBAL__N_111atot_scalarIiEEbPKcPT_NSt3__117integral_constantIbLb0EEE: 104| 82.3k|static bool atot_scalar(const char* s, T* val, bool_constant) { 105| 82.3k| return StringToNumber(s, val); 106| 82.3k|} idl_parser.cpp:_ZN11flatbuffers12_GLOBAL__N_14atotIlEENS_12CheckedErrorEPKcRNS_6ParserEPT_: 117| 63.4k|static CheckedError atot(const char* s, Parser& parser, T* val) { 118| 63.4k| auto done = atot_scalar(s, val, bool_constant::value>()); 119| 63.4k| if (done) return NoError(); ------------------ | Branch (119:7): [True: 50.0k, False: 13.4k] ------------------ 120| 13.4k| if (0 == *val) ------------------ | Branch (120:7): [True: 7.57k, False: 5.84k] ------------------ 121| 7.57k| return parser.Error("invalid number: \"" + std::string(s) + "\""); 122| 5.84k| else 123| 5.84k| return parser.Error("invalid number: \"" + std::string(s) + "\"" + 124| 5.84k| ", constant does not fit " + TypeToIntervalString()); 125| 13.4k|} idl_parser.cpp:_ZN11flatbuffers12_GLOBAL__N_111atot_scalarIlEEbPKcPT_NSt3__117integral_constantIbLb0EEE: 104| 63.4k|static bool atot_scalar(const char* s, T* val, bool_constant) { 105| 63.4k| return StringToNumber(s, val); 106| 63.4k|} idl_parser.cpp:_ZN11flatbuffers12_GLOBAL__N_14atotImEENS_12CheckedErrorEPKcRNS_6ParserEPT_: 117| 92.5k|static CheckedError atot(const char* s, Parser& parser, T* val) { 118| 92.5k| auto done = atot_scalar(s, val, bool_constant::value>()); 119| 92.5k| if (done) return NoError(); ------------------ | Branch (119:7): [True: 75.9k, False: 16.5k] ------------------ 120| 16.5k| if (0 == *val) ------------------ | Branch (120:7): [True: 6.22k, False: 10.3k] ------------------ 121| 6.22k| return parser.Error("invalid number: \"" + std::string(s) + "\""); 122| 10.3k| else 123| 10.3k| return parser.Error("invalid number: \"" + std::string(s) + "\"" + 124| 10.3k| ", constant does not fit " + TypeToIntervalString()); 125| 16.5k|} idl_parser.cpp:_ZN11flatbuffers12_GLOBAL__N_111atot_scalarImEEbPKcPT_NSt3__117integral_constantIbLb0EEE: 104| 92.5k|static bool atot_scalar(const char* s, T* val, bool_constant) { 105| 92.5k| return StringToNumber(s, val); 106| 92.5k|} idl_parser.cpp:_ZN11flatbuffers12_GLOBAL__N_14atotIfEENS_12CheckedErrorEPKcRNS_6ParserEPT_: 117| 78.3k|static CheckedError atot(const char* s, Parser& parser, T* val) { 118| 78.3k| auto done = atot_scalar(s, val, bool_constant::value>()); 119| 78.3k| if (done) return NoError(); ------------------ | Branch (119:7): [True: 57.5k, False: 20.8k] ------------------ 120| 20.8k| if (0 == *val) ------------------ | Branch (120:7): [True: 20.8k, False: 0] ------------------ 121| 20.8k| return parser.Error("invalid number: \"" + std::string(s) + "\""); 122| 0| else 123| 0| return parser.Error("invalid number: \"" + std::string(s) + "\"" + 124| 0| ", constant does not fit " + TypeToIntervalString()); 125| 20.8k|} idl_parser.cpp:_ZN11flatbuffers12_GLOBAL__N_111atot_scalarIfEEbPKcPT_NSt3__117integral_constantIbLb1EEE: 109| 78.3k|static bool atot_scalar(const char* s, T* val, bool_constant) { 110| | // Normalize NaN parsed from fbs or json to unsigned NaN. 111| 78.3k| if (false == StringToNumber(s, val)) return false; ------------------ | Branch (111:7): [True: 20.8k, False: 57.5k] ------------------ 112| 57.5k| *val = (*val != *val) ? std::fabs(*val) : *val; ------------------ | Branch (112:10): [True: 3.40k, False: 54.1k] ------------------ 113| 57.5k| return true; 114| 78.3k|} idl_parser.cpp:_ZN11flatbuffers12_GLOBAL__N_14atotIdEENS_12CheckedErrorEPKcRNS_6ParserEPT_: 117| 68.0k|static CheckedError atot(const char* s, Parser& parser, T* val) { 118| 68.0k| auto done = atot_scalar(s, val, bool_constant::value>()); 119| 68.0k| if (done) return NoError(); ------------------ | Branch (119:7): [True: 54.5k, False: 13.5k] ------------------ 120| 13.5k| if (0 == *val) ------------------ | Branch (120:7): [True: 13.5k, False: 0] ------------------ 121| 13.5k| return parser.Error("invalid number: \"" + std::string(s) + "\""); 122| 0| else 123| 0| return parser.Error("invalid number: \"" + std::string(s) + "\"" + 124| 0| ", constant does not fit " + TypeToIntervalString()); 125| 13.5k|} idl_parser.cpp:_ZN11flatbuffers12_GLOBAL__N_111atot_scalarIdEEbPKcPT_NSt3__117integral_constantIbLb1EEE: 109| 68.0k|static bool atot_scalar(const char* s, T* val, bool_constant) { 110| | // Normalize NaN parsed from fbs or json to unsigned NaN. 111| 68.0k| if (false == StringToNumber(s, val)) return false; ------------------ | Branch (111:7): [True: 13.5k, False: 54.5k] ------------------ 112| 54.5k| *val = (*val != *val) ? std::fabs(*val) : *val; ------------------ | Branch (112:10): [True: 3.64k, False: 50.9k] ------------------ 113| 54.5k| return true; 114| 68.0k|} idl_parser.cpp:_ZN11flatbuffers12_GLOBAL__N_117SingleValueRepackIhEEvRNS_5ValueET_: 296| 8.86k|static inline void SingleValueRepack(Value& e, T val) { 297| | // Remove leading zeros. 298| 8.86k| if (IsInteger(e.type.base_type)) { ------------------ | Branch (298:7): [True: 8.86k, False: 0] ------------------ 299| 8.86k| e.constant = NumToString(val); 300| 8.86k| } 301| 8.86k|} idl_parser.cpp:_ZN11flatbuffers12_GLOBAL__N_117SingleValueRepackIaEEvRNS_5ValueET_: 296| 5.59k|static inline void SingleValueRepack(Value& e, T val) { 297| | // Remove leading zeros. 298| 5.59k| if (IsInteger(e.type.base_type)) { ------------------ | Branch (298:7): [True: 5.59k, False: 0] ------------------ 299| 5.59k| e.constant = NumToString(val); 300| 5.59k| } 301| 5.59k|} idl_parser.cpp:_ZN11flatbuffers12_GLOBAL__N_117SingleValueRepackIsEEvRNS_5ValueET_: 296| 7.08k|static inline void SingleValueRepack(Value& e, T val) { 297| | // Remove leading zeros. 298| 7.08k| if (IsInteger(e.type.base_type)) { ------------------ | Branch (298:7): [True: 7.08k, False: 0] ------------------ 299| 7.08k| e.constant = NumToString(val); 300| 7.08k| } 301| 7.08k|} idl_parser.cpp:_ZN11flatbuffers12_GLOBAL__N_117SingleValueRepackItEEvRNS_5ValueET_: 296| 7.30k|static inline void SingleValueRepack(Value& e, T val) { 297| | // Remove leading zeros. 298| 7.30k| if (IsInteger(e.type.base_type)) { ------------------ | Branch (298:7): [True: 7.30k, False: 0] ------------------ 299| 7.30k| e.constant = NumToString(val); 300| 7.30k| } 301| 7.30k|} idl_parser.cpp:_ZN11flatbuffers12_GLOBAL__N_117SingleValueRepackIiEEvRNS_5ValueET_: 296| 12.4k|static inline void SingleValueRepack(Value& e, T val) { 297| | // Remove leading zeros. 298| 12.4k| if (IsInteger(e.type.base_type)) { ------------------ | Branch (298:7): [True: 12.4k, False: 0] ------------------ 299| 12.4k| e.constant = NumToString(val); 300| 12.4k| } 301| 12.4k|} idl_parser.cpp:_ZN11flatbuffers12_GLOBAL__N_117SingleValueRepackIjEEvRNS_5ValueET_: 296| 8.75k|static inline void SingleValueRepack(Value& e, T val) { 297| | // Remove leading zeros. 298| 8.75k| if (IsInteger(e.type.base_type)) { ------------------ | Branch (298:7): [True: 8.75k, False: 0] ------------------ 299| 8.75k| e.constant = NumToString(val); 300| 8.75k| } 301| 8.75k|} idl_parser.cpp:_ZN11flatbuffers12_GLOBAL__N_117SingleValueRepackIlEEvRNS_5ValueET_: 296| 10.0k|static inline void SingleValueRepack(Value& e, T val) { 297| | // Remove leading zeros. 298| 10.0k| if (IsInteger(e.type.base_type)) { ------------------ | Branch (298:7): [True: 10.0k, False: 0] ------------------ 299| 10.0k| e.constant = NumToString(val); 300| 10.0k| } 301| 10.0k|} idl_parser.cpp:_ZN11flatbuffers12_GLOBAL__N_117SingleValueRepackImEEvRNS_5ValueET_: 296| 15.3k|static inline void SingleValueRepack(Value& e, T val) { 297| | // Remove leading zeros. 298| 15.3k| if (IsInteger(e.type.base_type)) { ------------------ | Branch (298:7): [True: 15.3k, False: 0] ------------------ 299| 15.3k| e.constant = NumToString(val); 300| 15.3k| } 301| 15.3k|} _ZN11flatbuffers13ClassicLocaleC2Ev: 416| 2| : locale_(newlocale(LC_ALL, "C", nullptr)) {} _ZN11flatbuffers23ReadEnvironmentVariableEPKcPNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE: 437| 2|bool ReadEnvironmentVariable(const char* var_name, std::string* _value) { 438| |#ifdef _MSC_VER 439| | __pragma(warning(disable : 4996)); // _CRT_SECURE_NO_WARNINGS 440| |#endif 441| 2| auto env_str = std::getenv(var_name); 442| 2| if (!env_str) return false; ------------------ | Branch (442:7): [True: 2, False: 0] ------------------ 443| 0| if (_value) *_value = std::string(env_str); ------------------ | Branch (443:7): [True: 0, False: 0] ------------------ 444| 0| return true; 445| 2|} _Z5ParseRN11flatbuffers6ParserERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEPS8_: 228| 665k| std::string* _text) { 229| 665k| auto done = parser.ParseJson(json.c_str()); 230| 665k| if (done) { ------------------ | Branch (230:7): [True: 190k, False: 475k] ------------------ 231| 190k| TEST_NULL(GenText(parser, parser.builder_.GetBufferPointer(), _text)); ------------------ | | 22| 190k|#define TEST_NULL(val) TestEq(true, (val) == nullptr, "'" "nullptr" "' != '" #val "'", __FILE__, __LINE__, "") ------------------ 232| 475k| } else { 233| 475k| *_text = parser.error_; 234| 475k| } 235| 665k| return done; 236| 665k|} LLVMFuzzerTestOneInput: 243| 5.10k|extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) { 244| | // Reserve one byte for Parser flags and one byte for repetition counter. 245| 5.10k| if (size < 3) return 0; ------------------ | Branch (245:7): [True: 2, False: 5.10k] ------------------ 246| 5.10k| const uint8_t flags = data[0]; 247| | // normalize to ascii alphabet 248| 5.10k| const int extra_rep_number = 249| 5.10k| std::max(5, (data[1] > '0' ? (data[1] - '0') : 0)); ------------------ | Branch (249:20): [True: 4.17k, False: 935] ------------------ 250| 5.10k| data += 2; 251| 5.10k| size -= 2; // bypass 252| | 253| | // Guarantee 0-termination. 254| 5.10k| const std::string original(reinterpret_cast(data), size); 255| 5.10k| auto input = std::string(original.c_str()); // until '\0' 256| 5.10k| if (input.size() < kMinInputLength || input.size() > kMaxInputLength) ------------------ | Branch (256:7): [True: 2, False: 5.10k] | Branch (256:41): [True: 43, False: 5.06k] ------------------ 257| 45| return 0; 258| | 259| | // Break comments in json to avoid complexity with regex matcher. 260| | // The string " 12345 /* text */" will be accepted if insert it to string 261| | // expression: "table X { Y: " + " 12345 /* text */" + "; }. 262| | // But strings like this will complicate regex matcher. 263| | // We reject this by transform "/* text */ 12345" to "@* text */ 12345". 264| 5.06k| BreakSequence(input, "//", '@'); // "//" -> "@/" 265| 5.06k| BreakSequence(input, "/*", '@'); // "/*" -> "@*" 266| | // { "$schema: "text" } is exceptional case. 267| | // This key:value ignored by the parser. Numbers can not have $. 268| 5.06k| BreakSequence(input, "$schema", '@'); // "$schema" -> "@schema" 269| | // Break all known scalar functions (todo: add them to regex?): 270| 40.4k| for (auto f : {"deg", "rad", "sin", "cos", "tan", "asin", "acos", "atan"}) { ------------------ | Branch (270:15): [True: 40.4k, False: 5.06k] ------------------ 271| 40.4k| BreakSequence(input, f, '_'); // ident -> ident 272| 40.4k| } 273| | 274| | // Extract type of scalar from 'flags' and check if the input string satisfies 275| | // the scalar type. 276| 5.06k| const auto ref_res = 277| 5.06k| ScalarReferenceResult::Check(flags & flags_scalar_type, input); 278| 5.06k| auto& recheck = ref_res.matched; 279| | 280| | // Create parser 281| 5.06k| flatbuffers::IDLOptions opts; 282| 5.06k| opts.force_defaults = true; 283| 5.06k| opts.output_default_scalars_in_json = true; 284| 5.06k| opts.indent_step = -1; 285| 5.06k| opts.strict_json = true; 286| | 287| 5.06k| flatbuffers::Parser parser(opts); 288| 5.06k| auto schema = 289| 5.06k| "table X { Y: " + std::string(ref_res.type) + "; } root_type X;"; 290| 5.06k| TEST_EQ_FUNC(parser.Parse(schema.c_str()), true); ------------------ | | 31| 5.06k| #define TEST_EQ_FUNC(exp, val) TestEq(exp, val, "'" #exp "' != '" #val "'", __FILE__, __LINE__, __PRETTY_FUNCTION__) ------------------ 291| | 292| | // The fuzzer can adjust the number repetition if a side-effects have found. 293| | // Each test should pass at least two times to ensure that the parser doesn't 294| | // have any hidden-states or locale-depended effects. 295| 342k| for (auto cnt = 0; cnt < (extra_rep_number + 2); cnt++) { ------------------ | Branch (295:22): [True: 337k, False: 5.06k] ------------------ 296| | // Each even run (0,2,4..) will test locale independed code. 297| 337k| auto use_locale = !!OneTimeTestInit::test_locale() && (0 == (cnt % 2)); ------------------ | Branch (297:23): [True: 337k, False: 0] | Branch (297:59): [True: 170k, False: 167k] ------------------ 298| | // Set new locale. 299| 337k| if (use_locale) { ------------------ | Branch (299:9): [True: 170k, False: 167k] ------------------ 300| 170k| FLATBUFFERS_ASSERT(setlocale(LC_ALL, OneTimeTestInit::test_locale())); 301| 170k| } 302| | 303| | // Parse original input as-is. 304| 337k| auto orig_scalar = "{\"Y\" : " + input + "}"; 305| 337k| std::string orig_back; 306| 337k| auto orig_done = Parse(parser, orig_scalar, &orig_back); 307| | 308| 337k| if (recheck.res != orig_done) { ------------------ | Branch (308:9): [True: 38.7k, False: 299k] ------------------ 309| | // look for "does not fit" or "doesn't fit" or "out of range" 310| 38.7k| auto not_fit = 311| 38.7k| (true == recheck.res) ------------------ | Branch (311:11): [True: 38.7k, False: 0] ------------------ 312| 38.7k| ? ((orig_back.find("does not fit") != std::string::npos) || ------------------ | Branch (312:18): [True: 38.7k, False: 0] ------------------ 313| 0| (orig_back.find("out of range") != std::string::npos)) ------------------ | Branch (313:18): [True: 0, False: 0] ------------------ 314| 38.7k| : false; 315| | 316| 38.7k| if (false == not_fit) { ------------------ | Branch (316:11): [True: 0, False: 38.7k] ------------------ 317| 0| TEST_OUTPUT_LINE("Stage 1 failed: Parser(%d) != Regex(%d)", orig_done, ------------------ | | 16| 0| do { printf(__VA_ARGS__); printf("\n"); } while(!flatbuffers::IsConstTrue(true)) | | ------------------ | | | Branch (16:55): [Folded, False: 0] | | ------------------ ------------------ 318| 0| recheck.res); 319| 0| TEST_EQ_STR(orig_back.c_str(), ------------------ | | 24| 0|#define TEST_EQ_STR(exp, val) TestEqStr(exp, val, "'" #exp "' != '" #val "'", __FILE__, __LINE__, "") ------------------ 320| 0| input.substr(recheck.pos, recheck.len).c_str()); 321| 0| TEST_EQ_FUNC(orig_done, recheck.res); ------------------ | | 31| 0| #define TEST_EQ_FUNC(exp, val) TestEq(exp, val, "'" #exp "' != '" #val "'", __FILE__, __LINE__, __PRETTY_FUNCTION__) ------------------ 322| 0| } 323| 38.7k| } 324| | 325| | // Try to make quoted string and test it. 326| 337k| std::string qouted_input; 327| 337k| if (true == recheck.quoted) { ------------------ | Branch (327:9): [True: 9.76k, False: 328k] ------------------ 328| | // we can't simply remove quotes, they may be nested "'12'". 329| | // Original string "\'12\'" converted to "'12'". 330| | // The string can be an invalid string by JSON rules, but after quotes 331| | // removed can transform to valid. 332| 9.76k| assert(recheck.len >= 2); ------------------ | Branch (332:7): [True: 9.76k, False: 0] ------------------ 333| 328k| } else { 334| 328k| const auto quote = (flags & flags_quotes_kind) ? '\"' : '\''; ------------------ | Branch (334:26): [True: 157k, False: 171k] ------------------ 335| 328k| qouted_input = input; // copy 336| 328k| qouted_input.insert(recheck.pos + recheck.len, 1, quote); 337| 328k| qouted_input.insert(recheck.pos, 1, quote); 338| 328k| } 339| | 340| | // Test quoted version of the string 341| 337k| if (!qouted_input.empty()) { ------------------ | Branch (341:9): [True: 328k, False: 9.76k] ------------------ 342| 328k| auto fix_scalar = "{\"Y\" : " + qouted_input + "}"; 343| 328k| std::string fix_back; 344| 328k| auto fix_done = Parse(parser, fix_scalar, &fix_back); 345| | 346| 328k| if (orig_done != fix_done) { ------------------ | Branch (346:11): [True: 0, False: 328k] ------------------ 347| 0| TEST_OUTPUT_LINE("Stage 2 failed: Parser(%d) != Regex(%d)", fix_done, ------------------ | | 16| 0| do { printf(__VA_ARGS__); printf("\n"); } while(!flatbuffers::IsConstTrue(true)) | | ------------------ | | | Branch (16:55): [Folded, False: 0] | | ------------------ ------------------ 348| 0| orig_done); 349| 0| TEST_EQ_STR(fix_back.c_str(), orig_back.c_str()); ------------------ | | 24| 0|#define TEST_EQ_STR(exp, val) TestEqStr(exp, val, "'" #exp "' != '" #val "'", __FILE__, __LINE__, "") ------------------ 350| 0| } 351| 328k| if (orig_done) { ------------------ | Branch (351:11): [True: 92.1k, False: 235k] ------------------ 352| 92.1k| TEST_EQ_STR(fix_back.c_str(), orig_back.c_str()); ------------------ | | 24| 92.1k|#define TEST_EQ_STR(exp, val) TestEqStr(exp, val, "'" #exp "' != '" #val "'", __FILE__, __LINE__, "") ------------------ 353| 92.1k| } 354| 328k| TEST_EQ_FUNC(fix_done, orig_done); ------------------ | | 31| 328k| #define TEST_EQ_FUNC(exp, val) TestEq(exp, val, "'" #exp "' != '" #val "'", __FILE__, __LINE__, __PRETTY_FUNCTION__) ------------------ 355| 328k| } 356| | 357| | // Create new parser and test default value 358| 337k| if (true == orig_done) { ------------------ | Branch (358:9): [True: 98.3k, False: 239k] ------------------ 359| 98.3k| flatbuffers::Parser def_parser(opts); // re-use options 360| 98.3k| auto def_schema = "table X { Y: " + std::string(ref_res.type) + " = " + 361| 98.3k| input + "; } root_type X;" + 362| 98.3k| "{}"; // <- with empty json {}! 363| | 364| 98.3k| auto def_done = def_parser.Parse(def_schema.c_str()); 365| 98.3k| if (false == def_done) { ------------------ | Branch (365:11): [True: 0, False: 98.3k] ------------------ 366| 0| TEST_OUTPUT_LINE("Stage 3.1 failed with _error = %s", ------------------ | | 16| 0| do { printf(__VA_ARGS__); printf("\n"); } while(!flatbuffers::IsConstTrue(true)) | | ------------------ | | | Branch (16:55): [Folded, False: 0] | | ------------------ ------------------ 367| 0| def_parser.error_.c_str()); 368| 0| FLATBUFFERS_ASSERT(false); 369| 0| } 370| | // Compare with print. 371| 98.3k| std::string ref_string, def_string; 372| 98.3k| FLATBUFFERS_ASSERT( 373| 98.3k| !GenText(parser, parser.builder_.GetBufferPointer(), &ref_string)); 374| 98.3k| FLATBUFFERS_ASSERT(!GenText( 375| 98.3k| def_parser, def_parser.builder_.GetBufferPointer(), &def_string)); 376| 98.3k| if (ref_string != def_string) { ------------------ | Branch (376:11): [True: 0, False: 98.3k] ------------------ 377| 0| TEST_OUTPUT_LINE("Stage 3.2 failed: '%s' != '%s'", def_string.c_str(), ------------------ | | 16| 0| do { printf(__VA_ARGS__); printf("\n"); } while(!flatbuffers::IsConstTrue(true)) | | ------------------ | | | Branch (16:55): [Folded, False: 0] | | ------------------ ------------------ 378| 0| ref_string.c_str()); 379| 0| FLATBUFFERS_ASSERT(false); 380| 0| } 381| 98.3k| } 382| | 383| | // Restore locale. 384| 337k| if (use_locale) { ------------------ | Branch (384:9): [True: 170k, False: 167k] ------------------ 385| 170k| FLATBUFFERS_ASSERT(setlocale(LC_ALL, "C")); 386| 170k| } 387| 337k| } 388| 5.06k| return 0; 389| 5.06k|} flatbuffers_scalar_fuzzer.cc:_ZL13BreakSequenceRNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPKcc: 41| 55.6k|static void BreakSequence(std::string& s, const char* subj, char repl) { 42| 55.6k| size_t pos = 0; 43| 62.7k| while (pos = s.find(subj, pos), pos != std::string::npos) { ------------------ | Branch (43:10): [True: 7.05k, False: 55.6k] ------------------ 44| 7.05k| s.at(pos) = repl; 45| 7.05k| pos++; 46| 7.05k| } 47| 55.6k|} _ZN21ScalarReferenceResult5CheckEhRKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE: 194| 5.06k| static ScalarReferenceResult Check(uint8_t code, const std::string& input) { 195| 5.06k| switch (code) { 196| 468| case 0x0: ------------------ | Branch (196:7): [True: 468, False: 4.59k] ------------------ 197| 468| return {"double", FloatRegex().Match(input)}; 198| 197| case 0x1: ------------------ | Branch (198:7): [True: 197, False: 4.86k] ------------------ 199| 197| return {"float", FloatRegex().Match(input)}; 200| 418| case 0x2: ------------------ | Branch (200:7): [True: 418, False: 4.64k] ------------------ 201| 418| return {"int8", IntegerRegex().Match(input)}; 202| 417| case 0x3: ------------------ | Branch (202:7): [True: 417, False: 4.64k] ------------------ 203| 417| return {"int16", IntegerRegex().Match(input)}; 204| 461| case 0x4: ------------------ | Branch (204:7): [True: 461, False: 4.59k] ------------------ 205| 461| return {"int32", IntegerRegex().Match(input)}; 206| 423| case 0x5: ------------------ | Branch (206:7): [True: 423, False: 4.63k] ------------------ 207| 423| return {"int64", IntegerRegex().Match(input)}; 208| 274| case 0x6: ------------------ | Branch (208:7): [True: 274, False: 4.78k] ------------------ 209| 274| return {"uint8", UIntegerRegex().Match(input)}; 210| 395| case 0x7: ------------------ | Branch (210:7): [True: 395, False: 4.66k] ------------------ 211| 395| return {"uint16", UIntegerRegex().Match(input)}; 212| 440| case 0x8: ------------------ | Branch (212:7): [True: 440, False: 4.62k] ------------------ 213| 440| return {"uint32", UIntegerRegex().Match(input)}; 214| 502| case 0x9: ------------------ | Branch (214:7): [True: 502, False: 4.55k] ------------------ 215| 502| return {"uint64", UIntegerRegex().Match(input)}; 216| 371| case 0xA: ------------------ | Branch (216:7): [True: 371, False: 4.68k] ------------------ 217| 371| return {"bool", BooleanRegex().Match(input)}; 218| 694| default: ------------------ | Branch (218:7): [True: 694, False: 4.36k] ------------------ 219| 694| return {"float", FloatRegex().Match(input)}; 220| 5.06k| }; 221| 0| } _ZN10FloatRegexC2Ev: 183| 1.35k| FloatRegex() = default; _ZN12RegexMatcherD2Ev: 70| 5.06k| virtual ~RegexMatcher() = default; _ZNK10FloatRegex11MatchNumberERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE: 165| 1.08k| bool MatchNumber(const std::string& input) const override { 166| 1.08k| static const std::vector re_list = { 167| | // hex-float 168| 1.08k| std::regex{ 169| 1.08k| R"(^[-+]?0[xX](?:(?:[.][0-9a-fA-F]+)|(?:[0-9a-fA-F]+[.][0-9a-fA-F]*)|(?:[0-9a-fA-F]+))[pP][-+]?[0-9]+$)", 170| 1.08k| std::regex_constants::optimize}, 171| | // dec-float 172| 1.08k| std::regex{ 173| 1.08k| R"(^[-+]?(?:(?:[.][0-9]+)|(?:[0-9]+[.][0-9]*)|(?:[0-9]+))(?:[eE][-+]?[0-9]+)?$)", 174| 1.08k| std::regex_constants::optimize}, 175| | 176| 1.08k| std::regex{ 177| 1.08k| R"(^[-+]?(?:nan|inf|infinity)$)", 178| 1.08k| std::regex_constants::optimize | std::regex_constants::icase}}; 179| 1.08k| return MatchRegexList(input, re_list); 180| 1.08k| } _ZNK12RegexMatcher14MatchRegexListERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEERKNS0_6vectorINS0_11basic_regexIcNS0_12regex_traitsIcEEEENS4_ISD_EEEE: 107| 4.39k| const std::vector& re_list) const { 108| 4.39k| auto str = StripString(input, " "); 109| 4.39k| if (str.empty()) return false; ------------------ | Branch (109:9): [True: 7, False: 4.38k] ------------------ 110| 9.23k| for (auto& re : re_list) { ------------------ | Branch (110:19): [True: 9.23k, False: 2.42k] ------------------ 111| 9.23k| std::smatch match; 112| 9.23k| if (std::regex_match(str, match, re)) return true; ------------------ | Branch (112:11): [True: 1.96k, False: 7.27k] ------------------ 113| 9.23k| } 114| 2.42k| return false; 115| 4.38k| } flatbuffers_scalar_fuzzer.cc:_ZL11StripStringRKNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPKcPm: 52| 9.45k| size_t* pos = nullptr) { 53| 9.45k| if (pos) *pos = 0; ------------------ | Branch (53:7): [True: 5.06k, False: 4.39k] ------------------ 54| | // leading 55| 9.45k| auto first = s.find_first_not_of(pattern); 56| 9.45k| if (std::string::npos == first) return ""; ------------------ | Branch (56:7): [True: 68, False: 9.38k] ------------------ 57| 9.38k| if (pos) *pos = first; ------------------ | Branch (57:7): [True: 4.99k, False: 4.38k] ------------------ 58| | // trailing 59| 9.38k| auto last = s.find_last_not_of(pattern); 60| 9.38k| assert(last < s.length()); ------------------ | Branch (60:3): [True: 9.38k, False: 0] ------------------ 61| 9.38k| assert(first <= last); ------------------ | Branch (61:3): [True: 9.38k, False: 0] ------------------ 62| 9.38k| return s.substr(first, last - first + 1); 63| 9.38k|} _ZNK12RegexMatcher5MatchERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE: 79| 5.06k| MatchResult Match(const std::string& input) const { 80| 5.06k| MatchResult r; 81| | // strip leading and trailing "spaces" accepted by flatbuffer 82| 5.06k| auto test = StripString(input, "\t\r\n ", &r.pos); 83| 5.06k| r.len = test.size(); 84| | // check quotes 85| 5.06k| if (test.size() >= 2) { ------------------ | Branch (85:9): [True: 4.42k, False: 631] ------------------ 86| 4.42k| auto fch = test.front(); 87| 4.42k| auto lch = test.back(); 88| 4.42k| r.quoted = (fch == lch) && (fch == '\'' || fch == '\"'); ------------------ | Branch (88:18): [True: 400, False: 4.02k] | Branch (88:35): [True: 74, False: 326] | Branch (88:50): [True: 30, False: 296] ------------------ 89| 4.42k| if (r.quoted) { ------------------ | Branch (89:11): [True: 104, False: 4.32k] ------------------ 90| | // remove quotes for regex test 91| 104| test = test.substr(1, test.size() - 2); 92| 104| } 93| 4.42k| } 94| | // Fast check: 95| 5.06k| if (test.empty()) return r; ------------------ | Branch (95:9): [True: 66, False: 4.99k] ------------------ 96| | // A string with a valid scalar shouldn't have non-ascii or non-printable 97| | // symbols. 98| 405k| for (auto c : test) { ------------------ | Branch (98:17): [True: 405k, False: 4.40k] ------------------ 99| 405k| if ((c < ' ') || (c > '~')) return r; ------------------ | Branch (99:11): [True: 575, False: 404k] | Branch (99:24): [True: 12, False: 404k] ------------------ 100| 405k| } 101| | // Check with regex 102| 4.40k| r.res = MatchNumber(test); 103| 4.40k| return r; 104| 4.99k| } _ZN21ScalarReferenceResultC2EPKcN12RegexMatcher11MatchResultE: 190| 5.06k| : type(_type), matched(_matched) {} _ZN12IntegerRegexC2Ev: 130| 2.09k| IntegerRegex() = default; _ZNK12IntegerRegex11MatchNumberERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE: 120| 1.82k| bool MatchNumber(const std::string& input) const override { 121| 1.82k| static const std::vector re_list = { 122| 1.82k| std::regex{R"(^[-+]?[0-9]+$)", std::regex_constants::optimize}, 123| | 124| 1.82k| std::regex{R"(^[-+]?0[xX][0-9a-fA-F]+$)", 125| 1.82k| std::regex_constants::optimize}}; 126| 1.82k| return MatchRegexList(input, re_list); 127| 1.82k| } _ZN13UIntegerRegexC2Ev: 147| 1.61k| UIntegerRegex() = default; _ZNK13UIntegerRegex11MatchNumberERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE: 136| 1.48k| bool MatchNumber(const std::string& input) const override { 137| 1.48k| static const std::vector re_list = { 138| 1.48k| std::regex{R"(^[+]?[0-9]+$)", std::regex_constants::optimize}, 139| 1.48k| std::regex{R"(^[+]?0[xX][0-9a-fA-F]+$)", 140| 1.48k| std::regex_constants::optimize}, 141| | // accept -0 number 142| 1.48k| std::regex{R"(^[-](?:0[xX])?0+$)", std::regex_constants::optimize}}; 143| 1.48k| return MatchRegexList(input, re_list); 144| 1.48k| } _ZN12BooleanRegexC2Ev: 159| 371| BooleanRegex() = default; _ZNK12BooleanRegex11MatchNumberERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE: 153| 310| bool MatchNumber(const std::string& input) const override { 154| 310| if (input == "true" || input == "false") return true; ------------------ | Branch (154:9): [True: 7, False: 303] | Branch (154:28): [True: 7, False: 296] ------------------ 155| 296| return IntegerRegex::MatchNumber(input); 156| 310| } _ZN15OneTimeTestInitC2Ev: 27| 2| OneTimeTestInit() : has_locale_(false) { 28| | // Fuzzer test should be independent of the test engine implementation. 29| | // This hook will terminate test if TEST_EQ/TEST_ASSERT asserted. 30| 2| InitTestEngine(OneTimeTestInit::TestFailListener); 31| | 32| | // Read a locale for the test. 33| 2| if (flatbuffers::ReadEnvironmentVariable("FLATBUFFERS_TEST_LOCALE", ------------------ | Branch (33:9): [True: 0, False: 2] ------------------ 34| 2| &test_locale_)) { 35| 0| TEST_OUTPUT_LINE("The environment variable FLATBUFFERS_TEST_LOCALE=%s", ------------------ | | 16| 0| do { printf(__VA_ARGS__); printf("\n"); } while(!flatbuffers::IsConstTrue(true)) | | ------------------ | | | Branch (16:55): [Folded, False: 0] | | ------------------ ------------------ 36| 0| test_locale_.c_str()); 37| 0| test_locale_ = flatbuffers::RemoveStringQuotes(test_locale_); 38| 0| has_locale_ = true; 39| 0| } 40| 2| } _ZN15OneTimeTestInit11test_localeEv: 42| 508k| static const char* test_locale() { 43| 508k| return one_time_init_.has_locale_ ? nullptr ------------------ | Branch (43:12): [True: 0, False: 508k] ------------------ 44| 508k| : one_time_init_.test_locale_.c_str(); 45| 508k| } _Z9TestEqStrPKcS0_S0_S0_iS0_: 28| 92.1k| const char* file, int line, const char* func) { 29| 92.1k| if (strcmp(expval, val) != 0) { ------------------ | Branch (29:7): [True: 0, False: 92.1k] ------------------ 30| 0| TestFail(expval, val, exp, file, line, func); 31| 0| } 32| 92.1k|} _Z14InitTestEnginePFbPKcS0_S0_S0_iS0_E: 39| 2|void InitTestEngine(TestFailEventListener listener) { 40| 2| testing_fails = 0; 41| | // Disable stdout buffering to prevent information lost on assertion or core 42| | // dump. 43| 2| setvbuf(stdout, nullptr, _IONBF, 0); 44| 2| setvbuf(stderr, nullptr, _IONBF, 0); 45| | 46| | // clang-format off 47| | 48| | #if defined(FLATBUFFERS_MEMORY_LEAK_TRACKING_MSVC) 49| | // For more thorough checking: 50| | // _CRTDBG_DELAY_FREE_MEM_DF | _CRTDBG_CHECK_ALWAYS_DF 51| | auto flags = _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG); 52| | _CrtSetDbgFlag(flags | _CRTDBG_ALLOC_MEM_DF); 53| | #endif 54| | // clang-format on 55| | 56| 2| fail_listener_ = listener; 57| 2|} _Z6TestEqIbbEvT_T0_PKcS3_iS3_: 94| 523k| const char* func) { 95| 523k| if (static_cast(expval) != val) { ------------------ | Branch (95:7): [True: 0, False: 523k] ------------------ 96| 0| TestFail(flatbuffers::NumToString(scalar_as_underlying(expval)).c_str(), 97| 0| flatbuffers::NumToString(scalar_as_underlying(val)).c_str(), exp, 98| 0| file, line, func); 99| 0| } 100| 523k|}