_ZNK11ArduinoJson8V6213HB46detail14CollectionData4headEv: 69| 631| VariantSlot* head() const { 70| 631| return head_; 71| 631| } _ZN11ArduinoJson8V6213HB46detail14CollectionData10addElementEPNS1_10MemoryPoolE: 32| 8.57k|inline VariantData* CollectionData::addElement(MemoryPool* pool) { 33| 8.57k| return slotData(addSlot(pool)); 34| 8.57k|} _ZN11ArduinoJson8V6213HB46detail14CollectionData7addSlotEPNS1_10MemoryPoolE: 14| 10.1k|inline VariantSlot* CollectionData::addSlot(MemoryPool* pool) { 15| 10.1k| VariantSlot* slot = pool->allocVariant(); 16| 10.1k| if (!slot) ------------------ | Branch (16:7): [True: 2, False: 10.1k] ------------------ 17| 2| return 0; 18| | 19| 10.1k| if (tail_) { ------------------ | Branch (19:7): [True: 7.75k, False: 2.43k] ------------------ 20| 7.75k| ARDUINOJSON_ASSERT(pool->owns(tail_)); // Can't alter a linked array/object ------------------ | | 11| 7.75k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 21| 0| tail_->setNextNotNull(slot); 22| 7.75k| tail_ = slot; 23| 7.75k| } else { 24| 2.43k| head_ = slot; 25| 2.43k| tail_ = slot; 26| 2.43k| } 27| | 28| 0| slot->clear(); 29| 10.1k| return slot; 30| 10.1k|} _ZN11ArduinoJson8V6213HB46detail14CollectionData5clearEv: 47| 3.04k|inline void CollectionData::clear() { 48| 3.04k| head_ = 0; 49| 3.04k| tail_ = 0; 50| 3.04k|} _ZNK11ArduinoJson8V6213HB46detail14CollectionData9getMemberINS1_19StaticStringAdapterEEEPNS1_11VariantDataET_: 108| 1.94k|inline VariantData* CollectionData::getMember(TAdaptedString key) const { 109| 1.94k| VariantSlot* slot = getSlot(key); 110| 1.94k| return slot ? slot->data() : 0; ------------------ | Branch (110:10): [True: 326, False: 1.61k] ------------------ 111| 1.94k|} _ZNK11ArduinoJson8V6213HB46detail14CollectionData7getSlotINS1_19StaticStringAdapterEEEPNS1_11VariantSlotET_: 78| 1.94k|inline VariantSlot* CollectionData::getSlot(TAdaptedString key) const { 79| 1.94k| if (key.isNull()) ------------------ | Branch (79:7): [True: 0, False: 1.94k] ------------------ 80| 0| return 0; 81| 1.94k| VariantSlot* slot = head_; 82| 4.67k| while (slot) { ------------------ | Branch (82:10): [True: 3.05k, False: 1.61k] ------------------ 83| 3.05k| if (stringEquals(key, adaptString(slot->key()))) ------------------ | Branch (83:9): [True: 326, False: 2.73k] ------------------ 84| 326| break; 85| 2.73k| slot = slot->next(); 86| 2.73k| } 87| 1.94k| return slot; 88| 1.94k|} _ZNK11ArduinoJson8V6213HB420DeserializationErrorcvbEv: 56| 2.20k| explicit operator bool() const { 57| 2.20k| return code_ != Ok; 58| 2.20k| } _ZN11ArduinoJson8V6213HB420DeserializationErrorC2ENS1_4CodeE: 29| 2.20k| DeserializationError(Code c) : code_(c) {} _ZN11ArduinoJson8V6213HB46detail26makeDeserializationOptionsENS0_21DeserializationOption12NestingLimitE: 31| 2.20k| DeserializationOption::NestingLimit nestingLimit = {}) { 32| 2.20k| return {{}, nestingLimit}; 33| 2.20k|} _ZNK11ArduinoJson8V6213HB46detail14AllowAllFilter10allowArrayEv: 51| 1.61k| bool allowArray() const { 52| 1.61k| return true; 53| 1.61k| } _ZNK11ArduinoJson8V6213HB46detail14AllowAllFilterixImEES2_RKT_: 64| 1.42k| AllowAllFilter operator[](const TKey&) const { 65| 1.42k| return AllowAllFilter(); 66| 1.42k| } _ZNK11ArduinoJson8V6213HB46detail14AllowAllFilter5allowEv: 47| 10.5k| bool allow() const { 48| 10.5k| return true; 49| 10.5k| } _ZNK11ArduinoJson8V6213HB46detail14AllowAllFilter11allowObjectEv: 55| 1.42k| bool allowObject() const { 56| 1.42k| return true; 57| 1.42k| } _ZNK11ArduinoJson8V6213HB46detail14AllowAllFilterixIPKcEES2_RKT_: 64| 1.94k| AllowAllFilter operator[](const TKey&) const { 65| 1.94k| return AllowAllFilter(); 66| 1.94k| } _ZNK11ArduinoJson8V6213HB46detail14AllowAllFilter10allowValueEv: 59| 9.21k| bool allowValue() const { 60| 9.21k| return true; 61| 9.21k| } _ZN11ArduinoJson8V6213HB421DeserializationOption12NestingLimitC2Ev: 15| 2.20k| NestingLimit() : value_(ARDUINOJSON_DEFAULT_NESTING_LIMIT) {} _ZNK11ArduinoJson8V6213HB421DeserializationOption12NestingLimit7reachedEv: 23| 3.04k| bool reached() const { 24| 3.04k| return value_ == 0; 25| 3.04k| } _ZNK11ArduinoJson8V6213HB421DeserializationOption12NestingLimit9decrementEv: 18| 10.5k| NestingLimit decrement() const { 19| 10.5k| ARDUINOJSON_ASSERT(value_ > 0); ------------------ | | 11| 10.5k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 20| 0| return NestingLimit(static_cast(value_ - 1)); 21| 10.5k| } _ZN11ArduinoJson8V6213HB421DeserializationOption12NestingLimitC2Eh: 16| 10.5k| explicit NestingLimit(uint8_t n) : value_(n) {} _ZN11ArduinoJson8V6213HB46detail10makeReaderIKhEENS1_13BoundedReaderIPT_vEES6_m: 71| 2.20k|BoundedReader makeReader(TChar* input, size_t inputSize) { 72| 2.20k| return BoundedReader{input, inputSize}; 73| 2.20k|} _ZN11ArduinoJson8V6213HB46detail14IteratorReaderIPKcEC2ES4_S4_: 15| 2.20k| : ptr_(begin), end_(end) {} _ZN11ArduinoJson8V6213HB46detail14IteratorReaderIPKcE4readEv: 17| 59.9k| int read() { 18| 59.9k| if (ptr_ < end_) ------------------ | Branch (18:9): [True: 58.3k, False: 1.65k] ------------------ 19| 58.3k| return static_cast(*ptr_++); 20| 1.65k| else 21| 1.65k| return -1; 22| 59.9k| } _ZN11ArduinoJson8V6213HB46detail13BoundedReaderIPKhvEC2EPKvm: 48| 2.20k| reinterpret_cast(ptr) + len) {} _ZN11ArduinoJson8V6213HB46detail11deserializeINS1_16JsonDeserializerEKhmJEvEENS0_20DeserializationErrorERNS0_12JsonDocumentEPT0_T1_DpT2_: 55| 2.20k| Size inputSize, Args... args) { 56| 2.20k| auto reader = makeReader(input, size_t(inputSize)); 57| 2.20k| auto data = VariantAttorney::getData(doc); 58| 2.20k| auto pool = VariantAttorney::getPool(doc); 59| 2.20k| auto options = makeDeserializationOptions(args...); 60| 2.20k| doc.clear(); 61| 2.20k| return makeDeserializer(pool, reader, 62| 2.20k| makeStringStorage(input, pool)) 63| 2.20k| .parse(*data, options.filter, options.nestingLimit); 64| 2.20k|} _ZN11ArduinoJson8V6213HB46detail16makeDeserializerINS1_16JsonDeserializerENS1_13BoundedReaderIPKhvEENS1_12StringCopierEEET_IT0_T1_EPNS1_10MemoryPoolESA_SB_: 30| 2.20k| TWriter writer) { 31| 2.20k| ARDUINOJSON_ASSERT(pool != 0); ------------------ | | 11| 2.20k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 32| 0| return TDeserializer(pool, reader, writer); 33| 2.20k|} _ZN11ArduinoJson8V6213HB417BasicJsonDocumentINS0_16DefaultAllocatorEEC2EmS2_: 46| 2.20k| : AllocatorOwner(alloc), JsonDocument(allocPool(capa)) {} _ZN11ArduinoJson8V6213HB414AllocatorOwnerINS0_16DefaultAllocatorEEC2ES2_: 17| 2.20k| AllocatorOwner(TAllocator a) : allocator_(a) {} _ZN11ArduinoJson8V6213HB417BasicJsonDocumentINS0_16DefaultAllocatorEE9allocPoolEm: 137| 2.20k| detail::MemoryPool allocPool(size_t requiredSize) { 138| 2.20k| size_t capa = detail::addPadding(requiredSize); 139| 2.20k| return {reinterpret_cast(this->allocate(capa)), capa}; 140| 2.20k| } _ZN11ArduinoJson8V6213HB414AllocatorOwnerINS0_16DefaultAllocatorEE8allocateEm: 19| 2.20k| void* allocate(size_t size) { 20| 2.20k| return allocator_.allocate(size); 21| 2.20k| } _ZN11ArduinoJson8V6213HB417BasicJsonDocumentINS0_16DefaultAllocatorEED2Ev: 83| 2.20k| ~BasicJsonDocument() { 84| 2.20k| freePool(); 85| 2.20k| } _ZN11ArduinoJson8V6213HB417BasicJsonDocumentINS0_16DefaultAllocatorEE8freePoolEv: 150| 2.20k| void freePool() { 151| 2.20k| this->deallocate(getPool()->buffer()); 152| 2.20k| } _ZN11ArduinoJson8V6213HB414AllocatorOwnerINS0_16DefaultAllocatorEE10deallocateEPv: 23| 2.20k| void deallocate(void* ptr) { 24| 2.20k| if (ptr) ------------------ | Branch (24:9): [True: 2.20k, False: 0] ------------------ 25| 2.20k| allocator_.deallocate(ptr); 26| 2.20k| } _ZN11ArduinoJson8V6213HB416DefaultAllocator8allocateEm: 15| 2.20k| void* allocate(size_t size) { 16| 2.20k| return malloc(size); 17| 2.20k| } _ZN11ArduinoJson8V6213HB416DefaultAllocator10deallocateEPv: 19| 2.20k| void deallocate(void* ptr) { 20| 2.20k| free(ptr); 21| 2.20k| } _ZNK11ArduinoJson8V6213HB412JsonDocumentcvNS0_16JsonVariantConstEEv: 275| 847| FORCE_INLINE operator JsonVariantConst() const { 276| 847| return getVariant(); 277| 847| } _ZNK11ArduinoJson8V6213HB412JsonDocument10getVariantEv: 296| 847| JsonVariantConst getVariant() const { 297| 847| return JsonVariantConst(&data_); 298| 847| } _ZN11ArduinoJson8V6213HB412JsonDocumentC2ENS0_6detail10MemoryPoolE: 282| 2.20k| JsonDocument(detail::MemoryPool pool) : pool_(pool) {} _ZN11ArduinoJson8V6213HB412JsonDocument7getPoolEv: 304| 4.40k| detail::MemoryPool* getPool() { 305| 4.40k| return &pool_; 306| 4.40k| } _ZN11ArduinoJson8V6213HB412JsonDocumentD2Ev: 286| 2.20k| ~JsonDocument() {} _ZN11ArduinoJson8V6213HB412JsonDocument7getDataEv: 308| 2.20k| detail::VariantData* getData() { 309| 2.20k| return &data_; 310| 2.20k| } _ZN11ArduinoJson8V6213HB412JsonDocument5clearEv: 42| 2.20k| void clear() { 43| 2.20k| pool_.clear(); 44| 2.20k| data_.setNull(); 45| 2.20k| } _ZN11ArduinoJson8V6213HB46detail14EscapeSequence10escapeCharEc: 14| 1.40k| static char escapeChar(char c) { 15| 1.40k| const char* p = escapeTable(true); 16| 10.6k| while (p[0] && p[1] != c) { ------------------ | Branch (16:12): [True: 9.50k, False: 1.16k] | Branch (16:20): [True: 9.26k, False: 238] ------------------ 17| 9.26k| p += 2; 18| 9.26k| } 19| 1.40k| return p[0]; 20| 1.40k| } _ZN11ArduinoJson8V6213HB46detail14EscapeSequence11escapeTableEb: 35| 1.51k| static const char* escapeTable(bool excludeSolidus) { 36| 1.51k| return &"//\"\"\\\\b\bf\fn\nr\rt\t"[excludeSolidus ? 2 : 0]; ------------------ | Branch (36:41): [True: 1.40k, False: 115] ------------------ 37| 1.51k| } _ZN11ArduinoJson8V6213HB46detail14EscapeSequence12unescapeCharEc: 23| 115| static char unescapeChar(char c) { 24| 115| const char* p = escapeTable(false); 25| 604| for (;;) { 26| 604| if (p[0] == '\0') ------------------ | Branch (26:11): [True: 16, False: 588] ------------------ 27| 16| return 0; 28| 588| if (p[0] == c) ------------------ | Branch (28:11): [True: 99, False: 489] ------------------ 29| 99| return p[1]; 30| 489| p += 2; 31| 489| } 32| 115| } _ZN11ArduinoJson8V6213HB415deserializeJsonIKhJRmEEENS0_20DeserializationErrorERNS0_12JsonDocumentEPT_DpOT0_: 687| 2.20k| Args&&... args) { 688| 2.20k| using namespace detail; 689| 2.20k| return deserialize(doc, input, 690| 2.20k| detail::forward(args)...); 691| 2.20k|} _ZN11ArduinoJson8V6213HB46detail16JsonDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEEC2EPNS1_10MemoryPoolES6_S7_: 29| 2.20k| pool_(pool) {} _ZN11ArduinoJson8V6213HB46detail16JsonDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE5parseINS1_14AllowAllFilterEEENS0_20DeserializationErrorERNS1_11VariantDataET_NS0_21DeserializationOption12NestingLimitE: 33| 2.20k| DeserializationOption::NestingLimit nestingLimit) { 34| 2.20k| DeserializationError::Code err; 35| | 36| 2.20k| err = parseVariant(variant, filter, nestingLimit); 37| | 38| 2.20k| if (!err && latch_.last() != 0 && !variant.isEnclosed()) { ------------------ | Branch (38:9): [True: 855, False: 1.34k] | Branch (38:17): [True: 273, False: 582] | Branch (38:39): [True: 8, False: 265] ------------------ 39| | // We don't detect trailing characters earlier, so we need to check now 40| 8| return DeserializationError::InvalidInput; 41| 8| } 42| | 43| 2.19k| return err; 44| 2.20k| } _ZN11ArduinoJson8V6213HB46detail16JsonDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE12parseVariantINS1_14AllowAllFilterEEENS0_20DeserializationError4CodeERNS1_11VariantDataET_NS0_21DeserializationOption12NestingLimitE: 65| 12.7k| DeserializationOption::NestingLimit nestingLimit) { 66| 12.7k| DeserializationError::Code err; 67| | 68| 12.7k| err = skipSpacesAndComments(); 69| 12.7k| if (err) ------------------ | Branch (69:9): [True: 181, False: 12.5k] ------------------ 70| 181| return err; 71| | 72| 12.5k| switch (current()) { 73| 1.61k| case '[': ------------------ | Branch (73:7): [True: 1.61k, False: 10.9k] ------------------ 74| 1.61k| if (filter.allowArray()) ------------------ | Branch (74:13): [True: 1.61k, False: 0] ------------------ 75| 1.61k| return parseArray(variant.toArray(), filter, nestingLimit); 76| 0| else 77| 0| return skipArray(nestingLimit); 78| | 79| 1.42k| case '{': ------------------ | Branch (79:7): [True: 1.42k, False: 11.1k] ------------------ 80| 1.42k| if (filter.allowObject()) ------------------ | Branch (80:13): [True: 1.42k, False: 0] ------------------ 81| 1.42k| return parseObject(variant.toObject(), filter, nestingLimit); 82| 0| else 83| 0| return skipObject(nestingLimit); 84| | 85| 421| case '\"': ------------------ | Branch (85:7): [True: 421, False: 12.1k] ------------------ 86| 897| case '\'': ------------------ | Branch (86:7): [True: 476, False: 12.0k] ------------------ 87| 897| if (filter.allowValue()) ------------------ | Branch (87:13): [True: 897, False: 0] ------------------ 88| 897| return parseStringValue(variant); 89| 0| else 90| 0| return skipQuotedString(); 91| | 92| 282| case 't': ------------------ | Branch (92:7): [True: 282, False: 12.2k] ------------------ 93| 282| if (filter.allowValue()) ------------------ | Branch (93:13): [True: 282, False: 0] ------------------ 94| 282| variant.setBoolean(true); 95| 282| return skipKeyword("true"); 96| | 97| 257| case 'f': ------------------ | Branch (97:7): [True: 257, False: 12.2k] ------------------ 98| 257| if (filter.allowValue()) ------------------ | Branch (98:13): [True: 257, False: 0] ------------------ 99| 257| variant.setBoolean(false); 100| 257| return skipKeyword("false"); 101| | 102| 281| case 'n': ------------------ | Branch (102:7): [True: 281, False: 12.2k] ------------------ 103| | // the variant should already by null, except if the same object key was 104| | // used twice, as in {"a":1,"a":null} 105| 281| return skipKeyword("null"); 106| | 107| 7.78k| default: ------------------ | Branch (107:7): [True: 7.78k, False: 4.76k] ------------------ 108| 7.78k| if (filter.allowValue()) ------------------ | Branch (108:13): [True: 7.78k, False: 0] ------------------ 109| 7.78k| return parseNumericValue(variant); 110| 0| else 111| 0| return skipNumericValue(); 112| 12.5k| } 113| 12.5k| } _ZN11ArduinoJson8V6213HB46detail16JsonDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE21skipSpacesAndCommentsEv: 583| 28.1k| DeserializationError::Code skipSpacesAndComments() { 584| 34.2k| for (;;) { 585| 34.2k| switch (current()) { 586| | // end of string 587| 724| case '\0': ------------------ | Branch (587:9): [True: 724, False: 33.5k] ------------------ 588| 724| return foundSomething_ ? DeserializationError::IncompleteInput ------------------ | Branch (588:18): [True: 691, False: 33] ------------------ 589| 724| : DeserializationError::EmptyInput; 590| | 591| | // spaces 592| 1.46k| case ' ': ------------------ | Branch (592:9): [True: 1.46k, False: 32.8k] ------------------ 593| 2.99k| case '\t': ------------------ | Branch (593:9): [True: 1.53k, False: 32.7k] ------------------ 594| 4.62k| case '\r': ------------------ | Branch (594:9): [True: 1.63k, False: 32.6k] ------------------ 595| 6.08k| case '\n': ------------------ | Branch (595:9): [True: 1.45k, False: 32.8k] ------------------ 596| 6.08k| move(); 597| 6.08k| continue; 598| | 599| |#if ARDUINOJSON_ENABLE_COMMENTS 600| | // comments 601| | case '/': 602| | move(); // skip '/' 603| | switch (current()) { 604| | // block comment 605| | case '*': { 606| | move(); // skip '*' 607| | bool wasStar = false; 608| | for (;;) { 609| | char c = current(); 610| | if (c == '\0') 611| | return DeserializationError::IncompleteInput; 612| | if (c == '/' && wasStar) { 613| | move(); 614| | break; 615| | } 616| | wasStar = c == '*'; 617| | move(); 618| | } 619| | break; 620| | } 621| | 622| | // trailing comment 623| | case '/': 624| | // no need to skip "//" 625| | for (;;) { 626| | move(); 627| | char c = current(); 628| | if (c == '\0') 629| | return DeserializationError::IncompleteInput; 630| | if (c == '\n') 631| | break; 632| | } 633| | break; 634| | 635| | // not a comment, just a '/' 636| | default: 637| | return DeserializationError::InvalidInput; 638| | } 639| | break; 640| |#endif 641| | 642| 27.4k| default: ------------------ | Branch (642:9): [True: 27.4k, False: 6.80k] ------------------ 643| 27.4k| foundSomething_ = true; 644| 27.4k| return DeserializationError::Ok; 645| 34.2k| } 646| 34.2k| } 647| 28.1k| } _ZN11ArduinoJson8V6213HB46detail16JsonDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE4moveEv: 51| 58.2k| void move() { 52| 58.2k| latch_.clear(); 53| 58.2k| } _ZN11ArduinoJson8V6213HB46detail16JsonDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE7currentEv: 47| 121k| char current() { 48| 121k| return latch_.current(); 49| 121k| } _ZN11ArduinoJson8V6213HB46detail16JsonDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE10parseArrayINS1_14AllowAllFilterEEENS0_20DeserializationError4CodeERNS1_14CollectionDataET_NS0_21DeserializationOption12NestingLimitE: 151| 1.61k| DeserializationOption::NestingLimit nestingLimit) { 152| 1.61k| DeserializationError::Code err; 153| | 154| 1.61k| if (nestingLimit.reached()) ------------------ | Branch (154:9): [True: 4, False: 1.61k] ------------------ 155| 4| return DeserializationError::TooDeep; 156| | 157| | // Skip opening braket 158| 1.61k| ARDUINOJSON_ASSERT(current() == '['); ------------------ | | 11| 1.61k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 159| 0| move(); 160| | 161| | // Skip spaces 162| 1.61k| err = skipSpacesAndComments(); 163| 1.61k| if (err) ------------------ | Branch (163:9): [True: 41, False: 1.57k] ------------------ 164| 41| return err; 165| | 166| | // Empty array? 167| 1.57k| if (eat(']')) ------------------ | Branch (167:9): [True: 147, False: 1.42k] ------------------ 168| 147| return DeserializationError::Ok; 169| | 170| 1.42k| TFilter memberFilter = filter[0UL]; 171| | 172| | // Read each value 173| 8.57k| for (;;) { 174| 8.57k| if (memberFilter.allow()) { ------------------ | Branch (174:11): [True: 8.57k, False: 0] ------------------ 175| | // Allocate slot in array 176| 8.57k| VariantData* value = array.addElement(pool_); 177| 8.57k| if (!value) ------------------ | Branch (177:13): [True: 1, False: 8.57k] ------------------ 178| 1| return DeserializationError::NoMemory; 179| | 180| | // 1 - Parse value 181| 8.57k| err = parseVariant(*value, memberFilter, nestingLimit.decrement()); 182| 8.57k| if (err) ------------------ | Branch (182:13): [True: 674, False: 7.90k] ------------------ 183| 674| return err; 184| 8.57k| } else { 185| 0| err = skipVariant(nestingLimit.decrement()); 186| 0| if (err) ------------------ | Branch (186:13): [True: 0, False: 0] ------------------ 187| 0| return err; 188| 0| } 189| | 190| | // 2 - Skip spaces 191| 7.90k| err = skipSpacesAndComments(); 192| 7.90k| if (err) ------------------ | Branch (192:11): [True: 205, False: 7.69k] ------------------ 193| 205| return err; 194| | 195| | // 3 - More values? 196| 7.69k| if (eat(']')) ------------------ | Branch (196:11): [True: 521, False: 7.17k] ------------------ 197| 521| return DeserializationError::Ok; 198| 7.17k| if (!eat(',')) ------------------ | Branch (198:11): [True: 23, False: 7.15k] ------------------ 199| 23| return DeserializationError::InvalidInput; 200| 7.17k| } 201| 1.42k| } _ZN11ArduinoJson8V6213HB46detail16JsonDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE3eatEc: 55| 22.1k| bool eat(char charToSkip) { 56| 22.1k| if (current() != charToSkip) ------------------ | Branch (56:9): [True: 10.9k, False: 11.2k] ------------------ 57| 10.9k| return false; 58| 11.2k| move(); 59| 11.2k| return true; 60| 22.1k| } _ZN11ArduinoJson8V6213HB46detail16JsonDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE11parseObjectINS1_14AllowAllFilterEEENS0_20DeserializationError4CodeERNS1_14CollectionDataET_NS0_21DeserializationOption12NestingLimitE: 237| 1.42k| DeserializationOption::NestingLimit nestingLimit) { 238| 1.42k| DeserializationError::Code err; 239| | 240| 1.42k| if (nestingLimit.reached()) ------------------ | Branch (240:9): [True: 2, False: 1.42k] ------------------ 241| 2| return DeserializationError::TooDeep; 242| | 243| | // Skip opening brace 244| 1.42k| ARDUINOJSON_ASSERT(current() == '{'); ------------------ | | 11| 1.42k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 245| 0| move(); 246| | 247| | // Skip spaces 248| 1.42k| err = skipSpacesAndComments(); 249| 1.42k| if (err) ------------------ | Branch (249:9): [True: 42, False: 1.38k] ------------------ 250| 42| return err; 251| | 252| | // Empty object? 253| 1.38k| if (eat('}')) ------------------ | Branch (253:9): [True: 174, False: 1.21k] ------------------ 254| 174| return DeserializationError::Ok; 255| | 256| | // Read each key value pair 257| 2.15k| for (;;) { 258| | // Parse key 259| 2.15k| err = parseKey(); 260| 2.15k| if (err) ------------------ | Branch (260:11): [True: 55, False: 2.10k] ------------------ 261| 55| return err; 262| | 263| | // Skip spaces 264| 2.10k| err = skipSpacesAndComments(); 265| 2.10k| if (err) ------------------ | Branch (265:11): [True: 131, False: 1.97k] ------------------ 266| 131| return err; 267| | 268| | // Colon 269| 1.97k| if (!eat(':')) ------------------ | Branch (269:11): [True: 28, False: 1.94k] ------------------ 270| 28| return DeserializationError::InvalidInput; 271| | 272| 1.94k| JsonString key = stringStorage_.str(); 273| | 274| 1.94k| TFilter memberFilter = filter[key.c_str()]; 275| | 276| 1.94k| if (memberFilter.allow()) { ------------------ | Branch (276:11): [True: 1.94k, False: 0] ------------------ 277| 1.94k| VariantData* variant = object.getMember(adaptString(key.c_str())); 278| 1.94k| if (!variant) { ------------------ | Branch (278:13): [True: 1.61k, False: 326] ------------------ 279| | // Save key in memory pool. 280| | // This MUST be done before adding the slot. 281| 1.61k| key = stringStorage_.save(); 282| | 283| | // Allocate slot in object 284| 1.61k| VariantSlot* slot = object.addSlot(pool_); 285| 1.61k| if (!slot) ------------------ | Branch (285:15): [True: 1, False: 1.61k] ------------------ 286| 1| return DeserializationError::NoMemory; 287| | 288| 1.61k| slot->setKey(key); 289| | 290| 1.61k| variant = slot->data(); 291| 1.61k| } 292| | 293| | // Parse value 294| 1.94k| err = parseVariant(*variant, memberFilter, nestingLimit.decrement()); 295| 1.94k| if (err) ------------------ | Branch (295:13): [True: 505, False: 1.43k] ------------------ 296| 505| return err; 297| 1.94k| } else { 298| 0| err = skipVariant(nestingLimit.decrement()); 299| 0| if (err) ------------------ | Branch (299:13): [True: 0, False: 0] ------------------ 300| 0| return err; 301| 0| } 302| | 303| | // Skip spaces 304| 1.43k| err = skipSpacesAndComments(); 305| 1.43k| if (err) ------------------ | Branch (305:11): [True: 84, False: 1.35k] ------------------ 306| 84| return err; 307| | 308| | // More keys/values? 309| 1.35k| if (eat('}')) ------------------ | Branch (309:11): [True: 342, False: 1.01k] ------------------ 310| 342| return DeserializationError::Ok; 311| 1.01k| if (!eat(',')) ------------------ | Branch (311:11): [True: 25, False: 988] ------------------ 312| 25| return DeserializationError::InvalidInput; 313| | 314| | // Skip spaces 315| 988| err = skipSpacesAndComments(); 316| 988| if (err) ------------------ | Branch (316:11): [True: 40, False: 948] ------------------ 317| 40| return err; 318| 988| } 319| 1.21k| } _ZN11ArduinoJson8V6213HB46detail16JsonDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE8parseKeyEv: 379| 2.15k| DeserializationError::Code parseKey() { 380| 2.15k| stringStorage_.startString(); 381| 2.15k| if (isQuote(current())) { ------------------ | Branch (381:9): [True: 231, False: 1.92k] ------------------ 382| 231| return parseQuotedString(); 383| 1.92k| } else { 384| 1.92k| return parseNonQuotedString(); 385| 1.92k| } 386| 2.15k| } _ZN11ArduinoJson8V6213HB46detail16JsonDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE7isQuoteEc: 572| 2.15k| static inline bool isQuote(char c) { 573| 2.15k| return c == '\'' || c == '\"'; ------------------ | Branch (573:12): [True: 211, False: 1.94k] | Branch (573:25): [True: 20, False: 1.92k] ------------------ 574| 2.15k| } _ZN11ArduinoJson8V6213HB46detail16JsonDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE17parseQuotedStringEv: 402| 1.12k| DeserializationError::Code parseQuotedString() { 403| 1.12k|#if ARDUINOJSON_DECODE_UNICODE 404| 1.12k| Utf16::Codepoint codepoint; 405| 1.12k| DeserializationError::Code err; 406| 1.12k|#endif 407| 1.12k| const char stopChar = current(); 408| | 409| 1.12k| move(); 410| 3.27k| for (;;) { 411| 3.27k| char c = current(); 412| 3.27k| move(); 413| 3.27k| if (c == stopChar) ------------------ | Branch (413:11): [True: 866, False: 2.41k] ------------------ 414| 866| break; 415| | 416| 2.41k| if (c == '\0') ------------------ | Branch (416:11): [True: 216, False: 2.19k] ------------------ 417| 216| return DeserializationError::IncompleteInput; 418| | 419| 2.19k| if (c == '\\') { ------------------ | Branch (419:11): [True: 680, False: 1.51k] ------------------ 420| 680| c = current(); 421| | 422| 680| if (c == '\0') ------------------ | Branch (422:13): [True: 2, False: 678] ------------------ 423| 2| return DeserializationError::IncompleteInput; 424| | 425| 678| if (c == 'u') { ------------------ | Branch (425:13): [True: 563, False: 115] ------------------ 426| 563|#if ARDUINOJSON_DECODE_UNICODE 427| 563| move(); 428| 563| uint16_t codeunit; 429| 563| err = parseHex4(codeunit); 430| 563| if (err) ------------------ | Branch (430:15): [True: 28, False: 535] ------------------ 431| 28| return err; 432| 535| if (codepoint.append(codeunit)) ------------------ | Branch (432:15): [True: 449, False: 86] ------------------ 433| 449| Utf8::encodeCodepoint(codepoint.value(), stringStorage_); 434| |#else 435| | stringStorage_.append('\\'); 436| |#endif 437| 535| continue; 438| 563| } 439| | 440| | // replace char 441| 115| c = EscapeSequence::unescapeChar(c); 442| 115| if (c == '\0') ------------------ | Branch (442:13): [True: 16, False: 99] ------------------ 443| 16| return DeserializationError::InvalidInput; 444| 99| move(); 445| 99| } 446| | 447| 1.61k| stringStorage_.append(c); 448| 1.61k| } 449| | 450| 866| if (!stringStorage_.isValid()) ------------------ | Branch (450:9): [True: 1, False: 865] ------------------ 451| 1| return DeserializationError::NoMemory; 452| | 453| 865| return DeserializationError::Ok; 454| 866| } _ZN11ArduinoJson8V6213HB46detail16JsonDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE9parseHex4ERt: 539| 563| DeserializationError::Code parseHex4(uint16_t& result) { 540| 563| result = 0; 541| 2.72k| for (uint8_t i = 0; i < 4; ++i) { ------------------ | Branch (541:25): [True: 2.19k, False: 535] ------------------ 542| 2.19k| char digit = current(); 543| 2.19k| if (!digit) ------------------ | Branch (543:11): [True: 17, False: 2.17k] ------------------ 544| 17| return DeserializationError::IncompleteInput; 545| 2.17k| uint8_t value = decodeHex(digit); 546| 2.17k| if (value > 0x0F) ------------------ | Branch (546:11): [True: 11, False: 2.16k] ------------------ 547| 11| return DeserializationError::InvalidInput; 548| 2.16k| result = uint16_t((result << 4) | value); 549| 2.16k| move(); 550| 2.16k| } 551| 535| return DeserializationError::Ok; 552| 563| } _ZN11ArduinoJson8V6213HB46detail16JsonDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE9decodeHexEc: 576| 2.17k| static inline uint8_t decodeHex(char c) { 577| 2.17k| if (c < 'A') ------------------ | Branch (577:9): [True: 1.46k, False: 712] ------------------ 578| 1.46k| return uint8_t(c - '0'); 579| 712| c = char(c & ~0x20); // uppercase 580| 712| return uint8_t(c - 'A' + 10); 581| 2.17k| } _ZN11ArduinoJson8V6213HB46detail16JsonDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE20parseNonQuotedStringEv: 456| 1.92k| DeserializationError::Code parseNonQuotedString() { 457| 1.92k| char c = current(); 458| 1.92k| ARDUINOJSON_ASSERT(c); ------------------ | | 11| 1.92k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 459| | 460| 1.92k| if (canBeInNonQuotedString(c)) { // no quotes ------------------ | Branch (460:9): [True: 1.88k, False: 42] ------------------ 461| 4.12k| do { 462| 4.12k| move(); 463| 4.12k| stringStorage_.append(c); 464| 4.12k| c = current(); 465| 4.12k| } while (canBeInNonQuotedString(c)); ------------------ | Branch (465:16): [True: 2.24k, False: 1.88k] ------------------ 466| 1.88k| } else { 467| 42| return DeserializationError::InvalidInput; 468| 42| } 469| | 470| 1.88k| if (!stringStorage_.isValid()) ------------------ | Branch (470:9): [True: 5, False: 1.88k] ------------------ 471| 5| return DeserializationError::NoMemory; 472| | 473| 1.88k| return DeserializationError::Ok; 474| 1.88k| } _ZN11ArduinoJson8V6213HB46detail16JsonDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE22canBeInNonQuotedStringEc: 567| 6.05k| static inline bool canBeInNonQuotedString(char c) { 568| 6.05k| return isBetween(c, '0', '9') || isBetween(c, '_', 'z') || ------------------ | Branch (568:12): [True: 1.21k, False: 4.83k] | Branch (568:38): [True: 1.57k, False: 3.26k] ------------------ 569| 6.05k| isBetween(c, 'A', 'Z'); ------------------ | Branch (569:12): [True: 1.33k, False: 1.92k] ------------------ 570| 6.05k| } _ZN11ArduinoJson8V6213HB46detail16JsonDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE9isBetweenEccc: 554| 45.1k| static inline bool isBetween(char c, char min, char max) { 555| 45.1k| return min <= c && c <= max; ------------------ | Branch (555:12): [True: 28.9k, False: 16.2k] | Branch (555:24): [True: 22.1k, False: 6.82k] ------------------ 556| 45.1k| } _ZN11ArduinoJson8V6213HB46detail16JsonDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE16parseStringValueERNS1_11VariantDataE: 388| 897| DeserializationError::Code parseStringValue(VariantData& variant) { 389| 897| DeserializationError::Code err; 390| | 391| 897| stringStorage_.startString(); 392| | 393| 897| err = parseQuotedString(); 394| 897| if (err) ------------------ | Branch (394:9): [True: 255, False: 642] ------------------ 395| 255| return err; 396| | 397| 642| variant.setString(stringStorage_.save()); 398| | 399| 642| return DeserializationError::Ok; 400| 897| } _ZN11ArduinoJson8V6213HB46detail16JsonDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE11skipKeywordEPKc: 649| 820| DeserializationError::Code skipKeyword(const char* s) { 650| 4.07k| while (*s) { ------------------ | Branch (650:12): [True: 3.35k, False: 725] ------------------ 651| 3.35k| char c = current(); 652| 3.35k| if (c == '\0') ------------------ | Branch (652:11): [True: 40, False: 3.31k] ------------------ 653| 40| return DeserializationError::IncompleteInput; 654| 3.31k| if (*s != c) ------------------ | Branch (654:11): [True: 55, False: 3.25k] ------------------ 655| 55| return DeserializationError::InvalidInput; 656| 3.25k| ++s; 657| 3.25k| move(); 658| 3.25k| } 659| 725| return DeserializationError::Ok; 660| 820| } _ZN11ArduinoJson8V6213HB46detail16JsonDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE17parseNumericValueERNS1_11VariantDataE: 513| 7.78k| DeserializationError::Code parseNumericValue(VariantData& result) { 514| 7.78k| uint8_t n = 0; 515| | 516| 7.78k| char c = current(); 517| 31.0k| while (canBeInNumber(c) && n < 63) { ------------------ | Branch (517:12): [True: 23.2k, False: 7.77k] | Branch (517:32): [True: 23.2k, False: 3] ------------------ 518| 23.2k| move(); 519| 23.2k| buffer_[n++] = c; 520| 23.2k| c = current(); 521| 23.2k| } 522| 7.78k| buffer_[n] = 0; 523| | 524| 7.78k| if (!parseNumber(buffer_, result)) ------------------ | Branch (524:9): [True: 135, False: 7.64k] ------------------ 525| 135| return DeserializationError::InvalidInput; 526| | 527| 7.64k| return DeserializationError::Ok; 528| 7.78k| } _ZN11ArduinoJson8V6213HB46detail16JsonDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE13canBeInNumberEc: 558| 31.0k| static inline bool canBeInNumber(char c) { 559| 31.0k| return isBetween(c, '0', '9') || c == '+' || c == '-' || c == '.' || ------------------ | Branch (559:12): [True: 18.0k, False: 13.0k] | Branch (559:38): [True: 345, False: 12.6k] | Branch (559:50): [True: 1.23k, False: 11.4k] | Branch (559:62): [True: 1.86k, False: 9.57k] ------------------ 560| |#if ARDUINOJSON_ENABLE_NAN || ARDUINOJSON_ENABLE_INFINITY 561| | isBetween(c, 'A', 'Z') || isBetween(c, 'a', 'z'); 562| |#else 563| 31.0k| c == 'e' || c == 'E'; ------------------ | Branch (563:12): [True: 1.11k, False: 8.45k] | Branch (563:24): [True: 678, False: 7.77k] ------------------ 564| 31.0k|#endif 565| 31.0k| } _ZN11ArduinoJson8V6213HB413serializeJsonINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEmNS0_16JsonVariantConstERT_: 125| 847|size_t serializeJson(JsonVariantConst source, TDestination& destination) { 126| 847| using namespace detail; 127| 847| return serialize(source, destination); 128| 847|} _ZN11ArduinoJson8V6213HB46detail14JsonSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEEC2ESB_: 19| 847| JsonSerializer(TWriter writer) : formatter_(writer) {} _ZN11ArduinoJson8V6213HB46detail14JsonSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE10visitFloatEd: 61| 1.20k| size_t visitFloat(JsonFloat value) { 62| 1.20k| formatter_.writeFloat(value); 63| 1.20k| return bytesWritten(); 64| 1.20k| } _ZNK11ArduinoJson8V6213HB46detail14JsonSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE12bytesWrittenEv: 102| 3.21k| size_t bytesWritten() const { 103| 3.21k| return formatter_.bytesWritten(); 104| 3.21k| } _ZN11ArduinoJson8V6213HB46detail14JsonSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE10visitArrayERKNS1_14CollectionDataE: 21| 375| FORCE_INLINE size_t visitArray(const CollectionData& array) { 22| 375| write('['); 23| | 24| 375| const VariantSlot* slot = array.head(); 25| | 26| 2.14k| while (slot != 0) { ------------------ | Branch (26:12): [True: 2.08k, False: 66] ------------------ 27| 2.08k| slot->data()->accept(*this); 28| | 29| 2.08k| slot = slot->next(); 30| 2.08k| if (slot == 0) ------------------ | Branch (30:11): [True: 309, False: 1.77k] ------------------ 31| 309| break; 32| | 33| 1.77k| write(','); 34| 1.77k| } 35| | 36| 375| write(']'); 37| 375| return bytesWritten(); 38| 375| } _ZN11ArduinoJson8V6213HB46detail14JsonSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE5writeEc: 106| 3.42k| void write(char c) { 107| 3.42k| formatter_.writeRaw(c); 108| 3.42k| } _ZN11ArduinoJson8V6213HB46detail14JsonSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE11visitObjectERKNS1_14CollectionDataE: 40| 256| size_t visitObject(const CollectionData& object) { 41| 256| write('{'); 42| | 43| 256| const VariantSlot* slot = object.head(); 44| | 45| 358| while (slot != 0) { ------------------ | Branch (45:12): [True: 291, False: 67] ------------------ 46| 291| formatter_.writeString(slot->key()); 47| 291| write(':'); 48| 291| slot->data()->accept(*this); 49| | 50| 291| slot = slot->next(); 51| 291| if (slot == 0) ------------------ | Branch (51:11): [True: 189, False: 102] ------------------ 52| 189| break; 53| | 54| 102| write(','); 55| 102| } 56| | 57| 256| write('}'); 58| 256| return bytesWritten(); 59| 256| } _ZN11ArduinoJson8V6213HB46detail14JsonSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE11visitStringEPKcm: 71| 175| size_t visitString(const char* value, size_t n) { 72| 175| formatter_.writeString(value, n); 73| 175| return bytesWritten(); 74| 175| } _ZN11ArduinoJson8V6213HB46detail14JsonSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE18visitSignedIntegerEl: 81| 321| size_t visitSignedInteger(JsonInteger value) { 82| 321| formatter_.writeInteger(value); 83| 321| return bytesWritten(); 84| 321| } _ZN11ArduinoJson8V6213HB46detail14JsonSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE20visitUnsignedIntegerEm: 86| 688| size_t visitUnsignedInteger(JsonUInt value) { 87| 688| formatter_.writeInteger(value); 88| 688| return bytesWritten(); 89| 688| } _ZN11ArduinoJson8V6213HB46detail14JsonSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE12visitBooleanEb: 91| 132| size_t visitBoolean(bool value) { 92| 132| formatter_.writeBoolean(value); 93| 132| return bytesWritten(); 94| 132| } _ZN11ArduinoJson8V6213HB46detail14JsonSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE9visitNullEv: 96| 66| size_t visitNull() { 97| 66| formatter_.writeRaw("null"); 98| 66| return bytesWritten(); 99| 66| } _ZN11ArduinoJson8V6213HB46detail5LatchINS1_13BoundedReaderIPKhvEEEC2ES6_: 14| 2.20k| Latch(TReader reader) : reader_(reader), loaded_(false) { 15| 2.20k|#if ARDUINOJSON_DEBUG 16| 2.20k| ended_ = false; 17| 2.20k|#endif 18| 2.20k| } _ZN11ArduinoJson8V6213HB46detail5LatchINS1_13BoundedReaderIPKhvEEE5clearEv: 20| 58.2k| void clear() { 21| 58.2k| loaded_ = false; 22| 58.2k| } _ZN11ArduinoJson8V6213HB46detail5LatchINS1_13BoundedReaderIPKhvEEE7currentEv: 28| 121k| FORCE_INLINE char current() { 29| 121k| if (!loaded_) { ------------------ | Branch (29:9): [True: 59.9k, False: 61.9k] ------------------ 30| 59.9k| load(); 31| 59.9k| } 32| 121k| return current_; 33| 121k| } _ZN11ArduinoJson8V6213HB46detail5LatchINS1_13BoundedReaderIPKhvEEE4loadEv: 36| 59.9k| void load() { 37| 59.9k| ARDUINOJSON_ASSERT(!ended_); ------------------ | | 11| 59.9k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 38| 0| int c = reader_.read(); 39| 59.9k|#if ARDUINOJSON_DEBUG 40| 59.9k| if (c <= 0) ------------------ | Branch (40:9): [True: 1.67k, False: 58.3k] ------------------ 41| 1.67k| ended_ = true; 42| 59.9k|#endif 43| 59.9k| current_ = static_cast(c > 0 ? c : 0); ------------------ | Branch (43:34): [True: 58.3k, False: 1.67k] ------------------ 44| 59.9k| loaded_ = true; 45| 59.9k| } _ZNK11ArduinoJson8V6213HB46detail5LatchINS1_13BoundedReaderIPKhvEEE4lastEv: 24| 855| int last() const { 25| 855| return current_; 26| 855| } _ZN11ArduinoJson8V6213HB46detail13TextFormatterINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEEC2ESB_: 23| 847| explicit TextFormatter(TWriter writer) : writer_(writer) {} _ZN11ArduinoJson8V6213HB46detail13TextFormatterINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE10writeFloatIdEEvT_: 68| 1.20k| void writeFloat(T value) { 69| 1.20k| if (isnan(value)) ------------------ | Branch (69:9): [True: 0, False: 1.20k] ------------------ 70| 0| return writeRaw(ARDUINOJSON_ENABLE_NAN ? "NaN" : "null"); ------------------ | | 156| 0|# define ARDUINOJSON_ENABLE_NAN 0 | | ------------------ | | | Branch (156:34): [Folded - Ignored] | | ------------------ ------------------ 71| | 72| |#if ARDUINOJSON_ENABLE_INFINITY 73| | if (value < 0.0) { 74| | writeRaw('-'); 75| | value = -value; 76| | } 77| | 78| | if (isinf(value)) 79| | return writeRaw("Infinity"); 80| |#else 81| 1.20k| if (isinf(value)) ------------------ | Branch (81:9): [True: 67, False: 1.13k] ------------------ 82| 67| return writeRaw("null"); 83| | 84| 1.13k| if (value < 0.0) { ------------------ | Branch (84:9): [True: 72, False: 1.06k] ------------------ 85| 72| writeRaw('-'); 86| 72| value = -value; 87| 72| } 88| 1.13k|#endif 89| | 90| 1.13k| FloatParts parts(value); 91| | 92| 1.13k| writeInteger(parts.integral); 93| 1.13k| if (parts.decimalPlaces) ------------------ | Branch (93:9): [True: 230, False: 908] ------------------ 94| 230| writeDecimals(parts.decimal, parts.decimalPlaces); 95| | 96| 1.13k| if (parts.exponent) { ------------------ | Branch (96:9): [True: 462, False: 676] ------------------ 97| 462| writeRaw('e'); 98| 462| writeInteger(parts.exponent); 99| 462| } 100| 1.13k| } _ZN11ArduinoJson8V6213HB46detail13TextFormatterINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE8writeRawEPKc: 148| 331| void writeRaw(const char* s) { 149| 331| writer_.write(reinterpret_cast(s), strlen(s)); 150| 331| } _ZN11ArduinoJson8V6213HB46detail13TextFormatterINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE8writeRawEc: 165| 6.83k| void writeRaw(char c) { 166| 6.83k| writer_.write(static_cast(c)); 167| 6.83k| } _ZN11ArduinoJson8V6213HB46detail13TextFormatterINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE12writeIntegerIjEENS1_9enable_ifIXsr11is_unsignedIT_EE5valueEvE4typeESF_: 116| 1.13k| typename enable_if::value>::type writeInteger(T value) { 117| 1.13k| char buffer[22]; 118| 1.13k| char* end = buffer + sizeof(buffer); 119| 1.13k| char* begin = end; 120| | 121| | // write the string in reverse order 122| 1.94k| do { 123| 1.94k| *--begin = char(value % 10 + '0'); 124| 1.94k| value = T(value / 10); 125| 1.94k| } while (value); ------------------ | Branch (125:14): [True: 807, False: 1.13k] ------------------ 126| | 127| | // and dump it in the right order 128| 1.13k| writeRaw(begin, end); 129| 1.13k| } _ZN11ArduinoJson8V6213HB46detail13TextFormatterINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE8writeRawEPKcSE_: 156| 2.83k| void writeRaw(const char* begin, const char* end) { 157| 2.83k| writer_.write(reinterpret_cast(begin), 158| 2.83k| static_cast(end - begin)); 159| 2.83k| } _ZN11ArduinoJson8V6213HB46detail13TextFormatterINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE13writeDecimalsEja: 131| 230| void writeDecimals(uint32_t value, int8_t width) { 132| | // buffer should be big enough for all digits and the dot 133| 230| char buffer[16]; 134| 230| char* end = buffer + sizeof(buffer); 135| 230| char* begin = end; 136| | 137| | // write the string in reverse order 138| 1.56k| while (width--) { ------------------ | Branch (138:12): [True: 1.33k, False: 230] ------------------ 139| 1.33k| *--begin = char(value % 10 + '0'); 140| 1.33k| value /= 10; 141| 1.33k| } 142| 230| *--begin = '.'; 143| | 144| | // and dump it in the right order 145| 230| writeRaw(begin, end); 146| 230| } _ZN11ArduinoJson8V6213HB46detail13TextFormatterINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE12writeIntegerIsEENS1_9enable_ifIXsr9is_signedIT_EE5valueEvE4typeESF_: 103| 462| typename enable_if::value>::type writeInteger(T value) { 104| 462| typedef typename make_unsigned::type unsigned_type; 105| 462| unsigned_type unsigned_value; 106| 462| if (value < 0) { ------------------ | Branch (106:9): [True: 111, False: 351] ------------------ 107| 111| writeRaw('-'); 108| 111| unsigned_value = unsigned_type(unsigned_type(~value) + 1); 109| 351| } else { 110| 351| unsigned_value = unsigned_type(value); 111| 351| } 112| 462| writeInteger(unsigned_value); 113| 462| } _ZN11ArduinoJson8V6213HB46detail13TextFormatterINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE12writeIntegerItEENS1_9enable_ifIXsr11is_unsignedIT_EE5valueEvE4typeESF_: 116| 462| typename enable_if::value>::type writeInteger(T value) { 117| 462| char buffer[22]; 118| 462| char* end = buffer + sizeof(buffer); 119| 462| char* begin = end; 120| | 121| | // write the string in reverse order 122| 834| do { 123| 834| *--begin = char(value % 10 + '0'); 124| 834| value = T(value / 10); 125| 834| } while (value); ------------------ | Branch (125:14): [True: 372, False: 462] ------------------ 126| | 127| | // and dump it in the right order 128| 462| writeRaw(begin, end); 129| 462| } _ZNK11ArduinoJson8V6213HB46detail13TextFormatterINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE12bytesWrittenEv: 28| 3.21k| size_t bytesWritten() const { 29| 3.21k| return writer_.count(); 30| 3.21k| } _ZN11ArduinoJson8V6213HB46detail13TextFormatterINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE11writeStringEPKc: 39| 291| void writeString(const char* value) { 40| 291| ARDUINOJSON_ASSERT(value != NULL); ------------------ | | 11| 291|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 41| 0| writeRaw('\"'); 42| 710| while (*value) ------------------ | Branch (42:12): [True: 419, False: 291] ------------------ 43| 419| writeChar(*value++); 44| 291| writeRaw('\"'); 45| 291| } _ZN11ArduinoJson8V6213HB46detail13TextFormatterINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE9writeCharEc: 55| 1.40k| void writeChar(char c) { 56| 1.40k| char specialChar = EscapeSequence::escapeChar(c); 57| 1.40k| if (specialChar) { ------------------ | Branch (57:9): [True: 238, False: 1.16k] ------------------ 58| 238| writeRaw('\\'); 59| 238| writeRaw(specialChar); 60| 1.16k| } else if (c) { ------------------ | Branch (60:16): [True: 1.09k, False: 66] ------------------ 61| 1.09k| writeRaw(c); 62| 1.09k| } else { 63| 66| writeRaw("\\u0000"); 64| 66| } 65| 1.40k| } _ZN11ArduinoJson8V6213HB46detail13TextFormatterINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE11writeStringEPKcm: 47| 175| void writeString(const char* value, size_t n) { 48| 175| ARDUINOJSON_ASSERT(value != NULL); ------------------ | | 11| 175|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 49| 0| writeRaw('\"'); 50| 1.15k| while (n--) ------------------ | Branch (50:12): [True: 984, False: 175] ------------------ 51| 984| writeChar(*value++); 52| 175| writeRaw('\"'); 53| 175| } _ZN11ArduinoJson8V6213HB46detail13TextFormatterINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE12writeIntegerIlEENS1_9enable_ifIXsr9is_signedIT_EE5valueEvE4typeESF_: 103| 321| typename enable_if::value>::type writeInteger(T value) { 104| 321| typedef typename make_unsigned::type unsigned_type; 105| 321| unsigned_type unsigned_value; 106| 321| if (value < 0) { ------------------ | Branch (106:9): [True: 255, False: 66] ------------------ 107| 255| writeRaw('-'); 108| 255| unsigned_value = unsigned_type(unsigned_type(~value) + 1); 109| 255| } else { 110| 66| unsigned_value = unsigned_type(value); 111| 66| } 112| 321| writeInteger(unsigned_value); 113| 321| } _ZN11ArduinoJson8V6213HB46detail13TextFormatterINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE12writeIntegerImEENS1_9enable_ifIXsr11is_unsignedIT_EE5valueEvE4typeESF_: 116| 1.00k| typename enable_if::value>::type writeInteger(T value) { 117| 1.00k| char buffer[22]; 118| 1.00k| char* end = buffer + sizeof(buffer); 119| 1.00k| char* begin = end; 120| | 121| | // write the string in reverse order 122| 5.63k| do { 123| 5.63k| *--begin = char(value % 10 + '0'); 124| 5.63k| value = T(value / 10); 125| 5.63k| } while (value); ------------------ | Branch (125:14): [True: 4.62k, False: 1.00k] ------------------ 126| | 127| | // and dump it in the right order 128| 1.00k| writeRaw(begin, end); 129| 1.00k| } _ZN11ArduinoJson8V6213HB46detail13TextFormatterINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE12writeBooleanEb: 32| 132| void writeBoolean(bool value) { 33| 132| if (value) ------------------ | Branch (33:9): [True: 66, False: 66] ------------------ 34| 66| writeRaw("true"); 35| 66| else 36| 66| writeRaw("false"); 37| 132| } _ZN11ArduinoJson8V6213HB46detail5Utf169CodepointC2Ev: 34| 1.12k| Codepoint() : highSurrogate_(0), codepoint_(0) {} _ZN11ArduinoJson8V6213HB46detail5Utf169Codepoint6appendEt: 36| 535| bool append(uint16_t codeunit) { 37| 535| if (isHighSurrogate(codeunit)) { ------------------ | Branch (37:9): [True: 86, False: 449] ------------------ 38| 86| highSurrogate_ = codeunit & 0x3FF; 39| 86| return false; 40| 86| } 41| | 42| 449| if (isLowSurrogate(codeunit)) { ------------------ | Branch (42:9): [True: 107, False: 342] ------------------ 43| 107| codepoint_ = 44| 107| uint32_t(0x10000 + ((highSurrogate_ << 10) | (codeunit & 0x3FF))); 45| 107| return true; 46| 107| } 47| | 48| 342| codepoint_ = codeunit; 49| 342| return true; 50| 449| } _ZN11ArduinoJson8V6213HB46detail5Utf1615isHighSurrogateEt: 24| 535|inline bool isHighSurrogate(uint16_t codeunit) { 25| 535| return codeunit >= 0xD800 && codeunit < 0xDC00; ------------------ | Branch (25:10): [True: 233, False: 302] | Branch (25:32): [True: 86, False: 147] ------------------ 26| 535|} _ZN11ArduinoJson8V6213HB46detail5Utf1614isLowSurrogateEt: 28| 449|inline bool isLowSurrogate(uint16_t codeunit) { 29| 449| return codeunit >= 0xDC00 && codeunit < 0xE000; ------------------ | Branch (29:10): [True: 147, False: 302] | Branch (29:32): [True: 107, False: 40] ------------------ 30| 449|} _ZNK11ArduinoJson8V6213HB46detail5Utf169Codepoint5valueEv: 52| 449| uint32_t value() const { 53| 449| return codepoint_; 54| 449| } _ZN11ArduinoJson8V6213HB46detail4Utf815encodeCodepointINS1_12StringCopierEEEvjRT_: 13| 449|inline void encodeCodepoint(uint32_t codepoint32, TStringBuilder& str) { 14| | // this function was optimize for code size on AVR 15| | 16| 449| if (codepoint32 < 0x80) { ------------------ | Branch (16:7): [True: 146, False: 303] ------------------ 17| 146| str.append(char(codepoint32)); 18| 303| } else { 19| | // a buffer to store the string in reverse 20| 303| char buf[5]; 21| 303| char* p = buf; 22| | 23| 303| *(p++) = 0; 24| 303| *(p++) = char((codepoint32 | 0x80) & 0xBF); 25| 303| uint16_t codepoint16 = uint16_t(codepoint32 >> 6); 26| 303| if (codepoint16 < 0x20) { // 0x800 ------------------ | Branch (26:9): [True: 75, False: 228] ------------------ 27| 75| *(p++) = char(codepoint16 | 0xC0); 28| 228| } else { 29| 228| *(p++) = char((codepoint16 | 0x80) & 0xBF); 30| 228| codepoint16 = uint16_t(codepoint16 >> 6); 31| 228| if (codepoint16 < 0x10) { // 0x10000 ------------------ | Branch (31:11): [True: 121, False: 107] ------------------ 32| 121| *(p++) = char(codepoint16 | 0xE0); 33| 121| } else { 34| 107| *(p++) = char((codepoint16 | 0x80) & 0xBF); 35| 107| codepoint16 = uint16_t(codepoint16 >> 6); 36| 107| *(p++) = char(codepoint16 | 0xF0); 37| 107| } 38| 228| } 39| | 40| 1.24k| while (*(--p)) { ------------------ | Branch (40:12): [True: 941, False: 303] ------------------ 41| 941| str.append(*p); 42| 941| } 43| 303| } 44| 449|} _ZN11ArduinoJson8V6213HB46detail10addPaddingEm: 21| 2.20k|inline size_t addPadding(size_t bytes) { 22| 2.20k| const size_t mask = sizeof(void*) - 1; 23| 2.20k| return (bytes + mask) & ~mask; 24| 2.20k|} _ZN11ArduinoJson8V6213HB46detail9isAlignedIcEEbPT_: 50| 7.89k|inline bool isAligned(T* ptr) { 51| 7.89k| return isAligned(reinterpret_cast(ptr)); 52| 7.89k|} _ZN11ArduinoJson8V6213HB46detail9isAlignedEm: 15| 7.89k|inline bool isAligned(size_t value) { 16| 7.89k| const size_t mask = sizeof(void*) - 1; 17| 7.89k| size_t addr = value; 18| 7.89k| return (addr & mask) == 0; 19| 7.89k|} _ZN11ArduinoJson8V6213HB46detail10MemoryPoolC2EPcm: 44| 2.20k| overflowed_(false) { 45| 2.20k| ARDUINOJSON_ASSERT(isAligned(begin_)); ------------------ | | 11| 2.20k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 46| 2.20k| ARDUINOJSON_ASSERT(isAligned(right_)); ------------------ | | 11| 2.20k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 47| 2.20k| ARDUINOJSON_ASSERT(isAligned(end_)); ------------------ | | 11| 2.20k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 48| 2.20k| } _ZN11ArduinoJson8V6213HB46detail10MemoryPool6bufferEv: 50| 2.20k| void* buffer() { 51| 2.20k| return begin_; // NOLINT(clang-analyzer-unix.Malloc) 52| | // movePointers() alters this pointer 53| 2.20k| } _ZN11ArduinoJson8V6213HB46detail10MemoryPool5clearEv: 116| 2.20k| void clear() { 117| 2.20k| left_ = begin_; 118| 2.20k| right_ = end_; 119| 2.20k| overflowed_ = false; 120| 2.20k| } _ZN11ArduinoJson8V6213HB46detail10MemoryPool12allocVariantEv: 68| 10.1k| VariantSlot* allocVariant() { 69| 10.1k| return allocRight(); 70| 10.1k| } _ZN11ArduinoJson8V6213HB46detail10MemoryPool10allocRightINS1_11VariantSlotEEEPT_v: 205| 10.1k| T* allocRight() { 206| 10.1k| return reinterpret_cast(allocRight(sizeof(T))); 207| 10.1k| } _ZN11ArduinoJson8V6213HB46detail10MemoryPool10allocRightEm: 209| 10.1k| void* allocRight(size_t bytes) { 210| 10.1k| if (!canAlloc(bytes)) { ------------------ | Branch (210:9): [True: 2, False: 10.1k] ------------------ 211| 2| overflowed_ = true; 212| 2| return 0; 213| 2| } 214| 10.1k| right_ -= bytes; 215| 10.1k| return right_; 216| 10.1k| } _ZNK11ArduinoJson8V6213HB46detail10MemoryPool8canAllocEm: 122| 10.1k| bool canAlloc(size_t bytes) const { 123| 10.1k| return left_ + bytes <= right_; 124| 10.1k| } _ZNK11ArduinoJson8V6213HB46detail10MemoryPool4ownsEPv: 126| 7.75k| bool owns(void* p) const { 127| 7.75k| return begin_ <= p && p < end_; ------------------ | Branch (127:12): [True: 7.75k, False: 0] | Branch (127:27): [True: 7.75k, False: 0] ------------------ 128| 7.75k| } _ZNK11ArduinoJson8V6213HB46detail10MemoryPool11getFreeZoneEPPcPm: 93| 3.05k| void getFreeZone(char** zoneStart, size_t* zoneSize) const { 94| 3.05k| *zoneStart = left_; 95| 3.05k| *zoneSize = size_t(right_ - left_); 96| 3.05k| } _ZN11ArduinoJson8V6213HB46detail10MemoryPool16markAsOverflowedEv: 112| 62| void markAsOverflowed() { 113| 62| overflowed_ = true; 114| 62| } _ZNK11ArduinoJson8V6213HB46detail10MemoryPool10overflowedEv: 64| 2.75k| bool overflowed() const { 65| 2.75k| return overflowed_; 66| 2.75k| } _ZN11ArduinoJson8V6213HB46detail10MemoryPool22saveStringFromFreeZoneEm: 98| 2.26k| const char* saveStringFromFreeZone(size_t len) { 99| 2.26k|#if ARDUINOJSON_ENABLE_STRING_DEDUPLICATION 100| 2.26k| const char* dup = findString(adaptString(left_, len)); 101| 2.26k| if (dup) ------------------ | Branch (101:9): [True: 978, False: 1.28k] ------------------ 102| 978| return dup; 103| 1.28k|#endif 104| | 105| 1.28k| const char* str = left_; 106| 1.28k| left_ += len; 107| 1.28k| *left_++ = 0; 108| 1.28k| checkInvariants(); 109| 1.28k| return str; 110| 2.26k| } _ZNK11ArduinoJson8V6213HB46detail10MemoryPool10findStringINS1_14SizedRamStringEEEPKcRKT_: 179| 2.26k| const char* findString(const TAdaptedString& str) const { 180| 2.26k| size_t n = str.size(); 181| 7.64k| for (char* next = begin_; next + n < left_; ++next) { ------------------ | Branch (181:31): [True: 6.36k, False: 1.28k] ------------------ 182| 6.36k| if (next[n] == '\0' && stringEquals(str, adaptString(next, n))) ------------------ | Branch (182:11): [True: 5.71k, False: 641] | Branch (182:11): [True: 978, False: 5.38k] | Branch (182:30): [True: 978, False: 4.74k] ------------------ 183| 978| return next; 184| | 185| | // jump to next terminator 186| 11.6k| while (*next) ------------------ | Branch (186:14): [True: 6.29k, False: 5.38k] ------------------ 187| 6.29k| ++next; 188| 5.38k| } 189| 1.28k| return 0; 190| 2.26k| } _ZN11ArduinoJson8V6213HB46detail10MemoryPool15checkInvariantsEv: 170| 1.28k| void checkInvariants() { 171| 1.28k| ARDUINOJSON_ASSERT(begin_ <= left_); ------------------ | | 11| 1.28k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 172| 1.28k| ARDUINOJSON_ASSERT(left_ <= right_); ------------------ | | 11| 1.28k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 173| 1.28k| ARDUINOJSON_ASSERT(right_ <= end_); ------------------ | | 11| 1.28k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 174| 1.28k| ARDUINOJSON_ASSERT(isAligned(right_)); ------------------ | | 11| 1.28k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 175| 1.28k| } _ZN11ArduinoJson8V6213HB46detail10FloatPartsIdEC2Ed: 20| 1.13k| FloatParts(TFloat value) { 21| 1.13k| uint32_t maxDecimalPart = sizeof(TFloat) >= 8 ? 1000000000 : 1000000; ------------------ | Branch (21:31): [Folded - Ignored] ------------------ 22| 1.13k| decimalPlaces = sizeof(TFloat) >= 8 ? 9 : 6; ------------------ | Branch (22:21): [Folded - Ignored] ------------------ 23| | 24| 1.13k| exponent = normalize(value); 25| | 26| 1.13k| integral = uint32_t(value); 27| | // reduce number of decimal places by the number of integral places 28| 1.94k| for (uint32_t tmp = integral; tmp >= 10; tmp /= 10) { ------------------ | Branch (28:35): [True: 805, False: 1.13k] ------------------ 29| 805| maxDecimalPart /= 10; 30| 805| decimalPlaces--; 31| 805| } 32| | 33| 1.13k| TFloat remainder = (value - TFloat(integral)) * TFloat(maxDecimalPart); 34| | 35| 1.13k| decimal = uint32_t(remainder); 36| 1.13k| remainder = remainder - TFloat(decimal); 37| | 38| | // rounding: 39| | // increment by 1 if remainder >= 0.5 40| 1.13k| decimal += uint32_t(remainder * 2); 41| 1.13k| if (decimal >= maxDecimalPart) { ------------------ | Branch (41:9): [True: 195, False: 943] ------------------ 42| 195| decimal = 0; 43| 195| integral++; 44| 195| if (exponent && integral >= 10) { ------------------ | Branch (44:11): [True: 159, False: 36] | Branch (44:23): [True: 70, False: 89] ------------------ 45| 70| exponent++; 46| 70| integral = 1; 47| 70| } 48| 195| } 49| | 50| | // remove trailing zeros 51| 9.23k| while (decimal % 10 == 0 && decimalPlaces > 0) { ------------------ | Branch (51:12): [True: 9.00k, False: 230] | Branch (51:33): [True: 8.10k, False: 908] ------------------ 52| 8.10k| decimal /= 10; 53| 8.10k| decimalPlaces--; 54| 8.10k| } 55| 1.13k| } _ZN11ArduinoJson8V6213HB46detail10FloatPartsIdE9normalizeERd: 57| 1.13k| static int16_t normalize(TFloat& value) { 58| 1.13k| typedef FloatTraits traits; 59| 1.13k| int16_t powersOf10 = 0; 60| | 61| 1.13k| int8_t index = sizeof(TFloat) == 8 ? 8 : 5; ------------------ | Branch (61:20): [Folded - Ignored] ------------------ 62| 1.13k| int bit = 1 << index; 63| | 64| 1.13k| if (value >= ARDUINOJSON_POSITIVE_EXPONENTIATION_THRESHOLD) { ------------------ | | 167| 1.13k|# define ARDUINOJSON_POSITIVE_EXPONENTIATION_THRESHOLD 1e7 ------------------ | Branch (64:9): [True: 351, False: 787] ------------------ 65| 3.51k| for (; index >= 0; index--) { ------------------ | Branch (65:14): [True: 3.15k, False: 351] ------------------ 66| 3.15k| if (value >= traits::positiveBinaryPowersOfTen()[index]) { ------------------ | Branch (66:13): [True: 1.19k, False: 1.96k] ------------------ 67| 1.19k| value *= traits::negativeBinaryPowersOfTen()[index]; 68| 1.19k| powersOf10 = int16_t(powersOf10 + bit); 69| 1.19k| } 70| 3.15k| bit >>= 1; 71| 3.15k| } 72| 351| } 73| | 74| 1.13k| if (value > 0 && value <= ARDUINOJSON_NEGATIVE_EXPONENTIATION_THRESHOLD) { ------------------ | | 172| 910|# define ARDUINOJSON_NEGATIVE_EXPONENTIATION_THRESHOLD 1e-5 ------------------ | Branch (74:9): [True: 910, False: 228] | Branch (74:22): [True: 111, False: 799] ------------------ 75| 1.11k| for (; index >= 0; index--) { ------------------ | Branch (75:14): [True: 999, False: 111] ------------------ 76| 999| if (value < traits::negativeBinaryPowersOfTen()[index] * 10) { ------------------ | Branch (76:13): [True: 359, False: 640] ------------------ 77| 359| value *= traits::positiveBinaryPowersOfTen()[index]; 78| 359| powersOf10 = int16_t(powersOf10 - bit); 79| 359| } 80| 999| bit >>= 1; 81| 999| } 82| 111| } 83| | 84| 1.13k| return powersOf10; 85| 1.13k| } _ZN11ArduinoJson8V6213HB46detail11FloatTraitsIdLm8EE25positiveBinaryPowersOfTenEv: 32| 4.13k| static pgm_ptr positiveBinaryPowersOfTen() { 33| 4.13k| ARDUINOJSON_DEFINE_PROGMEM_ARRAY( // ------------------ | | 44| 4.13k| static type const name[] = __VA_ARGS__; ------------------ 34| 4.13k| uint64_t, factors, 35| 4.13k| { 36| 4.13k| 0x4024000000000000, // 1e1 37| 4.13k| 0x4059000000000000, // 1e2 38| 4.13k| 0x40C3880000000000, // 1e4 39| 4.13k| 0x4197D78400000000, // 1e8 40| 4.13k| 0x4341C37937E08000, // 1e16 41| 4.13k| 0x4693B8B5B5056E17, // 1e32 42| 4.13k| 0x4D384F03E93FF9F5, // 1e64 43| 4.13k| 0x5A827748F9301D32, // 1e128 44| 4.13k| 0x75154FDD7F73BF3C, // 1e256 45| 4.13k| }); 46| 4.13k| return pgm_ptr(reinterpret_cast(factors)); 47| 4.13k| } _ZN11ArduinoJson8V6213HB46detail11FloatTraitsIdLm8EE25negativeBinaryPowersOfTenEv: 49| 4.39k| static pgm_ptr negativeBinaryPowersOfTen() { 50| 4.39k| ARDUINOJSON_DEFINE_PROGMEM_ARRAY( // ------------------ | | 44| 4.39k| static type const name[] = __VA_ARGS__; ------------------ 51| 4.39k| uint64_t, factors, 52| 4.39k| { 53| 4.39k| 0x3FB999999999999A, // 1e-1 54| 4.39k| 0x3F847AE147AE147B, // 1e-2 55| 4.39k| 0x3F1A36E2EB1C432D, // 1e-4 56| 4.39k| 0x3E45798EE2308C3A, // 1e-8 57| 4.39k| 0x3C9CD2B297D889BC, // 1e-16 58| 4.39k| 0x3949F623D5A8A733, // 1e-32 59| 4.39k| 0x32A50FFD44F4A73D, // 1e-64 60| 4.39k| 0x255BBA08CF8C979D, // 1e-128 61| 4.39k| 0x0AC8062864AC6F43 // 1e-256 62| 4.39k| }); 63| 4.39k| return pgm_ptr(reinterpret_cast(factors)); 64| 4.39k| } _ZN11ArduinoJson8V6213HB46detail11FloatTraitsIdLm8EE3infEv: 70| 205| static T inf() { 71| 205| return forge(0x7ff0000000000000); 72| 205| } _ZN11ArduinoJson8V6213HB46detail11FloatTraitsIdLm8EE5forgeEm: 101| 205| static T forge(uint64_t bits) { 102| 205| return alias_cast(bits); 103| 205| } _ZN11ArduinoJson8V6213HB46detail10make_floatIdiEET_S3_T0_: 196| 2.82k|inline TFloat make_float(TFloat m, TExponent e) { 197| 2.82k| using traits = FloatTraits; 198| | 199| 2.82k| auto powersOfTen = e > 0 ? traits::positiveBinaryPowersOfTen() ------------------ | Branch (199:22): [True: 618, False: 2.20k] ------------------ 200| 2.82k| : traits::negativeBinaryPowersOfTen(); 201| 2.82k| if (e <= 0) ------------------ | Branch (201:7): [True: 2.20k, False: 618] ------------------ 202| 2.20k| e = TExponent(-e); 203| | 204| 6.76k| for (uint8_t index = 0; e != 0; index++) { ------------------ | Branch (204:27): [True: 3.94k, False: 2.82k] ------------------ 205| 3.94k| if (e & 1) ------------------ | Branch (205:9): [True: 2.38k, False: 1.56k] ------------------ 206| 2.38k| m *= powersOfTen[index]; 207| 3.94k| e >>= 1; 208| 3.94k| } 209| 2.82k| return m; 210| 2.82k|} _ZN11ArduinoJson8V6213HB46detail11parseNumberEPKcRNS1_11VariantDataE: 21| 7.78k|inline bool parseNumber(const char* s, VariantData& result) { 22| 7.78k| typedef FloatTraits traits; 23| 7.78k| typedef choose_largest::type mantissa_t; 24| 7.78k| typedef traits::exponent_type exponent_t; 25| | 26| 7.78k| ARDUINOJSON_ASSERT(s != 0); ------------------ | | 11| 7.78k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 27| | 28| 0| bool is_negative = false; 29| 7.78k| switch (*s) { ------------------ | Branch (29:11): [True: 6.98k, False: 797] ------------------ 30| 722| case '-': ------------------ | Branch (30:5): [True: 722, False: 7.05k] ------------------ 31| 722| is_negative = true; 32| 722| s++; 33| 722| break; 34| 75| case '+': ------------------ | Branch (34:5): [True: 75, False: 7.70k] ------------------ 35| 75| s++; 36| 75| break; 37| 7.78k| } 38| | 39| |#if ARDUINOJSON_ENABLE_NAN 40| | if (*s == 'n' || *s == 'N') { 41| | result.setFloat(traits::nan()); 42| | return true; 43| | } 44| |#endif 45| | 46| |#if ARDUINOJSON_ENABLE_INFINITY 47| | if (*s == 'i' || *s == 'I') { 48| | result.setFloat(is_negative ? -traits::inf() : traits::inf()); 49| | return true; 50| | } 51| |#endif 52| | 53| 7.78k| if (!isdigit(*s) && *s != '.') ------------------ | Branch (53:7): [True: 1.69k, False: 6.09k] | Branch (53:23): [True: 93, False: 1.59k] ------------------ 54| 93| return false; 55| | 56| 7.68k| mantissa_t mantissa = 0; 57| 7.68k| exponent_t exponent_offset = 0; 58| 7.68k| const mantissa_t maxUint = JsonUInt(-1); 59| | 60| 22.1k| while (isdigit(*s)) { ------------------ | Branch (60:10): [True: 14.5k, False: 7.62k] ------------------ 61| 14.5k| uint8_t digit = uint8_t(*s - '0'); 62| 14.5k| if (mantissa > maxUint / 10) ------------------ | Branch (62:9): [True: 48, False: 14.5k] ------------------ 63| 48| break; 64| 14.5k| mantissa *= 10; 65| 14.5k| if (mantissa > maxUint - digit) ------------------ | Branch (65:9): [True: 18, False: 14.4k] ------------------ 66| 18| break; 67| 14.4k| mantissa += digit; 68| 14.4k| s++; 69| 14.4k| } 70| | 71| 7.68k| if (*s == '\0') { ------------------ | Branch (71:7): [True: 4.57k, False: 3.11k] ------------------ 72| 4.57k| if (is_negative) { ------------------ | Branch (72:9): [True: 437, False: 4.13k] ------------------ 73| 437| const mantissa_t sintMantissaMax = mantissa_t(1) 74| 437| << (sizeof(JsonInteger) * 8 - 1); 75| 437| if (mantissa <= sintMantissaMax) { ------------------ | Branch (75:11): [True: 416, False: 21] ------------------ 76| 416| result.setInteger(JsonInteger(~mantissa + 1)); 77| 416| return true; 78| 416| } 79| 4.13k| } else { 80| 4.13k| result.setInteger(JsonUInt(mantissa)); 81| 4.13k| return true; 82| 4.13k| } 83| 4.57k| } 84| | 85| | // avoid mantissa overflow 86| 3.57k| while (mantissa > traits::mantissa_max) { ------------------ | Branch (86:10): [True: 438, False: 3.13k] ------------------ 87| 438| mantissa /= 10; 88| 438| exponent_offset++; 89| 438| } 90| | 91| | // remaing digits can't fit in the mantissa 92| 3.52k| while (isdigit(*s)) { ------------------ | Branch (92:10): [True: 393, False: 3.13k] ------------------ 93| 393| exponent_offset++; 94| 393| s++; 95| 393| } 96| | 97| 3.13k| if (*s == '.') { ------------------ | Branch (97:7): [True: 1.67k, False: 1.45k] ------------------ 98| 1.67k| s++; 99| 2.76k| while (isdigit(*s)) { ------------------ | Branch (99:12): [True: 1.08k, False: 1.67k] ------------------ 100| 1.08k| if (mantissa < traits::mantissa_max / 10) { ------------------ | Branch (100:11): [True: 876, False: 210] ------------------ 101| 876| mantissa = mantissa * 10 + uint8_t(*s - '0'); 102| 876| exponent_offset--; 103| 876| } 104| 1.08k| s++; 105| 1.08k| } 106| 1.67k| } 107| | 108| 3.13k| int exponent = 0; 109| 3.13k| if (*s == 'e' || *s == 'E') { ------------------ | Branch (109:7): [True: 924, False: 2.21k] | Branch (109:20): [True: 437, False: 1.77k] ------------------ 110| 1.36k| s++; 111| 1.36k| bool negative_exponent = false; 112| 1.36k| if (*s == '-') { ------------------ | Branch (112:9): [True: 271, False: 1.09k] ------------------ 113| 271| negative_exponent = true; 114| 271| s++; 115| 1.09k| } else if (*s == '+') { ------------------ | Branch (115:16): [True: 66, False: 1.02k] ------------------ 116| 66| s++; 117| 66| } 118| | 119| 3.08k| while (isdigit(*s)) { ------------------ | Branch (119:12): [True: 1.99k, False: 1.09k] ------------------ 120| 1.99k| exponent = exponent * 10 + (*s - '0'); 121| 1.99k| if (exponent + exponent_offset > traits::exponent_max) { ------------------ | Branch (121:11): [True: 271, False: 1.72k] ------------------ 122| 271| if (negative_exponent) ------------------ | Branch (122:13): [True: 66, False: 205] ------------------ 123| 66| result.setFloat(is_negative ? -0.0f : 0.0f); ------------------ | Branch (123:27): [True: 0, False: 66] ------------------ 124| 205| else 125| 205| result.setFloat(is_negative ? -traits::inf() : traits::inf()); ------------------ | Branch (125:27): [True: 67, False: 138] ------------------ 126| 271| return true; 127| 271| } 128| 1.72k| s++; 129| 1.72k| } 130| 1.09k| if (negative_exponent) ------------------ | Branch (130:9): [True: 205, False: 885] ------------------ 131| 205| exponent = -exponent; 132| 1.09k| } 133| 2.86k| exponent += exponent_offset; 134| | 135| | // we should be at the end of the string, otherwise it's an error 136| 2.86k| if (*s != '\0') ------------------ | Branch (136:7): [True: 42, False: 2.82k] ------------------ 137| 42| return false; 138| | 139| 2.82k| JsonFloat final_result = 140| 2.82k| make_float(static_cast(mantissa), exponent); 141| | 142| 2.82k| result.setFloat(is_negative ? -final_result : final_result); ------------------ | Branch (142:19): [True: 224, False: 2.59k] ------------------ 143| 2.82k| return true; 144| 2.86k|} _ZN11ArduinoJson8V6213HB46detail10alias_castIdmEET_T0_: 24| 205|T alias_cast(F raw_data) { 25| 205| alias_cast_t ac; 26| 205| ac.raw = raw_data; 27| 205| return ac.data; 28| 205|} _ZN11ArduinoJson8V6213HB46detail7isdigitEc: 12| 39.3k|inline bool isdigit(char c) { 13| 39.3k| return '0' <= c && c <= '9'; ------------------ | Branch (13:10): [True: 26.8k, False: 12.4k] | Branch (13:22): [True: 24.1k, False: 2.72k] ------------------ 14| 39.3k|} _ZN11ArduinoJson8V6213HB46detail14numeric_limitsIivE6lowestEv: 33| 15.5k| static T lowest() { 34| 15.5k| return T(T(1) << (sizeof(T) * 8 - 1)); 35| 15.5k| } _ZN11ArduinoJson8V6213HB46detail14numeric_limitsIivE7highestEv: 36| 7.75k| static T highest() { 37| 7.75k| return T(~lowest()); 38| 7.75k| } _ZN11ArduinoJson8V6213HB46detail5isnanIdEEbT_: 16| 1.20k|bool isnan(T x) { 17| 1.20k| return x != x; 18| 1.20k|} _ZN11ArduinoJson8V6213HB46detail5isinfIdEEbT_: 23| 1.20k|bool isinf(T x) { 24| 1.20k| return x != 0.0 && x * 2 == x; ------------------ | Branch (24:10): [True: 977, False: 228] | Branch (24:22): [True: 67, False: 910] ------------------ 25| 1.20k|} _ZN11ArduinoJson8V6213HB46detail7pgm_ptrIdEC2EPKd: 57| 8.52k| explicit pgm_ptr(const T* ptr) : ptr_(ptr) {} _ZNK11ArduinoJson8V6213HB46detail7pgm_ptrIdEixEl: 59| 8.09k| T operator[](intptr_t index) const { 60| 8.09k| return pgm_read(ptr_ + index); 61| 8.09k| } _ZN11ArduinoJson8V6213HB46detail8pgm_readIdEET_PKS3_: 48| 8.09k|inline T pgm_read(const T* p) { 49| 8.09k| return *p; 50| 8.09k|} _ZN11ArduinoJson8V6213HB46detail7forwardIRmEEOT_RNS1_16remove_referenceIS4_E4typeE: 12| 2.20k|T&& forward(typename remove_reference::type& t) noexcept { 13| 2.20k| return static_cast(t); 14| 2.20k|} _ZN11ArduinoJson8V6213HB46detail17CountingDecoratorINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEEC2ERSB_: 14| 847| explicit CountingDecorator(TWriter& writer) : writer_(writer), count_(0) {} _ZN11ArduinoJson8V6213HB46detail17CountingDecoratorINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE5writeEPKhm: 20| 3.17k| void write(const uint8_t* s, size_t n) { 21| 3.17k| count_ += writer_.write(s, n); 22| 3.17k| } _ZN11ArduinoJson8V6213HB46detail17CountingDecoratorINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE5writeEh: 16| 6.83k| void write(uint8_t c) { 17| 6.83k| count_ += writer_.write(c); 18| 6.83k| } _ZNK11ArduinoJson8V6213HB46detail17CountingDecoratorINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE5countEv: 24| 3.21k| size_t count() const { 25| 3.21k| return count_; 26| 3.21k| } _ZN11ArduinoJson8V6213HB46detail6WriterINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEvEC2ERS9_: 27| 847| Writer(TDestination& str) : str_(&str) {} _ZN11ArduinoJson8V6213HB46detail6WriterINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEvE5writeEPKhm: 34| 3.17k| size_t write(const uint8_t* s, size_t n) { 35| 3.17k| str_->append(reinterpret_cast(s), n); 36| 3.17k| return n; 37| 3.17k| } _ZN11ArduinoJson8V6213HB46detail6WriterINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEvE5writeEh: 29| 6.83k| size_t write(uint8_t c) { 30| 6.83k| str_->push_back(static_cast(c)); 31| 6.83k| return 1; 32| 6.83k| } _ZN11ArduinoJson8V6213HB46detail9serializeINS1_14JsonSerializerENSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEmNS0_16JsonVariantConstERT0_: 20| 847| TDestination& destination) { 21| 847| Writer writer(destination); 22| 847| return doSerialize(source, writer); 23| 847|} _ZN11ArduinoJson8V6213HB46detail11doSerializeINS1_14JsonSerializerENS1_6WriterINSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEvEEEEmNS0_16JsonVariantConstET0_: 13| 847|size_t doSerialize(ArduinoJson::JsonVariantConst source, TWriter writer) { 14| 847| TSerializer serializer(writer); 15| 847| return variantAccept(VariantAttorney::getData(source), serializer); 16| 847|} _ZN11ArduinoJson8V6213HB46detail12StringCopierC2EPNS1_10MemoryPoolE: 13| 2.20k| StringCopier(MemoryPool* pool) : pool_(pool) {} _ZN11ArduinoJson8V6213HB46detail12StringCopier11startStringEv: 15| 3.05k| void startString() { 16| 3.05k| pool_->getFreeZone(&ptr_, &capacity_); 17| 3.05k| size_ = 0; 18| 3.05k| if (capacity_ == 0) ------------------ | Branch (18:9): [True: 16, False: 3.04k] ------------------ 19| 16| pool_->markAsOverflowed(); 20| 3.05k| } _ZN11ArduinoJson8V6213HB46detail12StringCopier6appendEc: 39| 6.82k| void append(char c) { 40| 6.82k| if (size_ + 1 < capacity_) ------------------ | Branch (40:9): [True: 6.78k, False: 46] ------------------ 41| 6.78k| ptr_[size_++] = c; 42| 46| else 43| 46| pool_->markAsOverflowed(); 44| 6.82k| } _ZNK11ArduinoJson8V6213HB46detail12StringCopier7isValidEv: 46| 2.75k| bool isValid() const { 47| 2.75k| return !pool_->overflowed(); 48| 2.75k| } _ZNK11ArduinoJson8V6213HB46detail12StringCopier3strEv: 54| 1.94k| JsonString str() const { 55| 1.94k| ARDUINOJSON_ASSERT(ptr_); ------------------ | | 11| 1.94k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 56| 1.94k| ARDUINOJSON_ASSERT(size_ < capacity_); ------------------ | | 11| 1.94k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 57| 0| ptr_[size_] = 0; 58| 1.94k| return JsonString(ptr_, size_, JsonString::Copied); 59| 1.94k| } _ZN11ArduinoJson8V6213HB46detail12StringCopier4saveEv: 22| 2.26k| JsonString save() { 23| 2.26k| ARDUINOJSON_ASSERT(ptr_); ------------------ | | 11| 2.26k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 24| 2.26k| ARDUINOJSON_ASSERT(size_ < capacity_); // needs room for the terminator ------------------ | | 11| 2.26k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 25| 0| return JsonString(pool_->saveStringFromFreeZone(size_), size_, 26| 2.26k| JsonString::Copied); 27| 2.26k| } _ZN11ArduinoJson8V6213HB46detail17makeStringStorageIPKhEENS1_12StringCopierERT_PNS1_10MemoryPoolE: 13| 2.20k|StringCopier makeStringStorage(TInput&, MemoryPool* pool) { 14| 2.20k| ARDUINOJSON_ASSERT(pool != 0); ------------------ | | 11| 2.20k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 15| 0| return StringCopier(pool); 16| 2.20k|} _ZNK11ArduinoJson8V6213HB46detail23ZeroTerminatedRamString6isNullEv: 26| 8.05k| bool isNull() const { 27| 8.05k| return !str_; 28| 8.05k| } _ZNK11ArduinoJson8V6213HB46detail23ZeroTerminatedRamString4sizeEv: 30| 12.2k| size_t size() const { 31| 12.2k| return str_ ? ::strlen(str_) : 0; ------------------ | Branch (31:12): [True: 12.2k, False: 0] ------------------ 32| 12.2k| } _ZNK11ArduinoJson8V6213HB46detail23ZeroTerminatedRamStringixEm: 34| 6.09k| char operator[](size_t i) const { 35| 6.09k| ARDUINOJSON_ASSERT(str_ != 0); ------------------ | | 11| 6.09k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 36| 6.09k| ARDUINOJSON_ASSERT(i <= size()); ------------------ | | 11| 6.09k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 37| 0| return str_[i]; 38| 6.09k| } _ZN11ArduinoJson8V6213HB46detail13StringAdapterIPKcvE5adaptES4_: 95| 5.00k| static AdaptedString adapt(const char* p) { 96| 5.00k| return AdaptedString(p); 97| 5.00k| } _ZN11ArduinoJson8V6213HB46detail19StaticStringAdapterC2EPKc: 84| 5.00k| StaticStringAdapter(const char* str) : ZeroTerminatedRamString(str) {} _ZN11ArduinoJson8V6213HB46detail23ZeroTerminatedRamStringC2EPKc: 24| 5.00k| ZeroTerminatedRamString(const char* str) : str_(str) {} _ZNK11ArduinoJson8V6213HB46detail14SizedRamString4sizeEv: 110| 25.5k| size_t size() const { 111| 25.5k| return size_; 112| 25.5k| } _ZNK11ArduinoJson8V6213HB46detail14SizedRamString6isNullEv: 106| 11.4k| bool isNull() const { 107| 11.4k| return !str_; 108| 11.4k| } _ZNK11ArduinoJson8V6213HB46detail14SizedRamStringixEm: 114| 11.8k| char operator[](size_t i) const { 115| 11.8k| ARDUINOJSON_ASSERT(str_ != 0); ------------------ | | 11| 11.8k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 116| 11.8k| ARDUINOJSON_ASSERT(i <= size()); ------------------ | | 11| 11.8k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 117| 0| return str_[i]; 118| 11.8k| } _ZN11ArduinoJson8V6213HB46detail18SizedStringAdapterIPcvE5adaptEPKcm: 138| 7.98k| static AdaptedString adapt(const TChar* p, size_t n) { 139| 7.98k| return AdaptedString(reinterpret_cast(p), n); 140| 7.98k| } _ZN11ArduinoJson8V6213HB46detail14SizedRamStringC2EPKcm: 104| 7.98k| SizedRamString(const char* str, size_t sz) : str_(str), size_(sz) {} _ZN11ArduinoJson8V6213HB410JsonStringC2EPKcmNS1_9OwnershipE: 25| 4.20k| : data_(data), size_(sz), ownership_(ownership) {} _ZNK11ArduinoJson8V6213HB410JsonString5c_strEv: 28| 6.15k| const char* c_str() const { 29| 6.15k| return data_; 30| 6.15k| } _ZNK11ArduinoJson8V6213HB410JsonStringcvbEv: 49| 2.26k| explicit operator bool() const { 50| 2.26k| return data_ != 0; 51| 2.26k| } _ZNK11ArduinoJson8V6213HB410JsonString8isLinkedEv: 39| 2.26k| bool isLinked() const { 40| 2.26k| return ownership_ == Linked; 41| 2.26k| } _ZNK11ArduinoJson8V6213HB410JsonString4sizeEv: 44| 642| size_t size() const { 45| 642| return size_; 46| 642| } _ZN11ArduinoJson8V6213HB46detail11adaptStringIKcEENS1_13StringAdapterIPT_vE13AdaptedStringES6_: 21| 5.00k|typename StringAdapter::AdaptedString adaptString(TChar* p) { 22| 5.00k| return StringAdapter::adapt(p); 23| 5.00k|} _ZN11ArduinoJson8V6213HB46detail11adaptStringIcEENS1_18SizedStringAdapterIPT_vE13AdaptedStringES5_m: 27| 7.98k| size_t n) { 28| 7.98k| return SizedStringAdapter::adapt(p, n); 29| 7.98k|} _ZN11ArduinoJson8V6213HB46detail12stringEqualsINS1_19StaticStringAdapterES3_EENS1_9enable_ifIXlesrT_11typeSortKeysrT0_11typeSortKeyEbE4typeES5_S6_: 48| 3.05k|stringEquals(TAdaptedString1 s1, TAdaptedString2 s2) { 49| 3.05k| ARDUINOJSON_ASSERT(!s1.isNull()); ------------------ | | 11| 3.05k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 50| 3.05k| ARDUINOJSON_ASSERT(!s2.isNull()); ------------------ | | 11| 3.05k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 51| 0| size_t size1 = s1.size(); 52| 3.05k| size_t size2 = s2.size(); 53| 3.05k| if (size1 != size2) ------------------ | Branch (53:7): [True: 237, False: 2.82k] ------------------ 54| 237| return false; 55| 3.37k| for (size_t i = 0; i < size1; i++) { ------------------ | Branch (55:22): [True: 3.04k, False: 326] ------------------ 56| 3.04k| if (s1[i] != s2[i]) ------------------ | Branch (56:9): [True: 2.49k, False: 555] ------------------ 57| 2.49k| return false; 58| 3.04k| } 59| 326| return true; 60| 2.82k|} _ZN11ArduinoJson8V6213HB46detail12stringEqualsINS1_14SizedRamStringES3_EENS1_9enable_ifIXlesrT_11typeSortKeysrT0_11typeSortKeyEbE4typeES5_S6_: 48| 5.71k|stringEquals(TAdaptedString1 s1, TAdaptedString2 s2) { 49| 5.71k| ARDUINOJSON_ASSERT(!s1.isNull()); ------------------ | | 11| 5.71k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 50| 5.71k| ARDUINOJSON_ASSERT(!s2.isNull()); ------------------ | | 11| 5.71k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 51| 0| size_t size1 = s1.size(); 52| 5.71k| size_t size2 = s2.size(); 53| 5.71k| if (size1 != size2) ------------------ | Branch (53:7): [True: 0, False: 5.71k] ------------------ 54| 0| return false; 55| 6.88k| for (size_t i = 0; i < size1; i++) { ------------------ | Branch (55:22): [True: 5.90k, False: 978] ------------------ 56| 5.90k| if (s1[i] != s2[i]) ------------------ | Branch (56:9): [True: 4.74k, False: 1.16k] ------------------ 57| 4.74k| return false; 58| 5.90k| } 59| 978| return true; 60| 5.71k|} _ZN11ArduinoJson8V6213HB416JsonVariantConstC2EPKNS0_6detail11VariantDataE: 36| 847| explicit JsonVariantConst(const detail::VariantData* data) : data_(data) {} _ZNK11ArduinoJson8V6213HB416JsonVariantConst7getDataEv: 136| 847| const detail::VariantData* getData() const { 137| 847| return data_; 138| 847| } _ZN11ArduinoJson8V6213HB46detail8slotDataEPNS1_11VariantSlotE: 42| 8.57k|inline VariantData* slotData(VariantSlot* slot) { 43| 8.57k| return reinterpret_cast(slot); 44| 8.57k|} _ZN11ArduinoJson8V6213HB46detail15VariantAttorney7getDataINS0_16JsonVariantConstEEENS2_15ResultOfGetDataIT_E4typeERS6_: 38| 847| TClient& client) { 39| 847| return client.getData(); 40| 847| } _ZN11ArduinoJson8V6213HB46detail15VariantAttorney7getDataINS0_12JsonDocumentEEENS2_15ResultOfGetDataIT_E4typeERS6_: 38| 2.20k| TClient& client) { 39| 2.20k| return client.getData(); 40| 2.20k| } _ZN11ArduinoJson8V6213HB46detail15VariantAttorney7getPoolINS0_12JsonDocumentEEEPNS1_10MemoryPoolERT_: 32| 2.20k| FORCE_INLINE static MemoryPool* getPool(TClient& client) { 33| 2.20k| return client.getPool(); 34| 2.20k| } _ZNK11ArduinoJson8V6213HB46detail11VariantData6acceptINS1_14JsonSerializerINS1_6WriterINSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEvEEEEEENT_11result_typeERSF_: 29| 3.21k| typename TVisitor::result_type accept(TVisitor& visitor) const { 30| 3.21k| switch (type()) { 31| 1.20k| case VALUE_IS_FLOAT: ------------------ | Branch (31:7): [True: 1.20k, False: 2.01k] ------------------ 32| 1.20k| return visitor.visitFloat(content_.asFloat); 33| | 34| 375| case VALUE_IS_ARRAY: ------------------ | Branch (34:7): [True: 375, False: 2.84k] ------------------ 35| 375| return visitor.visitArray(content_.asCollection); 36| | 37| 256| case VALUE_IS_OBJECT: ------------------ | Branch (37:7): [True: 256, False: 2.96k] ------------------ 38| 256| return visitor.visitObject(content_.asCollection); 39| | 40| 0| case VALUE_IS_LINKED_STRING: ------------------ | Branch (40:7): [True: 0, False: 3.21k] ------------------ 41| 175| case VALUE_IS_OWNED_STRING: ------------------ | Branch (41:7): [True: 175, False: 3.04k] ------------------ 42| 175| return visitor.visitString(content_.asString.data, 43| 175| content_.asString.size); 44| | 45| 0| case VALUE_IS_OWNED_RAW: ------------------ | Branch (45:7): [True: 0, False: 3.21k] ------------------ 46| 0| case VALUE_IS_LINKED_RAW: ------------------ | Branch (46:7): [True: 0, False: 3.21k] ------------------ 47| 0| return visitor.visitRawJson(content_.asString.data, 48| 0| content_.asString.size); 49| | 50| 321| case VALUE_IS_SIGNED_INTEGER: ------------------ | Branch (50:7): [True: 321, False: 2.89k] ------------------ 51| 321| return visitor.visitSignedInteger(content_.asSignedInteger); 52| | 53| 688| case VALUE_IS_UNSIGNED_INTEGER: ------------------ | Branch (53:7): [True: 688, False: 2.53k] ------------------ 54| 688| return visitor.visitUnsignedInteger(content_.asUnsignedInteger); 55| | 56| 132| case VALUE_IS_BOOLEAN: ------------------ | Branch (56:7): [True: 132, False: 3.08k] ------------------ 57| 132| return visitor.visitBoolean(content_.asBoolean != 0); 58| | 59| 66| default: ------------------ | Branch (59:7): [True: 66, False: 3.15k] ------------------ 60| 66| return visitor.visitNull(); 61| 3.21k| } 62| 3.21k| } _ZNK11ArduinoJson8V6213HB46detail11VariantData4typeEv: 287| 3.21k| uint8_t type() const { 288| 3.21k| return flags_ & VALUE_MASK; 289| 3.21k| } _ZN11ArduinoJson8V6213HB46detail11VariantDataC2Ev: 21| 2.20k| VariantData() : flags_(VALUE_IS_NULL) {} _ZN11ArduinoJson8V6213HB46detail11VariantData7setNullEv: 199| 2.20k| void setNull() { 200| 2.20k| setType(VALUE_IS_NULL); 201| 2.20k| } _ZN11ArduinoJson8V6213HB46detail11VariantData7setTypeEh: 302| 14.0k| void setType(uint8_t t) { 303| 14.0k| flags_ &= OWNED_KEY_BIT; 304| 14.0k| flags_ |= t; 305| 14.0k| } _ZN11ArduinoJson8V6213HB46detail11VariantData7toArrayEv: 213| 1.61k| CollectionData& toArray() { 214| 1.61k| setType(VALUE_IS_ARRAY); 215| 1.61k| content_.asCollection.clear(); 216| 1.61k| return content_.asCollection; 217| 1.61k| } _ZN11ArduinoJson8V6213HB46detail11VariantData8toObjectEv: 219| 1.42k| CollectionData& toObject() { 220| 1.42k| setType(VALUE_IS_OBJECT); 221| 1.42k| content_.asCollection.clear(); 222| 1.42k| return content_.asCollection; 223| 1.42k| } _ZN11ArduinoJson8V6213HB46detail11VariantData9setStringENS0_10JsonStringE: 203| 642| void setString(JsonString s) { 204| 642| ARDUINOJSON_ASSERT(s); ------------------ | | 11| 642|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 205| 642| if (s.isLinked()) ------------------ | Branch (205:9): [True: 0, False: 642] ------------------ 206| 0| setType(VALUE_IS_LINKED_STRING); 207| 642| else 208| 642| setType(VALUE_IS_OWNED_STRING); 209| 642| content_.asString.data = s.c_str(); 210| 642| content_.asString.size = s.size(); 211| 642| } _ZN11ArduinoJson8V6213HB46detail11VariantData10setBooleanEb: 153| 539| void setBoolean(bool value) { 154| 539| setType(VALUE_IS_BOOLEAN); 155| 539| content_.asBoolean = value; 156| 539| } _ZN11ArduinoJson8V6213HB46detail11VariantData10setIntegerIlEENS1_9enable_ifIXsr9is_signedIT_EE5valueEvE4typeES5_: 194| 416| typename enable_if::value>::type setInteger(T value) { 195| 416| setType(VALUE_IS_SIGNED_INTEGER); 196| 416| content_.asSignedInteger = value; 197| 416| } _ZN11ArduinoJson8V6213HB46detail11VariantData10setIntegerImEENS1_9enable_ifIXsr11is_unsignedIT_EE5valueEvE4typeES5_: 188| 4.13k| typename enable_if::value>::type setInteger(T value) { 189| 4.13k| setType(VALUE_IS_UNSIGNED_INTEGER); 190| 4.13k| content_.asUnsignedInteger = static_cast(value); 191| 4.13k| } _ZN11ArduinoJson8V6213HB46detail11VariantData8setFloatEd: 158| 3.09k| void setFloat(JsonFloat value) { 159| 3.09k| setType(VALUE_IS_FLOAT); 160| 3.09k| content_.asFloat = value; 161| 3.09k| } _ZNK11ArduinoJson8V6213HB46detail11VariantData10isEnclosedEv: 138| 273| bool isEnclosed() const { 139| 273| return !isFloat(); 140| 273| } _ZNK11ArduinoJson8V6213HB46detail11VariantData7isFloatEv: 122| 273| bool isFloat() const { 123| 273| return (flags_ & NUMBER_BIT) != 0; 124| 273| } _ZN11ArduinoJson8V6213HB46detail13variantAcceptINS1_14JsonSerializerINS1_6WriterINSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEvEEEEEENT_11result_typeEPKNS1_11VariantDataERSE_: 16| 847| TVisitor& visitor) { 17| 847| if (var != 0) ------------------ | Branch (17:7): [True: 847, False: 0] ------------------ 18| 847| return var->accept(visitor); 19| 0| else 20| 0| return visitor.visitNull(); 21| 847|} _ZNK11ArduinoJson8V6213HB46detail11VariantSlot4dataEv: 36| 2.37k| const VariantData* data() const { 37| 2.37k| return reinterpret_cast(&content_); 38| 2.37k| } _ZNK11ArduinoJson8V6213HB46detail11VariantSlot4nextEv: 44| 2.37k| const VariantSlot* next() const { 45| 2.37k| return const_cast(this)->next(); 46| 2.37k| } _ZN11ArduinoJson8V6213HB46detail11VariantSlot4nextEv: 40| 5.10k| VariantSlot* next() { 41| 5.10k| return next_ ? this + next_ : 0; ------------------ | Branch (41:12): [True: 4.00k, False: 1.10k] ------------------ 42| 5.10k| } _ZNK11ArduinoJson8V6213HB46detail11VariantSlot3keyEv: 88| 3.34k| const char* key() const { 89| 3.34k| return key_; 90| 3.34k| } _ZN11ArduinoJson8V6213HB46detail11VariantSlot14setNextNotNullEPS2_: 70| 7.75k| void setNextNotNull(VariantSlot* slot) { 71| 7.75k| ARDUINOJSON_ASSERT(slot != 0); ------------------ | | 11| 7.75k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 72| 7.75k| ARDUINOJSON_ASSERT(slot - this >= ------------------ | | 11| 7.75k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 73| 0| numeric_limits::lowest()); 74| 7.75k| ARDUINOJSON_ASSERT(slot - this <= ------------------ | | 11| 7.75k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 75| 0| numeric_limits::highest()); 76| 0| next_ = VariantSlotDiff(slot - this); 77| 7.75k| } _ZN11ArduinoJson8V6213HB46detail11VariantSlot5clearEv: 96| 10.1k| void clear() { 97| 10.1k| next_ = 0; 98| 10.1k| flags_ = 0; 99| 10.1k| key_ = 0; 100| 10.1k| } _ZN11ArduinoJson8V6213HB46detail11VariantSlot6setKeyENS0_10JsonStringE: 79| 1.61k| void setKey(JsonString k) { 80| 1.61k| ARDUINOJSON_ASSERT(k); ------------------ | | 11| 1.61k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 81| 1.61k| if (k.isLinked()) ------------------ | Branch (81:9): [True: 0, False: 1.61k] ------------------ 82| 0| flags_ &= VALUE_MASK; 83| 1.61k| else 84| 1.61k| flags_ |= OWNED_KEY_BIT; 85| 1.61k| key_ = k.c_str(); 86| 1.61k| } _ZN11ArduinoJson8V6213HB46detail11VariantSlot4dataEv: 32| 1.94k| VariantData* data() { 33| 1.94k| return reinterpret_cast(&content_); 34| 1.94k| } LLVMFuzzerTestOneInput: 3| 2.20k|extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) { 4| 2.20k| DynamicJsonDocument doc(4096); 5| 2.20k| DeserializationError error = deserializeJson(doc, data, size); 6| 2.20k| if (!error) { ------------------ | Branch (6:7): [True: 847, False: 1.35k] ------------------ 7| 847| std::string json; 8| 847| serializeJson(doc, json); 9| 847| } 10| 2.20k| return 0; 11| 2.20k|}