LLVMFuzzerTestOneInput: 3| 1.41k|extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) { 4| 1.41k| JsonDocument doc; 5| 1.41k| DeserializationError error = deserializeMsgPack(doc, data, size); 6| 1.41k| if (!error) { ------------------ | Branch (6:7): [True: 669, False: 749] ------------------ 7| 669| std::string json; 8| 669| serializeMsgPack(doc, json); 9| 669| } 10| 1.41k| return 0; 11| 1.41k|} _ZN11ArduinoJson8V740HB426detail9ArrayData10addElementEPNS1_15ResourceManagerE: 23| 10.7k|inline VariantData* ArrayData::addElement(ResourceManager* resources) { 24| 10.7k| auto slot = resources->allocVariant(); 25| 10.7k| if (!slot) ------------------ | Branch (25:7): [True: 0, False: 10.7k] ------------------ 26| 0| return nullptr; 27| 10.7k| CollectionData::appendOne(slot, resources); 28| 10.7k| return slot.ptr(); 29| 10.7k|} _ZN11ArduinoJson8V740HB426detail14CollectionDatanwEmPv: 74| 4.33k| static void* operator new(size_t, void* p) noexcept { 75| 4.33k| return p; 76| 4.33k| } _ZNK11ArduinoJson8V740HB426detail18CollectionIterator4doneEv: 26| 8.35k| bool done() const { 27| 8.35k| return slot_ == nullptr; 28| 8.35k| } _ZNK11ArduinoJson8V740HB426detail14CollectionData4headEv: 95| 1.89k| SlotId head() const { 96| 1.89k| return head_; 97| 1.89k| } _ZN11ArduinoJson8V740HB426detail14CollectionData9appendOneENS1_4SlotINS1_11VariantDataEEEPKNS1_15ResourceManagerE: 34| 10.7k| const ResourceManager* resources) { 35| 10.7k| if (tail_ != NULL_SLOT) { ------------------ | Branch (35:7): [True: 8.74k, False: 2.00k] ------------------ 36| 8.74k| auto tail = resources->getVariant(tail_); 37| 8.74k| tail->setNext(slot.id()); 38| 8.74k| tail_ = slot.id(); 39| 8.74k| } else { 40| 2.00k| head_ = slot.id(); 41| 2.00k| tail_ = slot.id(); 42| 2.00k| } 43| 10.7k|} _ZN11ArduinoJson8V740HB426detail14CollectionData10appendPairENS1_4SlotINS1_11VariantDataEEES5_PKNS1_15ResourceManagerE: 47| 2.01k| const ResourceManager* resources) { 48| 2.01k| key->setNext(value.id()); 49| | 50| 2.01k| if (tail_ != NULL_SLOT) { ------------------ | Branch (50:7): [True: 1.46k, False: 549] ------------------ 51| 1.46k| auto tail = resources->getVariant(tail_); 52| 1.46k| tail->setNext(key.id()); 53| 1.46k| tail_ = value.id(); 54| 1.46k| } else { 55| 549| head_ = key.id(); 56| 549| tail_ = value.id(); 57| 549| } 58| 2.01k|} _ZNK11ArduinoJson8V740HB426detail14CollectionData4sizeEPKNS1_15ResourceManagerE: 130| 1.89k|inline size_t CollectionData::size(const ResourceManager* resources) const { 131| 1.89k| size_t count = 0; 132| 8.35k| for (auto it = createIterator(resources); !it.done(); it.next(resources)) ------------------ | Branch (132:45): [True: 6.45k, False: 1.89k] ------------------ 133| 6.45k| count++; 134| 1.89k| return count; 135| 1.89k|} _ZNK11ArduinoJson8V740HB426detail14CollectionData14createIteratorEPKNS1_15ResourceManagerE: 29| 1.89k| const ResourceManager* resources) const { 30| 1.89k| return iterator(resources->getVariant(head_), head_); 31| 1.89k|} _ZN11ArduinoJson8V740HB426detail18CollectionIteratorC2EPNS1_11VariantDataEj: 16| 1.89k| : slot_(slot), currentId_(slotId) { 17| 1.89k| nextId_ = slot_ ? slot_->next() : NULL_SLOT; ------------------ | Branch (17:13): [True: 958, False: 941] ------------------ 18| 1.89k|} _ZN11ArduinoJson8V740HB426detail18CollectionIterator4nextEPKNS1_15ResourceManagerE: 20| 6.45k|inline void CollectionIterator::next(const ResourceManager* resources) { 21| 6.45k| ARDUINOJSON_ASSERT(currentId_ != NULL_SLOT); ------------------ | | 11| 6.45k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 22| 6.45k| slot_ = resources->getVariant(nextId_); 23| 6.45k| currentId_ = nextId_; 24| 6.45k| if (slot_) ------------------ | Branch (24:7): [True: 5.49k, False: 958] ------------------ 25| 5.49k| nextId_ = slot_->next(); 26| 6.45k|} _ZNK11ArduinoJson8V740HB4220DeserializationErrorcvbEv: 56| 1.41k| explicit operator bool() const { 57| 1.41k| return code_ != Ok; 58| 1.41k| } _ZN11ArduinoJson8V740HB4220DeserializationErrorC2ENS1_4CodeE: 29| 1.41k| DeserializationError(Code c) : code_(c) {} _ZN11ArduinoJson8V740HB426detail26makeDeserializationOptionsENS0_21DeserializationOption12NestingLimitE: 31| 1.41k| DeserializationOption::NestingLimit nestingLimit = {}) { 32| 1.41k| return {{}, nestingLimit}; 33| 1.41k|} _ZNK11ArduinoJson8V740HB426detail14AllowAllFilter10allowValueEv: 66| 13.9k| bool allowValue() const { 67| 13.9k| return true; 68| 13.9k| } _ZNK11ArduinoJson8V740HB426detail14AllowAllFilter10allowArrayEv: 58| 3.18k| bool allowArray() const { 59| 3.18k| return true; 60| 3.18k| } _ZNK11ArduinoJson8V740HB426detail14AllowAllFilterixIjEES2_RKT_: 71| 3.18k| AllowAllFilter operator[](const TKey&) const { 72| 3.18k| return AllowAllFilter(); 73| 3.18k| } _ZNK11ArduinoJson8V740HB426detail14AllowAllFilter5allowEv: 54| 12.7k| bool allow() const { 55| 12.7k| return true; 56| 12.7k| } _ZNK11ArduinoJson8V740HB426detail14AllowAllFilter11allowObjectEv: 62| 1.14k| bool allowObject() const { 63| 1.14k| return true; 64| 1.14k| } _ZNK11ArduinoJson8V740HB426detail14AllowAllFilterixIPKcEES2_RKT_: 71| 2.01k| AllowAllFilter operator[](const TKey&) const { 72| 2.01k| return AllowAllFilter(); 73| 2.01k| } _ZNK11ArduinoJson8V740HB4221DeserializationOption12NestingLimit7reachedEv: 23| 4.33k| bool reached() const { 24| 4.33k| return value_ == 0; 25| 4.33k| } _ZNK11ArduinoJson8V740HB4221DeserializationOption12NestingLimit9decrementEv: 18| 12.7k| NestingLimit decrement() const { 19| 12.7k| ARDUINOJSON_ASSERT(value_ > 0); ------------------ | | 11| 12.7k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 20| 12.7k| return NestingLimit(static_cast(value_ - 1)); 21| 12.7k| } _ZN11ArduinoJson8V740HB4221DeserializationOption12NestingLimitC2Eh: 16| 12.7k| explicit NestingLimit(uint8_t n) : value_(n) {} _ZN11ArduinoJson8V740HB4221DeserializationOption12NestingLimitC2Ev: 15| 1.41k| NestingLimit() : value_(ARDUINOJSON_DEFAULT_NESTING_LIMIT) {} ------------------ | | 93| 1.41k|# define ARDUINOJSON_DEFAULT_NESTING_LIMIT 10 ------------------ _ZN11ArduinoJson8V740HB426detail10makeReaderIKhEENS1_13BoundedReaderIPT_vEES6_m: 70| 1.41k|BoundedReader makeReader(TChar* input, size_t inputSize) { 71| 1.41k| return BoundedReader{input, inputSize}; 72| 1.41k|} _ZN11ArduinoJson8V740HB426detail14IteratorReaderIPKcE9readBytesEPcm: 26| 24.0k| size_t readBytes(char* buffer, size_t length) { 27| 24.0k| size_t i = 0; 28| 54.8k| while (i < length && ptr_ < end_) ------------------ | Branch (28:12): [True: 31.3k, False: 23.4k] | Branch (28:26): [True: 30.8k, False: 559] ------------------ 29| 30.8k| buffer[i++] = *ptr_++; 30| 24.0k| return i; 31| 24.0k| } _ZN11ArduinoJson8V740HB426detail14IteratorReaderIPKcE4readEv: 19| 2.69k| int read() { 20| 2.69k| if (ptr_ < end_) ------------------ | Branch (20:9): [True: 2.62k, False: 76] ------------------ 21| 2.62k| return static_cast(*ptr_++); 22| 76| else 23| 76| return -1; 24| 2.69k| } _ZN11ArduinoJson8V740HB426detail14IteratorReaderIPKcEC2ES4_S4_: 17| 1.41k| : ptr_(begin), end_(end) {} _ZN11ArduinoJson8V740HB426detail13BoundedReaderIPKhvEC2EPKvm: 45| 1.41k| : IteratorReader(reinterpret_cast(ptr), 46| 1.41k| reinterpret_cast(ptr) + len) {} _ZN11ArduinoJson8V740HB426detail11deserializeINS1_19MsgPackDeserializerERNS0_12JsonDocumentEKhmJETnNS1_9enable_ifIXsr11is_integralIT2_EE5valueEiE4typeELi0EEENS0_20DeserializationErrorEOT0_PT1_S8_DpT3_: 74| 1.41k| Size inputSize, Args... args) { 75| 1.41k| return doDeserialize(dst, makeReader(input, size_t(inputSize)), 76| 1.41k| makeDeserializationOptions(args...)); 77| 1.41k|} _ZN11ArduinoJson8V740HB426detail13doDeserializeINS1_19MsgPackDeserializerERNS0_12JsonDocumentENS1_13BoundedReaderIPKhvEENS1_22DeserializationOptionsINS1_14AllowAllFilterEEEEENS0_20DeserializationErrorEOT0_T1_T2_: 46| 1.41k| TOptions options) { 47| 1.41k| auto data = VariantAttorney::getOrCreateData(dst); 48| 1.41k| if (!data) ------------------ | Branch (48:7): [True: 0, False: 1.41k] ------------------ 49| 0| return DeserializationError::NoMemory; 50| 1.41k| auto resources = VariantAttorney::getResourceManager(dst); 51| 1.41k| dst.clear(); 52| 1.41k| auto err = TDeserializer(resources, reader) 53| 1.41k| .parse(*data, options.filter, options.nestingLimit); 54| 1.41k| shrinkJsonDocument(dst); 55| 1.41k| return err; 56| 1.41k|} _ZN11ArduinoJson8V740HB426detail18shrinkJsonDocumentERNS0_12JsonDocumentE: 38| 1.41k|inline void shrinkJsonDocument(JsonDocument& doc) { 39| 1.41k| doc.shrinkToFit(); 40| 1.41k|} _ZN11ArduinoJson8V740HB4212JsonDocumentC2EPNS0_9AllocatorE: 25| 1.41k| : resources_(alloc) {} _ZNK11ArduinoJson8V740HB4212JsonDocumentcvNS0_16JsonVariantConstEEv: 332| 669| operator JsonVariantConst() const { 333| 669| return getVariant(); 334| 669| } _ZNK11ArduinoJson8V740HB4212JsonDocument10getVariantEv: 398| 669| JsonVariantConst getVariant() const { 399| 669| return JsonVariantConst(&data_, &resources_); 400| 669| } _ZN11ArduinoJson8V740HB4212JsonDocument15getOrCreateDataEv: 414| 1.41k| detail::VariantData* getOrCreateData() { 415| 1.41k| return &data_; 416| 1.41k| } _ZN11ArduinoJson8V740HB4212JsonDocument18getResourceManagerEv: 402| 1.41k| detail::ResourceManager* getResourceManager() { 403| 1.41k| return &resources_; 404| 1.41k| } _ZN11ArduinoJson8V740HB4212JsonDocument5clearEv: 89| 1.41k| void clear() { 90| 1.41k| resources_.clear(); 91| 1.41k| data_.reset(); 92| 1.41k| } _ZN11ArduinoJson8V740HB4212JsonDocument11shrinkToFitEv: 69| 1.41k| void shrinkToFit() { 70| 1.41k| resources_.shrinkToFit(); 71| 1.41k| } _ZN11ArduinoJson8V740HB426detail16DefaultAllocator8instanceEv: 38| 1.41k| static Allocator* instance() { 39| 1.41k| static DefaultAllocator allocator; 40| 1.41k| return &allocator; 41| 1.41k| } _ZN11ArduinoJson8V740HB426detail16DefaultAllocator8allocateEm: 26| 1.91k| void* allocate(size_t size) override { 27| 1.91k| return malloc(size); 28| 1.91k| } _ZN11ArduinoJson8V740HB426detail16DefaultAllocator10deallocateEPv: 30| 1.91k| void deallocate(void* ptr) override { 31| 1.91k| free(ptr); 32| 1.91k| } _ZN11ArduinoJson8V740HB426detail16DefaultAllocator10reallocateEPvm: 34| 889| void* reallocate(void* ptr, size_t new_size) override { 35| 889| return realloc(ptr, new_size); 36| 889| } _ZN11ArduinoJson8V740HB426detail10MemoryPoolINS1_15ResourceManager8SlotDataEE7destroyEPNS0_9AllocatorE: 57| 881| void destroy(Allocator* allocator) { 58| 881| if (slots_) ------------------ | Branch (58:9): [True: 881, False: 0] ------------------ 59| 881| allocator->deallocate(slots_); 60| 881| slots_ = nullptr; 61| 881| capacity_ = 0; 62| 881| usage_ = 0; 63| 881| } _ZNK11ArduinoJson8V740HB426detail10MemoryPoolINS1_15ResourceManager8SlotDataEE7getSlotEj: 74| 23.3k| T* getSlot(SlotId id) const { 75| 23.3k| ARDUINOJSON_ASSERT(id < usage_); ------------------ | | 11| 23.3k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 76| 23.3k| return slots_ + id; 77| 23.3k| } _ZN11ArduinoJson8V740HB426detail4SlotINS1_15ResourceManager8SlotDataEEC2EPS4_j: 21| 30.2k| Slot(T* p, SlotId id) : ptr_(p), id_(id) { 22| 30.2k| ARDUINOJSON_ASSERT((p == nullptr) == (id == NULL_SLOT)); ------------------ | | 11| 30.2k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 23| 30.2k| } _ZN11ArduinoJson8V740HB426detail10MemoryPoolINS1_15ResourceManager8SlotDataEE9allocSlotEv: 65| 15.1k| Slot allocSlot() { 66| 15.1k| if (!slots_) ------------------ | Branch (66:9): [True: 0, False: 15.1k] ------------------ 67| 0| return {}; 68| 15.1k| if (usage_ >= capacity_) ------------------ | Branch (68:9): [True: 0, False: 15.1k] ------------------ 69| 0| return {}; 70| 15.1k| auto index = usage_++; 71| 15.1k| return {slots_ + index, SlotId(index)}; 72| 15.1k| } _ZNK11ArduinoJson8V740HB426detail4SlotINS1_15ResourceManager8SlotDataEE3ptrEv: 33| 15.1k| T* ptr() const { 34| 15.1k| return ptr_; 35| 15.1k| } _ZN11ArduinoJson8V740HB426detail10MemoryPoolINS1_15ResourceManager8SlotDataEE6createEjPNS0_9AllocatorE: 50| 881| void create(SlotCount cap, Allocator* allocator) { 51| 881| ARDUINOJSON_ASSERT(cap > 0); ------------------ | | 11| 881|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 52| 881| slots_ = reinterpret_cast(allocator->allocate(slotsToBytes(cap))); 53| 881| capacity_ = slots_ ? cap : 0; ------------------ | Branch (53:17): [True: 881, False: 0] ------------------ 54| 881| usage_ = 0; 55| 881| } _ZN11ArduinoJson8V740HB426detail10MemoryPoolINS1_15ResourceManager8SlotDataEE12slotsToBytesEj: 100| 1.76k| static size_t slotsToBytes(SlotCount n) { 101| 1.76k| return n * sizeof(T); 102| 1.76k| } _ZNK11ArduinoJson8V740HB426detail4SlotINS1_15ResourceManager8SlotDataEEcvbEv: 25| 44.4k| explicit operator bool() const { 26| 44.4k| return ptr_ != nullptr; 27| 44.4k| } _ZNK11ArduinoJson8V740HB426detail4SlotINS1_15ResourceManager8SlotDataEEptEv: 37| 15.1k| T* operator->() const { 38| 15.1k| ARDUINOJSON_ASSERT(ptr_ != nullptr); ------------------ | | 11| 15.1k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 39| 15.1k| return ptr_; 40| 15.1k| } _ZNK11ArduinoJson8V740HB426detail4SlotINS1_15ResourceManager8SlotDataEE2idEv: 29| 30.2k| SlotId id() const { 30| 30.2k| return id_; 31| 30.2k| } _ZN11ArduinoJson8V740HB426detail4SlotINS1_16VariantExtensionEEC2EPS3_j: 21| 346| Slot(T* p, SlotId id) : ptr_(p), id_(id) { 22| 346| ARDUINOJSON_ASSERT((p == nullptr) == (id == NULL_SLOT)); ------------------ | | 11| 346|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 23| 346| } _ZNK11ArduinoJson8V740HB426detail4SlotINS1_16VariantExtensionEEcvbEv: 25| 346| explicit operator bool() const { 26| 346| return ptr_ != nullptr; 27| 346| } _ZNK11ArduinoJson8V740HB426detail4SlotINS1_16VariantExtensionEE2idEv: 29| 346| SlotId id() const { 30| 346| return id_; 31| 346| } _ZNK11ArduinoJson8V740HB426detail4SlotINS1_16VariantExtensionEEptEv: 37| 346| T* operator->() const { 38| 346| ARDUINOJSON_ASSERT(ptr_ != nullptr); ------------------ | | 11| 346|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 39| 346| return ptr_; 40| 346| } _ZN11ArduinoJson8V740HB426detail4SlotINS1_11VariantDataEEC2EPS3_j: 21| 14.7k| Slot(T* p, SlotId id) : ptr_(p), id_(id) { 22| 14.7k| ARDUINOJSON_ASSERT((p == nullptr) == (id == NULL_SLOT)); ------------------ | | 11| 14.7k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 23| 14.7k| } _ZNK11ArduinoJson8V740HB426detail4SlotINS1_11VariantDataEEcvbEv: 25| 14.7k| explicit operator bool() const { 26| 14.7k| return ptr_ != nullptr; 27| 14.7k| } _ZNK11ArduinoJson8V740HB426detail4SlotINS1_11VariantDataEE2idEv: 29| 27.5k| SlotId id() const { 30| 27.5k| return id_; 31| 27.5k| } _ZNK11ArduinoJson8V740HB426detail4SlotINS1_11VariantDataEE3ptrEv: 33| 14.7k| T* ptr() const { 34| 14.7k| return ptr_; 35| 14.7k| } _ZNK11ArduinoJson8V740HB426detail4SlotINS1_11VariantDataEEptEv: 37| 2.01k| T* operator->() const { 38| 2.01k| ARDUINOJSON_ASSERT(ptr_ != nullptr); ------------------ | | 11| 2.01k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 39| 2.01k| return ptr_; 40| 2.01k| } _ZN11ArduinoJson8V740HB426detail10MemoryPoolINS1_15ResourceManager8SlotDataEE11shrinkToFitEPNS0_9AllocatorE: 83| 881| void shrinkToFit(Allocator* allocator) { 84| 881| auto newSlots = reinterpret_cast( 85| 881| allocator->reallocate(slots_, slotsToBytes(usage_))); 86| 881| if (newSlots) { ------------------ | Branch (86:9): [True: 881, False: 0] ------------------ 87| 881| slots_ = newSlots; 88| 881| capacity_ = usage_; 89| 881| } 90| 881| } _ZN11ArduinoJson8V740HB426detail14MemoryPoolListINS1_15ResourceManager8SlotDataEEC2Ev: 28| 1.41k| MemoryPoolList() = default; _ZN11ArduinoJson8V740HB426detail14MemoryPoolListINS1_15ResourceManager8SlotDataEE5clearEPNS0_9AllocatorE: 117| 2.83k| void clear(Allocator* allocator) { 118| 3.71k| for (PoolCount i = 0; i < count_; i++) ------------------ | Branch (118:27): [True: 881, False: 2.83k] ------------------ 119| 881| pools_[i].destroy(allocator); 120| 2.83k| count_ = 0; 121| 2.83k| freeList_ = NULL_SLOT; 122| 2.83k| if (pools_ != preallocatedPools_) { ------------------ | Branch (122:9): [True: 0, False: 2.83k] ------------------ 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.83k| } _ZN11ArduinoJson8V740HB426detail14MemoryPoolListINS1_15ResourceManager8SlotDataEED2Ev: 30| 1.41k| ~MemoryPoolList() { 31| 1.41k| ARDUINOJSON_ASSERT(count_ == 0); ------------------ | | 11| 1.41k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 32| 1.41k| } _ZN11ArduinoJson8V740HB426detail14MemoryPoolListINS1_15ResourceManager8SlotDataEE9allocSlotEPNS0_9AllocatorE: 82| 15.1k| Slot allocSlot(Allocator* allocator) { 83| | // try to allocate from free list 84| 15.1k| if (freeList_ != NULL_SLOT) { ------------------ | Branch (84:9): [True: 0, False: 15.1k] ------------------ 85| 0| return allocFromFreeList(); 86| 0| } 87| | 88| | // try to allocate from last pool (other pools are full) 89| 15.1k| if (count_) { ------------------ | Branch (89:9): [True: 14.2k, False: 881] ------------------ 90| 14.2k| auto slot = allocFromLastPool(); 91| 14.2k| if (slot) ------------------ | Branch (91:11): [True: 14.2k, False: 0] ------------------ 92| 14.2k| return slot; 93| 14.2k| } 94| | 95| | // create a new pool and try again 96| 881| auto pool = addPool(allocator); 97| 881| if (!pool) ------------------ | Branch (97:9): [True: 0, False: 881] ------------------ 98| 0| return {}; 99| | 100| 881| return allocFromLastPool(); 101| 881| } _ZNK11ArduinoJson8V740HB426detail14MemoryPoolListINS1_15ResourceManager8SlotDataEE7getSlotEj: 108| 25.2k| T* getSlot(SlotId id) const { 109| 25.2k| if (id == NULL_SLOT) ------------------ | Branch (109:9): [True: 1.89k, False: 23.3k] ------------------ 110| 1.89k| return nullptr; 111| 23.3k| auto poolIndex = SlotId(id / ARDUINOJSON_POOL_CAPACITY); ------------------ | | 118| 23.3k|# define ARDUINOJSON_POOL_CAPACITY 256 // 4096 bytes ------------------ 112| 23.3k| auto indexInPool = SlotId(id % ARDUINOJSON_POOL_CAPACITY); ------------------ | | 118| 23.3k|# define ARDUINOJSON_POOL_CAPACITY 256 // 4096 bytes ------------------ 113| 23.3k| ARDUINOJSON_ASSERT(poolIndex < count_); ------------------ | | 11| 23.3k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 114| 23.3k| return pools_[poolIndex].getSlot(indexInPool); 115| 23.3k| } _ZN11ArduinoJson8V740HB426detail14MemoryPoolListINS1_15ResourceManager8SlotDataEE17allocFromLastPoolEv: 160| 15.1k| Slot allocFromLastPool() { 161| 15.1k| ARDUINOJSON_ASSERT(count_ > 0); ------------------ | | 11| 15.1k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 162| 15.1k| auto poolIndex = SlotId(count_ - 1); 163| 15.1k| auto slot = pools_[poolIndex].allocSlot(); 164| 15.1k| if (!slot) ------------------ | Branch (164:9): [True: 0, False: 15.1k] ------------------ 165| 0| return {}; 166| 15.1k| return {slot.ptr(), 167| 15.1k| SlotId(poolIndex * ARDUINOJSON_POOL_CAPACITY + slot.id())}; ------------------ | | 118| 15.1k|# define ARDUINOJSON_POOL_CAPACITY 256 // 4096 bytes ------------------ 168| 15.1k| } _ZN11ArduinoJson8V740HB426detail14MemoryPoolListINS1_15ResourceManager8SlotDataEE7addPoolEPNS0_9AllocatorE: 170| 881| Pool* addPool(Allocator* allocator) { 171| 881| if (count_ == capacity_ && !increaseCapacity(allocator)) ------------------ | Branch (171:9): [True: 0, False: 881] | Branch (171:32): [True: 0, False: 0] ------------------ 172| 0| return nullptr; 173| 881| auto pool = &pools_[count_++]; 174| 881| SlotCount poolCapacity = ARDUINOJSON_POOL_CAPACITY; ------------------ | | 118| 881|# define ARDUINOJSON_POOL_CAPACITY 256 // 4096 bytes ------------------ 175| 881| if (count_ == maxPools) // last pool is smaller because of NULL_SLOT ------------------ | Branch (175:9): [True: 0, False: 881] ------------------ 176| 0| poolCapacity--; 177| 881| pool->create(poolCapacity, allocator); 178| 881| return pool; 179| 881| } _ZN11ArduinoJson8V740HB426detail14MemoryPoolListINS1_15ResourceManager8SlotDataEE11shrinkToFitEPNS0_9AllocatorE: 140| 1.41k| void shrinkToFit(Allocator* allocator) { 141| 1.41k| if (count_ > 0) ------------------ | Branch (141:9): [True: 881, False: 537] ------------------ 142| 881| pools_[count_ - 1].shrinkToFit(allocator); 143| 1.41k| if (pools_ != preallocatedPools_ && count_ != capacity_) { ------------------ | Branch (143:9): [True: 0, False: 1.41k] | 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.41k| } _ZN11ArduinoJson8V740HB426detail15ResourceManagerC2EPNS0_9AllocatorE: 32| 1.41k| : allocator_(allocator), overflowed_(false) {} _ZN11ArduinoJson8V740HB426detail15ResourceManagerD2Ev: 34| 1.41k| ~ResourceManager() { 35| 1.41k| stringPool_.clear(allocator_); 36| 1.41k| variantPools_.clear(allocator_); 37| 1.41k| } _ZN11ArduinoJson8V740HB426detail15ResourceManager5clearEv: 114| 1.41k| void clear() { 115| 1.41k| variantPools_.clear(allocator_); 116| 1.41k| overflowed_ = false; 117| 1.41k| stringPool_.clear(allocator_); 118| 1.41k| } _ZN11ArduinoJson8V740HB426detail15ResourceManager13destroyStringEPNS1_10StringNodeE: 106| 667| void destroyString(StringNode* node) { 107| 667| StringNode::destroy(node, allocator_); 108| 667| } _ZN11ArduinoJson8V740HB426detail15ResourceManager12createStringEm: 92| 1.12k| StringNode* createString(size_t length) { 93| 1.12k| auto node = StringNode::create(length, allocator_); 94| 1.12k| if (!node) ------------------ | Branch (94:9): [True: 86, False: 1.03k] ------------------ 95| 86| overflowed_ = true; 96| 1.12k| return node; 97| 1.12k| } _ZNK11ArduinoJson8V740HB426detail15ResourceManager9getStringINS1_9RamStringEEEPNS1_10StringNodeERKT_: 88| 964| StringNode* getString(const TAdaptedString& str) const { 89| 964| return stringPool_.get(str); 90| 964| } _ZN11ArduinoJson8V740HB426detail15ResourceManager12resizeStringEPNS1_10StringNodeEm: 99| 8| StringNode* resizeString(StringNode* node, size_t length) { 100| 8| node = StringNode::resize(node, length, allocator_); 101| 8| if (!node) ------------------ | Branch (101:9): [True: 0, False: 8] ------------------ 102| 0| overflowed_ = true; 103| 8| return node; 104| 8| } _ZN11ArduinoJson8V740HB426detail15ResourceManager10saveStringEPNS1_10StringNodeE: 83| 368| void saveString(StringNode* node) { 84| 368| stringPool_.add(node); 85| 368| } _ZN11ArduinoJson8V740HB426detail15ResourceManager11shrinkToFitEv: 120| 1.41k| void shrinkToFit() { 121| 1.41k| variantPools_.shrinkToFit(allocator_); 122| 1.41k| } _ZN11ArduinoJson8V740HB426detail15ResourceManager14allocExtensionEv: 33| 346|inline Slot ResourceManager::allocExtension() { 34| 346| auto p = variantPools_.allocSlot(allocator_); 35| 346| if (!p) { ------------------ | Branch (35:7): [True: 0, False: 346] ------------------ 36| 0| overflowed_ = true; 37| 0| return {}; 38| 0| } 39| 346| return {&p->extension, p.id()}; 40| 346|} _ZN11ArduinoJson8V740HB426detail15ResourceManager12allocVariantEv: 14| 14.7k|inline Slot ResourceManager::allocVariant() { 15| 14.7k| auto p = variantPools_.allocSlot(allocator_); 16| 14.7k| if (!p) { ------------------ | Branch (16:7): [True: 0, False: 14.7k] ------------------ 17| 0| overflowed_ = true; 18| 0| return {}; 19| 0| } 20| 14.7k| return {new (&p->variant) VariantData, p.id()}; 21| 14.7k|} _ZNK11ArduinoJson8V740HB426detail15ResourceManager10getVariantEj: 28| 25.0k|inline VariantData* ResourceManager::getVariant(SlotId id) const { 29| 25.0k| return reinterpret_cast(variantPools_.getSlot(id)); 30| 25.0k|} _ZNK11ArduinoJson8V740HB426detail15ResourceManager12getExtensionEj: 47| 250|inline VariantExtension* ResourceManager::getExtension(SlotId id) const { 48| 250| return &variantPools_.getSlot(id)->extension; 49| 250|} _ZN11ArduinoJson8V740HB426detail12StringBufferC2EPNS1_15ResourceManagerE: 13| 1.41k| StringBuffer(ResourceManager* resources) : resources_(resources) {} _ZN11ArduinoJson8V740HB426detail12StringBuffer7reserveEm: 20| 6.12k| char* reserve(size_t capacity) { 21| 6.12k| if (node_ && capacity > node_->length) { ------------------ | Branch (21:9): [True: 5.24k, False: 885] | Branch (21:18): [True: 236, False: 5.00k] ------------------ 22| | // existing buffer is too small, we need to reallocate 23| 236| resources_->destroyString(node_); 24| 236| node_ = nullptr; 25| 236| } 26| 6.12k| if (!node_) ------------------ | Branch (26:9): [True: 1.12k, False: 5.00k] ------------------ 27| 1.12k| node_ = resources_->createString(capacity); 28| 6.12k| if (!node_) ------------------ | Branch (28:9): [True: 86, False: 6.04k] ------------------ 29| 86| return nullptr; 30| 6.04k| size_ = capacity; 31| 6.04k| node_->data[capacity] = 0; // null-terminate the string 32| 6.04k| return node_->data; 33| 6.12k| } _ZNK11ArduinoJson8V740HB426detail12StringBuffer3strEv: 35| 2.01k| JsonString str() const { 36| 2.01k| ARDUINOJSON_ASSERT(node_ != nullptr); ------------------ | | 11| 2.01k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 37| 2.01k| return JsonString(node_->data, node_->length); 38| 2.01k| } _ZN11ArduinoJson8V740HB426detail12StringBuffer4saveEPNS1_11VariantDataE: 40| 4.95k| void save(VariantData* data) { 41| 4.95k| ARDUINOJSON_ASSERT(node_ != nullptr); ------------------ | | 11| 4.95k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 42| 4.95k| const char* s = node_->data; 43| 4.95k| if (isTinyString(s, size_)) ------------------ | Branch (43:9): [True: 4.89k, False: 63] ------------------ 44| 4.89k| data->setTinyString(s, static_cast(size_)); 45| 63| else 46| 63| data->setOwnedString(commitStringNode()); 47| 4.95k| } _ZN11ArduinoJson8V740HB426detail12StringBuffer16commitStringNodeEv: 54| 964| StringNode* commitStringNode() { 55| 964| ARDUINOJSON_ASSERT(node_ != nullptr); ------------------ | | 11| 964|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 56| 964| node_->data[size_] = 0; 57| 964| auto node = resources_->getString(adaptString(node_->data, size_)); 58| 964| if (node) { ------------------ | Branch (58:9): [True: 596, False: 368] ------------------ 59| 596| node->references++; 60| 596| return node; 61| 596| } 62| | 63| 368| if (node_->length != size_) { ------------------ | Branch (63:9): [True: 8, False: 360] ------------------ 64| 8| node = resources_->resizeString(node_, size_); 65| 8| ARDUINOJSON_ASSERT(node != nullptr); // realloc to smaller can't fail ------------------ | | 11| 8|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 66| 360| } else { 67| 360| node = node_; 68| 360| } 69| 368| node_ = nullptr; 70| 368| resources_->saveString(node); 71| 368| return node; 72| 368| } _ZN11ArduinoJson8V740HB426detail12StringBuffer7saveRawEPNS1_11VariantDataE: 49| 901| void saveRaw(VariantData* data) { 50| 901| data->setRawString(commitStringNode()); 51| 901| } _ZN11ArduinoJson8V740HB426detail12StringBufferD2Ev: 15| 1.41k| ~StringBuffer() { 16| 1.41k| if (node_) ------------------ | Branch (16:9): [True: 431, False: 987] ------------------ 17| 431| resources_->destroyString(node_); 18| 1.41k| } _ZN11ArduinoJson8V740HB426detail10StringNode7destroyEPS2_PNS0_9AllocatorE: 65| 1.03k| static void destroy(StringNode* node, Allocator* allocator) { 66| 1.03k| allocator->deallocate(node); 67| 1.03k| } _ZN11ArduinoJson8V740HB426detail10StringNode6createEmPNS0_9AllocatorE: 35| 1.12k| static StringNode* create(size_t length, Allocator* allocator) { 36| 1.12k| if (length > maxLength) ------------------ | Branch (36:9): [True: 86, False: 1.03k] ------------------ 37| 86| return nullptr; 38| 1.03k| auto size = sizeForLength(length); 39| 1.03k| if (size < length) // integer overflow ------------------ | Branch (39:9): [True: 0, False: 1.03k] ------------------ 40| 0| return nullptr; // (not testable on 64-bit) 41| 1.03k| auto node = reinterpret_cast(allocator->allocate(size)); 42| 1.03k| if (node) { ------------------ | Branch (42:9): [True: 1.03k, False: 0] ------------------ 43| 1.03k| node->length = length_type(length); 44| 1.03k| node->references = 1; 45| 1.03k| } 46| 1.03k| return node; 47| 1.03k| } _ZN11ArduinoJson8V740HB426detail10StringNode13sizeForLengthEm: 31| 1.04k| static constexpr size_t sizeForLength(size_t n) { 32| 1.04k| return n + 1 + offsetof(StringNode, data); 33| 1.04k| } _ZN11ArduinoJson8V740HB426detail10StringNode6resizeEPS2_mPNS0_9AllocatorE: 50| 8| Allocator* allocator) { 51| 8| ARDUINOJSON_ASSERT(node != nullptr); ------------------ | | 11| 8|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 52| 8| StringNode* newNode; 53| 8| if (length <= maxLength) ------------------ | Branch (53:9): [True: 8, False: 0] ------------------ 54| 8| newNode = reinterpret_cast( 55| 8| allocator->reallocate(node, sizeForLength(length))); 56| 0| else 57| 0| newNode = nullptr; 58| 8| if (newNode) ------------------ | Branch (58:9): [True: 8, False: 0] ------------------ 59| 8| newNode->length = length_type(length); 60| 0| else 61| 0| allocator->deallocate(node); 62| 8| return newNode; 63| 8| } _ZN11ArduinoJson8V740HB426detail10StringPoolC2Ev: 17| 1.41k| StringPool() = default; _ZN11ArduinoJson8V740HB426detail10StringPool5clearEPNS0_9AllocatorE: 29| 2.83k| void clear(Allocator* allocator) { 30| 3.20k| while (strings_) { ------------------ | Branch (30:12): [True: 368, False: 2.83k] ------------------ 31| 368| auto node = strings_; 32| 368| strings_ = node->next; 33| 368| StringNode::destroy(node, allocator); 34| 368| } 35| 2.83k| } _ZN11ArduinoJson8V740HB426detail10StringPoolD2Ev: 21| 1.41k| ~StringPool() { 22| 1.41k| ARDUINOJSON_ASSERT(strings_ == nullptr); ------------------ | | 11| 1.41k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 23| 1.41k| } _ZNK11ArduinoJson8V740HB426detail10StringPool3getINS1_9RamStringEEEPNS1_10StringNodeERKT_: 73| 964| StringNode* get(const TAdaptedString& str) const { 74| 2.78k| for (auto node = strings_; node; node = node->next) { ------------------ | Branch (74:32): [True: 2.41k, False: 368] ------------------ 75| 2.41k| if (stringEquals(str, adaptString(node->data, node->length))) ------------------ | Branch (75:11): [True: 596, False: 1.81k] ------------------ 76| 596| return node; 77| 2.41k| } 78| 368| return nullptr; 79| 964| } _ZN11ArduinoJson8V740HB426detail10StringPool3addEPNS1_10StringNodeE: 66| 368| void add(StringNode* node) { 67| 368| ARDUINOJSON_ASSERT(node != nullptr); ------------------ | | 11| 368|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 68| 368| node->next = strings_; 69| 368| strings_ = node; 70| 368| } _ZNK11ArduinoJson8V740HB4215SerializedValueIPKcE4dataEv: 41| 74| TChar* data() const { 42| 74| return data_; 43| 74| } _ZNK11ArduinoJson8V740HB4215SerializedValueIPKcE4sizeEv: 45| 74| size_t size() const { 46| 74| return size_; 47| 74| } _ZN11ArduinoJson8V740HB4215SerializedValueIPKcEC2ES3_m: 36| 74| explicit SerializedValue(TChar* p, size_t n) : data_(p), size_(n) {} _ZN11ArduinoJson8V740HB4218deserializeMsgPackIRNS0_12JsonDocumentEKhJRmETnNS0_6detail9enable_ifIXsr6detail26is_deserialize_destinationIT_EE5valueEiE4typeELi0EEENS0_20DeserializationErrorEOS8_PT0_DpOT1_: 480| 1.41k| Args&&... args) { 481| 1.41k| using namespace detail; 482| 1.41k| return deserialize(detail::forward(dst), 483| 1.41k| input, 484| 1.41k| detail::forward(args)...); 485| 1.41k|} _ZN11ArduinoJson8V740HB426detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEEEC2EPNS1_15ResourceManagerES6_: 21| 1.41k| : resources_(resources), 22| 1.41k| reader_(reader), 23| 1.41k| stringBuffer_(resources), 24| 1.41k| foundSomething_(false) {} _ZN11ArduinoJson8V740HB426detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEEE5parseINS1_14AllowAllFilterEEENS0_20DeserializationErrorERNS1_11VariantDataET_NS0_21DeserializationOption12NestingLimitE: 28| 1.41k| DeserializationOption::NestingLimit nestingLimit) { 29| 1.41k| DeserializationError::Code err; 30| 1.41k| err = parseVariant(&variant, filter, nestingLimit); 31| 1.41k| return foundSomething_ ? err : DeserializationError::EmptyInput; ------------------ | Branch (31:12): [True: 1.41k, False: 0] ------------------ 32| 1.41k| } _ZN11ArduinoJson8V740HB426detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEEE12parseVariantINS1_14AllowAllFilterEEENS0_20DeserializationError4CodeEPNS1_11VariantDataET_NS0_21DeserializationOption12NestingLimitE: 38| 14.1k| DeserializationOption::NestingLimit nestingLimit) { 39| 14.1k| DeserializationError::Code err; 40| | 41| 14.1k| uint8_t header[5]; 42| 14.1k| err = readBytes(header, 1); 43| 14.1k| if (err) ------------------ | Branch (43:9): [True: 231, False: 13.9k] ------------------ 44| 231| return err; 45| | 46| 13.9k| const uint8_t& code = header[0]; 47| | 48| 13.9k| foundSomething_ = true; 49| | 50| 13.9k| bool allowValue = filter.allowValue(); 51| | 52| 13.9k| if (allowValue) { ------------------ | Branch (52:9): [True: 13.9k, False: 0] ------------------ 53| | // callers pass a null pointer only when value must be ignored 54| 13.9k| ARDUINOJSON_ASSERT(variant != 0); ------------------ | | 11| 13.9k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 55| 13.9k| } 56| | 57| 13.9k| if (code >= 0xcc && code <= 0xd3) { ------------------ | Branch (57:9): [True: 3.76k, False: 10.1k] | Branch (57:25): [True: 876, False: 2.88k] ------------------ 58| 876| auto width = uint8_t(1U << ((code - 0xcc) % 4)); 59| 876| if (allowValue) ------------------ | Branch (59:11): [True: 876, False: 0] ------------------ 60| 876| return readInteger(variant, width, code >= 0xd0); 61| 0| else 62| 0| return skipBytes(width); 63| 876| } 64| | 65| 13.0k| switch (code) { ------------------ | Branch (65:13): [True: 11.7k, False: 1.31k] ------------------ 66| 245| case 0xc0: ------------------ | Branch (66:7): [True: 245, False: 12.8k] ------------------ 67| | // already null 68| 245| return DeserializationError::Ok; 69| | 70| 3| case 0xc1: ------------------ | Branch (70:7): [True: 3, False: 13.0k] ------------------ 71| 3| return DeserializationError::InvalidInput; 72| | 73| 262| case 0xc2: ------------------ | Branch (73:7): [True: 262, False: 12.8k] ------------------ 74| 504| case 0xc3: ------------------ | Branch (74:7): [True: 242, False: 12.8k] ------------------ 75| 504| if (allowValue) ------------------ | Branch (75:13): [True: 504, False: 0] ------------------ 76| 504| variant->setBoolean(code == 0xc3); 77| 504| return DeserializationError::Ok; 78| | 79| 420| case 0xca: ------------------ | Branch (79:7): [True: 420, False: 12.6k] ------------------ 80| 420| if (allowValue) ------------------ | Branch (80:13): [True: 420, False: 0] ------------------ 81| 420| return readFloat(variant); 82| 0| else 83| 0| return skipBytes(4); 84| | 85| 138| case 0xcb: ------------------ | Branch (85:7): [True: 138, False: 12.9k] ------------------ 86| 138| if (allowValue) ------------------ | Branch (86:13): [True: 138, False: 0] ------------------ 87| 138| return readDouble(variant); 88| 0| else 89| 0| return skipBytes(8); 90| 13.0k| } 91| | 92| 11.7k| if (code <= 0x7f || code >= 0xe0) { // fixint ------------------ | Branch (92:9): [True: 1.97k, False: 9.79k] | Branch (92:25): [True: 1.26k, False: 8.52k] ------------------ 93| 3.24k| if (allowValue) ------------------ | Branch (93:11): [True: 3.24k, False: 0] ------------------ 94| 3.24k| variant->setInteger(static_cast(code), resources_); 95| 3.24k| return DeserializationError::Ok; 96| 3.24k| } 97| | 98| 8.52k| uint8_t sizeBytes = 0; 99| 8.52k| size_t size = 0; 100| 8.52k| bool isExtension = code >= 0xc7 && code <= 0xc9; ------------------ | Branch (100:24): [True: 1.86k, False: 6.65k] | Branch (100:40): [True: 246, False: 1.62k] ------------------ 101| | 102| 8.52k| switch (code) { ------------------ | Branch (102:13): [True: 6.16k, False: 2.35k] ------------------ 103| 469| case 0xc4: // bin 8 ------------------ | Branch (103:7): [True: 469, False: 8.05k] ------------------ 104| 561| case 0xc7: // ext 8 ------------------ | Branch (104:7): [True: 92, False: 8.42k] ------------------ 105| 927| case 0xd9: // str 8 ------------------ | Branch (105:7): [True: 366, False: 8.15k] ------------------ 106| 927| sizeBytes = 1; 107| 927| break; 108| | 109| 93| case 0xc5: // bin 16 ------------------ | Branch (109:7): [True: 93, False: 8.42k] ------------------ 110| 172| case 0xc8: // ext 16 ------------------ | Branch (110:7): [True: 79, False: 8.44k] ------------------ 111| 325| case 0xda: // str 16 ------------------ | Branch (111:7): [True: 153, False: 8.36k] ------------------ 112| 526| case 0xdc: // array 16 ------------------ | Branch (112:7): [True: 201, False: 8.32k] ------------------ 113| 690| case 0xde: // map 16 ------------------ | Branch (113:7): [True: 164, False: 8.35k] ------------------ 114| 690| sizeBytes = 2; 115| 690| break; 116| | 117| 104| case 0xc6: // bin 32 ------------------ | Branch (117:7): [True: 104, False: 8.41k] ------------------ 118| 179| case 0xc9: // ext 32 ------------------ | Branch (118:7): [True: 75, False: 8.44k] ------------------ 119| 337| case 0xdb: // str 32 ------------------ | Branch (119:7): [True: 158, False: 8.36k] ------------------ 120| 590| case 0xdd: // array 32 ------------------ | Branch (120:7): [True: 253, False: 8.26k] ------------------ 121| 738| case 0xdf: // map 32 ------------------ | Branch (121:7): [True: 148, False: 8.37k] ------------------ 122| 738| sizeBytes = 4; 123| 738| break; 124| 8.52k| } 125| | 126| 8.52k| if (code >= 0xd4 && code <= 0xd8) { // fixext ------------------ | Branch (126:9): [True: 1.62k, False: 6.90k] | Branch (126:25): [True: 177, False: 1.44k] ------------------ 127| 177| size = size_t(1) << (code - 0xd4); 128| 177| isExtension = true; 129| 177| } 130| | 131| 8.52k| switch (code & 0xf0) { ------------------ | Branch (131:13): [True: 4.91k, False: 3.60k] ------------------ 132| 2.75k| case 0x90: // fixarray ------------------ | Branch (132:7): [True: 2.75k, False: 5.76k] ------------------ 133| 3.60k| case 0x80: // fixmap ------------------ | Branch (133:7): [True: 854, False: 7.66k] ------------------ 134| 3.60k| size = code & 0x0F; 135| 3.60k| break; 136| 8.52k| } 137| | 138| 8.52k| switch (code & 0xe0) { ------------------ | Branch (138:13): [True: 6.13k, False: 2.38k] ------------------ 139| 2.38k| case 0xa0: // fixstr ------------------ | Branch (139:7): [True: 2.38k, False: 6.13k] ------------------ 140| 2.38k| size = code & 0x1f; 141| 2.38k| break; 142| 8.52k| } 143| | 144| 8.52k| if (sizeBytes) { ------------------ | Branch (144:9): [True: 2.35k, False: 6.16k] ------------------ 145| 2.35k| err = readBytes(header + 1, sizeBytes); 146| 2.35k| if (err) ------------------ | Branch (146:11): [True: 101, False: 2.25k] ------------------ 147| 101| return err; 148| | 149| 2.25k| uint32_t size32 = 0; 150| 7.25k| for (uint8_t i = 0; i < sizeBytes; i++) ------------------ | Branch (150:27): [True: 4.99k, False: 2.25k] ------------------ 151| 4.99k| size32 = (size32 << 8) | header[i + 1]; 152| | 153| 2.25k| size = size_t(size32); 154| 2.25k| if (size < size32) // integer overflow ------------------ | Branch (154:11): [True: 0, False: 2.25k] ------------------ 155| 0| return DeserializationError::NoMemory; // (not testable on 32/64-bit) 156| 2.25k| } 157| | 158| | // array 16, 32 and fixarray 159| 8.42k| if (code == 0xdc || code == 0xdd || (code & 0xf0) == 0x90) ------------------ | Branch (159:9): [True: 194, False: 8.22k] | Branch (159:25): [True: 241, False: 7.98k] | Branch (159:41): [True: 2.75k, False: 5.23k] ------------------ 160| 3.18k| return readArray(variant, size, filter, nestingLimit); 161| | 162| | // map 16, 32 and fixmap 163| 5.23k| if (code == 0xde || code == 0xdf || (code & 0xf0) == 0x80) ------------------ | Branch (163:9): [True: 156, False: 5.07k] | Branch (163:25): [True: 140, False: 4.93k] | Branch (163:41): [True: 854, False: 4.08k] ------------------ 164| 1.15k| return readObject(variant, size, filter, nestingLimit); 165| | 166| | // str 8, 16, 32 and fixstr 167| 4.08k| if (code == 0xd9 || code == 0xda || code == 0xdb || (code & 0xe0) == 0xa0) { ------------------ | Branch (167:9): [True: 357, False: 3.72k] | Branch (167:25): [True: 145, False: 3.58k] | Branch (167:41): [True: 151, False: 3.42k] | Branch (167:57): [True: 2.38k, False: 1.04k] ------------------ 168| 3.03k| if (allowValue) ------------------ | Branch (168:11): [True: 3.03k, False: 0] ------------------ 169| 3.03k| return readString(variant, size); 170| 0| else 171| 0| return skipBytes(size); 172| 3.03k| } 173| | 174| 1.04k| if (isExtension) ------------------ | Branch (174:9): [True: 402, False: 645] ------------------ 175| 402| size++; // to include the type 176| | 177| 1.04k| if (allowValue) ------------------ | Branch (177:9): [True: 1.04k, False: 0] ------------------ 178| 1.04k| return readRawString(variant, header, uint8_t(1 + sizeBytes), size); 179| 0| else 180| 0| return skipBytes(size); 181| 1.04k| } _ZN11ArduinoJson8V740HB426detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEEE9readBytesEPvm: 191| 24.0k| DeserializationError::Code readBytes(void* p, size_t n) { 192| 24.0k| if (reader_.readBytes(reinterpret_cast(p), n) == n) ------------------ | Branch (192:9): [True: 23.4k, False: 559] ------------------ 193| 23.4k| return DeserializationError::Ok; 194| 559| return DeserializationError::IncompleteInput; 195| 24.0k| } _ZN11ArduinoJson8V740HB426detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEEE11readIntegerEPNS1_11VariantDataEhb: 211| 876| bool isSigned) { 212| 876| uint8_t buffer[8]; 213| | 214| 876| auto err = readBytes(buffer, width); 215| 876| if (err) ------------------ | Branch (215:9): [True: 18, False: 858] ------------------ 216| 18| return err; 217| | 218| 858| union { 219| 858| int64_t signedValue; 220| 858| uint64_t unsignedValue; 221| 858| }; 222| | 223| 858| if (isSigned) ------------------ | Branch (223:9): [True: 459, False: 399] ------------------ 224| 459| signedValue = static_cast(buffer[0]); // propagate sign bit 225| 399| else 226| 399| unsignedValue = static_cast(buffer[0]); 227| | 228| 3.46k| for (uint8_t i = 1; i < width; i++) ------------------ | Branch (228:25): [True: 2.60k, False: 858] ------------------ 229| 2.60k| unsignedValue = (unsignedValue << 8) | buffer[i]; 230| | 231| 858| if (isSigned) { ------------------ | Branch (231:9): [True: 459, False: 399] ------------------ 232| 459| auto truncatedValue = static_cast(signedValue); 233| 459| if (truncatedValue == signedValue) { ------------------ | Branch (233:11): [True: 459, False: 0] ------------------ 234| 459| if (!variant->setInteger(truncatedValue, resources_)) ------------------ | Branch (234:13): [True: 0, False: 459] ------------------ 235| 0| return DeserializationError::NoMemory; 236| 459| } 237| | // else set null on overflow 238| 459| } else { 239| 399| auto truncatedValue = static_cast(unsignedValue); 240| 399| if (truncatedValue == unsignedValue) ------------------ | Branch (240:11): [True: 399, False: 0] ------------------ 241| 399| if (!variant->setInteger(truncatedValue, resources_)) ------------------ | Branch (241:13): [True: 0, False: 399] ------------------ 242| 0| return DeserializationError::NoMemory; 243| | // else set null on overflow 244| 399| } 245| | 246| 858| return DeserializationError::Ok; 247| 858| } _ZN11ArduinoJson8V740HB426detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEEE9readFloatIfEENS1_9enable_ifIXeqstT_Li4EENS0_20DeserializationError4CodeEE4typeEPNS1_11VariantDataE: 251| 420| VariantData* variant) { 252| 420| DeserializationError::Code err; 253| 420| T value; 254| | 255| 420| err = readBytes(value); 256| 420| if (err) ------------------ | Branch (256:9): [True: 8, False: 412] ------------------ 257| 8| return err; 258| | 259| 412| fixEndianness(value); 260| 412| variant->setFloat(value, resources_); 261| | 262| 412| return DeserializationError::Ok; 263| 420| } _ZN11ArduinoJson8V740HB426detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEEE9readBytesIfEENS0_20DeserializationError4CodeERT_: 198| 420| DeserializationError::Code readBytes(T& value) { 199| 420| return readBytes(&value, sizeof(value)); 200| 420| } _ZN11ArduinoJson8V740HB426detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEEE10readDoubleIdEENS1_9enable_ifIXeqstT_Li8EENS0_20DeserializationError4CodeEE4typeEPNS1_11VariantDataE: 267| 138| VariantData* variant) { 268| 138| DeserializationError::Code err; 269| 138| T value; 270| | 271| 138| err = readBytes(value); 272| 138| if (err) ------------------ | Branch (272:9): [True: 15, False: 123] ------------------ 273| 15| return err; 274| | 275| 123| fixEndianness(value); 276| 123| if (variant->setFloat(value, resources_)) ------------------ | Branch (276:9): [True: 123, False: 0] ------------------ 277| 123| return DeserializationError::Ok; 278| 0| else 279| 0| return DeserializationError::NoMemory; 280| 123| } _ZN11ArduinoJson8V740HB426detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEEE9readBytesIdEENS0_20DeserializationError4CodeERT_: 198| 138| DeserializationError::Code readBytes(T& value) { 199| 138| return readBytes(&value, sizeof(value)); 200| 138| } _ZN11ArduinoJson8V740HB426detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEEE9readArrayINS1_14AllowAllFilterEEENS0_20DeserializationError4CodeEPNS1_11VariantDataEmT_NS0_21DeserializationOption12NestingLimitE: 344| 3.18k| DeserializationOption::NestingLimit nestingLimit) { 345| 3.18k| DeserializationError::Code err; 346| | 347| 3.18k| if (nestingLimit.reached()) ------------------ | Branch (347:9): [True: 4, False: 3.18k] ------------------ 348| 4| return DeserializationError::TooDeep; 349| | 350| 3.18k| bool allowArray = filter.allowArray(); 351| | 352| 3.18k| ArrayData* array; 353| 3.18k| if (allowArray) { ------------------ | Branch (353:9): [True: 3.18k, False: 0] ------------------ 354| 3.18k| ARDUINOJSON_ASSERT(variant != 0); ------------------ | | 11| 3.18k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 355| 3.18k| array = &variant->toArray(); 356| 3.18k| } else { 357| 0| array = 0; 358| 0| } 359| | 360| 3.18k| TFilter elementFilter = filter[0U]; 361| | 362| 13.1k| for (; n; --n) { ------------------ | Branch (362:12): [True: 10.7k, False: 2.45k] ------------------ 363| 10.7k| VariantData* value; 364| | 365| 10.7k| if (elementFilter.allow()) { ------------------ | Branch (365:11): [True: 10.7k, False: 0] ------------------ 366| 10.7k| ARDUINOJSON_ASSERT(array != 0); ------------------ | | 11| 10.7k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 367| 10.7k| value = array->addElement(resources_); 368| 10.7k| if (!value) ------------------ | Branch (368:13): [True: 0, False: 10.7k] ------------------ 369| 0| return DeserializationError::NoMemory; 370| 10.7k| } else { 371| 0| value = 0; 372| 0| } 373| | 374| 10.7k| err = parseVariant(value, elementFilter, nestingLimit.decrement()); 375| 10.7k| if (err) ------------------ | Branch (375:11): [True: 732, False: 10.0k] ------------------ 376| 732| return err; 377| 10.7k| } 378| | 379| 2.45k| return DeserializationError::Ok; 380| 3.18k| } _ZN11ArduinoJson8V740HB426detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEEE10readObjectINS1_14AllowAllFilterEEENS0_20DeserializationError4CodeEPNS1_11VariantDataEmT_NS0_21DeserializationOption12NestingLimitE: 385| 1.15k| DeserializationOption::NestingLimit nestingLimit) { 386| 1.15k| DeserializationError::Code err; 387| | 388| 1.15k| if (nestingLimit.reached()) ------------------ | Branch (388:9): [True: 1, False: 1.14k] ------------------ 389| 1| return DeserializationError::TooDeep; 390| | 391| 1.14k| ObjectData* object; 392| 1.14k| if (filter.allowObject()) { ------------------ | Branch (392:9): [True: 1.14k, False: 0] ------------------ 393| 1.14k| ARDUINOJSON_ASSERT(variant != 0); ------------------ | | 11| 1.14k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 394| 1.14k| object = &variant->toObject(); 395| 1.14k| } else { 396| 0| object = 0; 397| 0| } 398| | 399| 3.01k| for (; n; --n) { ------------------ | Branch (399:12): [True: 2.14k, False: 877] ------------------ 400| 2.14k| err = readKey(); 401| 2.14k| if (err) ------------------ | Branch (401:11): [True: 122, False: 2.01k] ------------------ 402| 122| return err; 403| | 404| 2.01k| JsonString key = stringBuffer_.str(); 405| 2.01k| TFilter memberFilter = filter[key.c_str()]; 406| 2.01k| VariantData* member = 0; 407| | 408| 2.01k| if (memberFilter.allow()) { ------------------ | Branch (408:11): [True: 2.01k, False: 0] ------------------ 409| 2.01k| ARDUINOJSON_ASSERT(object != 0); ------------------ | | 11| 2.01k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 410| | 411| 2.01k| auto keyVariant = object->addPair(&member, resources_); 412| 2.01k| if (!keyVariant) ------------------ | Branch (412:13): [True: 0, False: 2.01k] ------------------ 413| 0| return DeserializationError::NoMemory; 414| | 415| 2.01k| stringBuffer_.save(keyVariant); 416| 2.01k| } 417| | 418| 2.01k| err = parseVariant(member, memberFilter, nestingLimit.decrement()); 419| 2.01k| if (err) ------------------ | Branch (419:11): [True: 150, False: 1.86k] ------------------ 420| 150| return err; 421| 2.01k| } 422| | 423| 877| return DeserializationError::Ok; 424| 1.14k| } _ZN11ArduinoJson8V740HB426detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEEE7readKeyEv: 426| 2.14k| DeserializationError::Code readKey() { 427| 2.14k| DeserializationError::Code err; 428| 2.14k| uint8_t code; 429| | 430| 2.14k| err = readByte(code); 431| 2.14k| if (err) ------------------ | Branch (431:9): [True: 61, False: 2.07k] ------------------ 432| 61| return err; 433| | 434| 2.07k| if ((code & 0xe0) == 0xa0) ------------------ | Branch (434:9): [True: 1.86k, False: 219] ------------------ 435| 1.86k| return readString(code & 0x1f); 436| | 437| 219| if (code >= 0xd9 && code <= 0xdb) { ------------------ | Branch (437:9): [True: 206, False: 13] | Branch (437:25): [True: 199, False: 7] ------------------ 438| 199| uint8_t sizeBytes = uint8_t(1U << (code - 0xd9)); 439| 199| uint32_t size = 0; 440| 741| for (uint8_t i = 0; i < sizeBytes; i++) { ------------------ | Branch (440:27): [True: 557, False: 184] ------------------ 441| 557| err = readByte(code); 442| 557| if (err) ------------------ | Branch (442:13): [True: 15, False: 542] ------------------ 443| 15| return err; 444| 542| size = (size << 8) | code; 445| 542| } 446| 184| return readString(size); 447| 199| } 448| | 449| 20| return DeserializationError::InvalidInput; 450| 219| } _ZN11ArduinoJson8V740HB426detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEEE8readByteERh: 183| 2.69k| DeserializationError::Code readByte(uint8_t& value) { 184| 2.69k| int c = reader_.read(); 185| 2.69k| if (c < 0) ------------------ | Branch (185:9): [True: 76, False: 2.62k] ------------------ 186| 76| return DeserializationError::IncompleteInput; 187| 2.62k| value = static_cast(c); 188| 2.62k| return DeserializationError::Ok; 189| 2.69k| } _ZN11ArduinoJson8V740HB426detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEEE10readStringEm: 312| 5.07k| DeserializationError::Code readString(size_t n) { 313| 5.07k| char* p = stringBuffer_.reserve(n); 314| 5.07k| if (!p) ------------------ | Branch (314:9): [True: 36, False: 5.04k] ------------------ 315| 36| return DeserializationError::NoMemory; 316| | 317| 5.04k| return readBytes(p, n); 318| 5.07k| } _ZN11ArduinoJson8V740HB426detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEEE10readStringEPNS1_11VariantDataEm: 301| 3.03k| DeserializationError::Code readString(VariantData* variant, size_t n) { 302| 3.03k| DeserializationError::Code err; 303| | 304| 3.03k| err = readString(n); 305| 3.03k| if (err) ------------------ | Branch (305:9): [True: 100, False: 2.93k] ------------------ 306| 100| return err; 307| | 308| 2.93k| stringBuffer_.save(variant); 309| 2.93k| return DeserializationError::Ok; 310| 3.03k| } _ZN11ArduinoJson8V740HB426detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEEE13readRawStringEPNS1_11VariantDataEPKvhm: 322| 1.04k| uint8_t headerSize, size_t n) { 323| 1.04k| auto totalSize = size_t(headerSize + n); 324| 1.04k| if (totalSize < n) // integer overflow ------------------ | Branch (324:9): [True: 0, False: 1.04k] ------------------ 325| 0| return DeserializationError::NoMemory; // (not testable on 64-bit) 326| | 327| 1.04k| char* p = stringBuffer_.reserve(totalSize); 328| 1.04k| if (!p) ------------------ | Branch (328:9): [True: 50, False: 997] ------------------ 329| 50| return DeserializationError::NoMemory; 330| | 331| 997| memcpy(p, header, headerSize); 332| | 333| 997| auto err = readBytes(p + headerSize, n); 334| 997| if (err) ------------------ | Branch (334:9): [True: 96, False: 901] ------------------ 335| 96| return err; 336| | 337| 901| stringBuffer_.saveRaw(variant); 338| 901| return DeserializationError::Ok; 339| 997| } _ZN11ArduinoJson8V740HB4216serializeMsgPackINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEETnNS0_6detail9enable_ifIXntsr6detail10is_pointerIT_EE5valueEiE4typeELi0EEEmNS0_16JsonVariantConstERSB_: 224| 669|inline size_t serializeMsgPack(JsonVariantConst source, TDestination& output) { 225| 669| using namespace ArduinoJson::detail; 226| 669| return serialize(source, output); 227| 669|} _ZN11ArduinoJson8V740HB426detail17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEEC2ESB_PKNS1_15ResourceManagerE: 23| 669| : writer_(writer), resources_(resources) {} _ZN11ArduinoJson8V740HB426detail17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE5visitIfEENS1_9enable_ifIXaasr17is_floating_pointIT_EE5valueeqstSF_Li4EEmE4typeESF_: 27| 371| T value32) { 28| 371| if (canConvertNumber(value32)) { ------------------ | Branch (28:9): [True: 305, False: 66] ------------------ 29| 305| JsonInteger truncatedValue = JsonInteger(value32); 30| 305| if (value32 == T(truncatedValue)) ------------------ | Branch (30:11): [True: 238, False: 67] ------------------ 31| 238| return visit(truncatedValue); 32| 305| } 33| 133| writeByte(0xCA); 34| 133| writeInteger(value32); 35| 133| return bytesWritten(); 36| 371| } _ZN11ArduinoJson8V740HB426detail17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE9writeByteEh: 197| 5.22k| void writeByte(uint8_t c) { 198| 5.22k| writer_.write(c); 199| 5.22k| } _ZN11ArduinoJson8V740HB426detail17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE12writeIntegerIfEEvT_: 206| 133| void writeInteger(T value) { 207| 133| fixEndianness(value); 208| 133| writeBytes(reinterpret_cast(&value), sizeof(value)); 209| 133| } _ZN11ArduinoJson8V740HB426detail17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE10writeBytesEPKhm: 201| 4.83k| void writeBytes(const uint8_t* p, size_t n) { 202| 4.83k| writer_.write(p, n); 203| 4.83k| } _ZNK11ArduinoJson8V740HB426detail17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE12bytesWrittenEv: 193| 7.85k| size_t bytesWritten() const { 194| 7.85k| return writer_.count(); 195| 7.85k| } _ZN11ArduinoJson8V740HB426detail17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE5visitIdEENS1_9enable_ifIXaasr17is_floating_pointIT_EE5valueeqstSF_Li8EEmE4typeESF_: 41| 38| T value64) { 42| 38| float value32 = float(value64); 43| 38| if (value32 == value64) ------------------ | Branch (43:9): [True: 0, False: 38] ------------------ 44| 0| return visit(value32); 45| 38| writeByte(0xCB); 46| 38| writeInteger(value64); 47| 38| return bytesWritten(); 48| 38| } _ZN11ArduinoJson8V740HB426detail17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE12writeIntegerIdEEvT_: 206| 38| void writeInteger(T value) { 207| 38| fixEndianness(value); 208| 38| writeBytes(reinterpret_cast(&value), sizeof(value)); 209| 38| } _ZN11ArduinoJson8V740HB426detail17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE5visitERKNS1_9ArrayDataE: 50| 1.49k| size_t visit(const ArrayData& array) { 51| 1.49k| size_t n = array.size(resources_); 52| 1.49k| if (n < 0x10) { ------------------ | Branch (52:9): [True: 1.46k, False: 32] ------------------ 53| 1.46k| writeByte(uint8_t(0x90 + n)); 54| 1.46k| } else if (n < 0x10000) { ------------------ | Branch (54:16): [True: 32, False: 0] ------------------ 55| 32| writeByte(0xDC); 56| 32| writeInteger(uint16_t(n)); 57| 32| } else { 58| 0| writeByte(0xDD); 59| 0| writeInteger(uint32_t(n)); 60| 0| } 61| | 62| 1.49k| auto slotId = array.head(); 63| 6.29k| while (slotId != NULL_SLOT) { ------------------ | Branch (63:12): [True: 4.79k, False: 1.49k] ------------------ 64| 4.79k| auto slot = resources_->getVariant(slotId); 65| 4.79k| slot->accept(*this, resources_); 66| 4.79k| slotId = slot->next(); 67| 4.79k| } 68| | 69| 1.49k| return bytesWritten(); 70| 1.49k| } _ZN11ArduinoJson8V740HB426detail17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE12writeIntegerItEEvT_: 206| 143| void writeInteger(T value) { 207| 143| fixEndianness(value); 208| 143| writeBytes(reinterpret_cast(&value), sizeof(value)); 209| 143| } _ZN11ArduinoJson8V740HB426detail17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE12writeIntegerIjEEvT_: 206| 135| void writeInteger(T value) { 207| 135| fixEndianness(value); 208| 135| writeBytes(reinterpret_cast(&value), sizeof(value)); 209| 135| } _ZN11ArduinoJson8V740HB426detail17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE5visitERKNS1_10ObjectDataE: 72| 401| size_t visit(const ObjectData& object) { 73| 401| size_t n = object.size(resources_); 74| 401| if (n < 0x10) { ------------------ | Branch (74:9): [True: 383, False: 18] ------------------ 75| 383| writeByte(uint8_t(0x80 + n)); 76| 383| } else if (n < 0x10000) { ------------------ | Branch (76:16): [True: 18, False: 0] ------------------ 77| 18| writeByte(0xDE); 78| 18| writeInteger(uint16_t(n)); 79| 18| } else { 80| 0| writeByte(0xDF); 81| 0| writeInteger(uint32_t(n)); 82| 0| } 83| | 84| 401| auto slotId = object.head(); 85| 2.05k| while (slotId != NULL_SLOT) { ------------------ | Branch (85:12): [True: 1.65k, False: 401] ------------------ 86| 1.65k| auto slot = resources_->getVariant(slotId); 87| 1.65k| slot->accept(*this, resources_); 88| 1.65k| slotId = slot->next(); 89| 1.65k| } 90| | 91| 401| return bytesWritten(); 92| 401| } _ZN11ArduinoJson8V740HB426detail17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE5visitENS0_10JsonStringE: 98| 1.71k| size_t visit(JsonString value) { 99| 1.71k| ARDUINOJSON_ASSERT(!value.isNull()); ------------------ | | 11| 1.71k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 100| | 101| 1.71k| auto n = value.size(); 102| | 103| 1.71k| if (n < 0x20) { ------------------ | Branch (103:9): [True: 1.68k, False: 24] ------------------ 104| 1.68k| writeByte(uint8_t(0xA0 + n)); 105| 1.68k| } 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.71k| writeBytes(reinterpret_cast(value.c_str()), n); 116| 1.71k| return bytesWritten(); 117| 1.71k| } _ZN11ArduinoJson8V740HB426detail17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE12writeIntegerIhEEvT_: 206| 707| void writeInteger(T value) { 207| 707| fixEndianness(value); 208| 707| writeBytes(reinterpret_cast(&value), sizeof(value)); 209| 707| } _ZN11ArduinoJson8V740HB426detail17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE5visitENS0_15SerializedValueIPKcEE: 119| 74| size_t visit(RawString value) { 120| 74| writeBytes(reinterpret_cast(value.data()), value.size()); 121| 74| return bytesWritten(); 122| 74| } _ZN11ArduinoJson8V740HB426detail17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE5visitEl: 124| 2.44k| size_t visit(JsonInteger value) { 125| 2.44k| if (value > 0) { ------------------ | Branch (125:9): [True: 731, False: 1.71k] ------------------ 126| 731| visit(static_cast(value)); 127| 1.71k| } else if (value >= -0x20) { ------------------ | Branch (127:16): [True: 1.21k, False: 499] ------------------ 128| 1.21k| writeInteger(int8_t(value)); 129| 1.21k| } else if (value >= -0x80) { ------------------ | Branch (129:16): [True: 73, False: 426] ------------------ 130| 73| writeByte(0xD0); 131| 73| writeInteger(int8_t(value)); 132| 426| } else if (value >= -0x8000) { ------------------ | Branch (132:16): [True: 84, False: 342] ------------------ 133| 84| writeByte(0xD1); 134| 84| writeInteger(int16_t(value)); 135| 84| } 136| 342|#if ARDUINOJSON_USE_LONG_LONG 137| 342| else if (value >= -0x80000000LL) ------------------ | Branch (137:14): [True: 104, False: 238] ------------------ 138| |#else 139| | else 140| |#endif 141| 104| { 142| 104| writeByte(0xD2); 143| 104| writeInteger(int32_t(value)); 144| 104| } 145| 238|#if ARDUINOJSON_USE_LONG_LONG 146| 238| else { 147| 238| writeByte(0xD3); 148| 238| writeInteger(int64_t(value)); 149| 238| } 150| 2.44k|#endif 151| 2.44k| return bytesWritten(); 152| 2.44k| } _ZN11ArduinoJson8V740HB426detail17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE12writeIntegerIaEEvT_: 206| 1.29k| void writeInteger(T value) { 207| 1.29k| fixEndianness(value); 208| 1.29k| writeBytes(reinterpret_cast(&value), sizeof(value)); 209| 1.29k| } _ZN11ArduinoJson8V740HB426detail17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE12writeIntegerIsEEvT_: 206| 84| void writeInteger(T value) { 207| 84| fixEndianness(value); 208| 84| writeBytes(reinterpret_cast(&value), sizeof(value)); 209| 84| } _ZN11ArduinoJson8V740HB426detail17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE12writeIntegerIiEEvT_: 206| 104| void writeInteger(T value) { 207| 104| fixEndianness(value); 208| 104| writeBytes(reinterpret_cast(&value), sizeof(value)); 209| 104| } _ZN11ArduinoJson8V740HB426detail17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE12writeIntegerIlEEvT_: 206| 238| void writeInteger(T value) { 207| 238| fixEndianness(value); 208| 238| writeBytes(reinterpret_cast(&value), sizeof(value)); 209| 238| } _ZN11ArduinoJson8V740HB426detail17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE5visitEm: 154| 1.08k| size_t visit(JsonUInt value) { 155| 1.08k| if (value <= 0x7F) { ------------------ | Branch (155:9): [True: 609, False: 479] ------------------ 156| 609| writeInteger(uint8_t(value)); 157| 609| } else if (value <= 0xFF) { ------------------ | Branch (157:16): [True: 74, False: 405] ------------------ 158| 74| writeByte(0xCC); 159| 74| writeInteger(uint8_t(value)); 160| 405| } else if (value <= 0xFFFF) { ------------------ | Branch (160:16): [True: 93, False: 312] ------------------ 161| 93| writeByte(0xCD); 162| 93| writeInteger(uint16_t(value)); 163| 93| } 164| 312|#if ARDUINOJSON_USE_LONG_LONG 165| 312| else if (value <= 0xFFFFFFFF) ------------------ | Branch (165:14): [True: 135, False: 177] ------------------ 166| |#else 167| | else 168| |#endif 169| 135| { 170| 135| writeByte(0xCE); 171| 135| writeInteger(uint32_t(value)); 172| 135| } 173| 177|#if ARDUINOJSON_USE_LONG_LONG 174| 177| else { 175| 177| writeByte(0xCF); 176| 177| writeInteger(uint64_t(value)); 177| 177| } 178| 1.08k|#endif 179| 1.08k| return bytesWritten(); 180| 1.08k| } _ZN11ArduinoJson8V740HB426detail17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE12writeIntegerImEEvT_: 206| 177| void writeInteger(T value) { 207| 177| fixEndianness(value); 208| 177| writeBytes(reinterpret_cast(&value), sizeof(value)); 209| 177| } _ZN11ArduinoJson8V740HB426detail17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE5visitEb: 182| 216| size_t visit(bool value) { 183| 216| writeByte(value ? 0xC3 : 0xC2); ------------------ | Branch (183:15): [True: 41, False: 175] ------------------ 184| 216| return bytesWritten(); 185| 216| } _ZN11ArduinoJson8V740HB426detail17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE5visitEDn: 187| 245| size_t visit(nullptr_t) { 188| 245| writeByte(0xC0); 189| 245| return bytesWritten(); 190| 245| } _ZN11ArduinoJson8V740HB426detail13fixEndiannessIfEEvRT_: 37| 545|inline void fixEndianness(T& value) { 38| 545| fixEndianness(reinterpret_cast(&value), 39| 545| integral_constant()); 40| 545|} _ZN11ArduinoJson8V740HB426detail13fixEndiannessEPhNS1_17integral_constantImLm4EEE: 25| 784|inline void fixEndianness(uint8_t* p, integral_constant) { 26| 784| swapBytes(p[0], p[3]); 27| 784| swapBytes(p[1], p[2]); 28| 784|} _ZN11ArduinoJson8V740HB426detail9swapBytesERhS2_: 12| 4.09k|inline void swapBytes(uint8_t& a, uint8_t& b) { 13| 4.09k| uint8_t t(a); 14| 4.09k| a = b; 15| 4.09k| b = t; 16| 4.09k|} _ZN11ArduinoJson8V740HB426detail13fixEndiannessIdEEvRT_: 37| 161|inline void fixEndianness(T& value) { 38| 161| fixEndianness(reinterpret_cast(&value), 39| 161| integral_constant()); 40| 161|} _ZN11ArduinoJson8V740HB426detail13fixEndiannessEPhNS1_17integral_constantImLm8EEE: 18| 576|inline void fixEndianness(uint8_t* p, integral_constant) { 19| 576| swapBytes(p[0], p[7]); 20| 576| swapBytes(p[1], p[6]); 21| 576| swapBytes(p[2], p[5]); 22| 576| swapBytes(p[3], p[4]); 23| 576|} _ZN11ArduinoJson8V740HB426detail13fixEndiannessItEEvRT_: 37| 143|inline void fixEndianness(T& value) { 38| 143| fixEndianness(reinterpret_cast(&value), 39| 143| integral_constant()); 40| 143|} _ZN11ArduinoJson8V740HB426detail13fixEndiannessEPhNS1_17integral_constantImLm2EEE: 30| 227|inline void fixEndianness(uint8_t* p, integral_constant) { 31| 227| swapBytes(p[0], p[1]); 32| 227|} _ZN11ArduinoJson8V740HB426detail13fixEndiannessIjEEvRT_: 37| 135|inline void fixEndianness(T& value) { 38| 135| fixEndianness(reinterpret_cast(&value), 39| 135| integral_constant()); 40| 135|} _ZN11ArduinoJson8V740HB426detail13fixEndiannessIhEEvRT_: 37| 707|inline void fixEndianness(T& value) { 38| 707| fixEndianness(reinterpret_cast(&value), 39| 707| integral_constant()); 40| 707|} _ZN11ArduinoJson8V740HB426detail13fixEndiannessEPhNS1_17integral_constantImLm1EEE: 34| 1.99k|inline void fixEndianness(uint8_t*, integral_constant) {} _ZN11ArduinoJson8V740HB426detail13fixEndiannessIaEEvRT_: 37| 1.29k|inline void fixEndianness(T& value) { 38| 1.29k| fixEndianness(reinterpret_cast(&value), 39| 1.29k| integral_constant()); 40| 1.29k|} _ZN11ArduinoJson8V740HB426detail13fixEndiannessIsEEvRT_: 37| 84|inline void fixEndianness(T& value) { 38| 84| fixEndianness(reinterpret_cast(&value), 39| 84| integral_constant()); 40| 84|} _ZN11ArduinoJson8V740HB426detail13fixEndiannessIiEEvRT_: 37| 104|inline void fixEndianness(T& value) { 38| 104| fixEndianness(reinterpret_cast(&value), 39| 104| integral_constant()); 40| 104|} _ZN11ArduinoJson8V740HB426detail13fixEndiannessIlEEvRT_: 37| 238|inline void fixEndianness(T& value) { 38| 238| fixEndianness(reinterpret_cast(&value), 39| 238| integral_constant()); 40| 238|} _ZN11ArduinoJson8V740HB426detail13fixEndiannessImEEvRT_: 37| 177|inline void fixEndianness(T& value) { 38| 177| fixEndianness(reinterpret_cast(&value), 39| 177| integral_constant()); 40| 177|} _ZN11ArduinoJson8V740HB426detail11FloatTraitsIfLm4EE11highest_forIlEEfPNS1_9enable_ifIXaaaasr11is_integralIT_EE5valuesr9is_signedIS6_EE5valueeqstS6_Li8EEiE4typeE: 178| 305| signed>* = 0) { 179| 305| return forge(0x5EFFFFFF); // 9.22337148709896192E18 180| 305| } _ZN11ArduinoJson8V740HB426detail11FloatTraitsIfLm4EE5forgeEj: 142| 305| static T forge(uint32_t bits) { 143| 305| return alias_cast(bits); 144| 305| } _ZN11ArduinoJson8V740HB426detail16canConvertNumberIilEENS1_9enable_ifIXaaaaaaaasr11is_integralIT0_EE5valuesr9is_signedIS4_EE5valuesr11is_integralIT_EE5valuesr9is_signedIS5_EE5valueltstS5_stS4_EbE4typeES4_: 55| 459|canConvertNumber(TIn value) { 56| 459| return value >= TIn(numeric_limits::lowest()) && ------------------ | Branch (56:10): [True: 346, False: 113] ------------------ 57| 459| value <= TIn(numeric_limits::highest()); ------------------ | Branch (57:10): [True: 338, False: 8] ------------------ 58| 459|} _ZN11ArduinoJson8V740HB426detail16canConvertNumberIjmEENS1_9enable_ifIXaaaaaasr11is_integralIT0_EE5valuesr11is_unsignedIS4_EE5valuesr11is_integralIT_EE5valuelestS5_stS4_EbE4typeES4_: 28| 399|canConvertNumber(TIn value) { 29| 399| return value <= TIn(numeric_limits::highest()); 30| 399|} _ZN11ArduinoJson8V740HB426detail16canConvertNumberIiaEENS1_9enable_ifIXaaaaaaaasr11is_integralIT0_EE5valuesr9is_signedIS4_EE5valuesr11is_integralIT_EE5valuesr9is_signedIS5_EE5valuelestS4_stS5_EbE4typeES4_: 67| 3.24k|canConvertNumber(TIn) { 68| 3.24k| return true; 69| 3.24k|} _ZN11ArduinoJson8V740HB426detail16canConvertNumberIlfEENS1_9enable_ifIXaaaasr17is_floating_pointIT0_EE5valuesr11is_integralIT_EE5valuegestS5_stS4_EbE4typeES4_: 117| 371|canConvertNumber(TIn value) { 118| | // Avoid error "9.22337e+18 is outside the range of representable values of 119| | // type 'long'" 120| 371| return value >= numeric_limits::lowest() && ------------------ | Branch (120:10): [True: 305, False: 66] ------------------ 121| 371| value <= FloatTraits::template highest_for(); ------------------ | Branch (121:10): [True: 305, False: 0] ------------------ 122| 371|} _ZNK11ArduinoJson8V740HB426detail10ObjectData4sizeEPKNS1_15ResourceManagerE: 55| 401| size_t size(const ResourceManager* resources) const { 56| 401| return CollectionData::size(resources) / 2; 57| 401| } _ZN11ArduinoJson8V740HB426detail10ObjectData7addPairEPPNS1_11VariantDataEPNS1_15ResourceManagerE: 72| 2.01k| ResourceManager* resources) { 73| 2.01k| auto keySlot = resources->allocVariant(); 74| 2.01k| if (!keySlot) ------------------ | Branch (74:7): [True: 0, False: 2.01k] ------------------ 75| 0| return nullptr; 76| | 77| 2.01k| auto valueSlot = resources->allocVariant(); 78| 2.01k| if (!valueSlot) ------------------ | Branch (78:7): [True: 0, False: 2.01k] ------------------ 79| 0| return nullptr; 80| 2.01k| *value = valueSlot.ptr(); 81| | 82| 2.01k| CollectionData::appendPair(keySlot, valueSlot, resources); 83| | 84| 2.01k| return keySlot.ptr(); 85| 2.01k|} _ZN11ArduinoJson8V740HB426detail10alias_castIfjEET_T0_: 24| 305|T alias_cast(F raw_data) { 25| 305| alias_cast_t ac; 26| 305| ac.raw = raw_data; 27| 305| return ac.data; 28| 305|} _ZN11ArduinoJson8V740HB426detail14numeric_limitsIivE6lowestEv: 33| 805| static constexpr T lowest() { 34| 805| return T(T(1) << (sizeof(T) * 8 - 1)); 35| 805| } _ZN11ArduinoJson8V740HB426detail14numeric_limitsIivE7highestEv: 36| 346| static constexpr T highest() { 37| 346| return T(~lowest()); 38| 346| } _ZN11ArduinoJson8V740HB426detail14numeric_limitsIjvE7highestEv: 25| 399| static constexpr T highest() { 26| 399| return T(-1); 27| 399| } _ZN11ArduinoJson8V740HB426detail14numeric_limitsIlvE6lowestEv: 33| 371| static constexpr T lowest() { 34| 371| return T(T(1) << (sizeof(T) * 8 - 1)); 35| 371| } _ZN11ArduinoJson8V740HB426detail7forwardIRNS0_12JsonDocumentEEEOT_RNS1_16remove_referenceIS5_E4typeE: 14| 1.41k|T&& forward(remove_reference_t& t) noexcept { 15| 1.41k| return static_cast(t); 16| 1.41k|} _ZN11ArduinoJson8V740HB426detail7forwardIRmEEOT_RNS1_16remove_referenceIS4_E4typeE: 14| 1.41k|T&& forward(remove_reference_t& t) noexcept { 15| 1.41k| return static_cast(t); 16| 1.41k|} _ZN11ArduinoJson8V740HB426detail17CountingDecoratorINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEEC2ERSB_: 14| 669| explicit CountingDecorator(TWriter& writer) : writer_(writer), count_(0) {} _ZN11ArduinoJson8V740HB426detail17CountingDecoratorINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE5writeEh: 16| 5.22k| void write(uint8_t c) { 17| 5.22k| count_ += writer_.write(c); 18| 5.22k| } _ZN11ArduinoJson8V740HB426detail17CountingDecoratorINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE5writeEPKhm: 20| 4.83k| void write(const uint8_t* s, size_t n) { 21| 4.83k| count_ += writer_.write(s, n); 22| 4.83k| } _ZNK11ArduinoJson8V740HB426detail17CountingDecoratorINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE5countEv: 24| 7.85k| size_t count() const { 25| 7.85k| return count_; 26| 7.85k| } _ZN11ArduinoJson8V740HB426detail6WriterINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEvEC2ERS9_: 24| 669| Writer(TDestination& str) : str_(&str) { 25| 669| str.clear(); 26| 669| } _ZN11ArduinoJson8V740HB426detail6WriterINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEvE5writeEh: 28| 5.22k| size_t write(uint8_t c) { 29| 5.22k| str_->push_back(static_cast(c)); 30| 5.22k| return 1; 31| 5.22k| } _ZN11ArduinoJson8V740HB426detail6WriterINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEvE5writeEPKhm: 33| 4.83k| size_t write(const uint8_t* s, size_t n) { 34| 4.83k| str_->append(reinterpret_cast(s), n); 35| 4.83k| return n; 36| 4.83k| } _ZN11ArduinoJson8V740HB426detail9serializeINS1_17MsgPackSerializerENSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEmNS0_16JsonVariantConstERT0_: 21| 669| TDestination& destination) { 22| 669| Writer writer(destination); 23| 669| return doSerialize(source, writer); 24| 669|} _ZN11ArduinoJson8V740HB426detail11doSerializeINS1_17MsgPackSerializerENS1_6WriterINSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEvEEEEmNS0_16JsonVariantConstET0_: 12| 669|size_t doSerialize(ArduinoJson::JsonVariantConst source, TWriter writer) { 13| 669| auto data = VariantAttorney::getData(source); 14| 669| auto resources = VariantAttorney::getResourceManager(source); 15| 669| TSerializer serializer(writer, resources); 16| 669| return VariantData::accept(data, resources, serializer); 17| 669|} _ZN11ArduinoJson8V740HB426detail9RamStringC2EPKcmb: 30| 7.10k| : str_(str), size_(sz & sizeMask), static_(isStatic) { 31| 7.10k| ARDUINOJSON_ASSERT(size_ == sz); ------------------ | | 11| 7.10k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 32| 7.10k| } _ZNK11ArduinoJson8V740HB426detail9RamString4dataEv: 48| 3.72k| const char* data() const { 49| 3.72k| return str_; 50| 3.72k| } _ZNK11ArduinoJson8V740HB426detail9RamString6isNullEv: 34| 6.53k| bool isNull() const { 35| 6.53k| return !str_; 36| 6.53k| } _ZNK11ArduinoJson8V740HB426detail9RamString4sizeEv: 38| 18.2k| size_t size() const { 39| 18.2k| return size_; 40| 18.2k| } _ZNK11ArduinoJson8V740HB426detail9RamStringixEm: 42| 11.7k| char operator[](size_t i) const { 43| 11.7k| ARDUINOJSON_ASSERT(str_ != 0); ------------------ | | 11| 11.7k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 44| 11.7k| ARDUINOJSON_ASSERT(i <= size()); ------------------ | | 11| 11.7k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 45| 11.7k| return str_[i]; 46| 11.7k| } _ZN11ArduinoJson8V740HB426detail18SizedStringAdapterIPcvE5adaptEPKcm: 113| 3.37k| static AdaptedString adapt(const TChar* p, size_t n) { 114| 3.37k| return AdaptedString(reinterpret_cast(p), n); 115| 3.37k| } _ZN11ArduinoJson8V740HB4210JsonStringC2ItTnNS0_6detail9enable_ifIXaasr6detail11is_integralIT_EE5valuentsr6detail7is_sameIS5_bEE5valueEiE4typeELi0EEEPKcS5_b: 32| 2.05k| : str_(data, size_t(sz), isStatic) {} _ZNK11ArduinoJson8V740HB4210JsonString5c_strEv: 35| 3.72k| const char* c_str() const { 36| 3.72k| return str_.data(); 37| 3.72k| } _ZNK11ArduinoJson8V740HB4210JsonString6isNullEv: 40| 1.71k| bool isNull() const { 41| 1.71k| return str_.isNull(); 42| 1.71k| } _ZNK11ArduinoJson8V740HB4210JsonString4sizeEv: 51| 1.71k| size_t size() const { 52| 1.71k| return str_.size(); 53| 1.71k| } _ZN11ArduinoJson8V740HB4210JsonStringC2EPKcb: 25| 1.67k| : str_(data, data ? ::strlen(data) : 0, isStatic) {} ------------------ | Branch (25:20): [True: 1.67k, False: 0] ------------------ _ZN11ArduinoJson8V740HB426detail11adaptStringIcEENS1_13StringAdapterINS1_11conditionalIXsr15IsStringLiteralIPT_EE5valueES6_NS1_9remove_cvINS1_16remove_referenceIS6_E4typeEE4typeEE4typeEvE13AdaptedStringES6_m: 43| 3.37k|AdaptedString adaptString(TChar* p, size_t n) { 44| 3.37k| return SizedStringAdapter::adapt(p, n); 45| 3.37k|} _ZN11ArduinoJson8V740HB426detail12stringEqualsINS1_9RamStringES3_EENS1_9enable_ifIXlesrT_11typeSortKeysrT0_11typeSortKeyEbE4typeES5_S6_: 44| 2.41k|stringEquals(TAdaptedString1 s1, TAdaptedString2 s2) { 45| 2.41k| ARDUINOJSON_ASSERT(!s1.isNull()); ------------------ | | 11| 2.41k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 46| 2.41k| ARDUINOJSON_ASSERT(!s2.isNull()); ------------------ | | 11| 2.41k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 47| 2.41k| size_t size1 = s1.size(); 48| 2.41k| size_t size2 = s2.size(); 49| 2.41k| if (size1 != size2) ------------------ | Branch (49:7): [True: 415, False: 1.99k] ------------------ 50| 415| return false; 51| 6.46k| for (size_t i = 0; i < size1; i++) { ------------------ | Branch (51:22): [True: 5.87k, False: 596] ------------------ 52| 5.87k| if (s1[i] != s2[i]) ------------------ | Branch (52:9): [True: 1.40k, False: 4.46k] ------------------ 53| 1.40k| return false; 54| 5.87k| } 55| 596| return true; 56| 1.99k|} _ZN11ArduinoJson8V740HB4216JsonVariantConstC2EPKNS0_6detail11VariantDataEPKNS2_15ResourceManagerE: 43| 669| : data_(data), resources_(resources) {} _ZNK11ArduinoJson8V740HB4216JsonVariantConst7getDataEv: 184| 669| const detail::VariantData* getData() const { 185| 669| return data_; 186| 669| } _ZNK11ArduinoJson8V740HB4216JsonVariantConst18getResourceManagerEv: 188| 669| const detail::ResourceManager* getResourceManager() const { 189| 669| return resources_; 190| 669| } _ZN11ArduinoJson8V740HB426detail15VariantAttorney15getOrCreateDataINS0_12JsonDocumentEEEPNS1_11VariantDataERT_: 30| 1.41k| static VariantData* getOrCreateData(TClient& client) { 31| 1.41k| return client.getOrCreateData(); 32| 1.41k| } _ZN11ArduinoJson8V740HB426detail15VariantAttorney18getResourceManagerINS0_12JsonDocumentEEEDTcldtfp_18getResourceManagerEERT_: 20| 1.41k| -> decltype(client.getResourceManager()) { 21| 1.41k| return client.getResourceManager(); 22| 1.41k| } _ZN11ArduinoJson8V740HB426detail15VariantAttorney7getDataINS0_16JsonVariantConstEEEDTcldtfp_7getDataEERT_: 25| 669| static auto getData(TClient& client) -> decltype(client.getData()) { 26| 669| return client.getData(); 27| 669| } _ZN11ArduinoJson8V740HB426detail15VariantAttorney18getResourceManagerINS0_16JsonVariantConstEEEDTcldtfp_18getResourceManagerEERT_: 20| 669| -> decltype(client.getResourceManager()) { 21| 669| return client.getResourceManager(); 22| 669| } _ZN11ArduinoJson8V740HB426detail14VariantContentC2Ev: 53| 16.1k| VariantContent() {} _ZN11ArduinoJson8V740HB426detailanENS1_11VariantTypeENS1_15VariantTypeBitsE: 46| 7.12k|inline bool operator&(VariantType type, VariantTypeBits bit) { 47| 7.12k| return (uint8_t(type) & uint8_t(bit)) != 0; 48| 7.12k|} _ZN11ArduinoJson8V740HB426detail11VariantDataC2Ev: 43| 16.1k| VariantData() : type_(VariantType::Null), next_(NULL_SLOT) {} _ZN11ArduinoJson8V740HB426detail11VariantData5resetEv: 462| 1.41k| void reset() { // TODO: remove 463| 1.41k| type_ = VariantType::Null; 464| 1.41k| } _ZN11ArduinoJson8V740HB426detail11VariantData10setBooleanEb: 466| 504| void setBoolean(bool value) { 467| 504| ARDUINOJSON_ASSERT(type_ == VariantType::Null); // must call clear() first ------------------ | | 11| 504|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 468| 504| type_ = VariantType::Boolean; 469| 504| content_.asBoolean = value; 470| 504| } _ZN11ArduinoJson8V740HB426detail11VariantData8setFloatIfEENS1_9enable_ifIXeqstT_Li4EEbE4typeES5_PNS1_15ResourceManagerE: 473| 412| enable_if_t setFloat(T value, ResourceManager*) { 474| 412| ARDUINOJSON_ASSERT(type_ == VariantType::Null); // must call clear() first ------------------ | | 11| 412|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 475| 412| type_ = VariantType::Float; 476| 412| content_.asFloat = value; 477| 412| return true; 478| 412| } _ZN11ArduinoJson8V740HB426detail11VariantData7toArrayEv: 559| 3.18k| ArrayData& toArray() { 560| 3.18k| ARDUINOJSON_ASSERT(type_ == VariantType::Null); // must call clear() first ------------------ | | 11| 3.18k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 561| 3.18k| type_ = VariantType::Array; 562| 3.18k| new (&content_.asArray) ArrayData(); 563| 3.18k| return content_.asArray; 564| 3.18k| } _ZN11ArduinoJson8V740HB426detail11VariantDatanwEmPv: 37| 14.7k| static void* operator new(size_t, void* p) noexcept { 38| 14.7k| return p; 39| 14.7k| } _ZN11ArduinoJson8V740HB426detail11VariantData7setNextEj: 49| 12.2k| void setNext(SlotId slot) { 50| 12.2k| next_ = slot; 51| 12.2k| } _ZN11ArduinoJson8V740HB426detail11VariantData8toObjectEv: 573| 1.14k| ObjectData& toObject() { 574| 1.14k| ARDUINOJSON_ASSERT(type_ == VariantType::Null); // must call clear() first ------------------ | | 11| 1.14k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 575| 1.14k| type_ = VariantType::Object; 576| 1.14k| new (&content_.asObject) ObjectData(); 577| 1.14k| return content_.asObject; 578| 1.14k| } msgpack_fuzzer.cpp:_ZN11ArduinoJson8V740HB426detailL12isTinyStringIPKcEEbRKT_m: 21| 4.95k|static bool isTinyString(const T& s, size_t n) { 22| 4.95k| if (n > tinyStringMaxLength) ------------------ | Branch (22:7): [True: 34, False: 4.91k] ------------------ 23| 34| return false; 24| 4.91k| bool containsNul = false; 25| 5.39k| for (uint8_t i = 0; i < uint8_t(n); i++) ------------------ | Branch (25:23): [True: 475, False: 4.91k] ------------------ 26| 475| containsNul |= !s[i]; 27| 4.91k| return !containsNul; 28| 4.95k|} _ZN11ArduinoJson8V740HB426detail11VariantData13setTinyStringEPKch: 529| 4.89k| void setTinyString(const char* s, uint8_t n) { 530| 4.89k| ARDUINOJSON_ASSERT(type_ == VariantType::Null); // must call clear() first ------------------ | | 11| 4.89k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 531| 4.89k| ARDUINOJSON_ASSERT(s); ------------------ | | 11| 4.89k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 532| 4.89k| type_ = VariantType::TinyString; 533| 5.33k| for (uint8_t i = 0; i < n; i++) ------------------ | Branch (533:25): [True: 445, False: 4.89k] ------------------ 534| 445| content_.asTinyString[i] = s[i]; 535| 4.89k| content_.asTinyString[n] = 0; 536| 4.89k| } _ZN11ArduinoJson8V740HB426detail11VariantData14setOwnedStringEPNS1_10StringNodeE: 538| 63| void setOwnedString(StringNode* s) { 539| 63| ARDUINOJSON_ASSERT(type_ == VariantType::Null); // must call clear() first ------------------ | | 11| 63|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 540| 63| ARDUINOJSON_ASSERT(s); ------------------ | | 11| 63|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 541| 63| type_ = VariantType::OwnedString; 542| 63| content_.asOwnedString = s; 543| 63| } _ZN11ArduinoJson8V740HB426detail11VariantData12setRawStringEPNS1_10StringNodeE: 491| 901| void setRawString(StringNode* s) { 492| 901| ARDUINOJSON_ASSERT(type_ == VariantType::Null); // must call clear() first ------------------ | | 11| 901|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 493| 901| ARDUINOJSON_ASSERT(s); ------------------ | | 11| 901|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 494| 901| type_ = VariantType::RawString; 495| 901| content_.asOwnedString = s; 496| 901| } _ZN11ArduinoJson8V740HB426detail11VariantData6acceptINS1_17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEvEEEEEENT_11result_typeEPKS2_PKNS1_15ResourceManagerERSF_: 115| 669| TVisitor& visit) { 116| 669| if (var != 0) ------------------ | Branch (116:9): [True: 669, False: 0] ------------------ 117| 669| return var->accept(visit, resources); 118| 0| else 119| 0| return visit.visit(nullptr); 120| 669| } _ZNK11ArduinoJson8V740HB426detail11VariantData6acceptINS1_17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEvEEEEEENT_11result_typeERSF_PKNS1_15ResourceManagerE: 55| 7.12k| TVisitor& visit, const ResourceManager* resources) const { 56| 7.12k|#if ARDUINOJSON_USE_EXTENSIONS 57| 7.12k| auto extension = getExtension(resources); 58| |#else 59| | (void)resources; // silence warning 60| |#endif 61| 7.12k| switch (type_) { 62| 371| case VariantType::Float: ------------------ | Branch (62:7): [True: 371, False: 6.75k] ------------------ 63| 371| return visit.visit(content_.asFloat); 64| | 65| 0|#if ARDUINOJSON_USE_DOUBLE 66| 38| case VariantType::Double: ------------------ | Branch (66:7): [True: 38, False: 7.08k] ------------------ 67| 38| return visit.visit(extension->asDouble); 68| 0|#endif 69| | 70| 1.49k| case VariantType::Array: ------------------ | Branch (70:7): [True: 1.49k, False: 5.62k] ------------------ 71| 1.49k| return visit.visit(content_.asArray); 72| | 73| 401| case VariantType::Object: ------------------ | Branch (73:7): [True: 401, False: 6.72k] ------------------ 74| 401| return visit.visit(content_.asObject); 75| | 76| 1.67k| case VariantType::TinyString: ------------------ | Branch (76:7): [True: 1.67k, False: 5.44k] ------------------ 77| 1.67k| return visit.visit(JsonString(content_.asTinyString)); 78| | 79| 0| case VariantType::LinkedString: ------------------ | Branch (79:7): [True: 0, False: 7.12k] ------------------ 80| 0| return visit.visit(JsonString(content_.asLinkedString, true)); 81| | 82| 33| case VariantType::OwnedString: ------------------ | Branch (82:7): [True: 33, False: 7.08k] ------------------ 83| 33| return visit.visit(JsonString(content_.asOwnedString->data, 84| 33| content_.asOwnedString->length)); 85| | 86| 74| case VariantType::RawString: ------------------ | Branch (86:7): [True: 74, False: 7.04k] ------------------ 87| 74| return visit.visit(RawString(content_.asOwnedString->data, 88| 74| content_.asOwnedString->length)); 89| | 90| 2.09k| case VariantType::Int32: ------------------ | Branch (90:7): [True: 2.09k, False: 5.02k] ------------------ 91| 2.09k| return visit.visit(static_cast(content_.asInt32)); 92| | 93| 256| case VariantType::Uint32: ------------------ | Branch (93:7): [True: 256, False: 6.86k] ------------------ 94| 256| return visit.visit(static_cast(content_.asUint32)); 95| | 96| 0|#if ARDUINOJSON_USE_LONG_LONG 97| 111| case VariantType::Int64: ------------------ | Branch (97:7): [True: 111, False: 7.01k] ------------------ 98| 111| return visit.visit(extension->asInt64); 99| | 100| 101| case VariantType::Uint64: ------------------ | Branch (100:7): [True: 101, False: 7.02k] ------------------ 101| 101| return visit.visit(extension->asUint64); 102| 0|#endif 103| | 104| 216| case VariantType::Boolean: ------------------ | Branch (104:7): [True: 216, False: 6.90k] ------------------ 105| 216| return visit.visit(content_.asBoolean != 0); 106| | 107| 245| default: ------------------ | Branch (107:7): [True: 245, False: 6.87k] ------------------ 108| 245| return visit.visit(nullptr); 109| 7.12k| } 110| 7.12k| } _ZNK11ArduinoJson8V740HB426detail11VariantData4nextEv: 45| 12.9k| SlotId next() const { 46| 12.9k| return next_; 47| 12.9k| } _ZN11ArduinoJson8V740HB426detail11VariantData10setIntegerIlEENS1_9enable_ifIXsr9is_signedIT_EE5valueEbE4typeES5_PNS1_15ResourceManagerE: 102| 459| T value, ResourceManager* resources) { 103| 459| ARDUINOJSON_ASSERT(type_ == VariantType::Null); // must call clear() first ------------------ | | 11| 459|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 104| 459| (void)resources; // silence warning 105| | 106| 459| if (canConvertNumber(value)) { ------------------ | Branch (106:7): [True: 338, False: 121] ------------------ 107| 338| type_ = VariantType::Int32; 108| 338| content_.asInt32 = static_cast(value); 109| 338| } 110| 121|#if ARDUINOJSON_USE_LONG_LONG 111| 121| else { 112| 121| auto extension = resources->allocExtension(); 113| 121| if (!extension) ------------------ | Branch (113:9): [True: 0, False: 121] ------------------ 114| 0| return false; 115| 121| type_ = VariantType::Int64; 116| 121| content_.asSlotId = extension.id(); 117| 121| extension->asInt64 = value; 118| 121| } 119| 459|#endif 120| 459| return true; 121| 459|} _ZN11ArduinoJson8V740HB426detail11VariantData10setIntegerImEENS1_9enable_ifIXsr11is_unsignedIT_EE5valueEbE4typeES5_PNS1_15ResourceManagerE: 125| 399| T value, ResourceManager* resources) { 126| 399| ARDUINOJSON_ASSERT(type_ == VariantType::Null); // must call clear() first ------------------ | | 11| 399|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 127| 399| (void)resources; // silence warning 128| | 129| 399| if (canConvertNumber(value)) { ------------------ | Branch (129:7): [True: 262, False: 137] ------------------ 130| 262| type_ = VariantType::Uint32; 131| 262| content_.asUint32 = static_cast(value); 132| 262| } 133| 137|#if ARDUINOJSON_USE_LONG_LONG 134| 137| else { 135| 137| auto extension = resources->allocExtension(); 136| 137| if (!extension) ------------------ | Branch (136:9): [True: 0, False: 137] ------------------ 137| 0| return false; 138| 137| type_ = VariantType::Uint64; 139| 137| content_.asSlotId = extension.id(); 140| 137| extension->asUint64 = value; 141| 137| } 142| 399|#endif 143| 399| return true; 144| 399|} _ZN11ArduinoJson8V740HB426detail11VariantData8setFloatIdEENS1_9enable_ifIXeqstT_Li8EEbE4typeES5_PNS1_15ResourceManagerE: 75| 123| T value, ResourceManager* resources) { 76| 123| ARDUINOJSON_ASSERT(type_ == VariantType::Null); // must call clear() first ------------------ | | 11| 123|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 77| 123| (void)resources; // silence warning 78| | 79| 123| float valueAsFloat = static_cast(value); 80| | 81| 123|#if ARDUINOJSON_USE_DOUBLE 82| 123| if (value == valueAsFloat) { ------------------ | Branch (82:7): [True: 35, False: 88] ------------------ 83| 35| type_ = VariantType::Float; 84| 35| content_.asFloat = valueAsFloat; 85| 88| } else { 86| 88| auto extension = resources->allocExtension(); 87| 88| if (!extension) ------------------ | Branch (87:9): [True: 0, False: 88] ------------------ 88| 0| return false; 89| 88| type_ = VariantType::Double; 90| 88| content_.asSlotId = extension.id(); 91| 88| extension->asDouble = value; 92| 88| } 93| |#else 94| | type_ = VariantType::Float; 95| | content_.asFloat = valueAsFloat; 96| |#endif 97| 123| return true; 98| 123|} _ZN11ArduinoJson8V740HB426detail11VariantData10setIntegerIaEENS1_9enable_ifIXsr9is_signedIT_EE5valueEbE4typeES5_PNS1_15ResourceManagerE: 102| 3.24k| T value, ResourceManager* resources) { 103| 3.24k| ARDUINOJSON_ASSERT(type_ == VariantType::Null); // must call clear() first ------------------ | | 11| 3.24k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 104| 3.24k| (void)resources; // silence warning 105| | 106| 3.24k| if (canConvertNumber(value)) { ------------------ | Branch (106:7): [True: 3.24k, False: 0] ------------------ 107| 3.24k| type_ = VariantType::Int32; 108| 3.24k| content_.asInt32 = static_cast(value); 109| 3.24k| } 110| 0|#if ARDUINOJSON_USE_LONG_LONG 111| 0| else { 112| 0| auto extension = resources->allocExtension(); 113| 0| if (!extension) ------------------ | Branch (113:9): [True: 0, False: 0] ------------------ 114| 0| return false; 115| 0| type_ = VariantType::Int64; 116| 0| content_.asSlotId = extension.id(); 117| 0| extension->asInt64 = value; 118| 0| } 119| 3.24k|#endif 120| 3.24k| return true; 121| 3.24k|} _ZNK11ArduinoJson8V740HB426detail11VariantData12getExtensionEPKNS1_15ResourceManagerE: 66| 7.12k| const ResourceManager* resources) const { 67| 7.12k| return type_ & VariantTypeBits::ExtensionBit ------------------ | Branch (67:10): [True: 250, False: 6.87k] ------------------ 68| 7.12k| ? resources->getExtension(content_.asSlotId) 69| 7.12k| : nullptr; 70| 7.12k|}