LLVMFuzzerTestOneInput: 3| 1.46k|extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) { 4| 1.46k| JsonDocument doc; 5| 1.46k| DeserializationError error = deserializeMsgPack(doc, data, size); 6| 1.46k| if (!error) { ------------------ | Branch (6:7): [True: 703, False: 761] ------------------ 7| 703| std::string json; 8| 703| serializeMsgPack(doc, json); 9| 703| } 10| 1.46k| return 0; 11| 1.46k|} _ZN11ArduinoJson8V710HB426detail9ArrayData10addElementEPNS1_15ResourceManagerE: 23| 11.0k|inline VariantData* ArrayData::addElement(ResourceManager* resources) { 24| 11.0k| auto slot = resources->allocVariant(); 25| 11.0k| if (!slot) ------------------ | Branch (25:7): [True: 0, False: 11.0k] ------------------ 26| 0| return nullptr; 27| 11.0k| CollectionData::appendOne(slot, resources); 28| 11.0k| return slot.ptr(); 29| 11.0k|} _ZN11ArduinoJson8V710HB426detail14CollectionDatanwEmPv: 74| 4.25k| static void* operator new(size_t, void* p) noexcept { 75| 4.25k| return p; 76| 4.25k| } _ZNK11ArduinoJson8V710HB426detail18CollectionIterator4doneEv: 26| 8.41k| bool done() const { 27| 8.41k| return slot_ == nullptr; 28| 8.41k| } _ZNK11ArduinoJson8V710HB426detail14CollectionData4headEv: 95| 1.73k| SlotId head() const { 96| 1.73k| return head_; 97| 1.73k| } _ZN11ArduinoJson8V710HB426detail14CollectionData9appendOneENS1_4SlotINS1_11VariantDataEEEPKNS1_15ResourceManagerE: 34| 11.0k| const ResourceManager* resources) { 35| 11.0k| if (tail_ != NULL_SLOT) { ------------------ | Branch (35:7): [True: 9.08k, False: 2.01k] ------------------ 36| 9.08k| auto tail = resources->getVariant(tail_); 37| 9.08k| tail->setNext(slot.id()); 38| 9.08k| tail_ = slot.id(); 39| 9.08k| } else { 40| 2.01k| head_ = slot.id(); 41| 2.01k| tail_ = slot.id(); 42| 2.01k| } 43| 11.0k|} _ZN11ArduinoJson8V710HB426detail14CollectionData10appendPairENS1_4SlotINS1_11VariantDataEEES5_PKNS1_15ResourceManagerE: 47| 2.10k| const ResourceManager* resources) { 48| 2.10k| key->setNext(value.id()); 49| | 50| 2.10k| if (tail_ != NULL_SLOT) { ------------------ | Branch (50:7): [True: 1.51k, False: 591] ------------------ 51| 1.51k| auto tail = resources->getVariant(tail_); 52| 1.51k| tail->setNext(key.id()); 53| 1.51k| tail_ = value.id(); 54| 1.51k| } else { 55| 591| head_ = key.id(); 56| 591| tail_ = value.id(); 57| 591| } 58| 2.10k|} _ZNK11ArduinoJson8V710HB426detail14CollectionData4sizeEPKNS1_15ResourceManagerE: 130| 1.73k|inline size_t CollectionData::size(const ResourceManager* resources) const { 131| 1.73k| size_t count = 0; 132| 8.41k| for (auto it = createIterator(resources); !it.done(); it.next(resources)) ------------------ | Branch (132:45): [True: 6.68k, False: 1.73k] ------------------ 133| 6.68k| count++; 134| 1.73k| return count; 135| 1.73k|} _ZNK11ArduinoJson8V710HB426detail14CollectionData14createIteratorEPKNS1_15ResourceManagerE: 29| 1.73k| const ResourceManager* resources) const { 30| 1.73k| return iterator(resources->getVariant(head_), head_); 31| 1.73k|} _ZN11ArduinoJson8V710HB426detail18CollectionIteratorC2EPNS1_11VariantDataEj: 16| 1.73k| : slot_(slot), currentId_(slotId) { 17| 1.73k| nextId_ = slot_ ? slot_->next() : NULL_SLOT; ------------------ | Branch (17:13): [True: 913, False: 823] ------------------ 18| 1.73k|} _ZN11ArduinoJson8V710HB426detail18CollectionIterator4nextEPKNS1_15ResourceManagerE: 20| 6.68k|inline void CollectionIterator::next(const ResourceManager* resources) { 21| 6.68k| ARDUINOJSON_ASSERT(currentId_ != NULL_SLOT); ------------------ | | 11| 6.68k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 22| 6.68k| slot_ = resources->getVariant(nextId_); 23| 6.68k| currentId_ = nextId_; 24| 6.68k| if (slot_) ------------------ | Branch (24:7): [True: 5.76k, False: 913] ------------------ 25| 5.76k| nextId_ = slot_->next(); 26| 6.68k|} _ZNK11ArduinoJson8V710HB4220DeserializationErrorcvbEv: 56| 1.46k| explicit operator bool() const { 57| 1.46k| return code_ != Ok; 58| 1.46k| } _ZN11ArduinoJson8V710HB4220DeserializationErrorC2ENS1_4CodeE: 29| 1.46k| DeserializationError(Code c) : code_(c) {} _ZN11ArduinoJson8V710HB426detail26makeDeserializationOptionsENS0_21DeserializationOption12NestingLimitE: 31| 1.46k| DeserializationOption::NestingLimit nestingLimit = {}) { 32| 1.46k| return {{}, nestingLimit}; 33| 1.46k|} _ZNK11ArduinoJson8V710HB426detail14AllowAllFilter10allowValueEv: 66| 14.4k| bool allowValue() const { 67| 14.4k| return true; 68| 14.4k| } _ZNK11ArduinoJson8V710HB426detail14AllowAllFilter10allowArrayEv: 58| 3.07k| bool allowArray() const { 59| 3.07k| return true; 60| 3.07k| } _ZNK11ArduinoJson8V710HB426detail14AllowAllFilterixIjEES2_RKT_: 71| 3.07k| AllowAllFilter operator[](const TKey&) const { 72| 3.07k| return AllowAllFilter(); 73| 3.07k| } _ZNK11ArduinoJson8V710HB426detail14AllowAllFilter5allowEv: 54| 13.2k| bool allow() const { 55| 13.2k| return true; 56| 13.2k| } _ZNK11ArduinoJson8V710HB426detail14AllowAllFilter11allowObjectEv: 62| 1.18k| bool allowObject() const { 63| 1.18k| return true; 64| 1.18k| } _ZNK11ArduinoJson8V710HB426detail14AllowAllFilterixIPKcEES2_RKT_: 71| 2.10k| AllowAllFilter operator[](const TKey&) const { 72| 2.10k| return AllowAllFilter(); 73| 2.10k| } _ZNK11ArduinoJson8V710HB4221DeserializationOption12NestingLimit7reachedEv: 23| 4.25k| bool reached() const { 24| 4.25k| return value_ == 0; 25| 4.25k| } _ZNK11ArduinoJson8V710HB4221DeserializationOption12NestingLimit9decrementEv: 18| 13.2k| NestingLimit decrement() const { 19| 13.2k| ARDUINOJSON_ASSERT(value_ > 0); ------------------ | | 11| 13.2k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 20| 13.2k| return NestingLimit(static_cast(value_ - 1)); 21| 13.2k| } _ZN11ArduinoJson8V710HB4221DeserializationOption12NestingLimitC2Eh: 16| 13.2k| explicit NestingLimit(uint8_t n) : value_(n) {} _ZN11ArduinoJson8V710HB4221DeserializationOption12NestingLimitC2Ev: 15| 1.46k| NestingLimit() : value_(ARDUINOJSON_DEFAULT_NESTING_LIMIT) {} _ZN11ArduinoJson8V710HB426detail10makeReaderIKhEENS1_13BoundedReaderIPT_vEES6_m: 70| 1.46k|BoundedReader makeReader(TChar* input, size_t inputSize) { 71| 1.46k| return BoundedReader{input, inputSize}; 72| 1.46k|} _ZN11ArduinoJson8V710HB426detail14IteratorReaderIPKcE9readBytesEPcm: 26| 24.5k| size_t readBytes(char* buffer, size_t length) { 27| 24.5k| size_t i = 0; 28| 56.6k| while (i < length && ptr_ < end_) ------------------ | Branch (28:12): [True: 32.6k, False: 23.9k] | Branch (28:26): [True: 32.1k, False: 568] ------------------ 29| 32.1k| buffer[i++] = *ptr_++; 30| 24.5k| return i; 31| 24.5k| } _ZN11ArduinoJson8V710HB426detail14IteratorReaderIPKcE4readEv: 19| 2.76k| int read() { 20| 2.76k| if (ptr_ < end_) ------------------ | Branch (20:9): [True: 2.69k, False: 74] ------------------ 21| 2.69k| return static_cast(*ptr_++); 22| 74| else 23| 74| return -1; 24| 2.76k| } _ZN11ArduinoJson8V710HB426detail14IteratorReaderIPKcEC2ES4_S4_: 17| 1.46k| : ptr_(begin), end_(end) {} _ZN11ArduinoJson8V710HB426detail13BoundedReaderIPKhvEC2EPKvm: 46| 1.46k| reinterpret_cast(ptr) + len) {} _ZN11ArduinoJson8V710HB426detail11deserializeINS1_19MsgPackDeserializerERNS0_12JsonDocumentEKhmJEvEENS0_20DeserializationErrorEOT0_PT1_T2_DpT3_: 77| 1.46k| Size inputSize, Args... args) { 78| 1.46k| return doDeserialize(dst, makeReader(input, size_t(inputSize)), 79| 1.46k| makeDeserializationOptions(args...)); 80| 1.46k|} _ZN11ArduinoJson8V710HB426detail13doDeserializeINS1_19MsgPackDeserializerERNS0_12JsonDocumentENS1_13BoundedReaderIPKhvEENS1_22DeserializationOptionsINS1_14AllowAllFilterEEEEENS0_20DeserializationErrorEOT0_T1_T2_: 50| 1.46k| TOptions options) { 51| 1.46k| auto data = VariantAttorney::getOrCreateData(dst); 52| 1.46k| if (!data) ------------------ | Branch (52:7): [True: 0, False: 1.46k] ------------------ 53| 0| return DeserializationError::NoMemory; 54| 1.46k| auto resources = VariantAttorney::getResourceManager(dst); 55| 1.46k| dst.clear(); 56| 1.46k| auto err = TDeserializer(resources, reader) 57| 1.46k| .parse(*data, options.filter, options.nestingLimit); 58| 1.46k| shrinkJsonDocument(dst); 59| 1.46k| return err; 60| 1.46k|} _ZN11ArduinoJson8V710HB426detail18shrinkJsonDocumentERNS0_12JsonDocumentE: 42| 1.46k|inline void shrinkJsonDocument(JsonDocument& doc) { 43| 1.46k| doc.shrinkToFit(); 44| 1.46k|} _ZN11ArduinoJson8V710HB4212JsonDocumentC2EPNS0_9AllocatorE: 25| 1.46k| : resources_(alloc) {} _ZNK11ArduinoJson8V710HB4212JsonDocumentcvNS0_16JsonVariantConstEEv: 312| 703| operator JsonVariantConst() const { 313| 703| return getVariant(); 314| 703| } _ZNK11ArduinoJson8V710HB4212JsonDocument10getVariantEv: 378| 703| JsonVariantConst getVariant() const { 379| 703| return JsonVariantConst(&data_, &resources_); 380| 703| } _ZN11ArduinoJson8V710HB4212JsonDocument15getOrCreateDataEv: 394| 1.46k| detail::VariantData* getOrCreateData() { 395| 1.46k| return &data_; 396| 1.46k| } _ZN11ArduinoJson8V710HB4212JsonDocument18getResourceManagerEv: 382| 1.46k| detail::ResourceManager* getResourceManager() { 383| 1.46k| return &resources_; 384| 1.46k| } _ZN11ArduinoJson8V710HB4212JsonDocument5clearEv: 88| 1.46k| void clear() { 89| 1.46k| resources_.clear(); 90| 1.46k| data_.reset(); 91| 1.46k| } _ZN11ArduinoJson8V710HB4212JsonDocument11shrinkToFitEv: 68| 1.46k| void shrinkToFit() { 69| 1.46k| resources_.shrinkToFit(); 70| 1.46k| } _ZN11ArduinoJson8V710HB426detail16DefaultAllocator8instanceEv: 38| 1.46k| static Allocator* instance() { 39| 1.46k| static DefaultAllocator allocator; 40| 1.46k| return &allocator; 41| 1.46k| } _ZN11ArduinoJson8V710HB426detail16DefaultAllocator8allocateEm: 26| 2.66k| void* allocate(size_t size) override { 27| 2.66k| return malloc(size); 28| 2.66k| } _ZN11ArduinoJson8V710HB426detail16DefaultAllocator10deallocateEPv: 30| 2.66k| void deallocate(void* ptr) override { 31| 2.66k| free(ptr); 32| 2.66k| } _ZN11ArduinoJson8V710HB426detail16DefaultAllocator10reallocateEPvm: 34| 971| void* reallocate(void* ptr, size_t new_size) override { 35| 971| return realloc(ptr, new_size); 36| 971| } _ZN11ArduinoJson8V710HB426detail10MemoryPoolINS1_15ResourceManager8SlotDataEE7destroyEPNS0_9AllocatorE: 57| 903| void destroy(Allocator* allocator) { 58| 903| if (slots_) ------------------ | Branch (58:9): [True: 903, False: 0] ------------------ 59| 903| allocator->deallocate(slots_); 60| 903| slots_ = nullptr; 61| 903| capacity_ = 0; 62| 903| usage_ = 0; 63| 903| } _ZNK11ArduinoJson8V710HB426detail10MemoryPoolINS1_15ResourceManager8SlotDataEE7getSlotEj: 74| 24.2k| T* getSlot(SlotId id) const { 75| 24.2k| ARDUINOJSON_ASSERT(id < usage_); ------------------ | | 11| 24.2k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 76| 24.2k| return slots_ + id; 77| 24.2k| } _ZN11ArduinoJson8V710HB426detail4SlotINS1_15ResourceManager8SlotDataEEC2EPS4_j: 21| 31.3k| Slot(T* p, SlotId id) : ptr_(p), id_(id) { 22| 31.3k| ARDUINOJSON_ASSERT((p == nullptr) == (id == NULL_SLOT)); ------------------ | | 11| 31.3k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 23| 31.3k| } _ZN11ArduinoJson8V710HB426detail10MemoryPoolINS1_15ResourceManager8SlotDataEE9allocSlotEv: 65| 15.6k| Slot allocSlot() { 66| 15.6k| if (!slots_) ------------------ | Branch (66:9): [True: 0, False: 15.6k] ------------------ 67| 0| return {}; 68| 15.6k| if (usage_ >= capacity_) ------------------ | Branch (68:9): [True: 0, False: 15.6k] ------------------ 69| 0| return {}; 70| 15.6k| auto index = usage_++; 71| 15.6k| return {slots_ + index, SlotId(index)}; 72| 15.6k| } _ZNK11ArduinoJson8V710HB426detail4SlotINS1_15ResourceManager8SlotDataEE3ptrEv: 33| 15.6k| T* ptr() const { 34| 15.6k| return ptr_; 35| 15.6k| } _ZN11ArduinoJson8V710HB426detail10MemoryPoolINS1_15ResourceManager8SlotDataEE6createEjPNS0_9AllocatorE: 50| 903| void create(SlotCount cap, Allocator* allocator) { 51| 903| ARDUINOJSON_ASSERT(cap > 0); ------------------ | | 11| 903|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 52| 903| slots_ = reinterpret_cast(allocator->allocate(slotsToBytes(cap))); 53| 903| capacity_ = slots_ ? cap : 0; ------------------ | Branch (53:17): [True: 903, False: 0] ------------------ 54| 903| usage_ = 0; 55| 903| } _ZN11ArduinoJson8V710HB426detail10MemoryPoolINS1_15ResourceManager8SlotDataEE12slotsToBytesEj: 100| 1.80k| static size_t slotsToBytes(SlotCount n) { 101| 1.80k| return n * sizeof(T); 102| 1.80k| } _ZNK11ArduinoJson8V710HB426detail4SlotINS1_15ResourceManager8SlotDataEEcvbEv: 25| 46.1k| explicit operator bool() const { 26| 46.1k| return ptr_ != nullptr; 27| 46.1k| } _ZNK11ArduinoJson8V710HB426detail4SlotINS1_15ResourceManager8SlotDataEEptEv: 37| 15.6k| T* operator->() const { 38| 15.6k| ARDUINOJSON_ASSERT(ptr_ != nullptr); ------------------ | | 11| 15.6k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 39| 15.6k| return ptr_; 40| 15.6k| } _ZNK11ArduinoJson8V710HB426detail4SlotINS1_15ResourceManager8SlotDataEE2idEv: 29| 31.3k| SlotId id() const { 30| 31.3k| return id_; 31| 31.3k| } _ZN11ArduinoJson8V710HB426detail4SlotINS1_16VariantExtensionEEC2EPS3_j: 21| 378| Slot(T* p, SlotId id) : ptr_(p), id_(id) { 22| 378| ARDUINOJSON_ASSERT((p == nullptr) == (id == NULL_SLOT)); ------------------ | | 11| 378|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 23| 378| } _ZNK11ArduinoJson8V710HB426detail4SlotINS1_16VariantExtensionEEcvbEv: 25| 378| explicit operator bool() const { 26| 378| return ptr_ != nullptr; 27| 378| } _ZNK11ArduinoJson8V710HB426detail4SlotINS1_16VariantExtensionEE2idEv: 29| 378| SlotId id() const { 30| 378| return id_; 31| 378| } _ZNK11ArduinoJson8V710HB426detail4SlotINS1_16VariantExtensionEEptEv: 37| 378| T* operator->() const { 38| 378| ARDUINOJSON_ASSERT(ptr_ != nullptr); ------------------ | | 11| 378|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 39| 378| return ptr_; 40| 378| } _ZN11ArduinoJson8V710HB426detail4SlotINS1_11VariantDataEEC2EPS3_j: 21| 15.3k| Slot(T* p, SlotId id) : ptr_(p), id_(id) { 22| 15.3k| ARDUINOJSON_ASSERT((p == nullptr) == (id == NULL_SLOT)); ------------------ | | 11| 15.3k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 23| 15.3k| } _ZNK11ArduinoJson8V710HB426detail4SlotINS1_11VariantDataEEcvbEv: 25| 15.3k| explicit operator bool() const { 26| 15.3k| return ptr_ != nullptr; 27| 15.3k| } _ZNK11ArduinoJson8V710HB426detail4SlotINS1_11VariantDataEE2idEv: 29| 28.5k| SlotId id() const { 30| 28.5k| return id_; 31| 28.5k| } _ZNK11ArduinoJson8V710HB426detail4SlotINS1_11VariantDataEE3ptrEv: 33| 13.2k| T* ptr() const { 34| 13.2k| return ptr_; 35| 13.2k| } _ZNK11ArduinoJson8V710HB426detail4SlotINS1_11VariantDataEEptEv: 37| 4.21k| T* operator->() const { 38| 4.21k| ARDUINOJSON_ASSERT(ptr_ != nullptr); ------------------ | | 11| 4.21k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 39| 4.21k| return ptr_; 40| 4.21k| } _ZN11ArduinoJson8V710HB426detail10MemoryPoolINS1_15ResourceManager8SlotDataEE11shrinkToFitEPNS0_9AllocatorE: 83| 903| void shrinkToFit(Allocator* allocator) { 84| 903| auto newSlots = reinterpret_cast( 85| 903| allocator->reallocate(slots_, slotsToBytes(usage_))); 86| 903| if (newSlots) { ------------------ | Branch (86:9): [True: 903, False: 0] ------------------ 87| 903| slots_ = newSlots; 88| 903| capacity_ = usage_; 89| 903| } 90| 903| } _ZN11ArduinoJson8V710HB426detail14MemoryPoolListINS1_15ResourceManager8SlotDataEEC2Ev: 28| 1.46k| MemoryPoolList() = default; _ZN11ArduinoJson8V710HB426detail14MemoryPoolListINS1_15ResourceManager8SlotDataEE5clearEPNS0_9AllocatorE: 117| 2.92k| void clear(Allocator* allocator) { 118| 3.83k| for (PoolCount i = 0; i < count_; i++) ------------------ | Branch (118:27): [True: 903, False: 2.92k] ------------------ 119| 903| pools_[i].destroy(allocator); 120| 2.92k| count_ = 0; 121| 2.92k| freeList_ = NULL_SLOT; 122| 2.92k| if (pools_ != preallocatedPools_) { ------------------ | Branch (122:9): [True: 0, False: 2.92k] ------------------ 123| 0| allocator->deallocate(pools_); 124| 0| pools_ = preallocatedPools_; 125| 0| capacity_ = ARDUINOJSON_INITIAL_POOL_COUNT; ------------------ | | 124| 0|# define ARDUINOJSON_INITIAL_POOL_COUNT 4 ------------------ 126| 0| } 127| 2.92k| } _ZN11ArduinoJson8V710HB426detail14MemoryPoolListINS1_15ResourceManager8SlotDataEED2Ev: 30| 1.46k| ~MemoryPoolList() { 31| 1.46k| ARDUINOJSON_ASSERT(count_ == 0); ------------------ | | 11| 1.46k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 32| 1.46k| } _ZN11ArduinoJson8V710HB426detail14MemoryPoolListINS1_15ResourceManager8SlotDataEE9allocSlotEPNS0_9AllocatorE: 82| 15.6k| Slot allocSlot(Allocator* allocator) { 83| | // try to allocate from free list 84| 15.6k| if (freeList_ != NULL_SLOT) { ------------------ | Branch (84:9): [True: 0, False: 15.6k] ------------------ 85| 0| return allocFromFreeList(); 86| 0| } 87| | 88| | // try to allocate from last pool (other pools are full) 89| 15.6k| if (count_) { ------------------ | Branch (89:9): [True: 14.7k, False: 903] ------------------ 90| 14.7k| auto slot = allocFromLastPool(); 91| 14.7k| if (slot) ------------------ | Branch (91:11): [True: 14.7k, False: 0] ------------------ 92| 14.7k| return slot; 93| 14.7k| } 94| | 95| | // create a new pool and try again 96| 903| auto pool = addPool(allocator); 97| 903| if (!pool) ------------------ | Branch (97:9): [True: 0, False: 903] ------------------ 98| 0| return {}; 99| | 100| 903| return allocFromLastPool(); 101| 903| } _ZNK11ArduinoJson8V710HB426detail14MemoryPoolListINS1_15ResourceManager8SlotDataEE7getSlotEj: 108| 25.9k| T* getSlot(SlotId id) const { 109| 25.9k| if (id == NULL_SLOT) ------------------ | Branch (109:9): [True: 1.73k, False: 24.2k] ------------------ 110| 1.73k| return nullptr; 111| 24.2k| auto poolIndex = SlotId(id / ARDUINOJSON_POOL_CAPACITY); ------------------ | | 118| 24.2k|# define ARDUINOJSON_POOL_CAPACITY 256 // 4096 bytes ------------------ 112| 24.2k| auto indexInPool = SlotId(id % ARDUINOJSON_POOL_CAPACITY); ------------------ | | 118| 24.2k|# define ARDUINOJSON_POOL_CAPACITY 256 // 4096 bytes ------------------ 113| 24.2k| ARDUINOJSON_ASSERT(poolIndex < count_); ------------------ | | 11| 24.2k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 114| 24.2k| return pools_[poolIndex].getSlot(indexInPool); 115| 24.2k| } _ZN11ArduinoJson8V710HB426detail14MemoryPoolListINS1_15ResourceManager8SlotDataEE17allocFromLastPoolEv: 160| 15.6k| Slot allocFromLastPool() { 161| 15.6k| ARDUINOJSON_ASSERT(count_ > 0); ------------------ | | 11| 15.6k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 162| 15.6k| auto poolIndex = SlotId(count_ - 1); 163| 15.6k| auto slot = pools_[poolIndex].allocSlot(); 164| 15.6k| if (!slot) ------------------ | Branch (164:9): [True: 0, False: 15.6k] ------------------ 165| 0| return {}; 166| 15.6k| return {slot.ptr(), 167| 15.6k| SlotId(poolIndex * ARDUINOJSON_POOL_CAPACITY + slot.id())}; ------------------ | | 118| 15.6k|# define ARDUINOJSON_POOL_CAPACITY 256 // 4096 bytes ------------------ 168| 15.6k| } _ZN11ArduinoJson8V710HB426detail14MemoryPoolListINS1_15ResourceManager8SlotDataEE7addPoolEPNS0_9AllocatorE: 170| 903| Pool* addPool(Allocator* allocator) { 171| 903| if (count_ == capacity_ && !increaseCapacity(allocator)) ------------------ | Branch (171:9): [True: 0, False: 903] | Branch (171:32): [True: 0, False: 0] ------------------ 172| 0| return nullptr; 173| 903| auto pool = &pools_[count_++]; 174| 903| SlotCount poolCapacity = ARDUINOJSON_POOL_CAPACITY; ------------------ | | 118| 903|# define ARDUINOJSON_POOL_CAPACITY 256 // 4096 bytes ------------------ 175| 903| if (count_ == maxPools) // last pool is smaller because of NULL_SLOT ------------------ | Branch (175:9): [True: 0, False: 903] ------------------ 176| 0| poolCapacity--; 177| 903| pool->create(poolCapacity, allocator); 178| 903| return pool; 179| 903| } _ZN11ArduinoJson8V710HB426detail14MemoryPoolListINS1_15ResourceManager8SlotDataEE11shrinkToFitEPNS0_9AllocatorE: 140| 1.46k| void shrinkToFit(Allocator* allocator) { 141| 1.46k| if (count_ > 0) ------------------ | Branch (141:9): [True: 903, False: 561] ------------------ 142| 903| pools_[count_ - 1].shrinkToFit(allocator); 143| 1.46k| if (pools_ != preallocatedPools_ && count_ != capacity_) { ------------------ | Branch (143:9): [True: 0, False: 1.46k] | Branch (143:41): [True: 0, False: 0] ------------------ 144| 0| pools_ = static_cast( 145| 0| allocator->reallocate(pools_, count_ * sizeof(Pool))); 146| 0| ARDUINOJSON_ASSERT(pools_ != nullptr); // realloc to smaller can't fail ------------------ | | 11| 0|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 147| 0| capacity_ = count_; 148| 0| } 149| 1.46k| } _ZN11ArduinoJson8V710HB426detail15ResourceManagerC2EPNS0_9AllocatorE: 30| 1.46k| : allocator_(allocator), overflowed_(false) {} _ZN11ArduinoJson8V710HB426detail15ResourceManagerD2Ev: 32| 1.46k| ~ResourceManager() { 33| 1.46k| stringPool_.clear(allocator_); 34| 1.46k| variantPools_.clear(allocator_); 35| 1.46k| } _ZN11ArduinoJson8V710HB426detail15ResourceManager5clearEv: 112| 1.46k| void clear() { 113| 1.46k| variantPools_.clear(allocator_); 114| 1.46k| overflowed_ = false; 115| 1.46k| stringPool_.clear(allocator_); 116| 1.46k| } _ZN11ArduinoJson8V710HB426detail15ResourceManager13destroyStringEPNS1_10StringNodeE: 104| 662| void destroyString(StringNode* node) { 105| 662| StringNode::destroy(node, allocator_); 106| 662| } _ZN11ArduinoJson8V710HB426detail15ResourceManager12createStringEm: 90| 1.84k| StringNode* createString(size_t length) { 91| 1.84k| auto node = StringNode::create(length, allocator_); 92| 1.84k| if (!node) ------------------ | Branch (92:9): [True: 91, False: 1.75k] ------------------ 93| 91| overflowed_ = true; 94| 1.84k| return node; 95| 1.84k| } _ZNK11ArduinoJson8V710HB426detail15ResourceManager9getStringINS1_14SizedRamStringEEEPNS1_10StringNodeERKT_: 86| 5.88k| StringNode* getString(const TAdaptedString& str) const { 87| 5.88k| return stringPool_.get(str); 88| 5.88k| } _ZN11ArduinoJson8V710HB426detail15ResourceManager12resizeStringEPNS1_10StringNodeEm: 97| 68| StringNode* resizeString(StringNode* node, size_t length) { 98| 68| node = StringNode::resize(node, length, allocator_); 99| 68| if (!node) ------------------ | Branch (99:9): [True: 0, False: 68] ------------------ 100| 0| overflowed_ = true; 101| 68| return node; 102| 68| } _ZN11ArduinoJson8V710HB426detail15ResourceManager10saveStringEPNS1_10StringNodeE: 81| 1.09k| void saveString(StringNode* node) { 82| 1.09k| stringPool_.add(node); 83| 1.09k| } _ZN11ArduinoJson8V710HB426detail15ResourceManager11shrinkToFitEv: 118| 1.46k| void shrinkToFit() { 119| 1.46k| variantPools_.shrinkToFit(allocator_); 120| 1.46k| } _ZN11ArduinoJson8V710HB426detail15ResourceManager14allocExtensionEv: 33| 378|inline Slot ResourceManager::allocExtension() { 34| 378| auto p = variantPools_.allocSlot(allocator_); 35| 378| if (!p) { ------------------ | Branch (35:7): [True: 0, False: 378] ------------------ 36| 0| overflowed_ = true; 37| 0| return {}; 38| 0| } 39| 378| return {&p->extension, p.id()}; 40| 378|} _ZN11ArduinoJson8V710HB426detail15ResourceManager12allocVariantEv: 14| 15.3k|inline Slot ResourceManager::allocVariant() { 15| 15.3k| auto p = variantPools_.allocSlot(allocator_); 16| 15.3k| if (!p) { ------------------ | Branch (16:7): [True: 0, False: 15.3k] ------------------ 17| 0| overflowed_ = true; 18| 0| return {}; 19| 0| } 20| 15.3k| return {new (&p->variant) VariantData, p.id()}; 21| 15.3k|} _ZNK11ArduinoJson8V710HB426detail15ResourceManager10getVariantEj: 28| 25.6k|inline VariantData* ResourceManager::getVariant(SlotId id) const { 29| 25.6k| return reinterpret_cast(variantPools_.getSlot(id)); 30| 25.6k|} _ZNK11ArduinoJson8V710HB426detail15ResourceManager12getExtensionEj: 47| 255|inline VariantExtension* ResourceManager::getExtension(SlotId id) const { 48| 255| return &variantPools_.getSlot(id)->extension; 49| 255|} _ZN11ArduinoJson8V710HB426detail12StringBufferC2EPNS1_15ResourceManagerE: 13| 1.46k| StringBuffer(ResourceManager* resources) : resources_(resources) {} _ZN11ArduinoJson8V710HB426detail12StringBuffer7reserveEm: 20| 6.16k| char* reserve(size_t capacity) { 21| 6.16k| if (node_ && capacity > node_->length) { ------------------ | Branch (21:9): [True: 4.60k, False: 1.56k] | Branch (21:18): [True: 284, False: 4.31k] ------------------ 22| | // existing buffer is too small, we need to reallocate 23| 284| resources_->destroyString(node_); 24| 284| node_ = nullptr; 25| 284| } 26| 6.16k| if (!node_) ------------------ | Branch (26:9): [True: 1.84k, False: 4.31k] ------------------ 27| 1.84k| node_ = resources_->createString(capacity); 28| 6.16k| if (!node_) ------------------ | Branch (28:9): [True: 91, False: 6.07k] ------------------ 29| 91| return nullptr; 30| 6.07k| size_ = capacity; 31| 6.07k| node_->data[capacity] = 0; // null-terminate the string 32| 6.07k| return node_->data; 33| 6.16k| } _ZNK11ArduinoJson8V710HB426detail12StringBuffer3strEv: 55| 2.10k| JsonString str() const { 56| 2.10k| ARDUINOJSON_ASSERT(node_ != nullptr); ------------------ | | 11| 2.10k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 57| | 58| 2.10k| return JsonString(node_->data, node_->length, JsonString::Copied); 59| 2.10k| } _ZN11ArduinoJson8V710HB426detail12StringBuffer4saveEv: 35| 5.88k| StringNode* save() { 36| 5.88k| ARDUINOJSON_ASSERT(node_ != nullptr); ------------------ | | 11| 5.88k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 37| 5.88k| node_->data[size_] = 0; 38| 5.88k| auto node = resources_->getString(adaptString(node_->data, size_)); 39| 5.88k| if (node) { ------------------ | Branch (39:9): [True: 4.78k, False: 1.09k] ------------------ 40| 4.78k| node->references++; 41| 4.78k| return node; 42| 4.78k| } 43| | 44| 1.09k| if (node_->length != size_) { ------------------ | Branch (44:9): [True: 68, False: 1.02k] ------------------ 45| 68| node = resources_->resizeString(node_, size_); 46| 68| ARDUINOJSON_ASSERT(node != nullptr); // realloc to smaller can't fail ------------------ | | 11| 68|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 47| 1.02k| } else { 48| 1.02k| node = node_; 49| 1.02k| } 50| 1.09k| node_ = nullptr; 51| 1.09k| resources_->saveString(node); 52| 1.09k| return node; 53| 1.09k| } _ZN11ArduinoJson8V710HB426detail12StringBufferD2Ev: 15| 1.46k| ~StringBuffer() { 16| 1.46k| if (node_) ------------------ | Branch (16:9): [True: 378, False: 1.08k] ------------------ 17| 378| resources_->destroyString(node_); 18| 1.46k| } _ZN11ArduinoJson8V710HB426detail10StringNode7destroyEPS2_PNS0_9AllocatorE: 65| 1.75k| static void destroy(StringNode* node, Allocator* allocator) { 66| 1.75k| allocator->deallocate(node); 67| 1.75k| } _ZN11ArduinoJson8V710HB426detail10StringNode6createEmPNS0_9AllocatorE: 35| 1.84k| static StringNode* create(size_t length, Allocator* allocator) { 36| 1.84k| if (length > maxLength) ------------------ | Branch (36:9): [True: 91, False: 1.75k] ------------------ 37| 91| return nullptr; 38| 1.75k| auto size = sizeForLength(length); 39| 1.75k| if (size < length) // integer overflow ------------------ | Branch (39:9): [True: 0, False: 1.75k] ------------------ 40| 0| return nullptr; // (not testable on 64-bit) 41| 1.75k| auto node = reinterpret_cast(allocator->allocate(size)); 42| 1.75k| if (node) { ------------------ | Branch (42:9): [True: 1.75k, False: 0] ------------------ 43| 1.75k| node->length = length_type(length); 44| 1.75k| node->references = 1; 45| 1.75k| } 46| 1.75k| return node; 47| 1.75k| } _ZN11ArduinoJson8V710HB426detail10StringNode13sizeForLengthEm: 31| 1.82k| static constexpr size_t sizeForLength(size_t n) { 32| 1.82k| return n + 1 + offsetof(StringNode, data); 33| 1.82k| } _ZN11ArduinoJson8V710HB426detail10StringNode6resizeEPS2_mPNS0_9AllocatorE: 50| 68| Allocator* allocator) { 51| 68| ARDUINOJSON_ASSERT(node != nullptr); ------------------ | | 11| 68|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 52| 68| StringNode* newNode; 53| 68| if (length <= maxLength) ------------------ | Branch (53:9): [True: 68, False: 0] ------------------ 54| 68| newNode = reinterpret_cast( 55| 68| allocator->reallocate(node, sizeForLength(length))); 56| 0| else 57| 0| newNode = nullptr; 58| 68| if (newNode) ------------------ | Branch (58:9): [True: 68, False: 0] ------------------ 59| 68| newNode->length = length_type(length); 60| 0| else 61| 0| allocator->deallocate(node); 62| 68| return newNode; 63| 68| } _ZN11ArduinoJson8V710HB426detail10StringPoolC2Ev: 17| 1.46k| StringPool() = default; _ZN11ArduinoJson8V710HB426detail10StringPool5clearEPNS0_9AllocatorE: 29| 2.92k| void clear(Allocator* allocator) { 30| 4.02k| while (strings_) { ------------------ | Branch (30:12): [True: 1.09k, False: 2.92k] ------------------ 31| 1.09k| auto node = strings_; 32| 1.09k| strings_ = node->next; 33| 1.09k| StringNode::destroy(node, allocator); 34| 1.09k| } 35| 2.92k| } _ZN11ArduinoJson8V710HB426detail10StringPoolD2Ev: 21| 1.46k| ~StringPool() { 22| 1.46k| ARDUINOJSON_ASSERT(strings_ == nullptr); ------------------ | | 11| 1.46k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 23| 1.46k| } _ZNK11ArduinoJson8V710HB426detail10StringPool3getINS1_14SizedRamStringEEEPNS1_10StringNodeERKT_: 73| 5.88k| StringNode* get(const TAdaptedString& str) const { 74| 12.4k| for (auto node = strings_; node; node = node->next) { ------------------ | Branch (74:32): [True: 11.3k, False: 1.09k] ------------------ 75| 11.3k| if (stringEquals(str, adaptString(node->data, node->length))) ------------------ | Branch (75:11): [True: 4.78k, False: 6.54k] ------------------ 76| 4.78k| return node; 77| 11.3k| } 78| 1.09k| return nullptr; 79| 5.88k| } _ZN11ArduinoJson8V710HB426detail10StringPool3addEPNS1_10StringNodeE: 66| 1.09k| void add(StringNode* node) { 67| 1.09k| ARDUINOJSON_ASSERT(node != nullptr); ------------------ | | 11| 1.09k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 68| 1.09k| node->next = strings_; 69| 1.09k| strings_ = node; 70| 1.09k| } _ZNK11ArduinoJson8V710HB4215SerializedValueIPKcE4dataEv: 41| 82| TChar* data() const { 42| 82| return data_; 43| 82| } _ZNK11ArduinoJson8V710HB4215SerializedValueIPKcE4sizeEv: 45| 82| size_t size() const { 46| 82| return size_; 47| 82| } _ZN11ArduinoJson8V710HB4215SerializedValueIPKcEC2ES3_m: 36| 82| explicit SerializedValue(TChar* p, size_t n) : data_(p), size_(n) {} _ZN11ArduinoJson8V710HB4218deserializeMsgPackIRNS0_12JsonDocumentEKhJRmEEENS0_6detail9enable_ifIXsr6detail26is_deserialize_destinationIT_EE5valueENS0_20DeserializationErrorEE4typeEOS8_PT0_DpOT1_: 481| 1.46k|deserializeMsgPack(TDestination&& dst, TChar* input, Args&&... args) { 482| 1.46k| using namespace detail; 483| 1.46k| return deserialize(detail::forward(dst), 484| 1.46k| input, 485| 1.46k| detail::forward(args)...); 486| 1.46k|} _ZN11ArduinoJson8V710HB426detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEEEC2EPNS1_15ResourceManagerES6_: 24| 1.46k| foundSomething_(false) {} _ZN11ArduinoJson8V710HB426detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEEE5parseINS1_14AllowAllFilterEEENS0_20DeserializationErrorERNS1_11VariantDataET_NS0_21DeserializationOption12NestingLimitE: 28| 1.46k| DeserializationOption::NestingLimit nestingLimit) { 29| 1.46k| DeserializationError::Code err; 30| 1.46k| err = parseVariant(&variant, filter, nestingLimit); 31| 1.46k| return foundSomething_ ? err : DeserializationError::EmptyInput; ------------------ | Branch (31:12): [True: 1.46k, False: 0] ------------------ 32| 1.46k| } _ZN11ArduinoJson8V710HB426detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEEE12parseVariantINS1_14AllowAllFilterEEENS0_20DeserializationError4CodeEPNS1_11VariantDataET_NS0_21DeserializationOption12NestingLimitE: 38| 14.6k| DeserializationOption::NestingLimit nestingLimit) { 39| 14.6k| DeserializationError::Code err; 40| | 41| 14.6k| uint8_t header[5]; 42| 14.6k| err = readBytes(header, 1); 43| 14.6k| if (err) ------------------ | Branch (43:9): [True: 235, False: 14.4k] ------------------ 44| 235| return err; 45| | 46| 14.4k| const uint8_t& code = header[0]; 47| | 48| 14.4k| foundSomething_ = true; 49| | 50| 14.4k| bool allowValue = filter.allowValue(); 51| | 52| 14.4k| if (allowValue) { ------------------ | Branch (52:9): [True: 14.4k, False: 0] ------------------ 53| | // callers pass a null pointer only when value must be ignored 54| 14.4k| ARDUINOJSON_ASSERT(variant != 0); ------------------ | | 11| 14.4k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 55| 14.4k| } 56| | 57| 14.4k| if (code >= 0xcc && code <= 0xd3) { ------------------ | Branch (57:9): [True: 3.87k, False: 10.5k] | Branch (57:25): [True: 865, False: 3.01k] ------------------ 58| 865| auto width = uint8_t(1U << ((code - 0xcc) % 4)); 59| 865| if (allowValue) ------------------ | Branch (59:11): [True: 865, False: 0] ------------------ 60| 865| return readInteger(variant, width, code >= 0xd0); 61| 0| else 62| 0| return skipBytes(width); 63| 865| } 64| | 65| 13.5k| switch (code) { ------------------ | Branch (65:13): [True: 12.3k, False: 1.20k] ------------------ 66| 215| case 0xc0: ------------------ | Branch (66:7): [True: 215, False: 13.3k] ------------------ 67| | // already null 68| 215| return DeserializationError::Ok; 69| | 70| 3| case 0xc1: ------------------ | Branch (70:7): [True: 3, False: 13.5k] ------------------ 71| 3| return DeserializationError::InvalidInput; 72| | 73| 212| case 0xc2: ------------------ | Branch (73:7): [True: 212, False: 13.3k] ------------------ 74| 416| case 0xc3: ------------------ | Branch (74:7): [True: 204, False: 13.3k] ------------------ 75| 416| if (allowValue) ------------------ | Branch (75:13): [True: 416, False: 0] ------------------ 76| 416| variant->setBoolean(code == 0xc3); 77| 416| return DeserializationError::Ok; 78| | 79| 416| case 0xca: ------------------ | Branch (79:7): [True: 416, False: 13.1k] ------------------ 80| 416| if (allowValue) ------------------ | Branch (80:13): [True: 416, False: 0] ------------------ 81| 416| return readFloat(variant); 82| 0| else 83| 0| return skipBytes(4); 84| | 85| 150| case 0xcb: ------------------ | Branch (85:7): [True: 150, False: 13.4k] ------------------ 86| 150| if (allowValue) ------------------ | Branch (86:13): [True: 150, False: 0] ------------------ 87| 150| return readDouble(variant); 88| 0| else 89| 0| return skipBytes(8); 90| 13.5k| } 91| | 92| 12.3k| if (code <= 0x7f || code >= 0xe0) { // fixint ------------------ | Branch (92:9): [True: 2.59k, False: 9.77k] | Branch (92:25): [True: 1.37k, False: 8.39k] ------------------ 93| 3.97k| if (allowValue) ------------------ | Branch (93:11): [True: 3.97k, False: 0] ------------------ 94| 3.97k| variant->setInteger(static_cast(code), resources_); 95| 3.97k| return DeserializationError::Ok; 96| 3.97k| } 97| | 98| 8.39k| uint8_t sizeBytes = 0; 99| 8.39k| size_t size = 0; 100| 8.39k| bool isExtension = code >= 0xc7 && code <= 0xc9; ------------------ | Branch (100:24): [True: 1.90k, False: 6.49k] | Branch (100:40): [True: 273, False: 1.63k] ------------------ 101| | 102| 8.39k| switch (code) { ------------------ | Branch (102:13): [True: 6.01k, False: 2.38k] ------------------ 103| 455| case 0xc4: // bin 8 ------------------ | Branch (103:7): [True: 455, False: 7.94k] ------------------ 104| 573| case 0xc7: // ext 8 ------------------ | Branch (104:7): [True: 118, False: 8.28k] ------------------ 105| 940| case 0xd9: // str 8 ------------------ | Branch (105:7): [True: 367, False: 8.03k] ------------------ 106| 940| sizeBytes = 1; 107| 940| break; 108| | 109| 94| case 0xc5: // bin 16 ------------------ | Branch (109:7): [True: 94, False: 8.30k] ------------------ 110| 171| case 0xc8: // ext 16 ------------------ | Branch (110:7): [True: 77, False: 8.32k] ------------------ 111| 330| case 0xda: // str 16 ------------------ | Branch (111:7): [True: 159, False: 8.23k] ------------------ 112| 534| case 0xdc: // array 16 ------------------ | Branch (112:7): [True: 204, False: 8.19k] ------------------ 113| 699| case 0xde: // map 16 ------------------ | Branch (113:7): [True: 165, False: 8.23k] ------------------ 114| 699| sizeBytes = 2; 115| 699| break; 116| | 117| 105| case 0xc6: // bin 32 ------------------ | Branch (117:7): [True: 105, False: 8.29k] ------------------ 118| 183| case 0xc9: // ext 32 ------------------ | Branch (118:7): [True: 78, False: 8.32k] ------------------ 119| 384| case 0xdb: // str 32 ------------------ | Branch (119:7): [True: 201, False: 8.19k] ------------------ 120| 597| case 0xdd: // array 32 ------------------ | Branch (120:7): [True: 213, False: 8.18k] ------------------ 121| 746| case 0xdf: // map 32 ------------------ | Branch (121:7): [True: 149, False: 8.24k] ------------------ 122| 746| sizeBytes = 4; 123| 746| break; 124| 8.39k| } 125| | 126| 8.39k| if (code >= 0xd4 && code <= 0xd8) { // fixext ------------------ | Branch (126:9): [True: 1.63k, False: 6.76k] | Branch (126:25): [True: 173, False: 1.45k] ------------------ 127| 173| size = size_t(1) << (code - 0xd4); 128| 173| isExtension = true; 129| 173| } 130| | 131| 8.39k| switch (code & 0xf0) { ------------------ | Branch (131:13): [True: 4.83k, False: 3.56k] ------------------ 132| 2.67k| case 0x90: // fixarray ------------------ | Branch (132:7): [True: 2.67k, False: 5.72k] ------------------ 133| 3.56k| case 0x80: // fixmap ------------------ | Branch (133:7): [True: 884, False: 7.51k] ------------------ 134| 3.56k| size = code & 0x0F; 135| 3.56k| break; 136| 8.39k| } 137| | 138| 8.39k| switch (code & 0xe0) { ------------------ | Branch (138:13): [True: 6.12k, False: 2.27k] ------------------ 139| 2.27k| case 0xa0: // fixstr ------------------ | Branch (139:7): [True: 2.27k, False: 6.12k] ------------------ 140| 2.27k| size = code & 0x1f; 141| 2.27k| break; 142| 8.39k| } 143| | 144| 8.39k| if (sizeBytes) { ------------------ | Branch (144:9): [True: 2.38k, False: 6.01k] ------------------ 145| 2.38k| err = readBytes(header + 1, sizeBytes); 146| 2.38k| if (err) ------------------ | Branch (146:11): [True: 102, False: 2.28k] ------------------ 147| 102| return err; 148| | 149| 2.28k| uint32_t size32 = 0; 150| 7.34k| for (uint8_t i = 0; i < sizeBytes; i++) ------------------ | Branch (150:27): [True: 5.05k, False: 2.28k] ------------------ 151| 5.05k| size32 = (size32 << 8) | header[i + 1]; 152| | 153| 2.28k| size = size_t(size32); 154| 2.28k| if (size < size32) // integer overflow ------------------ | Branch (154:11): [True: 0, False: 2.28k] ------------------ 155| 0| return DeserializationError::NoMemory; // (not testable on 32/64-bit) 156| 2.28k| } 157| | 158| | // array 16, 32 and fixarray 159| 8.29k| if (code == 0xdc || code == 0xdd || (code & 0xf0) == 0x90) ------------------ | Branch (159:9): [True: 196, False: 8.10k] | Branch (159:25): [True: 201, False: 7.89k] | Branch (159:41): [True: 2.67k, False: 5.22k] ------------------ 160| 3.07k| return readArray(variant, size, filter, nestingLimit); 161| | 162| | // map 16, 32 and fixmap 163| 5.22k| if (code == 0xde || code == 0xdf || (code & 0xf0) == 0x80) ------------------ | Branch (163:9): [True: 157, False: 5.06k] | Branch (163:25): [True: 141, False: 4.92k] | Branch (163:41): [True: 884, False: 4.03k] ------------------ 164| 1.18k| return readObject(variant, size, filter, nestingLimit); 165| | 166| | // str 8, 16, 32 and fixstr 167| 4.03k| if (code == 0xd9 || code == 0xda || code == 0xdb || (code & 0xe0) == 0xa0) { ------------------ | Branch (167:9): [True: 358, False: 3.68k] | Branch (167:25): [True: 151, False: 3.53k] | Branch (167:41): [True: 194, False: 3.33k] | Branch (167:57): [True: 2.27k, False: 1.05k] ------------------ 168| 2.98k| if (allowValue) ------------------ | Branch (168:11): [True: 2.98k, False: 0] ------------------ 169| 2.98k| return readString(variant, size); 170| 0| else 171| 0| return skipBytes(size); 172| 2.98k| } 173| | 174| 1.05k| if (isExtension) ------------------ | Branch (174:9): [True: 425, False: 633] ------------------ 175| 425| size++; // to include the type 176| | 177| 1.05k| if (allowValue) ------------------ | Branch (177:9): [True: 1.05k, False: 0] ------------------ 178| 1.05k| return readRawString(variant, header, uint8_t(1 + sizeBytes), size); 179| 0| else 180| 0| return skipBytes(size); 181| 1.05k| } _ZN11ArduinoJson8V710HB426detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEEE9readBytesEPvm: 191| 24.5k| DeserializationError::Code readBytes(void* p, size_t n) { 192| 24.5k| if (reader_.readBytes(reinterpret_cast(p), n) == n) ------------------ | Branch (192:9): [True: 23.9k, False: 568] ------------------ 193| 23.9k| return DeserializationError::Ok; 194| 568| return DeserializationError::IncompleteInput; 195| 24.5k| } _ZN11ArduinoJson8V710HB426detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEEE11readIntegerEPNS1_11VariantDataEhb: 211| 865| bool isSigned) { 212| 865| uint8_t buffer[8]; 213| | 214| 865| auto err = readBytes(buffer, width); 215| 865| if (err) ------------------ | Branch (215:9): [True: 17, False: 848] ------------------ 216| 17| return err; 217| | 218| 848| union { 219| 848| int64_t signedValue; 220| 848| uint64_t unsignedValue; 221| 848| }; 222| | 223| 848| if (isSigned) ------------------ | Branch (223:9): [True: 441, False: 407] ------------------ 224| 441| signedValue = static_cast(buffer[0]); // propagate sign bit 225| 407| else 226| 407| unsignedValue = static_cast(buffer[0]); 227| | 228| 3.62k| for (uint8_t i = 1; i < width; i++) ------------------ | Branch (228:25): [True: 2.77k, False: 848] ------------------ 229| 2.77k| unsignedValue = (unsignedValue << 8) | buffer[i]; 230| | 231| 848| if (isSigned) { ------------------ | Branch (231:9): [True: 441, False: 407] ------------------ 232| 441| auto truncatedValue = static_cast(signedValue); 233| 441| if (truncatedValue == signedValue) { ------------------ | Branch (233:11): [True: 441, False: 0] ------------------ 234| 441| if (!variant->setInteger(truncatedValue, resources_)) ------------------ | Branch (234:13): [True: 0, False: 441] ------------------ 235| 0| return DeserializationError::NoMemory; 236| 441| } 237| | // else set null on overflow 238| 441| } else { 239| 407| auto truncatedValue = static_cast(unsignedValue); 240| 407| if (truncatedValue == unsignedValue) ------------------ | Branch (240:11): [True: 407, False: 0] ------------------ 241| 407| if (!variant->setInteger(truncatedValue, resources_)) ------------------ | Branch (241:13): [True: 0, False: 407] ------------------ 242| 0| return DeserializationError::NoMemory; 243| | // else set null on overflow 244| 407| } 245| | 246| 848| return DeserializationError::Ok; 247| 848| } _ZN11ArduinoJson8V710HB426detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEEE9readFloatIfEENS1_9enable_ifIXeqstT_Li4EENS0_20DeserializationError4CodeEE4typeEPNS1_11VariantDataE: 251| 416| VariantData* variant) { 252| 416| DeserializationError::Code err; 253| 416| T value; 254| | 255| 416| err = readBytes(value); 256| 416| if (err) ------------------ | Branch (256:9): [True: 8, False: 408] ------------------ 257| 8| return err; 258| | 259| 408| fixEndianness(value); 260| 408| variant->setFloat(value, resources_); 261| | 262| 408| return DeserializationError::Ok; 263| 416| } _ZN11ArduinoJson8V710HB426detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEEE9readBytesIfEENS0_20DeserializationError4CodeERT_: 198| 416| DeserializationError::Code readBytes(T& value) { 199| 416| return readBytes(&value, sizeof(value)); 200| 416| } _ZN11ArduinoJson8V710HB426detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEEE10readDoubleIdEENS1_9enable_ifIXeqstT_Li8EENS0_20DeserializationError4CodeEE4typeEPNS1_11VariantDataE: 267| 150| VariantData* variant) { 268| 150| DeserializationError::Code err; 269| 150| T value; 270| | 271| 150| err = readBytes(value); 272| 150| if (err) ------------------ | Branch (272:9): [True: 14, False: 136] ------------------ 273| 14| return err; 274| | 275| 136| fixEndianness(value); 276| 136| if (variant->setFloat(value, resources_)) ------------------ | Branch (276:9): [True: 136, False: 0] ------------------ 277| 136| return DeserializationError::Ok; 278| 0| else 279| 0| return DeserializationError::NoMemory; 280| 136| } _ZN11ArduinoJson8V710HB426detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEEE9readBytesIdEENS0_20DeserializationError4CodeERT_: 198| 150| DeserializationError::Code readBytes(T& value) { 199| 150| return readBytes(&value, sizeof(value)); 200| 150| } _ZN11ArduinoJson8V710HB426detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEEE9readArrayINS1_14AllowAllFilterEEENS0_20DeserializationError4CodeEPNS1_11VariantDataEmT_NS0_21DeserializationOption12NestingLimitE: 344| 3.07k| DeserializationOption::NestingLimit nestingLimit) { 345| 3.07k| DeserializationError::Code err; 346| | 347| 3.07k| if (nestingLimit.reached()) ------------------ | Branch (347:9): [True: 4, False: 3.07k] ------------------ 348| 4| return DeserializationError::TooDeep; 349| | 350| 3.07k| bool allowArray = filter.allowArray(); 351| | 352| 3.07k| ArrayData* array; 353| 3.07k| if (allowArray) { ------------------ | Branch (353:9): [True: 3.07k, False: 0] ------------------ 354| 3.07k| ARDUINOJSON_ASSERT(variant != 0); ------------------ | | 11| 3.07k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 355| 3.07k| array = &variant->toArray(); 356| 3.07k| } else { 357| 0| array = 0; 358| 0| } 359| | 360| 3.07k| TFilter elementFilter = filter[0U]; 361| | 362| 13.4k| for (; n; --n) { ------------------ | Branch (362:12): [True: 11.0k, False: 2.32k] ------------------ 363| 11.0k| VariantData* value; 364| | 365| 11.0k| if (elementFilter.allow()) { ------------------ | Branch (365:11): [True: 11.0k, False: 0] ------------------ 366| 11.0k| ARDUINOJSON_ASSERT(array != 0); ------------------ | | 11| 11.0k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 367| 11.0k| value = array->addElement(resources_); 368| 11.0k| if (!value) ------------------ | Branch (368:13): [True: 0, False: 11.0k] ------------------ 369| 0| return DeserializationError::NoMemory; 370| 11.0k| } else { 371| 0| value = 0; 372| 0| } 373| | 374| 11.0k| err = parseVariant(value, elementFilter, nestingLimit.decrement()); 375| 11.0k| if (err) ------------------ | Branch (375:11): [True: 743, False: 10.3k] ------------------ 376| 743| return err; 377| 11.0k| } 378| | 379| 2.32k| return DeserializationError::Ok; 380| 3.07k| } _ZN11ArduinoJson8V710HB426detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEEE10readObjectINS1_14AllowAllFilterEEENS0_20DeserializationError4CodeEPNS1_11VariantDataEmT_NS0_21DeserializationOption12NestingLimitE: 385| 1.18k| DeserializationOption::NestingLimit nestingLimit) { 386| 1.18k| DeserializationError::Code err; 387| | 388| 1.18k| if (nestingLimit.reached()) ------------------ | Branch (388:9): [True: 1, False: 1.18k] ------------------ 389| 1| return DeserializationError::TooDeep; 390| | 391| 1.18k| ObjectData* object; 392| 1.18k| if (filter.allowObject()) { ------------------ | Branch (392:9): [True: 1.18k, False: 0] ------------------ 393| 1.18k| ARDUINOJSON_ASSERT(variant != 0); ------------------ | | 11| 1.18k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 394| 1.18k| object = &variant->toObject(); 395| 1.18k| } else { 396| 0| object = 0; 397| 0| } 398| | 399| 3.16k| for (; n; --n) { ------------------ | Branch (399:12): [True: 2.22k, False: 945] ------------------ 400| 2.22k| err = readKey(); 401| 2.22k| if (err) ------------------ | Branch (401:11): [True: 116, False: 2.10k] ------------------ 402| 116| return err; 403| | 404| 2.10k| JsonString key = stringBuffer_.str(); 405| 2.10k| TFilter memberFilter = filter[key.c_str()]; 406| 2.10k| VariantData* member; 407| | 408| 2.10k| if (memberFilter.allow()) { ------------------ | Branch (408:11): [True: 2.10k, False: 0] ------------------ 409| 2.10k| ARDUINOJSON_ASSERT(object != 0); ------------------ | | 11| 2.10k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 410| | 411| | // Save key in memory pool. 412| 2.10k| auto savedKey = stringBuffer_.save(); 413| | 414| 2.10k| member = object->addMember(savedKey, resources_); 415| 2.10k| if (!member) ------------------ | Branch (415:13): [True: 0, False: 2.10k] ------------------ 416| 0| return DeserializationError::NoMemory; 417| 2.10k| } else { 418| 0| member = 0; 419| 0| } 420| | 421| 2.10k| err = parseVariant(member, memberFilter, nestingLimit.decrement()); 422| 2.10k| if (err) ------------------ | Branch (422:11): [True: 120, False: 1.98k] ------------------ 423| 120| return err; 424| 2.10k| } 425| | 426| 945| return DeserializationError::Ok; 427| 1.18k| } _ZN11ArduinoJson8V710HB426detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEEE7readKeyEv: 429| 2.22k| DeserializationError::Code readKey() { 430| 2.22k| DeserializationError::Code err; 431| 2.22k| uint8_t code; 432| | 433| 2.22k| err = readByte(code); 434| 2.22k| if (err) ------------------ | Branch (434:9): [True: 61, False: 2.16k] ------------------ 435| 61| return err; 436| | 437| 2.16k| if ((code & 0xe0) == 0xa0) ------------------ | Branch (437:9): [True: 1.94k, False: 216] ------------------ 438| 1.94k| return readString(code & 0x1f); 439| | 440| 216| if (code >= 0xd9 && code <= 0xdb) { ------------------ | Branch (440:9): [True: 203, False: 13] | Branch (440:25): [True: 196, False: 7] ------------------ 441| 196| uint8_t sizeBytes = uint8_t(1U << (code - 0xd9)); 442| 196| uint32_t size = 0; 443| 726| for (uint8_t i = 0; i < sizeBytes; i++) { ------------------ | Branch (443:27): [True: 543, False: 183] ------------------ 444| 543| err = readByte(code); 445| 543| if (err) ------------------ | Branch (445:13): [True: 13, False: 530] ------------------ 446| 13| return err; 447| 530| size = (size << 8) | code; 448| 530| } 449| 183| return readString(size); 450| 196| } 451| | 452| 20| return DeserializationError::InvalidInput; 453| 216| } _ZN11ArduinoJson8V710HB426detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEEE8readByteERh: 183| 2.76k| DeserializationError::Code readByte(uint8_t& value) { 184| 2.76k| int c = reader_.read(); 185| 2.76k| if (c < 0) ------------------ | Branch (185:9): [True: 74, False: 2.69k] ------------------ 186| 74| return DeserializationError::IncompleteInput; 187| 2.69k| value = static_cast(c); 188| 2.69k| return DeserializationError::Ok; 189| 2.76k| } _ZN11ArduinoJson8V710HB426detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEEE10readStringEm: 312| 5.11k| DeserializationError::Code readString(size_t n) { 313| 5.11k| char* p = stringBuffer_.reserve(n); 314| 5.11k| if (!p) ------------------ | Branch (314:9): [True: 39, False: 5.07k] ------------------ 315| 39| return DeserializationError::NoMemory; 316| | 317| 5.07k| return readBytes(p, n); 318| 5.11k| } _ZN11ArduinoJson8V710HB426detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEEE10readStringEPNS1_11VariantDataEm: 301| 2.98k| DeserializationError::Code readString(VariantData* variant, size_t n) { 302| 2.98k| DeserializationError::Code err; 303| | 304| 2.98k| err = readString(n); 305| 2.98k| if (err) ------------------ | Branch (305:9): [True: 112, False: 2.86k] ------------------ 306| 112| return err; 307| | 308| 2.86k| variant->setOwnedString(stringBuffer_.save()); 309| 2.86k| return DeserializationError::Ok; 310| 2.98k| } _ZN11ArduinoJson8V710HB426detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEEE13readRawStringEPNS1_11VariantDataEPKvhm: 322| 1.05k| uint8_t headerSize, size_t n) { 323| 1.05k| auto totalSize = size_t(headerSize + n); 324| 1.05k| if (totalSize < n) // integer overflow ------------------ | Branch (324:9): [True: 0, False: 1.05k] ------------------ 325| 0| return DeserializationError::NoMemory; // (not testable on 64-bit) 326| | 327| 1.05k| char* p = stringBuffer_.reserve(totalSize); 328| 1.05k| if (!p) ------------------ | Branch (328:9): [True: 52, False: 1.00k] ------------------ 329| 52| return DeserializationError::NoMemory; 330| | 331| 1.00k| memcpy(p, header, headerSize); 332| | 333| 1.00k| auto err = readBytes(p + headerSize, n); 334| 1.00k| if (err) ------------------ | Branch (334:9): [True: 97, False: 909] ------------------ 335| 97| return err; 336| | 337| 909| variant->setRawString(stringBuffer_.save()); 338| 909| return DeserializationError::Ok; 339| 1.00k| } _ZN11ArduinoJson8V710HB4216serializeMsgPackINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEENS0_6detail9enable_ifIXntsr6detail10is_pointerIT_EE5valueEmE4typeENS0_16JsonVariantConstERSB_: 223| 703|serializeMsgPack(JsonVariantConst source, TDestination& output) { 224| 703| using namespace ArduinoJson::detail; 225| 703| return serialize(source, output); 226| 703|} _ZN11ArduinoJson8V710HB426detail17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEEC2ESB_PKNS1_15ResourceManagerE: 23| 703| : writer_(writer), resources_(resources) {} _ZN11ArduinoJson8V710HB426detail17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE5visitIfEENS1_9enable_ifIXaasr17is_floating_pointIT_EE5valueeqstSF_Li4EEmE4typeESF_: 27| 367| T value32) { 28| 367| if (canConvertNumber(value32)) { ------------------ | Branch (28:9): [True: 301, False: 66] ------------------ 29| 301| JsonInteger truncatedValue = JsonInteger(value32); 30| 301| if (value32 == T(truncatedValue)) ------------------ | Branch (30:11): [True: 235, False: 66] ------------------ 31| 235| return visit(truncatedValue); 32| 301| } 33| 132| writeByte(0xCA); 34| 132| writeInteger(value32); 35| 132| return bytesWritten(); 36| 367| } _ZN11ArduinoJson8V710HB426detail17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE9writeByteEh: 197| 4.93k| void writeByte(uint8_t c) { 198| 4.93k| writer_.write(c); 199| 4.93k| } _ZN11ArduinoJson8V710HB426detail17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE12writeIntegerIfEEvT_: 206| 132| void writeInteger(T value) { 207| 132| fixEndianness(value); 208| 132| writeBytes(reinterpret_cast(&value), sizeof(value)); 209| 132| } _ZN11ArduinoJson8V710HB426detail17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE10writeBytesEPKhm: 201| 5.31k| void writeBytes(const uint8_t* p, size_t n) { 202| 5.31k| writer_.write(p, n); 203| 5.31k| } _ZNK11ArduinoJson8V710HB426detail17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE12bytesWrittenEv: 193| 8.48k| size_t bytesWritten() const { 194| 8.48k| return writer_.count(); 195| 8.48k| } _ZN11ArduinoJson8V710HB426detail17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE5visitIdEENS1_9enable_ifIXaasr17is_floating_pointIT_EE5valueeqstSF_Li8EEmE4typeESF_: 41| 43| T value64) { 42| 43| float value32 = float(value64); 43| 43| if (value32 == value64) ------------------ | Branch (43:9): [True: 0, False: 43] ------------------ 44| 0| return visit(value32); 45| 43| writeByte(0xCB); 46| 43| writeInteger(value64); 47| 43| return bytesWritten(); 48| 43| } _ZN11ArduinoJson8V710HB426detail17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE12writeIntegerIdEEvT_: 206| 43| void writeInteger(T value) { 207| 43| fixEndianness(value); 208| 43| writeBytes(reinterpret_cast(&value), sizeof(value)); 209| 43| } _ZN11ArduinoJson8V710HB426detail17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE5visitERKNS1_9ArrayDataE: 50| 1.34k| size_t visit(const ArrayData& array) { 51| 1.34k| size_t n = array.size(resources_); 52| 1.34k| if (n < 0x10) { ------------------ | Branch (52:9): [True: 1.30k, False: 37] ------------------ 53| 1.30k| writeByte(uint8_t(0x90 + n)); 54| 1.30k| } else if (n < 0x10000) { ------------------ | Branch (54:16): [True: 37, False: 0] ------------------ 55| 37| writeByte(0xDC); 56| 37| writeInteger(uint16_t(n)); 57| 37| } else { 58| 0| writeByte(0xDD); 59| 0| writeInteger(uint32_t(n)); 60| 0| } 61| | 62| 1.34k| auto slotId = array.head(); 63| 6.51k| while (slotId != NULL_SLOT) { ------------------ | Branch (63:12): [True: 5.17k, False: 1.34k] ------------------ 64| 5.17k| auto slot = resources_->getVariant(slotId); 65| 5.17k| slot->accept(*this, resources_); 66| 5.17k| slotId = slot->next(); 67| 5.17k| } 68| | 69| 1.34k| return bytesWritten(); 70| 1.34k| } _ZN11ArduinoJson8V710HB426detail17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE12writeIntegerItEEvT_: 206| 148| void writeInteger(T value) { 207| 148| fixEndianness(value); 208| 148| writeBytes(reinterpret_cast(&value), sizeof(value)); 209| 148| } _ZN11ArduinoJson8V710HB426detail17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE12writeIntegerIjEEvT_: 206| 141| void writeInteger(T value) { 207| 141| fixEndianness(value); 208| 141| writeBytes(reinterpret_cast(&value), sizeof(value)); 209| 141| } _ZN11ArduinoJson8V710HB426detail17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE5visitERKNS1_10ObjectDataE: 72| 394| size_t visit(const ObjectData& object) { 73| 394| size_t n = object.size(resources_); 74| 394| if (n < 0x10) { ------------------ | Branch (74:9): [True: 377, False: 17] ------------------ 75| 377| writeByte(uint8_t(0x80 + n)); 76| 377| } else if (n < 0x10000) { ------------------ | Branch (76:16): [True: 17, False: 0] ------------------ 77| 17| writeByte(0xDE); 78| 17| writeInteger(uint16_t(n)); 79| 17| } else { 80| 0| writeByte(0xDF); 81| 0| writeInteger(uint32_t(n)); 82| 0| } 83| | 84| 394| auto slotId = object.head(); 85| 1.90k| while (slotId != NULL_SLOT) { ------------------ | Branch (85:12): [True: 1.50k, False: 394] ------------------ 86| 1.50k| auto slot = resources_->getVariant(slotId); 87| 1.50k| slot->accept(*this, resources_); 88| 1.50k| slotId = slot->next(); 89| 1.50k| } 90| | 91| 394| return bytesWritten(); 92| 394| } _ZN11ArduinoJson8V710HB426detail17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE5visitENS0_10JsonStringE: 98| 1.61k| size_t visit(JsonString value) { 99| 1.61k| ARDUINOJSON_ASSERT(value != NULL); ------------------ | | 11| 1.61k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 100| | 101| 1.61k| auto n = value.size(); 102| | 103| 1.61k| if (n < 0x20) { ------------------ | Branch (103:9): [True: 1.59k, False: 24] ------------------ 104| 1.59k| writeByte(uint8_t(0xA0 + n)); 105| 1.59k| } else if (n < 0x100) { ------------------ | Branch (105:16): [True: 24, False: 0] ------------------ 106| 24| writeByte(0xD9); 107| 24| writeInteger(uint8_t(n)); 108| 24| } else if (n < 0x10000) { ------------------ | Branch (108:16): [True: 0, False: 0] ------------------ 109| 0| writeByte(0xDA); 110| 0| writeInteger(uint16_t(n)); 111| 0| } else { 112| 0| writeByte(0xDB); 113| 0| writeInteger(uint32_t(n)); 114| 0| } 115| 1.61k| writeBytes(reinterpret_cast(value.c_str()), n); 116| 1.61k| return bytesWritten(); 117| 1.61k| } _ZN11ArduinoJson8V710HB426detail17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE12writeIntegerIhEEvT_: 206| 1.06k| void writeInteger(T value) { 207| 1.06k| fixEndianness(value); 208| 1.06k| writeBytes(reinterpret_cast(&value), sizeof(value)); 209| 1.06k| } _ZN11ArduinoJson8V710HB426detail17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE5visitENS0_15SerializedValueIPKcEE: 119| 82| size_t visit(RawString value) { 120| 82| writeBytes(reinterpret_cast(value.data()), value.size()); 121| 82| return bytesWritten(); 122| 82| } _ZN11ArduinoJson8V710HB426detail17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE5visitEl: 124| 2.99k| size_t visit(JsonInteger value) { 125| 2.99k| if (value > 0) { ------------------ | Branch (125:9): [True: 1.09k, False: 1.89k] ------------------ 126| 1.09k| visit(static_cast(value)); 127| 1.89k| } else if (value >= -0x20) { ------------------ | Branch (127:16): [True: 1.39k, False: 500] ------------------ 128| 1.39k| writeInteger(int8_t(value)); 129| 1.39k| } else if (value >= -0x80) { ------------------ | Branch (129:16): [True: 75, False: 425] ------------------ 130| 75| writeByte(0xD0); 131| 75| writeInteger(int8_t(value)); 132| 425| } else if (value >= -0x8000) { ------------------ | Branch (132:16): [True: 89, False: 336] ------------------ 133| 89| writeByte(0xD1); 134| 89| writeInteger(int16_t(value)); 135| 89| } 136| 336|#if ARDUINOJSON_USE_LONG_LONG 137| 336| else if (value >= -0x80000000LL) ------------------ | Branch (137:14): [True: 108, False: 228] ------------------ 138| |#else 139| | else 140| |#endif 141| 108| { 142| 108| writeByte(0xD2); 143| 108| writeInteger(int32_t(value)); 144| 108| } 145| 228|#if ARDUINOJSON_USE_LONG_LONG 146| 228| else { 147| 228| writeByte(0xD3); 148| 228| writeInteger(int64_t(value)); 149| 228| } 150| 2.99k|#endif 151| 2.99k| return bytesWritten(); 152| 2.99k| } _ZN11ArduinoJson8V710HB426detail17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE12writeIntegerIaEEvT_: 206| 1.47k| void writeInteger(T value) { 207| 1.47k| fixEndianness(value); 208| 1.47k| writeBytes(reinterpret_cast(&value), sizeof(value)); 209| 1.47k| } _ZN11ArduinoJson8V710HB426detail17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE12writeIntegerIsEEvT_: 206| 89| void writeInteger(T value) { 207| 89| fixEndianness(value); 208| 89| writeBytes(reinterpret_cast(&value), sizeof(value)); 209| 89| } _ZN11ArduinoJson8V710HB426detail17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE12writeIntegerIiEEvT_: 206| 108| void writeInteger(T value) { 207| 108| fixEndianness(value); 208| 108| writeBytes(reinterpret_cast(&value), sizeof(value)); 209| 108| } _ZN11ArduinoJson8V710HB426detail17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE12writeIntegerIlEEvT_: 206| 228| void writeInteger(T value) { 207| 228| fixEndianness(value); 208| 228| writeBytes(reinterpret_cast(&value), sizeof(value)); 209| 228| } _ZN11ArduinoJson8V710HB426detail17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE5visitEm: 154| 1.46k| size_t visit(JsonUInt value) { 155| 1.46k| if (value <= 0x7F) { ------------------ | Branch (155:9): [True: 970, False: 492] ------------------ 156| 970| writeInteger(uint8_t(value)); 157| 970| } else if (value <= 0xFF) { ------------------ | Branch (157:16): [True: 74, False: 418] ------------------ 158| 74| writeByte(0xCC); 159| 74| writeInteger(uint8_t(value)); 160| 418| } else if (value <= 0xFFFF) { ------------------ | Branch (160:16): [True: 94, False: 324] ------------------ 161| 94| writeByte(0xCD); 162| 94| writeInteger(uint16_t(value)); 163| 94| } 164| 324|#if ARDUINOJSON_USE_LONG_LONG 165| 324| else if (value <= 0xFFFFFFFF) ------------------ | Branch (165:14): [True: 141, False: 183] ------------------ 166| |#else 167| | else 168| |#endif 169| 141| { 170| 141| writeByte(0xCE); 171| 141| writeInteger(uint32_t(value)); 172| 141| } 173| 183|#if ARDUINOJSON_USE_LONG_LONG 174| 183| else { 175| 183| writeByte(0xCF); 176| 183| writeInteger(uint64_t(value)); 177| 183| } 178| 1.46k|#endif 179| 1.46k| return bytesWritten(); 180| 1.46k| } _ZN11ArduinoJson8V710HB426detail17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE12writeIntegerImEEvT_: 206| 183| void writeInteger(T value) { 207| 183| fixEndianness(value); 208| 183| writeBytes(reinterpret_cast(&value), sizeof(value)); 209| 183| } _ZN11ArduinoJson8V710HB426detail17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE5visitEb: 182| 205| size_t visit(bool value) { 183| 205| writeByte(value ? 0xC3 : 0xC2); ------------------ | Branch (183:15): [True: 28, False: 177] ------------------ 184| 205| return bytesWritten(); 185| 205| } _ZN11ArduinoJson8V710HB426detail17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE5visitEDn: 187| 211| size_t visit(nullptr_t) { 188| 211| writeByte(0xC0); 189| 211| return bytesWritten(); 190| 211| } _ZN11ArduinoJson8V710HB426detail13fixEndiannessIfEEvRT_: 37| 540|inline void fixEndianness(T& value) { 38| 540| fixEndianness(reinterpret_cast(&value), 39| 540| integral_constant()); 40| 540|} _ZN11ArduinoJson8V710HB426detail13fixEndiannessEPhNS1_17integral_constantImLm4EEE: 25| 789|inline void fixEndianness(uint8_t* p, integral_constant) { 26| 789| swapBytes(p[0], p[3]); 27| 789| swapBytes(p[1], p[2]); 28| 789|} _ZN11ArduinoJson8V710HB426detail9swapBytesERhS2_: 12| 4.17k|inline void swapBytes(uint8_t& a, uint8_t& b) { 13| 4.17k| uint8_t t(a); 14| 4.17k| a = b; 15| 4.17k| b = t; 16| 4.17k|} _ZN11ArduinoJson8V710HB426detail13fixEndiannessIdEEvRT_: 37| 179|inline void fixEndianness(T& value) { 38| 179| fixEndianness(reinterpret_cast(&value), 39| 179| integral_constant()); 40| 179|} _ZN11ArduinoJson8V710HB426detail13fixEndiannessEPhNS1_17integral_constantImLm8EEE: 18| 590|inline void fixEndianness(uint8_t* p, integral_constant) { 19| 590| swapBytes(p[0], p[7]); 20| 590| swapBytes(p[1], p[6]); 21| 590| swapBytes(p[2], p[5]); 22| 590| swapBytes(p[3], p[4]); 23| 590|} _ZN11ArduinoJson8V710HB426detail13fixEndiannessItEEvRT_: 37| 148|inline void fixEndianness(T& value) { 38| 148| fixEndianness(reinterpret_cast(&value), 39| 148| integral_constant()); 40| 148|} _ZN11ArduinoJson8V710HB426detail13fixEndiannessEPhNS1_17integral_constantImLm2EEE: 30| 237|inline void fixEndianness(uint8_t* p, integral_constant) { 31| 237| swapBytes(p[0], p[1]); 32| 237|} _ZN11ArduinoJson8V710HB426detail13fixEndiannessIjEEvRT_: 37| 141|inline void fixEndianness(T& value) { 38| 141| fixEndianness(reinterpret_cast(&value), 39| 141| integral_constant()); 40| 141|} _ZN11ArduinoJson8V710HB426detail13fixEndiannessIhEEvRT_: 37| 1.06k|inline void fixEndianness(T& value) { 38| 1.06k| fixEndianness(reinterpret_cast(&value), 39| 1.06k| integral_constant()); 40| 1.06k|} _ZN11ArduinoJson8V710HB426detail13fixEndiannessEPhNS1_17integral_constantImLm1EEE: 34| 2.54k|inline void fixEndianness(uint8_t*, integral_constant) {} _ZN11ArduinoJson8V710HB426detail13fixEndiannessIaEEvRT_: 37| 1.47k|inline void fixEndianness(T& value) { 38| 1.47k| fixEndianness(reinterpret_cast(&value), 39| 1.47k| integral_constant()); 40| 1.47k|} _ZN11ArduinoJson8V710HB426detail13fixEndiannessIsEEvRT_: 37| 89|inline void fixEndianness(T& value) { 38| 89| fixEndianness(reinterpret_cast(&value), 39| 89| integral_constant()); 40| 89|} _ZN11ArduinoJson8V710HB426detail13fixEndiannessIiEEvRT_: 37| 108|inline void fixEndianness(T& value) { 38| 108| fixEndianness(reinterpret_cast(&value), 39| 108| integral_constant()); 40| 108|} _ZN11ArduinoJson8V710HB426detail13fixEndiannessIlEEvRT_: 37| 228|inline void fixEndianness(T& value) { 38| 228| fixEndianness(reinterpret_cast(&value), 39| 228| integral_constant()); 40| 228|} _ZN11ArduinoJson8V710HB426detail13fixEndiannessImEEvRT_: 37| 183|inline void fixEndianness(T& value) { 38| 183| fixEndianness(reinterpret_cast(&value), 39| 183| integral_constant()); 40| 183|} _ZN11ArduinoJson8V710HB426detail11FloatTraitsIfLm4EE11highest_forIlEEfPNS1_9enable_ifIXaaaasr11is_integralIT_EE5valuesr9is_signedIS6_EE5valueeqstS6_Li8EEiE4typeE: 178| 301| signed>* = 0) { 179| 301| return forge(0x5EFFFFFF); // 9.22337148709896192E18 180| 301| } _ZN11ArduinoJson8V710HB426detail11FloatTraitsIfLm4EE5forgeEj: 142| 301| static T forge(uint32_t bits) { 143| 301| return alias_cast(bits); 144| 301| } _ZN11ArduinoJson8V710HB426detail16canConvertNumberIilEENS1_9enable_ifIXaaaaaaaasr11is_integralIT0_EE5valuesr9is_signedIS4_EE5valuesr11is_integralIT_EE5valuesr9is_signedIS5_EE5valueltstS5_stS4_EbE4typeES4_: 55| 441|canConvertNumber(TIn value) { 56| 441| return value >= TIn(numeric_limits::lowest()) && ------------------ | Branch (56:10): [True: 315, False: 126] ------------------ 57| 441| value <= TIn(numeric_limits::highest()); ------------------ | Branch (57:10): [True: 300, False: 15] ------------------ 58| 441|} _ZN11ArduinoJson8V710HB426detail16canConvertNumberIjmEENS1_9enable_ifIXaaaaaasr11is_integralIT0_EE5valuesr11is_unsignedIS4_EE5valuesr11is_integralIT_EE5valuelestS5_stS4_EbE4typeES4_: 28| 407|canConvertNumber(TIn value) { 29| 407| return value <= TIn(numeric_limits::highest()); 30| 407|} _ZN11ArduinoJson8V710HB426detail16canConvertNumberIiaEENS1_9enable_ifIXaaaaaaaasr11is_integralIT0_EE5valuesr9is_signedIS4_EE5valuesr11is_integralIT_EE5valuesr9is_signedIS5_EE5valuelestS4_stS5_EbE4typeES4_: 67| 3.97k|canConvertNumber(TIn) { 68| 3.97k| return true; 69| 3.97k|} _ZN11ArduinoJson8V710HB426detail16canConvertNumberIlfEENS1_9enable_ifIXaaaasr17is_floating_pointIT0_EE5valuesr11is_integralIT_EE5valuegestS5_stS4_EbE4typeES4_: 117| 367|canConvertNumber(TIn value) { 118| | // Avoid error "9.22337e+18 is outside the range of representable values of 119| | // type 'long'" 120| 367| return value >= numeric_limits::lowest() && ------------------ | Branch (120:10): [True: 301, False: 66] ------------------ 121| 367| value <= FloatTraits::template highest_for(); ------------------ | Branch (121:10): [True: 301, False: 0] ------------------ 122| 367|} _ZNK11ArduinoJson8V710HB426detail10ObjectData4sizeEPKNS1_15ResourceManagerE: 53| 394| size_t size(const ResourceManager* resources) const { 54| 394| return CollectionData::size(resources) / 2; 55| 394| } _ZN11ArduinoJson8V710HB426detail10ObjectData9addMemberIPNS1_10StringNodeEEEPNS1_11VariantDataET_PNS1_15ResourceManagerE: 54| 2.10k| ResourceManager* resources) { 55| 2.10k| auto keySlot = resources->allocVariant(); 56| 2.10k| if (!keySlot) ------------------ | Branch (56:7): [True: 0, False: 2.10k] ------------------ 57| 0| return nullptr; 58| | 59| 2.10k| auto valueSlot = resources->allocVariant(); 60| 2.10k| if (!valueSlot) ------------------ | Branch (60:7): [True: 0, False: 2.10k] ------------------ 61| 0| return nullptr; 62| | 63| 2.10k| if (!keySlot->setString(key, resources)) ------------------ | Branch (63:7): [True: 0, False: 2.10k] ------------------ 64| 0| return nullptr; 65| | 66| 2.10k| CollectionData::appendPair(keySlot, valueSlot, resources); 67| | 68| 2.10k| return valueSlot.ptr(); 69| 2.10k|} _ZN11ArduinoJson8V710HB426detail10alias_castIfjEET_T0_: 24| 301|T alias_cast(F raw_data) { 25| 301| alias_cast_t ac; 26| 301| ac.raw = raw_data; 27| 301| return ac.data; 28| 301|} _ZN11ArduinoJson8V710HB426detail14numeric_limitsIivE6lowestEv: 33| 756| static constexpr T lowest() { 34| 756| return T(T(1) << (sizeof(T) * 8 - 1)); 35| 756| } _ZN11ArduinoJson8V710HB426detail14numeric_limitsIivE7highestEv: 36| 315| static constexpr T highest() { 37| 315| return T(~lowest()); 38| 315| } _ZN11ArduinoJson8V710HB426detail14numeric_limitsIjvE7highestEv: 25| 407| static constexpr T highest() { 26| 407| return T(-1); 27| 407| } _ZN11ArduinoJson8V710HB426detail14numeric_limitsIlvE6lowestEv: 33| 367| static constexpr T lowest() { 34| 367| return T(T(1) << (sizeof(T) * 8 - 1)); 35| 367| } _ZN11ArduinoJson8V710HB426detail7forwardIRNS0_12JsonDocumentEEEOT_RNS1_16remove_referenceIS5_E4typeE: 14| 1.46k|T&& forward(remove_reference_t& t) noexcept { 15| 1.46k| return static_cast(t); 16| 1.46k|} _ZN11ArduinoJson8V710HB426detail7forwardIRmEEOT_RNS1_16remove_referenceIS4_E4typeE: 14| 1.46k|T&& forward(remove_reference_t& t) noexcept { 15| 1.46k| return static_cast(t); 16| 1.46k|} _ZN11ArduinoJson8V710HB426detail17CountingDecoratorINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEEC2ERSB_: 14| 703| explicit CountingDecorator(TWriter& writer) : writer_(writer), count_(0) {} _ZN11ArduinoJson8V710HB426detail17CountingDecoratorINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE5writeEh: 16| 4.93k| void write(uint8_t c) { 17| 4.93k| count_ += writer_.write(c); 18| 4.93k| } _ZN11ArduinoJson8V710HB426detail17CountingDecoratorINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE5writeEPKhm: 20| 5.31k| void write(const uint8_t* s, size_t n) { 21| 5.31k| count_ += writer_.write(s, n); 22| 5.31k| } _ZNK11ArduinoJson8V710HB426detail17CountingDecoratorINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE5countEv: 24| 8.48k| size_t count() const { 25| 8.48k| return count_; 26| 8.48k| } _ZN11ArduinoJson8V710HB426detail6WriterINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEvEC2ERS9_: 24| 703| Writer(TDestination& str) : str_(&str) { 25| 703| str.clear(); 26| 703| } _ZN11ArduinoJson8V710HB426detail6WriterINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEvE5writeEh: 28| 4.93k| size_t write(uint8_t c) { 29| 4.93k| str_->push_back(static_cast(c)); 30| 4.93k| return 1; 31| 4.93k| } _ZN11ArduinoJson8V710HB426detail6WriterINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEvE5writeEPKhm: 33| 5.31k| size_t write(const uint8_t* s, size_t n) { 34| 5.31k| str_->append(reinterpret_cast(s), n); 35| 5.31k| return n; 36| 5.31k| } _ZN11ArduinoJson8V710HB426detail9serializeINS1_17MsgPackSerializerENSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEmNS0_16JsonVariantConstERT0_: 21| 703| TDestination& destination) { 22| 703| Writer writer(destination); 23| 703| return doSerialize(source, writer); 24| 703|} _ZN11ArduinoJson8V710HB426detail11doSerializeINS1_17MsgPackSerializerENS1_6WriterINSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEvEEEEmNS0_16JsonVariantConstET0_: 12| 703|size_t doSerialize(ArduinoJson::JsonVariantConst source, TWriter writer) { 13| 703| auto data = VariantAttorney::getData(source); 14| 703| auto resources = VariantAttorney::getResourceManager(source); 15| 703| TSerializer serializer(writer, resources); 16| 703| return VariantData::accept(data, resources, serializer); 17| 703|} _ZNK11ArduinoJson8V710HB426detail14SizedRamString6isNullEv: 106| 22.6k| bool isNull() const { 107| 22.6k| return !str_; 108| 22.6k| } _ZNK11ArduinoJson8V710HB426detail14SizedRamString4sizeEv: 110| 41.0k| size_t size() const { 111| 41.0k| return size_; 112| 41.0k| } _ZNK11ArduinoJson8V710HB426detail14SizedRamStringixEm: 114| 18.4k| char operator[](size_t i) const { 115| 18.4k| ARDUINOJSON_ASSERT(str_ != 0); ------------------ | | 11| 18.4k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 116| 18.4k| ARDUINOJSON_ASSERT(i <= size()); ------------------ | | 11| 18.4k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 117| 18.4k| return str_[i]; 118| 18.4k| } _ZN11ArduinoJson8V710HB426detail18SizedStringAdapterIPcvE5adaptEPKcm: 137| 17.2k| static AdaptedString adapt(const TChar* p, size_t n) { 138| 17.2k| return AdaptedString(reinterpret_cast(p), n); 139| 17.2k| } _ZN11ArduinoJson8V710HB426detail14SizedRamStringC2EPKcm: 104| 17.2k| SizedRamString(const char* str, size_t sz) : str_(str), size_(sz) {} _ZN11ArduinoJson8V710HB4210JsonStringC2EPKcmNS1_9OwnershipE: 25| 3.72k| : data_(data), size_(sz), ownership_(ownership) {} _ZNK11ArduinoJson8V710HB4210JsonString5c_strEv: 28| 3.72k| const char* c_str() const { 29| 3.72k| return data_; 30| 3.72k| } _ZN11ArduinoJson8V710HB42neENS0_10JsonStringES1_: 67| 1.61k| friend bool operator!=(JsonString lhs, JsonString rhs) { 68| 1.61k| return !(lhs == rhs); 69| 1.61k| } _ZN11ArduinoJson8V710HB42eqENS0_10JsonStringES1_: 54| 1.61k| friend bool operator==(JsonString lhs, JsonString rhs) { 55| 1.61k| if (lhs.size_ != rhs.size_) ------------------ | Branch (55:9): [True: 112, False: 1.50k] ------------------ 56| 112| return false; 57| 1.50k| if (lhs.data_ == rhs.data_) ------------------ | Branch (57:9): [True: 0, False: 1.50k] ------------------ 58| 0| return true; 59| 1.50k| if (!lhs.data_) ------------------ | Branch (59:9): [True: 0, False: 1.50k] ------------------ 60| 0| return false; 61| 1.50k| if (!rhs.data_) ------------------ | Branch (61:9): [True: 1.50k, False: 0] ------------------ 62| 1.50k| return false; 63| 0| return memcmp(lhs.data_, rhs.data_, lhs.size_) == 0; 64| 1.50k| } _ZNK11ArduinoJson8V710HB4210JsonString4sizeEv: 44| 1.61k| size_t size() const { 45| 1.61k| return size_; 46| 1.61k| } _ZN11ArduinoJson8V710HB4210JsonStringC2EPKcNS1_9OwnershipE: 22| 1.61k| : data_(data), size_(data ? ::strlen(data) : 0), ownership_(ownership) {} _ZN11ArduinoJson8V710HB426detail11adaptStringIcEENS1_18SizedStringAdapterIPT_vE13AdaptedStringES5_m: 27| 17.2k| size_t n) { 28| 17.2k| return SizedStringAdapter::adapt(p, n); 29| 17.2k|} _ZN11ArduinoJson8V710HB426detail12stringEqualsINS1_14SizedRamStringES3_EENS1_9enable_ifIXlesrT_11typeSortKeysrT0_11typeSortKeyEbE4typeES5_S6_: 45| 11.3k|stringEquals(TAdaptedString1 s1, TAdaptedString2 s2) { 46| 11.3k| ARDUINOJSON_ASSERT(!s1.isNull()); ------------------ | | 11| 11.3k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 47| 11.3k| ARDUINOJSON_ASSERT(!s2.isNull()); ------------------ | | 11| 11.3k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 48| 11.3k| size_t size1 = s1.size(); 49| 11.3k| size_t size2 = s2.size(); 50| 11.3k| if (size1 != size2) ------------------ | Branch (50:7): [True: 2.12k, False: 9.20k] ------------------ 51| 2.12k| return false; 52| 13.9k| for (size_t i = 0; i < size1; i++) { ------------------ | Branch (52:22): [True: 9.21k, False: 4.78k] ------------------ 53| 9.21k| if (s1[i] != s2[i]) ------------------ | Branch (53:9): [True: 4.42k, False: 4.79k] ------------------ 54| 4.42k| return false; 55| 9.21k| } 56| 4.78k| return true; 57| 9.20k|} _ZN11ArduinoJson8V710HB4216JsonVariantConstC2EPKNS0_6detail11VariantDataEPKNS2_15ResourceManagerE: 43| 703| : data_(data), resources_(resources) {} _ZNK11ArduinoJson8V710HB4216JsonVariantConst7getDataEv: 178| 703| const detail::VariantData* getData() const { 179| 703| return data_; 180| 703| } _ZNK11ArduinoJson8V710HB4216JsonVariantConst18getResourceManagerEv: 182| 703| const detail::ResourceManager* getResourceManager() const { 183| 703| return resources_; 184| 703| } _ZN11ArduinoJson8V710HB426detail15VariantAttorney15getOrCreateDataINS0_12JsonDocumentEEEPNS1_11VariantDataERT_: 30| 1.46k| static VariantData* getOrCreateData(TClient& client) { 31| 1.46k| return client.getOrCreateData(); 32| 1.46k| } _ZN11ArduinoJson8V710HB426detail15VariantAttorney18getResourceManagerINS0_12JsonDocumentEEEDTcldtfp_18getResourceManagerEERT_: 20| 1.46k| -> decltype(client.getResourceManager()) { 21| 1.46k| return client.getResourceManager(); 22| 1.46k| } _ZN11ArduinoJson8V710HB426detail15VariantAttorney7getDataINS0_16JsonVariantConstEEEDTcldtfp_7getDataEERT_: 25| 703| static auto getData(TClient& client) -> decltype(client.getData()) { 26| 703| return client.getData(); 27| 703| } _ZN11ArduinoJson8V710HB426detail15VariantAttorney18getResourceManagerINS0_16JsonVariantConstEEEDTcldtfp_18getResourceManagerEERT_: 20| 703| -> decltype(client.getResourceManager()) { 21| 703| return client.getResourceManager(); 22| 703| } _ZN11ArduinoJson8V710HB426detail14VariantContentC2Ev: 50| 16.7k| VariantContent() {} _ZN11ArduinoJson8V710HB426detailanENS1_11VariantTypeENS1_15VariantTypeBitsE: 45| 7.38k|inline bool operator&(VariantType type, VariantTypeBits bit) { 46| 7.38k| return (uint8_t(type) & uint8_t(bit)) != 0; 47| 7.38k|} _ZN11ArduinoJson8V710HB426detail11VariantDataC2Ev: 33| 16.7k| VariantData() : type_(VariantType::Null), next_(NULL_SLOT) {} _ZN11ArduinoJson8V710HB426detail11VariantData5resetEv: 429| 1.46k| void reset() { // TODO: remove 430| 1.46k| type_ = VariantType::Null; 431| 1.46k| } _ZN11ArduinoJson8V710HB426detail11VariantData10setBooleanEb: 433| 416| void setBoolean(bool value) { 434| 416| ARDUINOJSON_ASSERT(type_ == VariantType::Null); // must call clear() first ------------------ | | 11| 416|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 435| 416| type_ = VariantType::Boolean; 436| 416| content_.asBoolean = value; 437| 416| } _ZN11ArduinoJson8V710HB426detail11VariantData8setFloatIfEENS1_9enable_ifIXeqstT_Li4EEbE4typeES5_PNS1_15ResourceManagerE: 440| 408| enable_if_t setFloat(T value, ResourceManager*) { 441| 408| ARDUINOJSON_ASSERT(type_ == VariantType::Null); // must call clear() first ------------------ | | 11| 408|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 442| 408| type_ = VariantType::Float; 443| 408| content_.asFloat = value; 444| 408| return true; 445| 408| } _ZN11ArduinoJson8V710HB426detail11VariantData7toArrayEv: 522| 3.07k| ArrayData& toArray() { 523| 3.07k| ARDUINOJSON_ASSERT(type_ == VariantType::Null); // must call clear() first ------------------ | | 11| 3.07k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 524| 3.07k| type_ = VariantType::Array; 525| 3.07k| new (&content_.asArray) ArrayData(); 526| 3.07k| return content_.asArray; 527| 3.07k| } _ZN11ArduinoJson8V710HB426detail11VariantDatanwEmPv: 27| 15.3k| static void* operator new(size_t, void* p) noexcept { 28| 15.3k| return p; 29| 15.3k| } _ZN11ArduinoJson8V710HB426detail11VariantData7setNextEj: 39| 12.7k| void setNext(SlotId slot) { 40| 12.7k| next_ = slot; 41| 12.7k| } _ZN11ArduinoJson8V710HB426detail11VariantData8toObjectEv: 536| 1.18k| ObjectData& toObject() { 537| 1.18k| ARDUINOJSON_ASSERT(type_ == VariantType::Null); // must call clear() first ------------------ | | 11| 1.18k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 538| 1.18k| type_ = VariantType::Object; 539| 1.18k| new (&content_.asObject) ObjectData(); 540| 1.18k| return content_.asObject; 541| 1.18k| } _ZN11ArduinoJson8V710HB426detail11VariantData9setStringEPNS1_10StringNodeEPNS1_15ResourceManagerE: 480| 2.10k| bool setString(StringNode* s, ResourceManager*) { 481| 2.10k| setOwnedString(s); 482| 2.10k| return true; 483| 2.10k| } _ZN11ArduinoJson8V710HB426detail11VariantData14setOwnedStringEPNS1_10StringNodeE: 501| 4.97k| void setOwnedString(StringNode* s) { 502| 4.97k| ARDUINOJSON_ASSERT(type_ == VariantType::Null); // must call clear() first ------------------ | | 11| 4.97k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 503| 4.97k| ARDUINOJSON_ASSERT(s); ------------------ | | 11| 4.97k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 504| 4.97k| type_ = VariantType::OwnedString; 505| 4.97k| content_.asOwnedString = s; 506| 4.97k| } _ZN11ArduinoJson8V710HB426detail11VariantData12setRawStringEPNS1_10StringNodeE: 458| 909| void setRawString(StringNode* s) { 459| 909| ARDUINOJSON_ASSERT(type_ == VariantType::Null); // must call clear() first ------------------ | | 11| 909|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 460| 909| ARDUINOJSON_ASSERT(s); ------------------ | | 11| 909|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 461| 909| type_ = VariantType::RawString; 462| 909| content_.asOwnedString = s; 463| 909| } _ZN11ArduinoJson8V710HB426detail11VariantData6acceptINS1_17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEvEEEEEENT_11result_typeEPKS2_PKNS1_15ResourceManagerERSF_: 103| 703| TVisitor& visit) { 104| 703| if (var != 0) ------------------ | Branch (104:9): [True: 703, False: 0] ------------------ 105| 703| return var->accept(visit, resources); 106| 0| else 107| 0| return visit.visit(nullptr); 108| 703| } _ZNK11ArduinoJson8V710HB426detail11VariantData6acceptINS1_17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEvEEEEEENT_11result_typeERSF_PKNS1_15ResourceManagerE: 45| 7.38k| TVisitor& visit, const ResourceManager* resources) const { 46| 7.38k|#if ARDUINOJSON_USE_EXTENSIONS 47| 7.38k| auto extension = getExtension(resources); 48| |#else 49| | (void)resources; // silence warning 50| |#endif 51| 7.38k| switch (type_) { 52| 367| case VariantType::Float: ------------------ | Branch (52:7): [True: 367, False: 7.01k] ------------------ 53| 367| return visit.visit(content_.asFloat); 54| | 55| 0|#if ARDUINOJSON_USE_DOUBLE 56| 43| case VariantType::Double: ------------------ | Branch (56:7): [True: 43, False: 7.34k] ------------------ 57| 43| return visit.visit(extension->asDouble); 58| 0|#endif 59| | 60| 1.34k| case VariantType::Array: ------------------ | Branch (60:7): [True: 1.34k, False: 6.04k] ------------------ 61| 1.34k| return visit.visit(content_.asArray); 62| | 63| 394| case VariantType::Object: ------------------ | Branch (63:7): [True: 394, False: 6.99k] ------------------ 64| 394| return visit.visit(content_.asObject); 65| | 66| 0| case VariantType::LinkedString: ------------------ | Branch (66:7): [True: 0, False: 7.38k] ------------------ 67| 0| return visit.visit(JsonString(content_.asLinkedString)); 68| | 69| 1.61k| case VariantType::OwnedString: ------------------ | Branch (69:7): [True: 1.61k, False: 5.76k] ------------------ 70| 1.61k| return visit.visit(JsonString(content_.asOwnedString->data, 71| 1.61k| content_.asOwnedString->length, 72| 1.61k| JsonString::Copied)); 73| | 74| 82| case VariantType::RawString: ------------------ | Branch (74:7): [True: 82, False: 7.30k] ------------------ 75| 82| return visit.visit(RawString(content_.asOwnedString->data, 76| 82| content_.asOwnedString->length)); 77| | 78| 2.65k| case VariantType::Int32: ------------------ | Branch (78:7): [True: 2.65k, False: 4.73k] ------------------ 79| 2.65k| return visit.visit(static_cast(content_.asInt32)); 80| | 81| 260| case VariantType::Uint32: ------------------ | Branch (81:7): [True: 260, False: 7.12k] ------------------ 82| 260| return visit.visit(static_cast(content_.asUint32)); 83| | 84| 0|#if ARDUINOJSON_USE_LONG_LONG 85| 109| case VariantType::Int64: ------------------ | Branch (85:7): [True: 109, False: 7.27k] ------------------ 86| 109| return visit.visit(extension->asInt64); 87| | 88| 103| case VariantType::Uint64: ------------------ | Branch (88:7): [True: 103, False: 7.28k] ------------------ 89| 103| return visit.visit(extension->asUint64); 90| 0|#endif 91| | 92| 205| case VariantType::Boolean: ------------------ | Branch (92:7): [True: 205, False: 7.17k] ------------------ 93| 205| return visit.visit(content_.asBoolean != 0); 94| | 95| 211| default: ------------------ | Branch (95:7): [True: 211, False: 7.17k] ------------------ 96| 211| return visit.visit(nullptr); 97| 7.38k| } 98| 7.38k| } _ZNK11ArduinoJson8V710HB426detail11VariantData4nextEv: 35| 13.3k| SlotId next() const { 36| 13.3k| return next_; 37| 13.3k| } _ZN11ArduinoJson8V710HB426detail11VariantData10setIntegerIlEENS1_9enable_ifIXsr9is_signedIT_EE5valueEbE4typeES5_PNS1_15ResourceManagerE: 97| 441| T value, ResourceManager* resources) { 98| 441| ARDUINOJSON_ASSERT(type_ == VariantType::Null); // must call clear() first ------------------ | | 11| 441|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 99| 441| (void)resources; // silence warning 100| | 101| 441| if (canConvertNumber(value)) { ------------------ | Branch (101:7): [True: 300, False: 141] ------------------ 102| 300| type_ = VariantType::Int32; 103| 300| content_.asInt32 = static_cast(value); 104| 300| } 105| 141|#if ARDUINOJSON_USE_LONG_LONG 106| 141| else { 107| 141| auto extension = resources->allocExtension(); 108| 141| if (!extension) ------------------ | Branch (108:9): [True: 0, False: 141] ------------------ 109| 0| return false; 110| 141| type_ = VariantType::Int64; 111| 141| content_.asSlotId = extension.id(); 112| 141| extension->asInt64 = value; 113| 141| } 114| 441|#endif 115| 441| return true; 116| 441|} _ZN11ArduinoJson8V710HB426detail11VariantData10setIntegerImEENS1_9enable_ifIXsr11is_unsignedIT_EE5valueEbE4typeES5_PNS1_15ResourceManagerE: 120| 407| T value, ResourceManager* resources) { 121| 407| ARDUINOJSON_ASSERT(type_ == VariantType::Null); // must call clear() first ------------------ | | 11| 407|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 122| 407| (void)resources; // silence warning 123| | 124| 407| if (canConvertNumber(value)) { ------------------ | Branch (124:7): [True: 272, False: 135] ------------------ 125| 272| type_ = VariantType::Uint32; 126| 272| content_.asUint32 = static_cast(value); 127| 272| } 128| 135|#if ARDUINOJSON_USE_LONG_LONG 129| 135| else { 130| 135| auto extension = resources->allocExtension(); 131| 135| if (!extension) ------------------ | Branch (131:9): [True: 0, False: 135] ------------------ 132| 0| return false; 133| 135| type_ = VariantType::Uint64; 134| 135| content_.asSlotId = extension.id(); 135| 135| extension->asUint64 = value; 136| 135| } 137| 407|#endif 138| 407| return true; 139| 407|} _ZN11ArduinoJson8V710HB426detail11VariantData8setFloatIdEENS1_9enable_ifIXeqstT_Li8EEbE4typeES5_PNS1_15ResourceManagerE: 70| 136| T value, ResourceManager* resources) { 71| 136| ARDUINOJSON_ASSERT(type_ == VariantType::Null); // must call clear() first ------------------ | | 11| 136|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 72| 136| (void)resources; // silence warning 73| | 74| 136| float valueAsFloat = static_cast(value); 75| | 76| 136|#if ARDUINOJSON_USE_DOUBLE 77| 136| if (value == valueAsFloat) { ------------------ | Branch (77:7): [True: 34, False: 102] ------------------ 78| 34| type_ = VariantType::Float; 79| 34| content_.asFloat = valueAsFloat; 80| 102| } else { 81| 102| auto extension = resources->allocExtension(); 82| 102| if (!extension) ------------------ | Branch (82:9): [True: 0, False: 102] ------------------ 83| 0| return false; 84| 102| type_ = VariantType::Double; 85| 102| content_.asSlotId = extension.id(); 86| 102| extension->asDouble = value; 87| 102| } 88| |#else 89| | type_ = VariantType::Float; 90| | content_.asFloat = valueAsFloat; 91| |#endif 92| 136| return true; 93| 136|} _ZN11ArduinoJson8V710HB426detail11VariantData10setIntegerIaEENS1_9enable_ifIXsr9is_signedIT_EE5valueEbE4typeES5_PNS1_15ResourceManagerE: 97| 3.97k| T value, ResourceManager* resources) { 98| 3.97k| ARDUINOJSON_ASSERT(type_ == VariantType::Null); // must call clear() first ------------------ | | 11| 3.97k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 99| 3.97k| (void)resources; // silence warning 100| | 101| 3.97k| if (canConvertNumber(value)) { ------------------ | Branch (101:7): [True: 3.97k, False: 0] ------------------ 102| 3.97k| type_ = VariantType::Int32; 103| 3.97k| content_.asInt32 = static_cast(value); 104| 3.97k| } 105| 0|#if ARDUINOJSON_USE_LONG_LONG 106| 0| else { 107| 0| auto extension = resources->allocExtension(); 108| 0| if (!extension) ------------------ | Branch (108:9): [True: 0, False: 0] ------------------ 109| 0| return false; 110| 0| type_ = VariantType::Int64; 111| 0| content_.asSlotId = extension.id(); 112| 0| extension->asInt64 = value; 113| 0| } 114| 3.97k|#endif 115| 3.97k| return true; 116| 3.97k|} _ZNK11ArduinoJson8V710HB426detail11VariantData12getExtensionEPKNS1_15ResourceManagerE: 61| 7.38k| const ResourceManager* resources) const { 62| 7.38k| return type_ & VariantTypeBits::ExtensionBit ------------------ | Branch (62:10): [True: 255, False: 7.12k] ------------------ 63| 7.38k| ? resources->getExtension(content_.asSlotId) 64| 7.38k| : nullptr; 65| 7.38k|}