LLVMFuzzerTestOneInput: 3| 3.09k|extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) { 4| 3.09k| JsonDocument doc; 5| 3.09k| DeserializationError error = deserializeJson(doc, data, size); 6| 3.09k| if (!error) { ------------------ | Branch (6:7): [True: 1.21k, False: 1.88k] ------------------ 7| 1.21k| std::string json; 8| 1.21k| serializeJson(doc, json); 9| 1.21k| } 10| 3.09k| return 0; 11| 3.09k|} _ZN11ArduinoJson8V742HB426detail11VariantImpl13addNewElementEPNS1_11VariantDataEPNS1_15ResourceManagerE: 25| 74.5k| ResourceManager* resources) { 26| 74.5k| ARDUINOJSON_ASSERT(data != nullptr); ------------------ | | 11| 74.5k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ | Branch (26:3): [True: 74.5k, False: 0] ------------------ 27| 74.5k| ARDUINOJSON_ASSERT(data->isArray()); ------------------ | | 11| 74.5k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ | Branch (27:3): [True: 74.5k, False: 0] ------------------ 28| 74.5k| ARDUINOJSON_ASSERT(resources != nullptr); ------------------ | | 11| 74.5k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ | Branch (28:3): [True: 74.5k, False: 0] ------------------ 29| | 30| 74.5k| auto slot = resources->allocVariant(); 31| 74.5k| if (!slot) ------------------ | Branch (31:7): [True: 0, False: 74.5k] ------------------ 32| 0| return nullptr; 33| 74.5k| addElement(slot, data, resources); 34| 74.5k| return slot.ptr(); 35| 74.5k|} _ZN11ArduinoJson8V742HB426detail11VariantImpl10addElementENS1_4SlotINS1_11VariantDataEEEPS4_PNS1_15ResourceManagerE: 28| 74.5k| ResourceManager* resources) { 29| 74.5k| ARDUINOJSON_ASSERT(data != nullptr); ------------------ | | 11| 74.5k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ | Branch (29:3): [True: 74.5k, False: 0] ------------------ 30| 74.5k| ARDUINOJSON_ASSERT(data->isCollection()); ------------------ | | 11| 74.5k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ | Branch (30:3): [True: 74.5k, False: 0] ------------------ 31| 74.5k| ARDUINOJSON_ASSERT(resources != nullptr); ------------------ | | 11| 74.5k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ | Branch (31:3): [True: 74.5k, False: 0] ------------------ 32| | 33| 74.5k| auto coll = &data->content.asCollection; 34| | 35| 74.5k| if (coll->tail != NULL_SLOT) { ------------------ | Branch (35:7): [True: 69.4k, False: 5.11k] ------------------ 36| 69.4k| auto tail = resources->getVariant(coll->tail); 37| 69.4k| tail->next = slot.id(); 38| 69.4k| coll->tail = slot.id(); 39| 69.4k| } else { 40| 5.11k| coll->head = slot.id(); 41| 5.11k| coll->tail = slot.id(); 42| 5.11k| } 43| 74.5k|} _ZN11ArduinoJson8V742HB426detail11VariantImpl14createIteratorEPNS1_11VariantDataEPNS1_15ResourceManagerE: 19| 6.33k| VariantData* data, ResourceManager* resources) { 20| 6.33k| ARDUINOJSON_ASSERT(data != nullptr); ------------------ | | 11| 6.33k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ | Branch (20:3): [True: 6.33k, False: 0] ------------------ 21| 6.33k| ARDUINOJSON_ASSERT(data->isCollection()); ------------------ | | 11| 6.33k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ | Branch (21:3): [True: 6.33k, False: 0] ------------------ 22| 6.33k| ARDUINOJSON_ASSERT(resources != nullptr); ------------------ | | 11| 6.33k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ | Branch (22:3): [True: 6.33k, False: 0] ------------------ 23| 6.33k| auto head = data->content.asCollection.head; 24| 6.33k| return iterator(resources->getVariant(head), head); 25| 6.33k|} _ZN11ArduinoJson8V742HB426detail18CollectionIterator4moveEPKNS1_15ResourceManagerE: 11| 19.3k|inline void CollectionIterator::move(const ResourceManager* resources) { 12| 19.3k| ARDUINOJSON_ASSERT(slot_); ------------------ | | 11| 19.3k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ | Branch (12:3): [True: 19.3k, False: 0] ------------------ 13| 19.3k| auto nextId = slot_->next; 14| 19.3k| slot_ = resources->getVariant(nextId); 15| 19.3k| currentId_ = nextId; 16| 19.3k|} _ZN11ArduinoJson8V742HB426detail11VariantImpl10appendPairENS1_4SlotINS1_11VariantDataEEES5_PS4_PNS1_15ResourceManagerE: 47| 4.66k| ResourceManager* resources) { 48| 4.66k| ARDUINOJSON_ASSERT(data != nullptr); ------------------ | | 11| 4.66k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ | Branch (48:3): [True: 4.66k, False: 0] ------------------ 49| 4.66k| ARDUINOJSON_ASSERT(resources != nullptr); ------------------ | | 11| 4.66k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ | Branch (49:3): [True: 4.66k, False: 0] ------------------ 50| | 51| 4.66k| key->next = value.id(); 52| | 53| 4.66k| auto coll = &data->content.asCollection; 54| | 55| 4.66k| if (coll->tail != NULL_SLOT) { ------------------ | Branch (55:7): [True: 2.08k, False: 2.57k] ------------------ 56| 2.08k| auto tail = resources->getVariant(coll->tail); 57| 2.08k| tail->next = key.id(); 58| 2.08k| coll->tail = value.id(); 59| 2.57k| } else { 60| 2.57k| coll->head = key.id(); 61| 2.57k| coll->tail = value.id(); 62| 2.57k| } 63| 4.66k|} _ZN11ArduinoJson8V742HB426detail11VariantImpl5emptyEPNS1_11VariantDataEPNS1_15ResourceManagerE: 65| 776|inline void VariantImpl::empty(VariantData* data, ResourceManager* resources) { 66| 776| ARDUINOJSON_ASSERT(data != nullptr); ------------------ | | 11| 776|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ | Branch (66:3): [True: 776, False: 0] ------------------ 67| 776| ARDUINOJSON_ASSERT(data->isCollection()); ------------------ | | 11| 776|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ | Branch (67:3): [True: 776, False: 0] ------------------ 68| 776| ARDUINOJSON_ASSERT(resources != nullptr); ------------------ | | 11| 776|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ | Branch (68:3): [True: 776, False: 0] ------------------ 69| | 70| 776| auto coll = &data->content.asCollection; 71| | 72| 776| auto next = coll->head; 73| 5.40k| while (next != NULL_SLOT) { ------------------ | Branch (73:10): [True: 4.63k, False: 776] ------------------ 74| 4.63k| auto currId = next; 75| 4.63k| auto slot = resources->getVariant(next); 76| 4.63k| next = slot->next; 77| 4.63k| freeVariant({slot, currId}, resources); 78| 4.63k| } 79| | 80| 776| coll->head = NULL_SLOT; 81| 776| coll->tail = NULL_SLOT; 82| 776|} _ZN11ArduinoJson8V742HB426detail18CollectionIteratorC2Ev: 21| 4.66k| CollectionIterator() : slot_(nullptr), currentId_(NULL_SLOT) {} _ZN11ArduinoJson8V742HB426detail18CollectionIteratorC2EPNS1_11VariantDataEj: 62| 6.33k| : slot_(slot), currentId_(slotId) {} _ZN11ArduinoJson8V742HB426detail18CollectionIteratorptEv: 37| 10.4k| VariantData* operator->() { 38| 10.4k| ARDUINOJSON_ASSERT(slot_ != nullptr); ------------------ | | 11| 10.4k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ | Branch (38:5): [True: 10.4k, False: 0] ------------------ 39| 10.4k| return data(); 40| 10.4k| } _ZNK11ArduinoJson8V742HB426detail18CollectionIterator4doneEv: 25| 30.3k| bool done() const { 26| 30.3k| return slot_ == nullptr; 27| 30.3k| } _ZN11ArduinoJson8V742HB426detail18CollectionIterator4dataEv: 52| 12.1k| VariantData* data() { 53| 12.1k| return slot_; 54| 12.1k| } _ZNK11ArduinoJson8V742HB4220DeserializationErrorcvbEv: 56| 3.09k| explicit operator bool() const { 57| 3.09k| return code_ != Ok; 58| 3.09k| } _ZN11ArduinoJson8V742HB4220DeserializationErrorC2ENS1_4CodeE: 29| 3.09k| DeserializationError(Code c) : code_(c) {} _ZN11ArduinoJson8V742HB426detail26makeDeserializationOptionsENS0_21DeserializationOption12NestingLimitE: 31| 3.09k| DeserializationOption::NestingLimit nestingLimit = {}) { 32| 3.09k| return {{}, nestingLimit}; 33| 3.09k|} _ZNK11ArduinoJson8V742HB426detail14AllowAllFilter10allowArrayEv: 58| 5.66k| bool allowArray() const { 59| 5.66k| return true; 60| 5.66k| } _ZNK11ArduinoJson8V742HB426detail14AllowAllFilterixImEES2_RKT_: 71| 5.11k| AllowAllFilter operator[](const TKey&) const { 72| 5.11k| return AllowAllFilter(); 73| 5.11k| } _ZNK11ArduinoJson8V742HB426detail14AllowAllFilter5allowEv: 54| 80.8k| bool allow() const { 55| 80.8k| return true; 56| 80.8k| } _ZNK11ArduinoJson8V742HB426detail14AllowAllFilter11allowObjectEv: 62| 3.32k| bool allowObject() const { 63| 3.32k| return true; 64| 3.32k| } _ZNK11ArduinoJson8V742HB426detail14AllowAllFilterixINS0_10JsonStringEEES2_RKT_: 71| 6.33k| AllowAllFilter operator[](const TKey&) const { 72| 6.33k| return AllowAllFilter(); 73| 6.33k| } _ZNK11ArduinoJson8V742HB426detail14AllowAllFilter10allowValueEv: 66| 74.2k| bool allowValue() const { 67| 74.2k| return true; 68| 74.2k| } _ZNK11ArduinoJson8V742HB4221DeserializationOption12NestingLimit7reachedEv: 23| 8.98k| bool reached() const { 24| 8.98k| return value_ == 0; 25| 8.98k| } _ZNK11ArduinoJson8V742HB4221DeserializationOption12NestingLimit9decrementEv: 18| 80.8k| NestingLimit decrement() const { 19| 80.8k| ARDUINOJSON_ASSERT(value_ > 0); ------------------ | | 11| 80.8k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ | Branch (19:5): [True: 80.8k, False: 0] ------------------ 20| 80.8k| return NestingLimit(static_cast(value_ - 1)); 21| 80.8k| } _ZN11ArduinoJson8V742HB4221DeserializationOption12NestingLimitC2Eh: 16| 80.8k| explicit NestingLimit(uint8_t n) : value_(n) {} _ZN11ArduinoJson8V742HB4221DeserializationOption12NestingLimitC2Ev: 15| 3.09k| NestingLimit() : value_(ARDUINOJSON_DEFAULT_NESTING_LIMIT) {} ------------------ | | 93| 3.09k|# define ARDUINOJSON_DEFAULT_NESTING_LIMIT 10 ------------------ _ZN11ArduinoJson8V742HB426detail10makeReaderIKhEENS1_13BoundedReaderIPT_vEES6_m: 70| 3.09k|BoundedReader makeReader(TChar* input, size_t inputSize) { 71| 3.09k| return BoundedReader{input, inputSize}; 72| 3.09k|} _ZN11ArduinoJson8V742HB426detail14IteratorReaderIPKcE4readEv: 19| 361k| int read() { 20| 361k| if (ptr_ < end_) ------------------ | Branch (20:9): [True: 359k, False: 2.33k] ------------------ 21| 359k| return static_cast(*ptr_++); 22| 2.33k| else 23| 2.33k| return -1; 24| 361k| } _ZN11ArduinoJson8V742HB426detail14IteratorReaderIPKcEC2ES4_S4_: 17| 3.09k| : ptr_(begin), end_(end) {} _ZN11ArduinoJson8V742HB426detail13BoundedReaderIPKhvEC2EPKvm: 45| 3.09k| : IteratorReader(reinterpret_cast(ptr), 46| 3.09k| reinterpret_cast(ptr) + len) {} _ZN11ArduinoJson8V742HB426detail11deserializeINS1_16JsonDeserializerERNS0_12JsonDocumentEKhmJETnNS1_9enable_ifIXsr11is_integralIT2_EE5valueEiE4typeELi0EEENS0_20DeserializationErrorEOT0_PT1_S8_DpT3_: 74| 3.09k| Size inputSize, Args... args) { 75| 3.09k| return doDeserialize(dst, makeReader(input, size_t(inputSize)), 76| 3.09k| makeDeserializationOptions(args...)); 77| 3.09k|} _ZN11ArduinoJson8V742HB426detail13doDeserializeINS1_16JsonDeserializerERNS0_12JsonDocumentENS1_13BoundedReaderIPKhvEENS1_22DeserializationOptionsINS1_14AllowAllFilterEEEEENS0_20DeserializationErrorEOT0_T1_T2_: 46| 3.09k| TOptions options) { 47| 3.09k| auto data = VariantAttorney::getOrCreateData(dst); 48| 3.09k| if (!data) ------------------ | Branch (48:7): [True: 0, False: 3.09k] ------------------ 49| 0| return DeserializationError::NoMemory; 50| 3.09k| auto resources = VariantAttorney::getResourceManager(dst); 51| 3.09k| dst.clear(); 52| 3.09k| auto err = TDeserializer(resources, reader) 53| 3.09k| .parse(data, options.filter, options.nestingLimit); 54| 3.09k| shrinkJsonDocument(dst); 55| 3.09k| return err; 56| 3.09k|} _ZN11ArduinoJson8V742HB426detail18shrinkJsonDocumentERNS0_12JsonDocumentE: 38| 3.09k|inline void shrinkJsonDocument(JsonDocument& doc) { 39| 3.09k| doc.shrinkToFit(); 40| 3.09k|} _ZN11ArduinoJson8V742HB4212JsonDocumentC2EPNS0_9AllocatorE: 24| 3.09k| : resources_(alloc) {} _ZNK11ArduinoJson8V742HB4212JsonDocumentcvNS0_16JsonVariantConstEEv: 341| 1.21k| operator JsonVariantConst() const { 342| 1.21k| return getVariant(); 343| 1.21k| } _ZNK11ArduinoJson8V742HB4212JsonDocument10getVariantEv: 417| 1.21k| JsonVariantConst getVariant() const { 418| 1.21k| return JsonVariantConst(&data_, &resources_); 419| 1.21k| } _ZN11ArduinoJson8V742HB4212JsonDocument15getOrCreateDataEv: 433| 3.09k| detail::VariantData* getOrCreateData() { 434| 3.09k| return &data_; 435| 3.09k| } _ZN11ArduinoJson8V742HB4212JsonDocument18getResourceManagerEv: 421| 3.09k| detail::ResourceManager* getResourceManager() { 422| 3.09k| return &resources_; 423| 3.09k| } _ZN11ArduinoJson8V742HB4212JsonDocument5clearEv: 88| 3.09k| void clear() { 89| 3.09k| resources_.clear(); 90| 3.09k| data_.type = detail::VariantType::Null; 91| 3.09k| } _ZN11ArduinoJson8V742HB4212JsonDocument11shrinkToFitEv: 68| 3.09k| void shrinkToFit() { 69| 3.09k| resources_.shrinkToFit(); 70| 3.09k| } _ZN11ArduinoJson8V742HB426detail14EscapeSequence10escapeCharEc: 15| 14.8k| static char escapeChar(char c) { 16| 14.8k| const char* p = escapeTable(false) - 2; 17| 30.0k| do { 18| 30.0k| p += 2; 19| 30.0k| } while (uint8_t(c) < uint8_t(p[0])); ------------------ | Branch (19:14): [True: 15.2k, False: 14.8k] ------------------ 20| 14.8k| return c == p[0] ? p[1] : 0; ------------------ | Branch (20:12): [True: 989, False: 13.8k] ------------------ 21| 14.8k| } _ZN11ArduinoJson8V742HB426detail14EscapeSequence11escapeTableEb: 36| 15.2k| static const char* escapeTable(bool includeOptional) { 37| 15.2k| static const char charMap[] = { 38| | // Optional chars: only used for deserialization 39| 15.2k| 47, '/', // solidus 40| 15.2k| 39, '\'', // single quote 41| | // Mandatory chars: used for deserialization and serialization 42| | // Sorted in descending order to allow early exit 43| 15.2k| 92, '\\', // reverse solidus 44| 15.2k| 34, '"', // double quote 45| 15.2k| 13, 'r', // carriage return 46| 15.2k| 12, 'f', // formfeed 47| 15.2k| 10, 'n', // linefeed 48| 15.2k| 9, 't', // horizontal tab 49| 15.2k| 8, 'b', // backspace 50| 15.2k| 0, 0, // 51| 15.2k| }; 52| 15.2k| return &charMap[includeOptional ? 0 : 4]; ------------------ | Branch (52:21): [True: 454, False: 14.8k] ------------------ 53| 15.2k| } _ZN11ArduinoJson8V742HB426detail14EscapeSequence12unescapeCharEc: 24| 454| static char unescapeChar(char c) { 25| 454| const char* p = escapeTable(true); 26| 1.44k| for (;;) { 27| 1.44k| if (p[0] == '\0') ------------------ | Branch (27:11): [True: 26, False: 1.41k] ------------------ 28| 26| return 0; 29| 1.41k| if (p[1] == c) ------------------ | Branch (29:11): [True: 428, False: 988] ------------------ 30| 428| return p[0]; 31| 988| p += 2; 32| 988| } 33| 454| } _ZN11ArduinoJson8V742HB4215deserializeJsonIRNS0_12JsonDocumentEKhJRmETnNS0_6detail9enable_ifIXsr6detail26is_deserialize_destinationIT_EE5valueEiE4typeELi0EEENS0_20DeserializationErrorEOS8_PT0_DpOT1_: 721| 3.09k| Args&&... args) { 722| 3.09k| using namespace detail; 723| 3.09k| return deserialize(detail::forward(dst), 724| 3.09k| input, detail::forward(args)...); 725| 3.09k|} _ZN11ArduinoJson8V742HB426detail16JsonDeserializerINS1_13BoundedReaderIPKhvEEEC2EPNS1_15ResourceManagerES6_: 25| 3.09k| : stringBuilder_(resources), 26| 3.09k| foundSomething_(false), 27| 3.09k| latch_(reader), 28| 3.09k| resources_(resources) {} _ZN11ArduinoJson8V742HB426detail16JsonDeserializerINS1_13BoundedReaderIPKhvEEE5parseINS1_14AllowAllFilterEEENS0_20DeserializationErrorEPNS1_11VariantDataET_NS0_21DeserializationOption12NestingLimitE: 32| 3.09k| DeserializationOption::NestingLimit nestingLimit) { 33| 3.09k| DeserializationError::Code err; 34| | 35| 3.09k| err = parseVariant(variant, filter, nestingLimit); 36| | 37| 3.09k| if (!err && latch_.last() != 0 && variant->isFloat()) { ------------------ | Branch (37:9): [True: 1.22k, False: 1.87k] | Branch (37:17): [True: 372, False: 853] | Branch (37:39): [True: 9, False: 363] ------------------ 38| | // We don't detect trailing characters earlier, so we need to check now 39| 9| return DeserializationError::InvalidInput; 40| 9| } 41| | 42| 3.08k| return err; 43| 3.09k| } _ZN11ArduinoJson8V742HB426detail16JsonDeserializerINS1_13BoundedReaderIPKhvEEE12parseVariantINS1_14AllowAllFilterEEENS0_20DeserializationError4CodeEPNS1_11VariantDataET_NS0_21DeserializationOption12NestingLimitE: 64| 83.9k| DeserializationOption::NestingLimit nestingLimit) { 65| 83.9k| DeserializationError::Code err; 66| | 67| 83.9k| err = skipSpacesAndComments(); 68| 83.9k| if (err) ------------------ | Branch (68:9): [True: 355, False: 83.6k] ------------------ 69| 355| return err; 70| | 71| 83.6k| switch (current()) { 72| 5.66k| case '[': ------------------ | Branch (72:7): [True: 5.66k, False: 77.9k] ------------------ 73| 5.66k| if (filter.allowArray()) ------------------ | Branch (73:13): [True: 5.66k, False: 0] ------------------ 74| 5.66k| return parseArray(variant, filter, nestingLimit); 75| 0| else 76| 0| return skipArray(nestingLimit); 77| | 78| 3.32k| case '{': ------------------ | Branch (78:7): [True: 3.32k, False: 80.2k] ------------------ 79| 3.32k| if (filter.allowObject()) ------------------ | Branch (79:13): [True: 3.32k, False: 0] ------------------ 80| 3.32k| return parseObject(variant, filter, nestingLimit); 81| 0| else 82| 0| return skipObject(nestingLimit); 83| | 84| 1.55k| case '\"': ------------------ | Branch (84:7): [True: 1.55k, False: 82.0k] ------------------ 85| 2.85k| case '\'': ------------------ | Branch (85:7): [True: 1.30k, False: 82.3k] ------------------ 86| 2.85k| if (filter.allowValue()) ------------------ | Branch (86:13): [True: 2.85k, False: 0] ------------------ 87| 2.85k| return parseStringValue(variant); 88| 0| else 89| 0| return skipQuotedString(); 90| | 91| 416| case 't': ------------------ | Branch (91:7): [True: 416, False: 83.1k] ------------------ 92| 416| if (filter.allowValue()) ------------------ | Branch (92:13): [True: 416, False: 0] ------------------ 93| 416| variant->setBoolean(true); 94| 416| return skipKeyword("true"); 95| | 96| 390| case 'f': ------------------ | Branch (96:7): [True: 390, False: 83.2k] ------------------ 97| 390| if (filter.allowValue()) ------------------ | Branch (97:13): [True: 390, False: 0] ------------------ 98| 390| variant->setBoolean(false); 99| 390| return skipKeyword("false"); 100| | 101| 416| case 'n': ------------------ | Branch (101:7): [True: 416, False: 83.1k] ------------------ 102| | // the variant should already by null, except if the same object key was 103| | // used twice, as in {"a":1,"a":null} 104| 416| return skipKeyword("null"); 105| | 106| 70.5k| default: ------------------ | Branch (106:7): [True: 70.5k, False: 13.0k] ------------------ 107| 70.5k| if (filter.allowValue()) ------------------ | Branch (107:13): [True: 70.5k, False: 0] ------------------ 108| 70.5k| return parseNumericValue(variant); 109| 0| else 110| 0| return skipNumericValue(); 111| 83.6k| } 112| 83.6k| } _ZN11ArduinoJson8V742HB426detail16JsonDeserializerINS1_13BoundedReaderIPKhvEEE21skipSpacesAndCommentsEv: 611| 182k| DeserializationError::Code skipSpacesAndComments() { 612| 188k| for (;;) { 613| 188k| switch (current()) { 614| | // end of string 615| 1.05k| case '\0': ------------------ | Branch (615:9): [True: 1.05k, False: 187k] ------------------ 616| 1.05k| return foundSomething_ ? DeserializationError::IncompleteInput ------------------ | Branch (616:18): [True: 1.02k, False: 34] ------------------ 617| 1.05k| : DeserializationError::EmptyInput; 618| | 619| | // spaces 620| 1.53k| case ' ': ------------------ | Branch (620:9): [True: 1.53k, False: 186k] ------------------ 621| 3.12k| case '\t': ------------------ | Branch (621:9): [True: 1.58k, False: 186k] ------------------ 622| 4.72k| case '\r': ------------------ | Branch (622:9): [True: 1.60k, False: 186k] ------------------ 623| 6.45k| case '\n': ------------------ | Branch (623:9): [True: 1.72k, False: 186k] ------------------ 624| 6.45k| move(); 625| 6.45k| continue; 626| | 627| |#if ARDUINOJSON_ENABLE_COMMENTS 628| | // comments 629| | case '/': 630| | move(); // skip '/' 631| | switch (current()) { 632| | // block comment 633| | case '*': { 634| | move(); // skip '*' 635| | bool wasStar = false; 636| | for (;;) { 637| | char c = current(); 638| | if (c == '\0') 639| | return DeserializationError::IncompleteInput; 640| | if (c == '/' && wasStar) { 641| | move(); 642| | break; 643| | } 644| | wasStar = c == '*'; 645| | move(); 646| | } 647| | break; 648| | } 649| | 650| | // trailing comment 651| | case '/': 652| | // no need to skip "//" 653| | for (;;) { 654| | move(); 655| | char c = current(); 656| | if (c == '\0') 657| | return DeserializationError::IncompleteInput; 658| | if (c == '\n') 659| | break; 660| | } 661| | break; 662| | 663| | // not a comment, just a '/' 664| | default: 665| | return DeserializationError::InvalidInput; 666| | } 667| | break; 668| |#endif 669| | 670| 181k| default: ------------------ | Branch (670:9): [True: 181k, False: 7.50k] ------------------ 671| 181k| foundSomething_ = true; 672| 181k| return DeserializationError::Ok; 673| 188k| } 674| 188k| } 675| 182k| } _ZN11ArduinoJson8V742HB426detail16JsonDeserializerINS1_13BoundedReaderIPKhvEEE4moveEv: 50| 359k| void move() { 51| 359k| latch_.clear(); 52| 359k| } _ZN11ArduinoJson8V742HB426detail16JsonDeserializerINS1_13BoundedReaderIPKhvEEE7currentEv: 46| 789k| char current() { 47| 789k| return latch_.current(); 48| 789k| } _ZN11ArduinoJson8V742HB426detail16JsonDeserializerINS1_13BoundedReaderIPKhvEEE10parseArrayINS1_14AllowAllFilterEEENS0_20DeserializationError4CodeEPNS1_11VariantDataET_NS0_21DeserializationOption12NestingLimitE: 150| 5.66k| DeserializationOption::NestingLimit nestingLimit) { 151| 5.66k| DeserializationError::Code err; 152| | 153| 5.66k| array->toArray(); 154| | 155| 5.66k| if (nestingLimit.reached()) ------------------ | Branch (155:9): [True: 12, False: 5.65k] ------------------ 156| 12| return DeserializationError::TooDeep; 157| | 158| | // Skip opening braket 159| 5.65k| ARDUINOJSON_ASSERT(current() == '['); ------------------ | | 11| 5.65k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ | Branch (159:5): [True: 5.65k, False: 0] ------------------ 160| 5.65k| move(); 161| | 162| | // Skip spaces 163| 5.65k| err = skipSpacesAndComments(); 164| 5.65k| if (err) ------------------ | Branch (164:9): [True: 44, False: 5.60k] ------------------ 165| 44| return err; 166| | 167| | // Empty array? 168| 5.60k| if (eat(']')) ------------------ | Branch (168:9): [True: 494, False: 5.11k] ------------------ 169| 494| return DeserializationError::Ok; 170| | 171| 5.11k| TFilter elementFilter = filter[0UL]; 172| | 173| | // Read each value 174| 74.5k| for (;;) { 175| 74.5k| if (elementFilter.allow()) { ------------------ | Branch (175:11): [True: 74.5k, False: 0] ------------------ 176| | // Allocate slot in array 177| 74.5k| VariantData* value = VariantImpl::addNewElement(array, resources_); 178| 74.5k| if (!value) ------------------ | Branch (178:13): [True: 0, False: 74.5k] ------------------ 179| 0| return DeserializationError::NoMemory; 180| | 181| | // 1 - Parse value 182| 74.5k| err = parseVariant(value, elementFilter, nestingLimit.decrement()); 183| 74.5k| if (err) ------------------ | Branch (183:13): [True: 1.08k, False: 73.4k] ------------------ 184| 1.08k| return err; 185| 74.5k| } else { 186| 0| err = skipVariant(nestingLimit.decrement()); 187| 0| if (err) ------------------ | Branch (187:13): [True: 0, False: 0] ------------------ 188| 0| return err; 189| 0| } 190| | 191| | // 2 - Skip spaces 192| 73.4k| err = skipSpacesAndComments(); 193| 73.4k| if (err) ------------------ | Branch (193:11): [True: 318, False: 73.1k] ------------------ 194| 318| return err; 195| | 196| | // 3 - More values? 197| 73.1k| if (eat(']')) ------------------ | Branch (197:11): [True: 3.68k, False: 69.4k] ------------------ 198| 3.68k| return DeserializationError::Ok; 199| 69.4k| if (!eat(',')) ------------------ | Branch (199:11): [True: 23, False: 69.4k] ------------------ 200| 23| return DeserializationError::InvalidInput; 201| 69.4k| } 202| 5.11k| } _ZN11ArduinoJson8V742HB426detail16JsonDeserializerINS1_13BoundedReaderIPKhvEEE3eatEc: 54| 166k| bool eat(char charToSkip) { 55| 166k| if (current() != charToSkip) ------------------ | Branch (55:9): [True: 81.3k, False: 85.6k] ------------------ 56| 81.3k| return false; 57| 85.6k| move(); 58| 85.6k| return true; 59| 166k| } _ZN11ArduinoJson8V742HB426detail16JsonDeserializerINS1_13BoundedReaderIPKhvEEE11parseObjectINS1_14AllowAllFilterEEENS0_20DeserializationError4CodeEPNS1_11VariantDataET_NS0_21DeserializationOption12NestingLimitE: 238| 3.32k| DeserializationOption::NestingLimit nestingLimit) { 239| 3.32k| DeserializationError::Code err; 240| | 241| 3.32k| object->toObject(); 242| | 243| 3.32k| if (nestingLimit.reached()) ------------------ | Branch (243:9): [True: 1, False: 3.32k] ------------------ 244| 1| return DeserializationError::TooDeep; 245| | 246| | // Skip opening brace 247| 3.32k| ARDUINOJSON_ASSERT(current() == '{'); ------------------ | | 11| 3.32k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ | Branch (247:5): [True: 3.32k, False: 0] ------------------ 248| 3.32k| move(); 249| | 250| | // Skip spaces 251| 3.32k| err = skipSpacesAndComments(); 252| 3.32k| if (err) ------------------ | Branch (252:9): [True: 44, False: 3.28k] ------------------ 253| 44| return err; 254| | 255| | // Empty object? 256| 3.28k| if (eat('}')) ------------------ | Branch (256:9): [True: 466, False: 2.81k] ------------------ 257| 466| return DeserializationError::Ok; 258| | 259| | // Read each key value pair 260| 6.60k| for (;;) { 261| | // Parse key 262| 6.60k| err = parseKey(); 263| 6.60k| if (err) ------------------ | Branch (263:11): [True: 80, False: 6.52k] ------------------ 264| 80| return err; 265| | 266| | // Skip spaces 267| 6.52k| err = skipSpacesAndComments(); 268| 6.52k| if (err) ------------------ | Branch (268:11): [True: 156, False: 6.37k] ------------------ 269| 156| return err; 270| | 271| | // Colon 272| 6.37k| if (!eat(':')) ------------------ | Branch (272:11): [True: 38, False: 6.33k] ------------------ 273| 38| return DeserializationError::InvalidInput; 274| | 275| 6.33k| JsonString key = stringBuilder_.str(); 276| | 277| 6.33k| TFilter memberFilter = filter[key]; 278| | 279| 6.33k| if (memberFilter.allow()) { ------------------ | Branch (279:11): [True: 6.33k, False: 0] ------------------ 280| 6.33k| auto member = 281| 6.33k| VariantImpl::getMember(adaptString(key), object, resources_); 282| 6.33k| if (!member) { ------------------ | Branch (282:13): [True: 4.66k, False: 1.67k] ------------------ 283| 4.66k| auto keyVariant = VariantImpl::addPair(&member, object, resources_); 284| 4.66k| if (!keyVariant) ------------------ | Branch (284:15): [True: 0, False: 4.66k] ------------------ 285| 0| return DeserializationError::NoMemory; 286| | 287| 4.66k| stringBuilder_.save(keyVariant); 288| 4.66k| } else { 289| 1.67k| VariantImpl::clear(member, resources_); 290| 1.67k| } 291| | 292| | // Parse value 293| 6.33k| err = parseVariant(member, memberFilter, nestingLimit.decrement()); 294| 6.33k| if (err) ------------------ | Branch (294:13): [True: 997, False: 5.33k] ------------------ 295| 997| return err; 296| 6.33k| } else { 297| 0| err = skipVariant(nestingLimit.decrement()); 298| 0| if (err) ------------------ | Branch (298:13): [True: 0, False: 0] ------------------ 299| 0| return err; 300| 0| } 301| | 302| | // Skip spaces 303| 5.33k| err = skipSpacesAndComments(); 304| 5.33k| if (err) ------------------ | Branch (304:11): [True: 102, False: 5.23k] ------------------ 305| 102| return err; 306| | 307| | // More keys/values? 308| 5.23k| if (eat('}')) ------------------ | Branch (308:11): [True: 1.37k, False: 3.86k] ------------------ 309| 1.37k| return DeserializationError::Ok; 310| 3.86k| if (!eat(',')) ------------------ | Branch (310:11): [True: 29, False: 3.83k] ------------------ 311| 29| return DeserializationError::InvalidInput; 312| | 313| | // Skip spaces 314| 3.83k| err = skipSpacesAndComments(); 315| 3.83k| if (err) ------------------ | Branch (315:11): [True: 40, False: 3.79k] ------------------ 316| 40| return err; 317| 3.83k| } 318| 2.81k| } _ZN11ArduinoJson8V742HB426detail16JsonDeserializerINS1_13BoundedReaderIPKhvEEE8parseKeyEv: 378| 6.60k| DeserializationError::Code parseKey() { 379| 6.60k| stringBuilder_.startString(); 380| 6.60k| if (isQuote(current())) { ------------------ | Branch (380:9): [True: 428, False: 6.18k] ------------------ 381| 428| return parseQuotedString(); 382| 6.18k| } else { 383| 6.18k| return parseNonQuotedString(); 384| 6.18k| } 385| 6.60k| } _ZN11ArduinoJson8V742HB426detail16JsonDeserializerINS1_13BoundedReaderIPKhvEEE7isQuoteEc: 600| 6.60k| static inline bool isQuote(char c) { 601| 6.60k| return c == '\'' || c == '\"'; ------------------ | Branch (601:12): [True: 243, False: 6.36k] | Branch (601:25): [True: 185, False: 6.18k] ------------------ 602| 6.60k| } _ZN11ArduinoJson8V742HB426detail16JsonDeserializerINS1_13BoundedReaderIPKhvEEE17parseQuotedStringEv: 401| 3.28k| DeserializationError::Code parseQuotedString() { 402| 3.28k|#if ARDUINOJSON_DECODE_UNICODE 403| 3.28k| Utf16::Codepoint codepoint; 404| 3.28k| DeserializationError::Code err; 405| 3.28k|#endif 406| 3.28k| const char stopChar = current(); 407| | 408| 3.28k| move(); 409| 60.7k| for (;;) { 410| 60.7k| char c = current(); 411| 60.7k| move(); 412| 60.7k| if (c == stopChar) ------------------ | Branch (412:11): [True: 2.93k, False: 57.7k] ------------------ 413| 2.93k| break; 414| | 415| 57.7k| if (c == '\0') ------------------ | Branch (415:11): [True: 289, False: 57.4k] ------------------ 416| 289| return DeserializationError::IncompleteInput; 417| | 418| 57.4k| if (c == '\\') { ------------------ | Branch (418:11): [True: 2.45k, False: 55.0k] ------------------ 419| 2.45k| c = current(); 420| | 421| 2.45k| if (c == '\0') ------------------ | Branch (421:13): [True: 3, False: 2.45k] ------------------ 422| 3| return DeserializationError::IncompleteInput; 423| | 424| 2.45k| if (c == 'u') { ------------------ | Branch (424:13): [True: 2.00k, False: 454] ------------------ 425| 2.00k|#if ARDUINOJSON_DECODE_UNICODE 426| 2.00k| move(); 427| 2.00k| uint16_t codeunit; 428| 2.00k| err = parseHex4(codeunit); 429| 2.00k| if (err) ------------------ | Branch (429:15): [True: 34, False: 1.96k] ------------------ 430| 34| return err; 431| 1.96k| if (codepoint.append(codeunit)) ------------------ | Branch (431:15): [True: 1.74k, False: 221] ------------------ 432| 1.74k| Utf8::encodeCodepoint(codepoint.value(), stringBuilder_); 433| |#else 434| | stringBuilder_.append('\\'); 435| |#endif 436| 1.96k| continue; 437| 2.00k| } 438| | 439| | // replace char 440| 454| c = EscapeSequence::unescapeChar(c); 441| 454| if (c == '\0') ------------------ | Branch (441:13): [True: 26, False: 428] ------------------ 442| 26| return DeserializationError::InvalidInput; 443| 428| move(); 444| 428| } 445| | 446| 55.4k| stringBuilder_.append(c); 447| 55.4k| } 448| | 449| 2.93k| if (!stringBuilder_.isValid()) ------------------ | Branch (449:9): [True: 0, False: 2.93k] ------------------ 450| 0| return DeserializationError::NoMemory; 451| | 452| 2.93k| return DeserializationError::Ok; 453| 2.93k| } _ZN11ArduinoJson8V742HB426detail16JsonDeserializerINS1_13BoundedReaderIPKhvEEE9parseHex4ERt: 567| 2.00k| DeserializationError::Code parseHex4(uint16_t& result) { 568| 2.00k| result = 0; 569| 9.89k| for (uint8_t i = 0; i < 4; ++i) { ------------------ | Branch (569:25): [True: 7.92k, False: 1.96k] ------------------ 570| 7.92k| char digit = current(); 571| 7.92k| if (!digit) ------------------ | Branch (571:11): [True: 17, False: 7.90k] ------------------ 572| 17| return DeserializationError::IncompleteInput; 573| 7.90k| uint8_t value = decodeHex(digit); 574| 7.90k| if (value > 0x0F) ------------------ | Branch (574:11): [True: 17, False: 7.89k] ------------------ 575| 17| return DeserializationError::InvalidInput; 576| 7.89k| result = uint16_t((result << 4) | value); 577| 7.89k| move(); 578| 7.89k| } 579| 1.96k| return DeserializationError::Ok; 580| 2.00k| } _ZN11ArduinoJson8V742HB426detail16JsonDeserializerINS1_13BoundedReaderIPKhvEEE9decodeHexEc: 604| 7.90k| static inline uint8_t decodeHex(char c) { 605| 7.90k| if (c < 'A') ------------------ | Branch (605:9): [True: 5.90k, False: 2.00k] ------------------ 606| 5.90k| return uint8_t(c - '0'); 607| 2.00k| c = char(c & ~0x20); // uppercase 608| 2.00k| return uint8_t(c - 'A' + 10); 609| 7.90k| } _ZN11ArduinoJson8V742HB426detail16JsonDeserializerINS1_13BoundedReaderIPKhvEEE20parseNonQuotedStringEv: 455| 6.18k| DeserializationError::Code parseNonQuotedString() { 456| 6.18k| char c = current(); 457| 6.18k| ARDUINOJSON_ASSERT(c); ------------------ | | 11| 6.18k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ | Branch (457:5): [True: 6.18k, False: 0] ------------------ 458| | 459| 6.18k| if (canBeInNonQuotedString(c)) { // no quotes ------------------ | Branch (459:9): [True: 6.11k, False: 66] ------------------ 460| 37.5k| do { 461| 37.5k| move(); 462| 37.5k| stringBuilder_.append(c); 463| 37.5k| c = current(); 464| 37.5k| } while (canBeInNonQuotedString(c)); ------------------ | Branch (464:16): [True: 31.3k, False: 6.11k] ------------------ 465| 6.11k| } else { 466| 66| return DeserializationError::InvalidInput; 467| 66| } 468| | 469| 6.11k| if (!stringBuilder_.isValid()) ------------------ | Branch (469:9): [True: 0, False: 6.11k] ------------------ 470| 0| return DeserializationError::NoMemory; 471| | 472| 6.11k| return DeserializationError::Ok; 473| 6.11k| } _ZN11ArduinoJson8V742HB426detail16JsonDeserializerINS1_13BoundedReaderIPKhvEEE22canBeInNonQuotedStringEc: 595| 43.6k| static inline bool canBeInNonQuotedString(char c) { 596| 43.6k| return isBetween(c, '0', '9') || isBetween(c, '_', 'z') || ------------------ | Branch (596:12): [True: 8.12k, False: 35.5k] | Branch (596:38): [True: 21.1k, False: 14.3k] ------------------ 597| 14.3k| isBetween(c, 'A', 'Z'); ------------------ | Branch (597:12): [True: 8.18k, False: 6.18k] ------------------ 598| 43.6k| } _ZN11ArduinoJson8V742HB426detail16JsonDeserializerINS1_13BoundedReaderIPKhvEEE9isBetweenEccc: 582| 305k| static inline bool isBetween(char c, char min, char max) { 583| 305k| return min <= c && c <= max; ------------------ | Branch (583:12): [True: 166k, False: 139k] | Branch (583:24): [True: 116k, False: 49.8k] ------------------ 584| 305k| } _ZN11ArduinoJson8V742HB426detail16JsonDeserializerINS1_13BoundedReaderIPKhvEEE16parseStringValueEPNS1_11VariantDataE: 387| 2.85k| DeserializationError::Code parseStringValue(VariantData* variant) { 388| 2.85k| DeserializationError::Code err; 389| | 390| 2.85k| stringBuilder_.startString(); 391| | 392| 2.85k| err = parseQuotedString(); 393| 2.85k| if (err) ------------------ | Branch (393:9): [True: 338, False: 2.51k] ------------------ 394| 338| return err; 395| | 396| 2.51k| stringBuilder_.save(variant); 397| | 398| 2.51k| return DeserializationError::Ok; 399| 2.85k| } _ZN11ArduinoJson8V742HB426detail16JsonDeserializerINS1_13BoundedReaderIPKhvEEE11skipKeywordEPKc: 677| 1.22k| DeserializationError::Code skipKeyword(const char* s) { 678| 6.15k| while (*s) { ------------------ | Branch (678:12): [True: 5.04k, False: 1.10k] ------------------ 679| 5.04k| char c = current(); 680| 5.04k| if (c == '\0') ------------------ | Branch (680:11): [True: 36, False: 5.01k] ------------------ 681| 36| return DeserializationError::IncompleteInput; 682| 5.01k| if (*s != c) ------------------ | Branch (682:11): [True: 79, False: 4.93k] ------------------ 683| 79| return DeserializationError::InvalidInput; 684| 4.93k| ++s; 685| 4.93k| move(); 686| 4.93k| } 687| 1.10k| return DeserializationError::Ok; 688| 1.22k| } _ZN11ArduinoJson8V742HB426detail16JsonDeserializerINS1_13BoundedReaderIPKhvEEE17parseNumericValueEPNS1_11VariantDataE: 512| 70.5k| DeserializationError::Code parseNumericValue(VariantData* result) { 513| 70.5k| uint8_t n = 0; 514| | 515| 70.5k| char c = current(); 516| 212k| while (canBeInNumber(c) && n < 63) { ------------------ | Branch (516:12): [True: 141k, False: 70.5k] | Branch (516:32): [True: 141k, False: 1] ------------------ 517| 141k| move(); 518| 141k| buffer_[n++] = c; 519| 141k| c = current(); 520| 141k| } 521| 70.5k| buffer_[n] = 0; 522| | 523| 70.5k| auto number = parseNumber(buffer_); 524| 70.5k| switch (number.type()) { 525| 10.7k| case NumberType::UnsignedInteger: ------------------ | Branch (525:7): [True: 10.7k, False: 59.7k] ------------------ 526| 10.7k| if (VariantImpl::setInteger(number.asUnsignedInteger(), result, ------------------ | Branch (526:13): [True: 10.7k, False: 0] ------------------ 527| 10.7k| resources_)) 528| 10.7k| return DeserializationError::Ok; 529| 0| else 530| 0| return DeserializationError::NoMemory; 531| | 532| 1.27k| case NumberType::SignedInteger: ------------------ | Branch (532:7): [True: 1.27k, False: 69.2k] ------------------ 533| 1.27k| if (VariantImpl::setInteger(number.asSignedInteger(), result, ------------------ | Branch (533:13): [True: 1.27k, False: 0] ------------------ 534| 1.27k| resources_)) 535| 1.27k| return DeserializationError::Ok; 536| 0| else 537| 0| return DeserializationError::NoMemory; 538| | 539| 48.5k| case NumberType::Float: ------------------ | Branch (539:7): [True: 48.5k, False: 22.0k] ------------------ 540| 48.5k| if (VariantImpl::setFloat(number.asFloat(), result, resources_)) ------------------ | Branch (540:13): [True: 48.5k, False: 0] ------------------ 541| 48.5k| return DeserializationError::Ok; 542| 0| else 543| 0| return DeserializationError::NoMemory; 544| | 545| 0|#if ARDUINOJSON_USE_DOUBLE 546| 9.79k| case NumberType::Double: ------------------ | Branch (546:7): [True: 9.79k, False: 60.7k] ------------------ 547| 9.79k| if (VariantImpl::setFloat(number.asDouble(), result, resources_)) ------------------ | Branch (547:13): [True: 9.79k, False: 0] ------------------ 548| 9.79k| return DeserializationError::Ok; 549| 0| else 550| 0| return DeserializationError::NoMemory; 551| 0|#endif 552| | 553| 177| default: ------------------ | Branch (553:7): [True: 177, False: 70.3k] ------------------ 554| 177| return DeserializationError::InvalidInput; 555| 70.5k| } 556| 70.5k| } _ZN11ArduinoJson8V742HB426detail16JsonDeserializerINS1_13BoundedReaderIPKhvEEE13canBeInNumberEc: 586| 212k| static inline bool canBeInNumber(char c) { 587| 212k| return isBetween(c, '0', '9') || c == '+' || c == '-' || c == '.' || ------------------ | Branch (587:12): [True: 79.0k, False: 133k] | Branch (587:38): [True: 591, False: 132k] | Branch (587:50): [True: 3.65k, False: 128k] | Branch (587:62): [True: 46.5k, False: 82.2k] ------------------ 588| |#if ARDUINOJSON_ENABLE_NAN || ARDUINOJSON_ENABLE_INFINITY 589| | isBetween(c, 'A', 'Z') || isBetween(c, 'a', 'z'); 590| |#else 591| 82.2k| c == 'e' || c == 'E'; ------------------ | Branch (591:12): [True: 1.65k, False: 80.5k] | Branch (591:24): [True: 10.0k, False: 70.5k] ------------------ 592| 212k|#endif 593| 212k| } _ZN11ArduinoJson8V742HB4213serializeJsonINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEETnNS0_6detail9enable_ifIXntsr6detail10is_pointerIT_EE5valueEiE4typeELi0EEEmNS0_16JsonVariantConstERSB_: 141| 1.21k|size_t serializeJson(JsonVariantConst source, TDestination& destination) { 142| 1.21k| using namespace detail; 143| 1.21k| return serialize(source, destination); 144| 1.21k|} _ZN11ArduinoJson8V742HB426detail14JsonSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEEC2ESB_PNS1_15ResourceManagerE: 20| 1.21k| : formatter_(writer), resources_(resources) {} _ZN11ArduinoJson8V742HB426detail14JsonSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE5visitEDn: 107| 194| size_t visit(nullptr_t) { 108| 194| formatter_.writeRaw("null"); 109| 194| return bytesWritten(); 110| 194| } _ZNK11ArduinoJson8V742HB426detail14JsonSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE12bytesWrittenEv: 113| 18.0k| size_t bytesWritten() const { 114| 18.0k| return formatter_.bytesWritten(); 115| 18.0k| } _ZN11ArduinoJson8V742HB426detail14JsonSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE5visitIfEENS1_9enable_ifIXsr17is_floating_pointIT_EE5valueEmE4typeESF_: 72| 4.52k| enable_if_t::value, size_t> visit(T value) { 73| 4.52k| formatter_.writeFloat(value); 74| 4.52k| return bytesWritten(); 75| 4.52k| } _ZN11ArduinoJson8V742HB426detail14JsonSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE5visitIdEENS1_9enable_ifIXsr17is_floating_pointIT_EE5valueEmE4typeESF_: 72| 1.36k| enable_if_t::value, size_t> visit(T value) { 73| 1.36k| formatter_.writeFloat(value); 74| 1.36k| return bytesWritten(); 75| 1.36k| } _ZN11ArduinoJson8V742HB426detail14JsonSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE10visitArrayEPNS1_11VariantDataE: 22| 1.30k| size_t visitArray(VariantData* array) { 23| 1.30k| ARDUINOJSON_ASSERT(array != nullptr); ------------------ | | 11| 1.30k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ | Branch (23:5): [True: 1.30k, False: 0] ------------------ 24| 1.30k| ARDUINOJSON_ASSERT(array->isArray()); ------------------ | | 11| 1.30k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ | Branch (24:5): [True: 1.30k, False: 0] ------------------ 25| | 26| 1.30k| write('['); 27| | 28| 1.30k| auto slotId = array->content.asCollection.head; 29| | 30| 16.5k| while (slotId != NULL_SLOT) { ------------------ | Branch (30:12): [True: 15.2k, False: 1.30k] ------------------ 31| 15.2k| auto slot = resources_->getVariant(slotId); 32| | 33| 15.2k| VariantImpl::accept(*this, slot, resources_); 34| | 35| 15.2k| slotId = slot->next; 36| | 37| 15.2k| if (slotId != NULL_SLOT) ------------------ | Branch (37:11): [True: 14.1k, False: 1.08k] ------------------ 38| 14.1k| write(','); 39| 15.2k| } 40| | 41| 1.30k| write(']'); 42| 1.30k| return bytesWritten(); 43| 1.30k| } _ZN11ArduinoJson8V742HB426detail14JsonSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE5writeEc: 117| 19.2k| void write(char c) { 118| 19.2k| formatter_.writeRaw(c); 119| 19.2k| } _ZN11ArduinoJson8V742HB426detail14JsonSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE11visitObjectEPNS1_11VariantDataE: 45| 615| size_t visitObject(VariantData* object) { 46| 615| ARDUINOJSON_ASSERT(object != nullptr); ------------------ | | 11| 615|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ | Branch (46:5): [True: 615, False: 0] ------------------ 47| 615| ARDUINOJSON_ASSERT(object->isObject()); ------------------ | | 11| 615|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ | Branch (47:5): [True: 615, False: 0] ------------------ 48| | 49| 615| write('{'); 50| | 51| 615| auto slotId = object->content.asCollection.head; 52| | 53| 615| bool isKey = true; 54| | 55| 2.20k| while (slotId != NULL_SLOT) { ------------------ | Branch (55:12): [True: 1.58k, False: 615] ------------------ 56| 1.58k| auto slot = resources_->getVariant(slotId); 57| 1.58k| VariantImpl::accept(*this, slot, resources_); 58| | 59| 1.58k| slotId = slot->next; 60| | 61| 1.58k| if (slotId != NULL_SLOT) ------------------ | Branch (61:11): [True: 1.17k, False: 417] ------------------ 62| 1.17k| write(isKey ? ':' : ','); ------------------ | Branch (62:15): [True: 794, False: 377] ------------------ 63| | 64| 1.58k| isKey = !isKey; 65| 1.58k| } 66| | 67| 615| write('}'); 68| 615| return bytesWritten(); 69| 615| } _ZN11ArduinoJson8V742HB426detail14JsonSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE5visitENS0_10JsonStringE: 82| 1.25k| size_t visit(JsonString value) { 83| 1.25k| formatter_.writeString(value.c_str(), value.size()); 84| 1.25k| return bytesWritten(); 85| 1.25k| } _ZN11ArduinoJson8V742HB426detail14JsonSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE5visitEl: 92| 1.08k| size_t visit(JsonInteger value) { 93| 1.08k| formatter_.writeInteger(value); 94| 1.08k| return bytesWritten(); 95| 1.08k| } _ZN11ArduinoJson8V742HB426detail14JsonSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE5visitEm: 97| 7.35k| size_t visit(JsonUInt value) { 98| 7.35k| formatter_.writeInteger(value); 99| 7.35k| return bytesWritten(); 100| 7.35k| } _ZN11ArduinoJson8V742HB426detail14JsonSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE5visitEb: 102| 388| size_t visit(bool value) { 103| 388| formatter_.writeBoolean(value); 104| 388| return bytesWritten(); 105| 388| } _ZN11ArduinoJson8V742HB426detail5LatchINS1_13BoundedReaderIPKhvEEEC2ES6_: 14| 3.09k| Latch(TReader reader) : reader_(reader), loaded_(false) { 15| 3.09k|#if ARDUINOJSON_DEBUG 16| 3.09k| ended_ = false; 17| 3.09k|#endif 18| 3.09k| } _ZN11ArduinoJson8V742HB426detail5LatchINS1_13BoundedReaderIPKhvEEE5clearEv: 20| 359k| void clear() { 21| 359k| loaded_ = false; 22| 359k| } _ZN11ArduinoJson8V742HB426detail5LatchINS1_13BoundedReaderIPKhvEEE7currentEv: 28| 789k| FORCE_INLINE char current() { 29| 789k| if (!loaded_) { ------------------ | Branch (29:9): [True: 361k, False: 428k] ------------------ 30| 361k| load(); 31| 361k| } 32| 789k| return current_; 33| 789k| } _ZN11ArduinoJson8V742HB426detail5LatchINS1_13BoundedReaderIPKhvEEE4loadEv: 36| 361k| void load() { 37| 361k| ARDUINOJSON_ASSERT(!ended_); ------------------ | | 11| 361k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ | Branch (37:5): [True: 361k, False: 0] ------------------ 38| 361k| int c = reader_.read(); 39| 361k|#if ARDUINOJSON_DEBUG 40| 361k| if (c <= 0) ------------------ | Branch (40:9): [True: 2.34k, False: 359k] ------------------ 41| 2.34k| ended_ = true; 42| 361k|#endif 43| 361k| current_ = static_cast(c > 0 ? c : 0); ------------------ | Branch (43:34): [True: 359k, False: 2.34k] ------------------ 44| 361k| loaded_ = true; 45| 361k| } _ZNK11ArduinoJson8V742HB426detail5LatchINS1_13BoundedReaderIPKhvEEE4lastEv: 24| 1.22k| int last() const { 25| 1.22k| return current_; 26| 1.22k| } _ZN11ArduinoJson8V742HB426detail13TextFormatterINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEEC2ESB_: 23| 1.21k| explicit TextFormatter(TWriter writer) : writer_(writer) {} _ZN11ArduinoJson8V742HB426detail13TextFormatterINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE8writeRawEPKc: 152| 974| void writeRaw(const char* s) { 153| 974| writer_.write(reinterpret_cast(s), strlen(s)); 154| 974| } _ZNK11ArduinoJson8V742HB426detail13TextFormatterINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE12bytesWrittenEv: 28| 18.0k| size_t bytesWritten() const { 29| 18.0k| return writer_.count(); 30| 18.0k| } _ZN11ArduinoJson8V742HB426detail13TextFormatterINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE10writeFloatIfEEvT_: 68| 4.52k| void writeFloat(T value) { 69| 4.52k| writeFloat(JsonFloat(value), sizeof(T) >= 8 ? 9 : 6); ------------------ | Branch (69:34): [Folded, False: 4.52k] ------------------ 70| 4.52k| } _ZN11ArduinoJson8V742HB426detail13TextFormatterINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE10writeFloatEda: 72| 5.88k| void writeFloat(JsonFloat value, int8_t decimalPlaces) { 73| 5.88k| if (isnan(value)) ------------------ | Branch (73:9): [True: 0, False: 5.88k] ------------------ 74| 0| return writeRaw(ARDUINOJSON_ENABLE_NAN ? "NaN" : "null"); ------------------ | | 219| 0|# define ARDUINOJSON_ENABLE_NAN 0 | | ------------------ | | | Branch (219:34): [Folded, False: 0] | | ------------------ ------------------ 75| | 76| |#if ARDUINOJSON_ENABLE_INFINITY 77| | if (value < 0.0) { 78| | writeRaw('-'); 79| | value = -value; 80| | } 81| | 82| | if (isinf(value)) 83| | return writeRaw("Infinity"); 84| |#else 85| 5.88k| if (isinf(value)) ------------------ | Branch (85:9): [True: 196, False: 5.69k] ------------------ 86| 196| return writeRaw("null"); 87| | 88| 5.69k| if (value < 0.0) { ------------------ | Branch (88:9): [True: 197, False: 5.49k] ------------------ 89| 197| writeRaw('-'); 90| 197| value = -value; 91| 197| } 92| 5.69k|#endif 93| | 94| 5.69k| auto parts = decomposeFloat(value, decimalPlaces); 95| | 96| 5.69k| writeInteger(parts.integral); 97| 5.69k| if (parts.decimalPlaces) ------------------ | Branch (97:9): [True: 443, False: 5.24k] ------------------ 98| 443| writeDecimals(parts.decimal, parts.decimalPlaces); 99| | 100| 5.69k| if (parts.exponent) { ------------------ | Branch (100:9): [True: 2.09k, False: 3.59k] ------------------ 101| 2.09k| writeRaw('e'); 102| 2.09k| writeInteger(parts.exponent); 103| 2.09k| } 104| 5.69k| } _ZN11ArduinoJson8V742HB426detail13TextFormatterINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE8writeRawEc: 169| 40.7k| void writeRaw(char c) { 170| 40.7k| writer_.write(static_cast(c)); 171| 40.7k| } _ZN11ArduinoJson8V742HB426detail13TextFormatterINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE12writeIntegerIjEENS1_9enable_ifIXsr11is_unsignedIT_EE5valueEvE4typeESF_: 120| 5.69k| enable_if_t::value> writeInteger(T value) { 121| 5.69k| char buffer[22]; 122| 5.69k| char* end = buffer + sizeof(buffer); 123| 5.69k| char* begin = end; 124| | 125| | // write the string in reverse order 126| 7.91k| do { 127| 7.91k| *--begin = char(value % 10 + '0'); 128| 7.91k| value = T(value / 10); 129| 7.91k| } while (value); ------------------ | Branch (129:14): [True: 2.22k, False: 5.69k] ------------------ 130| | 131| | // and dump it in the right order 132| 5.69k| writeRaw(begin, end); 133| 5.69k| } _ZN11ArduinoJson8V742HB426detail13TextFormatterINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE8writeRawEPKcSE_: 160| 16.6k| void writeRaw(const char* begin, const char* end) { 161| 16.6k| writer_.write(reinterpret_cast(begin), 162| 16.6k| static_cast(end - begin)); 163| 16.6k| } _ZN11ArduinoJson8V742HB426detail13TextFormatterINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE13writeDecimalsEja: 135| 443| void writeDecimals(uint32_t value, int8_t width) { 136| | // buffer should be big enough for all digits and the dot 137| 443| char buffer[16]; 138| 443| char* end = buffer + sizeof(buffer); 139| 443| char* begin = end; 140| | 141| | // write the string in reverse order 142| 2.14k| while (width--) { ------------------ | Branch (142:12): [True: 1.70k, False: 443] ------------------ 143| 1.70k| *--begin = char(value % 10 + '0'); 144| 1.70k| value /= 10; 145| 1.70k| } 146| 443| *--begin = '.'; 147| | 148| | // and dump it in the right order 149| 443| writeRaw(begin, end); 150| 443| } _ZN11ArduinoJson8V742HB426detail13TextFormatterINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE12writeIntegerIsEENS1_9enable_ifIXsr9is_signedIT_EE5valueEvE4typeESF_: 107| 2.09k| enable_if_t::value> writeInteger(T value) { 108| 2.09k| using unsigned_type = make_unsigned_t; 109| 2.09k| unsigned_type unsigned_value; 110| 2.09k| if (value < 0) { ------------------ | Branch (110:9): [True: 540, False: 1.55k] ------------------ 111| 540| writeRaw('-'); 112| 540| unsigned_value = unsigned_type(unsigned_type(~value) + 1); 113| 1.55k| } else { 114| 1.55k| unsigned_value = unsigned_type(value); 115| 1.55k| } 116| 2.09k| writeInteger(unsigned_value); 117| 2.09k| } _ZN11ArduinoJson8V742HB426detail13TextFormatterINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE12writeIntegerItEENS1_9enable_ifIXsr11is_unsignedIT_EE5valueEvE4typeESF_: 120| 2.09k| enable_if_t::value> writeInteger(T value) { 121| 2.09k| char buffer[22]; 122| 2.09k| char* end = buffer + sizeof(buffer); 123| 2.09k| char* begin = end; 124| | 125| | // write the string in reverse order 126| 3.58k| do { 127| 3.58k| *--begin = char(value % 10 + '0'); 128| 3.58k| value = T(value / 10); 129| 3.58k| } while (value); ------------------ | Branch (129:14): [True: 1.48k, False: 2.09k] ------------------ 130| | 131| | // and dump it in the right order 132| 2.09k| writeRaw(begin, end); 133| 2.09k| } _ZN11ArduinoJson8V742HB426detail13TextFormatterINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE10writeFloatIdEEvT_: 68| 1.36k| void writeFloat(T value) { 69| 1.36k| writeFloat(JsonFloat(value), sizeof(T) >= 8 ? 9 : 6); ------------------ | Branch (69:34): [True: 1.36k, Folded] ------------------ 70| 1.36k| } _ZN11ArduinoJson8V742HB426detail13TextFormatterINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE11writeStringEPKcm: 47| 1.25k| void writeString(const char* value, size_t n) { 48| 1.25k| ARDUINOJSON_ASSERT(value != NULL); ------------------ | | 11| 1.25k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ | Branch (48:5): [True: 1.25k, False: 0] ------------------ 49| 1.25k| writeRaw('\"'); 50| 16.0k| while (n--) ------------------ | Branch (50:12): [True: 14.8k, False: 1.25k] ------------------ 51| 14.8k| writeChar(*value++); 52| 1.25k| writeRaw('\"'); 53| 1.25k| } _ZN11ArduinoJson8V742HB426detail13TextFormatterINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE9writeCharEc: 55| 14.8k| void writeChar(char c) { 56| 14.8k| char specialChar = EscapeSequence::escapeChar(c); 57| 14.8k| if (specialChar) { ------------------ | Branch (57:9): [True: 793, False: 14.0k] ------------------ 58| 793| writeRaw('\\'); 59| 793| writeRaw(specialChar); 60| 14.0k| } else if (c) { ------------------ | Branch (60:16): [True: 13.8k, False: 196] ------------------ 61| 13.8k| writeRaw(c); 62| 13.8k| } else { 63| 196| writeRaw("\\u0000"); 64| 196| } 65| 14.8k| } _ZN11ArduinoJson8V742HB426detail13TextFormatterINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE12writeIntegerIlEENS1_9enable_ifIXsr9is_signedIT_EE5valueEvE4typeESF_: 107| 1.08k| enable_if_t::value> writeInteger(T value) { 108| 1.08k| using unsigned_type = make_unsigned_t; 109| 1.08k| unsigned_type unsigned_value; 110| 1.08k| if (value < 0) { ------------------ | Branch (110:9): [True: 765, False: 322] ------------------ 111| 765| writeRaw('-'); 112| 765| unsigned_value = unsigned_type(unsigned_type(~value) + 1); 113| 765| } else { 114| 322| unsigned_value = unsigned_type(value); 115| 322| } 116| 1.08k| writeInteger(unsigned_value); 117| 1.08k| } _ZN11ArduinoJson8V742HB426detail13TextFormatterINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE12writeIntegerImEENS1_9enable_ifIXsr11is_unsignedIT_EE5valueEvE4typeESF_: 120| 8.44k| enable_if_t::value> writeInteger(T value) { 121| 8.44k| char buffer[22]; 122| 8.44k| char* end = buffer + sizeof(buffer); 123| 8.44k| char* begin = end; 124| | 125| | // write the string in reverse order 126| 20.9k| do { 127| 20.9k| *--begin = char(value % 10 + '0'); 128| 20.9k| value = T(value / 10); 129| 20.9k| } while (value); ------------------ | Branch (129:14): [True: 12.4k, False: 8.44k] ------------------ 130| | 131| | // and dump it in the right order 132| 8.44k| writeRaw(begin, end); 133| 8.44k| } _ZN11ArduinoJson8V742HB426detail13TextFormatterINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE12writeBooleanEb: 32| 388| void writeBoolean(bool value) { 33| 388| if (value) ------------------ | Branch (33:9): [True: 194, False: 194] ------------------ 34| 194| writeRaw("true"); 35| 194| else 36| 194| writeRaw("false"); 37| 388| } _ZN11ArduinoJson8V742HB426detail5Utf169CodepointC2Ev: 34| 3.28k| Codepoint() : highSurrogate_(0), codepoint_(0) {} _ZN11ArduinoJson8V742HB426detail5Utf169Codepoint6appendEt: 36| 1.96k| bool append(uint16_t codeunit) { 37| 1.96k| if (isHighSurrogate(codeunit)) { ------------------ | Branch (37:9): [True: 221, False: 1.74k] ------------------ 38| 221| highSurrogate_ = codeunit & 0x3FF; 39| 221| return false; 40| 221| } 41| | 42| 1.74k| if (isLowSurrogate(codeunit)) { ------------------ | Branch (42:9): [True: 494, False: 1.25k] ------------------ 43| 494| codepoint_ = 44| 494| uint32_t(0x10000 + ((highSurrogate_ << 10) | (codeunit & 0x3FF))); 45| 494| return true; 46| 494| } 47| | 48| 1.25k| codepoint_ = codeunit; 49| 1.25k| return true; 50| 1.74k| } _ZN11ArduinoJson8V742HB426detail5Utf1615isHighSurrogateEt: 24| 1.96k|inline bool isHighSurrogate(uint16_t codeunit) { 25| 1.96k| return codeunit >= 0xD800 && codeunit < 0xDC00; ------------------ | Branch (25:10): [True: 769, False: 1.19k] | Branch (25:32): [True: 221, False: 548] ------------------ 26| 1.96k|} _ZN11ArduinoJson8V742HB426detail5Utf1614isLowSurrogateEt: 28| 1.74k|inline bool isLowSurrogate(uint16_t codeunit) { 29| 1.74k| return codeunit >= 0xDC00 && codeunit < 0xE000; ------------------ | Branch (29:10): [True: 548, False: 1.19k] | Branch (29:32): [True: 494, False: 54] ------------------ 30| 1.74k|} _ZNK11ArduinoJson8V742HB426detail5Utf169Codepoint5valueEv: 52| 1.74k| uint32_t value() const { 53| 1.74k| return codepoint_; 54| 1.74k| } _ZN11ArduinoJson8V742HB426detail4Utf815encodeCodepointINS1_13StringBuilderEEEvjRT_: 13| 1.74k|inline void encodeCodepoint(uint32_t codepoint32, TStringBuilder& str) { 14| | // this function was optimize for code size on AVR 15| | 16| 1.74k| if (codepoint32 < 0x80) { ------------------ | Branch (16:7): [True: 640, False: 1.10k] ------------------ 17| 640| str.append(char(codepoint32)); 18| 1.10k| } else { 19| | // a buffer to store the string in reverse 20| 1.10k| char buf[5]; 21| 1.10k| char* p = buf; 22| | 23| 1.10k| *(p++) = 0; 24| 1.10k| *(p++) = char((codepoint32 | 0x80) & 0xBF); 25| 1.10k| uint16_t codepoint16 = uint16_t(codepoint32 >> 6); 26| 1.10k| if (codepoint16 < 0x20) { // 0x800 ------------------ | Branch (26:9): [True: 330, False: 776] ------------------ 27| 330| *(p++) = char(codepoint16 | 0xC0); 28| 776| } else { 29| 776| *(p++) = char((codepoint16 | 0x80) & 0xBF); 30| 776| codepoint16 = uint16_t(codepoint16 >> 6); 31| 776| if (codepoint16 < 0x10) { // 0x10000 ------------------ | Branch (31:11): [True: 282, False: 494] ------------------ 32| 282| *(p++) = char(codepoint16 | 0xE0); 33| 494| } else { 34| 494| *(p++) = char((codepoint16 | 0x80) & 0xBF); 35| 494| codepoint16 = uint16_t(codepoint16 >> 6); 36| 494| *(p++) = char(codepoint16 | 0xF0); 37| 494| } 38| 776| } 39| | 40| 4.58k| while (*(--p)) { ------------------ | Branch (40:12): [True: 3.48k, False: 1.10k] ------------------ 41| 3.48k| str.append(*p); 42| 3.48k| } 43| 1.10k| } 44| 1.74k|} _ZN11ArduinoJson8V742HB426detail16DefaultAllocator8instanceEv: 38| 3.09k| static Allocator* instance() { 39| 3.09k| static DefaultAllocator allocator; 40| 3.09k| return &allocator; 41| 3.09k| } _ZN11ArduinoJson8V742HB426detail16DefaultAllocator8allocateEm: 26| 5.33k| void* allocate(size_t size) override { 27| 5.33k| return malloc(size); 28| 5.33k| } _ZN11ArduinoJson8V742HB426detail16DefaultAllocator10deallocateEPv: 30| 5.33k| void deallocate(void* ptr) override { 31| 5.33k| free(ptr); 32| 5.33k| } _ZN11ArduinoJson8V742HB426detail16DefaultAllocator10reallocateEPvm: 34| 4.80k| void* reallocate(void* ptr, size_t new_size) override { 35| 4.80k| return realloc(ptr, new_size); 36| 4.80k| } _ZN11ArduinoJson8V742HB426detail10MemoryPoolINS1_11VariantDataEE7destroyEPNS0_9AllocatorE: 57| 1.57k| void destroy(Allocator* allocator) { 58| 1.57k| if (slots_) ------------------ | Branch (58:9): [True: 1.57k, False: 0] ------------------ 59| 1.57k| allocator->deallocate(slots_); 60| 1.57k| slots_ = nullptr; 61| 1.57k| capacity_ = 0; 62| 1.57k| usage_ = 0; 63| 1.57k| } _ZN11ArduinoJson8V742HB426detail10MemoryPoolINS1_14EightByteValueEE7destroyEPNS0_9AllocatorE: 57| 718| void destroy(Allocator* allocator) { 58| 718| if (slots_) ------------------ | Branch (58:9): [True: 718, False: 0] ------------------ 59| 718| allocator->deallocate(slots_); 60| 718| slots_ = nullptr; 61| 718| capacity_ = 0; 62| 718| usage_ = 0; 63| 718| } _ZNK11ArduinoJson8V742HB426detail10MemoryPoolINS1_14EightByteValueEE7getSlotEj: 74| 4.67k| T* getSlot(SlotId id) const { 75| 4.67k| ARDUINOJSON_ASSERT(id < usage_); ------------------ | | 11| 4.67k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ | Branch (75:5): [True: 4.67k, False: 0] ------------------ 76| 4.67k| return slots_ + id; 77| 4.67k| } _ZNK11ArduinoJson8V742HB426detail10MemoryPoolINS1_11VariantDataEE7getSlotEj: 74| 115k| T* getSlot(SlotId id) const { 75| 115k| ARDUINOJSON_ASSERT(id < usage_); ------------------ | | 11| 115k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ | Branch (75:5): [True: 115k, False: 0] ------------------ 76| 115k| return slots_ + id; 77| 115k| } _ZN11ArduinoJson8V742HB426detail4SlotINS1_11VariantDataEEC2EPS3_j: 21| 170k| Slot(T* p, SlotId id) : ptr_(p), id_(id) { 22| | ARDUINOJSON_ASSERT((p == nullptr) == (id == NULL_SLOT)); ------------------ | | 11| 170k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ | Branch (22:5): [True: 170k, False: 0] ------------------ 23| 170k| } _ZN11ArduinoJson8V742HB426detail10MemoryPoolINS1_11VariantDataEE9allocSlotEv: 65| 82.7k| Slot allocSlot() { 66| 82.7k| if (!slots_) ------------------ | Branch (66:9): [True: 0, False: 82.7k] ------------------ 67| 0| return {}; 68| 82.7k| if (usage_ >= capacity_) ------------------ | Branch (68:9): [True: 206, False: 82.5k] ------------------ 69| 206| return {}; 70| 82.5k| auto index = usage_++; 71| 82.5k| return {slots_ + index, SlotId(index)}; 72| 82.7k| } _ZNK11ArduinoJson8V742HB426detail4SlotINS1_11VariantDataEE2idEv: 29| 250k| SlotId id() const { 30| 250k| return id_; 31| 250k| } _ZN11ArduinoJson8V742HB426detail10MemoryPoolINS1_11VariantDataEE6createEjPNS0_9AllocatorE: 50| 1.57k| void create(SlotCount cap, Allocator* allocator) { 51| 1.57k| ARDUINOJSON_ASSERT(cap > 0); ------------------ | | 11| 1.57k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ | Branch (51:5): [True: 1.57k, False: 0] ------------------ 52| 1.57k| slots_ = reinterpret_cast(allocator->allocate(slotsToBytes(cap))); 53| 1.57k| capacity_ = slots_ ? cap : 0; ------------------ | Branch (53:17): [True: 1.57k, False: 0] ------------------ 54| 1.57k| usage_ = 0; 55| 1.57k| } _ZN11ArduinoJson8V742HB426detail10MemoryPoolINS1_11VariantDataEE12slotsToBytesEj: 100| 2.93k| static size_t slotsToBytes(SlotCount n) { 101| 2.93k| return n * sizeof(T); 102| 2.93k| } _ZN11ArduinoJson8V742HB426detail4SlotINS1_11VariantDataEEC2Ev: 20| 412| Slot() : ptr_(nullptr), id_(NULL_SLOT) {} _ZNK11ArduinoJson8V742HB426detail4SlotINS1_11VariantDataEEcvbEv: 25| 331k| explicit operator bool() const { 26| 331k| return ptr_ != nullptr; 27| 331k| } _ZNK11ArduinoJson8V742HB426detail4SlotINS1_11VariantDataEE3ptrEv: 33| 259k| T* ptr() const { 34| 259k| return ptr_; 35| 259k| } _ZNK11ArduinoJson8V742HB426detail4SlotINS1_11VariantDataEEptEv: 37| 9.29k| T* operator->() const { 38| 9.29k| ARDUINOJSON_ASSERT(ptr_ != nullptr); ------------------ | | 11| 9.29k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ | Branch (38:5): [True: 9.29k, False: 0] ------------------ 39| 9.29k| return ptr_; 40| 9.29k| } _ZNK11ArduinoJson8V742HB426detail4SlotINS1_14EightByteValueEE3ptrEv: 33| 11.5k| T* ptr() const { 34| 11.5k| return ptr_; 35| 11.5k| } _ZNK11ArduinoJson8V742HB426detail4SlotINS1_14EightByteValueEE2idEv: 29| 21.1k| SlotId id() const { 30| 21.1k| return id_; 31| 21.1k| } _ZN11ArduinoJson8V742HB426detail4SlotINS1_14EightByteValueEEC2EPS3_j: 21| 21.1k| Slot(T* p, SlotId id) : ptr_(p), id_(id) { 22| | ARDUINOJSON_ASSERT((p == nullptr) == (id == NULL_SLOT)); ------------------ | | 11| 21.1k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ | Branch (22:5): [True: 21.1k, False: 0] ------------------ 23| 21.1k| } _ZN11ArduinoJson8V742HB426detail10MemoryPoolINS1_14EightByteValueEE9allocSlotEv: 65| 9.37k| Slot allocSlot() { 66| 9.37k| if (!slots_) ------------------ | Branch (66:9): [True: 0, False: 9.37k] ------------------ 67| 0| return {}; 68| 9.37k| if (usage_ >= capacity_) ------------------ | Branch (68:9): [True: 15, False: 9.36k] ------------------ 69| 15| return {}; 70| 9.36k| auto index = usage_++; 71| 9.36k| return {slots_ + index, SlotId(index)}; 72| 9.37k| } _ZN11ArduinoJson8V742HB426detail10MemoryPoolINS1_14EightByteValueEE6createEjPNS0_9AllocatorE: 50| 718| void create(SlotCount cap, Allocator* allocator) { 51| 718| ARDUINOJSON_ASSERT(cap > 0); ------------------ | | 11| 718|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ | Branch (51:5): [True: 718, False: 0] ------------------ 52| 718| slots_ = reinterpret_cast(allocator->allocate(slotsToBytes(cap))); 53| 718| capacity_ = slots_ ? cap : 0; ------------------ | Branch (53:17): [True: 718, False: 0] ------------------ 54| 718| usage_ = 0; 55| 718| } _ZN11ArduinoJson8V742HB426detail10MemoryPoolINS1_14EightByteValueEE12slotsToBytesEj: 100| 1.42k| static size_t slotsToBytes(SlotCount n) { 101| 1.42k| return n * sizeof(T); 102| 1.42k| } _ZN11ArduinoJson8V742HB426detail4SlotINS1_14EightByteValueEEC2Ev: 20| 30| Slot() : ptr_(nullptr), id_(NULL_SLOT) {} _ZNK11ArduinoJson8V742HB426detail4SlotINS1_14EightByteValueEEcvbEv: 25| 37.1k| explicit operator bool() const { 26| 37.1k| return ptr_ != nullptr; 27| 37.1k| } _ZNK11ArduinoJson8V742HB426detail4SlotINS1_14EightByteValueEEptEv: 37| 9.56k| T* operator->() const { 38| 9.56k| ARDUINOJSON_ASSERT(ptr_ != nullptr); ------------------ | | 11| 9.56k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ | Branch (38:5): [True: 9.56k, False: 0] ------------------ 39| 9.56k| return ptr_; 40| 9.56k| } _ZN11ArduinoJson8V742HB426detail10MemoryPoolINS1_11VariantDataEE11shrinkToFitEPNS0_9AllocatorE: 83| 1.36k| void shrinkToFit(Allocator* allocator) { 84| 1.36k| auto newSlots = reinterpret_cast( 85| 1.36k| allocator->reallocate(slots_, slotsToBytes(usage_))); 86| 1.36k| if (newSlots) { ------------------ | Branch (86:9): [True: 1.36k, False: 0] ------------------ 87| 1.36k| slots_ = newSlots; 88| 1.36k| capacity_ = usage_; 89| 1.36k| } 90| 1.36k| } _ZN11ArduinoJson8V742HB426detail10MemoryPoolINS1_14EightByteValueEE11shrinkToFitEPNS0_9AllocatorE: 83| 703| void shrinkToFit(Allocator* allocator) { 84| 703| auto newSlots = reinterpret_cast( 85| 703| allocator->reallocate(slots_, slotsToBytes(usage_))); 86| 703| if (newSlots) { ------------------ | Branch (86:9): [True: 703, False: 0] ------------------ 87| 703| slots_ = newSlots; 88| 703| capacity_ = usage_; 89| 703| } 90| 703| } _ZN11ArduinoJson8V742HB426detail14MemoryPoolListINS1_11VariantDataEEC2Ev: 28| 3.09k| MemoryPoolList() = default; _ZN11ArduinoJson8V742HB426detail14MemoryPoolListINS1_14EightByteValueEEC2Ev: 28| 3.09k| MemoryPoolList() = default; _ZN11ArduinoJson8V742HB426detail14MemoryPoolListINS1_11VariantDataEE5clearEPNS0_9AllocatorE: 117| 6.19k| void clear(Allocator* allocator) { 118| 7.76k| for (PoolCount i = 0; i < count_; i++) ------------------ | Branch (118:27): [True: 1.57k, False: 6.19k] ------------------ 119| 1.57k| pools_[i].destroy(allocator); 120| 6.19k| count_ = 0; 121| 6.19k| freeList_ = NULL_SLOT; 122| 6.19k| if (pools_ != preallocatedPools_) { ------------------ | Branch (122:9): [True: 20, False: 6.17k] ------------------ 123| 20| allocator->deallocate(pools_); 124| 20| pools_ = preallocatedPools_; 125| 20| capacity_ = ARDUINOJSON_INITIAL_POOL_COUNT; ------------------ | | 124| 20|# define ARDUINOJSON_INITIAL_POOL_COUNT 4 ------------------ 126| 20| } 127| 6.19k| } _ZN11ArduinoJson8V742HB426detail14MemoryPoolListINS1_14EightByteValueEE5clearEPNS0_9AllocatorE: 117| 6.19k| void clear(Allocator* allocator) { 118| 6.91k| for (PoolCount i = 0; i < count_; i++) ------------------ | Branch (118:27): [True: 718, False: 6.19k] ------------------ 119| 718| pools_[i].destroy(allocator); 120| 6.19k| count_ = 0; 121| 6.19k| freeList_ = NULL_SLOT; 122| 6.19k| if (pools_ != preallocatedPools_) { ------------------ | Branch (122:9): [True: 0, False: 6.19k] ------------------ 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| 6.19k| } _ZN11ArduinoJson8V742HB426detail14MemoryPoolListINS1_14EightByteValueEED2Ev: 30| 3.09k| ~MemoryPoolList() { 31| | ARDUINOJSON_ASSERT(count_ == 0); ------------------ | | 11| 3.09k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ | Branch (31:5): [True: 3.09k, False: 0] ------------------ 32| 3.09k| } _ZN11ArduinoJson8V742HB426detail14MemoryPoolListINS1_11VariantDataEED2Ev: 30| 3.09k| ~MemoryPoolList() { 31| | ARDUINOJSON_ASSERT(count_ == 0); ------------------ | | 11| 3.09k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ | Branch (31:5): [True: 3.09k, False: 0] ------------------ 32| 3.09k| } _ZNK11ArduinoJson8V742HB426detail14MemoryPoolListINS1_14EightByteValueEE7getSlotEj: 108| 4.67k| T* getSlot(SlotId id) const { 109| 4.67k| if (id == NULL_SLOT) ------------------ | Branch (109:9): [True: 0, False: 4.67k] ------------------ 110| 0| return nullptr; 111| 4.67k| auto poolIndex = SlotId(id / ARDUINOJSON_POOL_CAPACITY); ------------------ | | 118| 4.67k|# define ARDUINOJSON_POOL_CAPACITY 256 // 4096 bytes ------------------ 112| 4.67k| auto indexInPool = SlotId(id % ARDUINOJSON_POOL_CAPACITY); ------------------ | | 118| 4.67k|# define ARDUINOJSON_POOL_CAPACITY 256 // 4096 bytes ------------------ 113| 4.67k| ARDUINOJSON_ASSERT(poolIndex < count_); ------------------ | | 11| 4.67k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ | Branch (113:5): [True: 4.67k, False: 0] ------------------ 114| 4.67k| return pools_[poolIndex].getSlot(indexInPool); 115| 4.67k| } _ZNK11ArduinoJson8V742HB426detail14MemoryPoolListINS1_11VariantDataEE7getSlotEj: 108| 120k| T* getSlot(SlotId id) const { 109| 120k| if (id == NULL_SLOT) ------------------ | Branch (109:9): [True: 4.66k, False: 115k] ------------------ 110| 4.66k| return nullptr; 111| 115k| auto poolIndex = SlotId(id / ARDUINOJSON_POOL_CAPACITY); ------------------ | | 118| 115k|# define ARDUINOJSON_POOL_CAPACITY 256 // 4096 bytes ------------------ 112| 115k| auto indexInPool = SlotId(id % ARDUINOJSON_POOL_CAPACITY); ------------------ | | 118| 115k|# define ARDUINOJSON_POOL_CAPACITY 256 // 4096 bytes ------------------ 113| 115k| ARDUINOJSON_ASSERT(poolIndex < count_); ------------------ | | 11| 115k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ | Branch (113:5): [True: 115k, False: 0] ------------------ 114| 115k| return pools_[poolIndex].getSlot(indexInPool); 115| 115k| } _ZN11ArduinoJson8V742HB426detail14MemoryPoolListINS1_11VariantDataEE9allocSlotEPNS0_9AllocatorE: 82| 83.8k| Slot allocSlot(Allocator* allocator) { 83| | // try to allocate from free list 84| 83.8k| if (freeList_ != NULL_SLOT) { ------------------ | Branch (84:9): [True: 1.35k, False: 82.5k] ------------------ 85| 1.35k| return allocFromFreeList(); 86| 1.35k| } 87| | 88| | // try to allocate from last pool (other pools are full) 89| 82.5k| if (count_) { ------------------ | Branch (89:9): [True: 81.1k, False: 1.36k] ------------------ 90| 81.1k| auto slot = allocFromLastPool(); 91| 81.1k| if (slot) ------------------ | Branch (91:11): [True: 80.9k, False: 206] ------------------ 92| 80.9k| return slot; 93| 81.1k| } 94| | 95| | // create a new pool and try again 96| 1.57k| auto pool = addPool(allocator); 97| 1.57k| if (!pool) ------------------ | Branch (97:9): [True: 0, False: 1.57k] ------------------ 98| 0| return {}; 99| | 100| 1.57k| return allocFromLastPool(); 101| 1.57k| } _ZN11ArduinoJson8V742HB426detail14MemoryPoolListINS1_11VariantDataEE17allocFromFreeListEv: 152| 1.35k| Slot allocFromFreeList() { 153| 1.35k| ARDUINOJSON_ASSERT(freeList_ != NULL_SLOT); ------------------ | | 11| 1.35k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ | Branch (153:5): [True: 1.35k, False: 0] ------------------ 154| 1.35k| auto id = freeList_; 155| 1.35k| auto slot = getSlot(freeList_); 156| 1.35k| freeList_ = reinterpret_cast(slot)->next; 157| 1.35k| return {slot, id}; 158| 1.35k| } _ZN11ArduinoJson8V742HB426detail14MemoryPoolListINS1_11VariantDataEE17allocFromLastPoolEv: 160| 82.7k| Slot allocFromLastPool() { 161| 82.7k| ARDUINOJSON_ASSERT(count_ > 0); ------------------ | | 11| 82.7k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ | Branch (161:5): [True: 82.7k, False: 0] ------------------ 162| 82.7k| auto poolIndex = SlotId(count_ - 1); 163| 82.7k| auto slot = pools_[poolIndex].allocSlot(); 164| 82.7k| if (!slot) ------------------ | Branch (164:9): [True: 206, False: 82.5k] ------------------ 165| 206| return {}; 166| 82.5k| return {slot.ptr(), 167| 82.5k| SlotId(poolIndex * ARDUINOJSON_POOL_CAPACITY + slot.id())}; ------------------ | | 118| 82.5k|# define ARDUINOJSON_POOL_CAPACITY 256 // 4096 bytes ------------------ 168| 82.7k| } _ZN11ArduinoJson8V742HB426detail14MemoryPoolListINS1_11VariantDataEE7addPoolEPNS0_9AllocatorE: 170| 1.57k| Pool* addPool(Allocator* allocator) { 171| 1.57k| if (count_ == capacity_ && !increaseCapacity(allocator)) ------------------ | Branch (171:9): [True: 24, False: 1.54k] | Branch (171:32): [True: 0, False: 24] ------------------ 172| 0| return nullptr; 173| 1.57k| auto pool = &pools_[count_++]; 174| 1.57k| SlotCount poolCapacity = ARDUINOJSON_POOL_CAPACITY; ------------------ | | 118| 1.57k|# define ARDUINOJSON_POOL_CAPACITY 256 // 4096 bytes ------------------ 175| 1.57k| if (count_ == maxPools) // last pool is smaller because of NULL_SLOT ------------------ | Branch (175:9): [True: 0, False: 1.57k] ------------------ 176| 0| poolCapacity--; 177| 1.57k| pool->create(poolCapacity, allocator); 178| 1.57k| return pool; 179| 1.57k| } _ZN11ArduinoJson8V742HB426detail14MemoryPoolListINS1_11VariantDataEE16increaseCapacityEPNS0_9AllocatorE: 181| 24| bool increaseCapacity(Allocator* allocator) { 182| 24| if (capacity_ == maxPools) ------------------ | Branch (182:9): [True: 0, False: 24] ------------------ 183| 0| return false; 184| 24| void* newPools; 185| 24| auto newCapacity = PoolCount(capacity_ * 2); 186| | 187| 24| if (pools_ == preallocatedPools_) { ------------------ | Branch (187:9): [True: 20, False: 4] ------------------ 188| 20| newPools = allocator->allocate(newCapacity * sizeof(Pool)); 189| 20| if (!newPools) ------------------ | Branch (189:11): [True: 0, False: 20] ------------------ 190| 0| return false; 191| 20| memcpy(newPools, preallocatedPools_, sizeof(preallocatedPools_)); 192| 20| } else { 193| 4| newPools = allocator->reallocate(pools_, newCapacity * sizeof(Pool)); 194| 4| if (!newPools) ------------------ | Branch (194:11): [True: 0, False: 4] ------------------ 195| 0| return false; 196| 4| } 197| | 198| 24| pools_ = static_cast(newPools); 199| 24| capacity_ = newCapacity; 200| 24| return true; 201| 24| } _ZN11ArduinoJson8V742HB426detail14MemoryPoolListINS1_14EightByteValueEE8freeSlotENS1_4SlotIS3_EE: 103| 2.23k| void freeSlot(Slot slot) { 104| 2.23k| reinterpret_cast(slot.ptr())->next = freeList_; 105| 2.23k| freeList_ = slot.id(); 106| 2.23k| } _ZN11ArduinoJson8V742HB426detail14MemoryPoolListINS1_11VariantDataEE8freeSlotENS1_4SlotIS3_EE: 103| 4.63k| void freeSlot(Slot slot) { 104| 4.63k| reinterpret_cast(slot.ptr())->next = freeList_; 105| 4.63k| freeList_ = slot.id(); 106| 4.63k| } _ZN11ArduinoJson8V742HB426detail14MemoryPoolListINS1_14EightByteValueEE9allocSlotEPNS0_9AllocatorE: 82| 9.56k| Slot allocSlot(Allocator* allocator) { 83| | // try to allocate from free list 84| 9.56k| if (freeList_ != NULL_SLOT) { ------------------ | Branch (84:9): [True: 205, False: 9.36k] ------------------ 85| 205| return allocFromFreeList(); 86| 205| } 87| | 88| | // try to allocate from last pool (other pools are full) 89| 9.36k| if (count_) { ------------------ | Branch (89:9): [True: 8.66k, False: 703] ------------------ 90| 8.66k| auto slot = allocFromLastPool(); 91| 8.66k| if (slot) ------------------ | Branch (91:11): [True: 8.64k, False: 15] ------------------ 92| 8.64k| return slot; 93| 8.66k| } 94| | 95| | // create a new pool and try again 96| 718| auto pool = addPool(allocator); 97| 718| if (!pool) ------------------ | Branch (97:9): [True: 0, False: 718] ------------------ 98| 0| return {}; 99| | 100| 718| return allocFromLastPool(); 101| 718| } _ZN11ArduinoJson8V742HB426detail14MemoryPoolListINS1_14EightByteValueEE17allocFromFreeListEv: 152| 205| Slot allocFromFreeList() { 153| 205| ARDUINOJSON_ASSERT(freeList_ != NULL_SLOT); ------------------ | | 11| 205|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ | Branch (153:5): [True: 205, False: 0] ------------------ 154| 205| auto id = freeList_; 155| 205| auto slot = getSlot(freeList_); 156| 205| freeList_ = reinterpret_cast(slot)->next; 157| 205| return {slot, id}; 158| 205| } _ZN11ArduinoJson8V742HB426detail14MemoryPoolListINS1_14EightByteValueEE17allocFromLastPoolEv: 160| 9.37k| Slot allocFromLastPool() { 161| 9.37k| ARDUINOJSON_ASSERT(count_ > 0); ------------------ | | 11| 9.37k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ | Branch (161:5): [True: 9.37k, False: 0] ------------------ 162| 9.37k| auto poolIndex = SlotId(count_ - 1); 163| 9.37k| auto slot = pools_[poolIndex].allocSlot(); 164| 9.37k| if (!slot) ------------------ | Branch (164:9): [True: 15, False: 9.36k] ------------------ 165| 15| return {}; 166| 9.36k| return {slot.ptr(), 167| 9.36k| SlotId(poolIndex * ARDUINOJSON_POOL_CAPACITY + slot.id())}; ------------------ | | 118| 9.36k|# define ARDUINOJSON_POOL_CAPACITY 256 // 4096 bytes ------------------ 168| 9.37k| } _ZN11ArduinoJson8V742HB426detail14MemoryPoolListINS1_14EightByteValueEE7addPoolEPNS0_9AllocatorE: 170| 718| Pool* addPool(Allocator* allocator) { 171| 718| if (count_ == capacity_ && !increaseCapacity(allocator)) ------------------ | Branch (171:9): [True: 0, False: 718] | Branch (171:32): [True: 0, False: 0] ------------------ 172| 0| return nullptr; 173| 718| auto pool = &pools_[count_++]; 174| 718| SlotCount poolCapacity = ARDUINOJSON_POOL_CAPACITY; ------------------ | | 118| 718|# define ARDUINOJSON_POOL_CAPACITY 256 // 4096 bytes ------------------ 175| 718| if (count_ == maxPools) // last pool is smaller because of NULL_SLOT ------------------ | Branch (175:9): [True: 0, False: 718] ------------------ 176| 0| poolCapacity--; 177| 718| pool->create(poolCapacity, allocator); 178| 718| return pool; 179| 718| } _ZN11ArduinoJson8V742HB426detail14MemoryPoolListINS1_11VariantDataEE11shrinkToFitEPNS0_9AllocatorE: 140| 3.09k| void shrinkToFit(Allocator* allocator) { 141| 3.09k| if (count_ > 0) ------------------ | Branch (141:9): [True: 1.36k, False: 1.73k] ------------------ 142| 1.36k| pools_[count_ - 1].shrinkToFit(allocator); 143| 3.09k| if (pools_ != preallocatedPools_ && count_ != capacity_) { ------------------ | Branch (143:9): [True: 20, False: 3.07k] | Branch (143:41): [True: 11, False: 9] ------------------ 144| 11| pools_ = static_cast( 145| 11| allocator->reallocate(pools_, count_ * sizeof(Pool))); 146| 11| ARDUINOJSON_ASSERT(pools_ != nullptr); // realloc to smaller can't fail ------------------ | | 11| 11|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ | Branch (146:7): [True: 11, False: 0] ------------------ 147| 11| capacity_ = count_; 148| 11| } 149| 3.09k| } _ZN11ArduinoJson8V742HB426detail14MemoryPoolListINS1_14EightByteValueEE11shrinkToFitEPNS0_9AllocatorE: 140| 3.09k| void shrinkToFit(Allocator* allocator) { 141| 3.09k| if (count_ > 0) ------------------ | Branch (141:9): [True: 703, False: 2.39k] ------------------ 142| 703| pools_[count_ - 1].shrinkToFit(allocator); 143| 3.09k| if (pools_ != preallocatedPools_ && count_ != capacity_) { ------------------ | Branch (143:9): [True: 0, False: 3.09k] | 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) ------------------ | Branch (146:7): [True: 0, False: 0] ------------------ 147| 0| capacity_ = count_; 148| 0| } 149| 3.09k| } _ZN11ArduinoJson8V742HB426detail15ResourceManagerC2EPNS0_9AllocatorE: 22| 3.09k| : allocator_(allocator), overflowed_(false) {} _ZN11ArduinoJson8V742HB426detail15ResourceManagerD2Ev: 24| 3.09k| ~ResourceManager() { 25| 3.09k| stringPool_.clear(allocator_); 26| 3.09k| variantPools_.clear(allocator_); 27| 3.09k|#if ARDUINOJSON_USE_8_BYTE_POOL 28| 3.09k| eightBytePools_.clear(allocator_); 29| 3.09k|#endif 30| 3.09k| } _ZNK11ArduinoJson8V742HB426detail15ResourceManager12getEightByteEj: 91| 4.46k| EightByteValue* getEightByte(SlotId id) const { 92| 4.46k| return eightBytePools_.getSlot(id); 93| 4.46k| } _ZNK11ArduinoJson8V742HB426detail15ResourceManager10getVariantEj: 72| 118k| VariantData* getVariant(SlotId id) const { 73| 118k| return reinterpret_cast(variantPools_.getSlot(id)); 74| 118k| } _ZN11ArduinoJson8V742HB426detail15ResourceManager5clearEv: 139| 3.09k| void clear() { 140| 3.09k| variantPools_.clear(allocator_); 141| 3.09k| overflowed_ = false; 142| 3.09k| stringPool_.clear(allocator_); 143| 3.09k|#if ARDUINOJSON_USE_8_BYTE_POOL 144| 3.09k| eightBytePools_.clear(allocator_); 145| 3.09k|#endif 146| 3.09k| } _ZN11ArduinoJson8V742HB426detail15ResourceManager13destroyStringEPNS1_10StringNodeE: 131| 1.10k| void destroyString(StringNode* node) { 132| 1.10k| StringNode::destroy(node, allocator_); 133| 1.10k| } _ZN11ArduinoJson8V742HB426detail15ResourceManager12allocVariantEv: 57| 83.8k| Slot allocVariant() { 58| 83.8k| auto slot = variantPools_.allocSlot(allocator_); 59| 83.8k| if (!slot) { ------------------ | Branch (59:9): [True: 0, False: 83.8k] ------------------ 60| 0| overflowed_ = true; 61| 0| return {}; 62| 0| } 63| 83.8k| new (slot.ptr()) VariantData(); 64| 83.8k| return slot; 65| 83.8k| } _ZN11ArduinoJson8V742HB426detail15ResourceManager12createStringEm: 117| 3.03k| StringNode* createString(size_t length) { 118| 3.03k| auto node = StringNode::create(length, allocator_); 119| 3.03k| if (!node) ------------------ | Branch (119:9): [True: 0, False: 3.03k] ------------------ 120| 0| overflowed_ = true; 121| 3.03k| return node; 122| 3.03k| } _ZN11ArduinoJson8V742HB426detail15ResourceManager12resizeStringEPNS1_10StringNodeEm: 124| 2.71k| StringNode* resizeString(StringNode* node, size_t length) { 125| 2.71k| node = StringNode::resize(node, length, allocator_); 126| 2.71k| if (!node) ------------------ | Branch (126:9): [True: 0, False: 2.71k] ------------------ 127| 0| overflowed_ = true; 128| 2.71k| return node; 129| 2.71k| } _ZNK11ArduinoJson8V742HB426detail15ResourceManager9getStringINS1_9RamStringEEEPNS1_10StringNodeERKT_: 113| 2.26k| StringNode* getString(const TAdaptedString& str) const { 114| 2.26k| return stringPool_.get(str); 115| 2.26k| } _ZN11ArduinoJson8V742HB426detail15ResourceManager10saveStringEPNS1_10StringNodeE: 108| 1.92k| void saveString(StringNode* node) { 109| 1.92k| stringPool_.add(node); 110| 1.92k| } _ZN11ArduinoJson8V742HB426detail15ResourceManager17dereferenceStringEPKc: 135| 1.01k| void dereferenceString(const char* s) { 136| 1.01k| stringPool_.dereference(s, allocator_); 137| 1.01k| } _ZN11ArduinoJson8V742HB426detail15ResourceManager13freeEightByteEj: 86| 2.23k| void freeEightByte(SlotId id) { 87| 2.23k| auto p = getEightByte(id); 88| 2.23k| eightBytePools_.freeSlot({p, id}); 89| 2.23k| } _ZN11ArduinoJson8V742HB426detail15ResourceManager11freeVariantENS1_4SlotINS1_11VariantDataEEE: 67| 4.63k| void freeVariant(Slot slot) { 68| 4.63k| ARDUINOJSON_ASSERT(slot->type == VariantType::Null); ------------------ | | 11| 4.63k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ | Branch (68:5): [True: 4.63k, False: 0] ------------------ 69| 4.63k| variantPools_.freeSlot(slot); 70| 4.63k| } _ZN11ArduinoJson8V742HB426detail15ResourceManager14allocEightByteEv: 77| 9.56k| Slot allocEightByte() { 78| 9.56k| auto slot = eightBytePools_.allocSlot(allocator_); 79| 9.56k| if (!slot) { ------------------ | Branch (79:9): [True: 0, False: 9.56k] ------------------ 80| 0| overflowed_ = true; 81| 0| return {}; 82| 0| } 83| 9.56k| return slot; 84| 9.56k| } _ZN11ArduinoJson8V742HB426detail15ResourceManager11shrinkToFitEv: 148| 3.09k| void shrinkToFit() { 149| 3.09k| variantPools_.shrinkToFit(allocator_); 150| 3.09k|#if ARDUINOJSON_USE_8_BYTE_POOL 151| 3.09k| eightBytePools_.shrinkToFit(allocator_); 152| 3.09k|#endif 153| 3.09k| } _ZN11ArduinoJson8V742HB426detail13StringBuilderC2EPNS1_15ResourceManagerE: 16| 3.09k| StringBuilder(ResourceManager* resources) : resources_(resources) {} _ZN11ArduinoJson8V742HB426detail13StringBuilderD2Ev: 18| 3.09k| ~StringBuilder() { 19| 3.09k| if (node_) ------------------ | Branch (19:9): [True: 1.10k, False: 1.99k] ------------------ 20| 1.10k| resources_->destroyString(node_); 21| 3.09k| } _ZN11ArduinoJson8V742HB426detail13StringBuilder11startStringEv: 23| 9.46k| void startString() { 24| 9.46k| size_ = 0; 25| 9.46k| if (!node_) ------------------ | Branch (25:9): [True: 3.03k, False: 6.43k] ------------------ 26| 3.03k| node_ = resources_->createString(initialCapacity); 27| 9.46k| } _ZN11ArduinoJson8V742HB426detail13StringBuilder6appendEc: 62| 97.0k| void append(char c) { 63| 97.0k| if (node_ && size_ == node_->length) ------------------ | Branch (63:9): [True: 97.0k, False: 0] | Branch (63:18): [True: 790, False: 96.2k] ------------------ 64| 790| node_ = resources_->resizeString(node_, size_ * 2U + 1); 65| 97.0k| if (node_) ------------------ | Branch (65:9): [True: 97.0k, False: 0] ------------------ 66| 97.0k| node_->data[size_++] = c; 67| 97.0k| } _ZNK11ArduinoJson8V742HB426detail13StringBuilder7isValidEv: 69| 9.04k| bool isValid() const { 70| 9.04k| return node_ != nullptr; 71| 9.04k| } _ZNK11ArduinoJson8V742HB426detail13StringBuilder3strEv: 77| 6.33k| JsonString str() const { 78| 6.33k| ARDUINOJSON_ASSERT(node_ != nullptr); ------------------ | | 11| 6.33k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ | Branch (78:5): [True: 6.33k, False: 0] ------------------ 79| 6.33k| node_->data[size_] = 0; 80| 6.33k| return JsonString(node_->data, size_); 81| 6.33k| } _ZN11ArduinoJson8V742HB426detail13StringBuilder4saveEPNS1_11VariantDataE: 29| 7.17k| void save(VariantData* variant) { 30| 7.17k| ARDUINOJSON_ASSERT(variant != nullptr); ------------------ | | 11| 7.17k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ | Branch (30:5): [True: 7.17k, False: 0] ------------------ 31| 7.17k| ARDUINOJSON_ASSERT(node_ != nullptr); ------------------ | | 11| 7.17k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ | Branch (31:5): [True: 7.17k, False: 0] ------------------ 32| | 33| 7.17k| char* p = node_->data; 34| 7.17k| if (isTinyString(p, size_)) { ------------------ | Branch (34:9): [True: 4.91k, False: 2.26k] ------------------ 35| 4.91k| variant->setTinyString(adaptString(p, size_)); 36| 4.91k| return; 37| 4.91k| } 38| | 39| 2.26k| p[size_] = 0; 40| 2.26k| StringNode* node = resources_->getString(adaptString(p, size_)); 41| 2.26k| if (!node) { ------------------ | Branch (41:9): [True: 1.92k, False: 336] ------------------ 42| 1.92k| node = resources_->resizeString(node_, size_); 43| 1.92k| ARDUINOJSON_ASSERT(node != nullptr); // realloc to smaller can't fail ------------------ | | 11| 1.92k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ | Branch (43:7): [True: 1.92k, False: 0] ------------------ 44| 1.92k| resources_->saveString(node); 45| 1.92k| node_ = nullptr; // next time we need a new string 46| 1.92k| } else { 47| 336| node->references++; 48| 336| } 49| 2.26k| variant->setLongString(node); 50| 2.26k| } _ZN11ArduinoJson8V742HB426detail10StringNode7destroyEPS2_PNS0_9AllocatorE: 65| 3.03k| static void destroy(StringNode* node, Allocator* allocator) { 66| 3.03k| allocator->deallocate(node); 67| 3.03k| } _ZN11ArduinoJson8V742HB426detail10StringNode6createEmPNS0_9AllocatorE: 35| 3.03k| static StringNode* create(size_t length, Allocator* allocator) { 36| 3.03k| if (length > maxLength) ------------------ | Branch (36:9): [True: 0, False: 3.03k] ------------------ 37| 0| return nullptr; 38| 3.03k| auto size = sizeForLength(length); 39| 3.03k| if (size < length) // integer overflow ------------------ | Branch (39:9): [True: 0, False: 3.03k] ------------------ 40| 0| return nullptr; // (not testable on 64-bit) 41| 3.03k| auto node = reinterpret_cast(allocator->allocate(size)); 42| 3.03k| if (node) { ------------------ | Branch (42:9): [True: 3.03k, False: 0] ------------------ 43| 3.03k| node->length = length_type(length); 44| 3.03k| node->references = 1; 45| 3.03k| } 46| 3.03k| return node; 47| 3.03k| } _ZN11ArduinoJson8V742HB426detail10StringNode13sizeForLengthEm: 31| 5.75k| static constexpr size_t sizeForLength(size_t n) { 32| | return n + 1 + offsetof(StringNode, data); 33| 5.75k| } _ZN11ArduinoJson8V742HB426detail10StringNode6resizeEPS2_mPNS0_9AllocatorE: 50| 2.71k| Allocator* allocator) { 51| 2.71k| ARDUINOJSON_ASSERT(node != nullptr); ------------------ | | 11| 2.71k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ | Branch (51:5): [True: 2.71k, False: 0] ------------------ 52| 2.71k| StringNode* newNode; 53| 2.71k| if (length <= maxLength) ------------------ | Branch (53:9): [True: 2.71k, False: 0] ------------------ 54| 2.71k| newNode = reinterpret_cast( 55| 2.71k| allocator->reallocate(node, sizeForLength(length))); 56| 0| else 57| 0| newNode = nullptr; 58| 2.71k| if (newNode) ------------------ | Branch (58:9): [True: 2.71k, False: 0] ------------------ 59| 2.71k| newNode->length = length_type(length); 60| 0| else 61| 0| allocator->deallocate(node); 62| 2.71k| return newNode; 63| 2.71k| } _ZN11ArduinoJson8V742HB426detail10StringPoolC2Ev: 17| 3.09k| StringPool() = default; _ZN11ArduinoJson8V742HB426detail10StringPool5clearEPNS0_9AllocatorE: 29| 6.19k| void clear(Allocator* allocator) { 30| 7.30k| while (strings_) { ------------------ | Branch (30:12): [True: 1.11k, False: 6.19k] ------------------ 31| 1.11k| auto node = strings_; 32| 1.11k| strings_ = node->next; 33| 1.11k| StringNode::destroy(node, allocator); 34| 1.11k| } 35| 6.19k| } _ZN11ArduinoJson8V742HB426detail10StringPoolD2Ev: 21| 3.09k| ~StringPool() { 22| | ARDUINOJSON_ASSERT(strings_ == nullptr); ------------------ | | 11| 3.09k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ | Branch (22:5): [True: 3.09k, False: 0] ------------------ 23| 3.09k| } _ZNK11ArduinoJson8V742HB426detail10StringPool3getINS1_9RamStringEEEPNS1_10StringNodeERKT_: 73| 2.26k| StringNode* get(const TAdaptedString& str) const { 74| 31.1k| for (auto node = strings_; node; node = node->next) { ------------------ | Branch (74:32): [True: 29.1k, False: 1.92k] ------------------ 75| 29.1k| if (stringEquals(str, adaptString(node->data, node->length))) ------------------ | Branch (75:11): [True: 336, False: 28.8k] ------------------ 76| 336| return node; 77| 29.1k| } 78| 1.92k| return nullptr; 79| 2.26k| } _ZN11ArduinoJson8V742HB426detail10StringPool3addEPNS1_10StringNodeE: 66| 1.92k| void add(StringNode* node) { 67| 1.92k| ARDUINOJSON_ASSERT(node != nullptr); ------------------ | | 11| 1.92k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ | Branch (67:5): [True: 1.92k, False: 0] ------------------ 68| 1.92k| node->next = strings_; 69| 1.92k| strings_ = node; 70| 1.92k| } _ZN11ArduinoJson8V742HB426detail10StringPool11dereferenceEPKcPNS0_9AllocatorE: 81| 1.01k| void dereference(const char* s, Allocator* allocator) { 82| 1.01k| StringNode* prev = nullptr; 83| 5.27k| for (auto node = strings_; node; node = node->next) { ------------------ | Branch (83:32): [True: 5.27k, False: 0] ------------------ 84| 5.27k| if (node->data == s) { ------------------ | Branch (84:11): [True: 1.01k, False: 4.26k] ------------------ 85| 1.01k| if (--node->references == 0) { ------------------ | Branch (85:13): [True: 818, False: 195] ------------------ 86| 818| if (prev) ------------------ | Branch (86:15): [True: 550, False: 268] ------------------ 87| 550| prev->next = node->next; 88| 268| else 89| 268| strings_ = node->next; 90| 818| StringNode::destroy(node, allocator); 91| 818| } 92| 1.01k| return; 93| 1.01k| } 94| 4.26k| prev = node; 95| 4.26k| } 96| 1.01k| } _ZN11ArduinoJson8V742HB426detail14decomposeFloatEda: 56| 5.69k|inline FloatParts decomposeFloat(JsonFloat value, int8_t decimalPlaces) { 57| 5.69k| uint32_t maxDecimalPart = pow10(decimalPlaces); 58| | 59| 5.69k| int16_t exponent = normalize(value); 60| | 61| 5.69k| uint32_t integral = uint32_t(value); 62| | // reduce number of decimal places by the number of integral places 63| 7.91k| for (uint32_t tmp = integral; tmp >= 10; tmp /= 10) { ------------------ | Branch (63:33): [True: 2.22k, False: 5.69k] ------------------ 64| 2.22k| maxDecimalPart /= 10; 65| 2.22k| decimalPlaces--; 66| 2.22k| } 67| | 68| 5.69k| JsonFloat remainder = 69| 5.69k| (value - JsonFloat(integral)) * JsonFloat(maxDecimalPart); 70| | 71| 5.69k| uint32_t decimal = uint32_t(remainder); 72| 5.69k| remainder = remainder - JsonFloat(decimal); 73| | 74| | // rounding: 75| | // increment by 1 if remainder >= 0.5 76| 5.69k| decimal += uint32_t(remainder * 2); 77| 5.69k| if (decimal >= maxDecimalPart) { ------------------ | Branch (77:7): [True: 786, False: 4.90k] ------------------ 78| 786| decimal = 0; 79| 786| integral++; 80| 786| if (exponent && integral >= 10) { ------------------ | Branch (80:9): [True: 592, False: 194] | Branch (80:21): [True: 326, False: 266] ------------------ 81| 326| exponent++; 82| 326| integral = 1; 83| 326| } 84| 786| } 85| | 86| | // remove trailing zeros 87| 40.0k| while (decimal % 10 == 0 && decimalPlaces > 0) { ------------------ | Branch (87:10): [True: 39.5k, False: 443] | Branch (87:31): [True: 34.3k, False: 5.24k] ------------------ 88| 34.3k| decimal /= 10; 89| 34.3k| decimalPlaces--; 90| 34.3k| } 91| | 92| 5.69k| return {integral, decimal, exponent, decimalPlaces}; 93| 5.69k|} _ZN11ArduinoJson8V742HB426detail5pow10Ei: 52| 43.9k|constexpr uint32_t pow10(int exponent) { 53| 43.9k| return (exponent == 0) ? 1 : 10 * pow10(exponent - 1); ------------------ | Branch (53:10): [True: 5.69k, False: 38.2k] ------------------ 54| 43.9k|} _ZN11ArduinoJson8V742HB426detail9normalizeIdEEsRT_: 22| 5.69k|inline int16_t normalize(TFloat& value) { 23| 5.69k| using traits = FloatTraits; 24| 5.69k| int16_t powersOf10 = 0; 25| | 26| 5.69k| int8_t index = sizeof(TFloat) == 8 ? 8 : 5; ------------------ | Branch (26:18): [True: 5.69k, Folded] ------------------ 27| 5.69k| int bit = 1 << index; 28| | 29| 5.69k| if (value >= ARDUINOJSON_POSITIVE_EXPONENTIATION_THRESHOLD) { ------------------ | | 232| 5.69k|# define ARDUINOJSON_POSITIVE_EXPONENTIATION_THRESHOLD 1e7 ------------------ | Branch (29:7): [True: 1.55k, False: 4.13k] ------------------ 30| 15.5k| for (; index >= 0; index--) { ------------------ | Branch (30:12): [True: 13.9k, False: 1.55k] ------------------ 31| 13.9k| if (value >= traits::positiveBinaryPowersOfTen()[uint8_t(index)]) { ------------------ | Branch (31:11): [True: 6.14k, False: 7.85k] ------------------ 32| 6.14k| value *= traits::negativeBinaryPowersOfTen()[uint8_t(index)]; 33| 6.14k| powersOf10 = int16_t(powersOf10 + bit); 34| 6.14k| } 35| 13.9k| bit >>= 1; 36| 13.9k| } 37| 1.55k| } 38| | 39| 5.69k| if (value > 0 && value <= ARDUINOJSON_NEGATIVE_EXPONENTIATION_THRESHOLD) { ------------------ | | 238| 3.04k|# define ARDUINOJSON_NEGATIVE_EXPONENTIATION_THRESHOLD 1e-5 ------------------ | Branch (39:7): [True: 3.04k, False: 2.65k] | Branch (39:20): [True: 540, False: 2.50k] ------------------ 40| 5.40k| for (; index >= 0; index--) { ------------------ | Branch (40:12): [True: 4.86k, False: 540] ------------------ 41| 4.86k| if (value < traits::negativeBinaryPowersOfTen()[uint8_t(index)] * 10) { ------------------ | Branch (41:11): [True: 1.08k, False: 3.77k] ------------------ 42| 1.08k| value *= traits::positiveBinaryPowersOfTen()[uint8_t(index)]; 43| 1.08k| powersOf10 = int16_t(powersOf10 - bit); 44| 1.08k| } 45| 4.86k| bit >>= 1; 46| 4.86k| } 47| 540| } 48| | 49| 5.69k| return powersOf10; 50| 5.69k|} _ZN11ArduinoJson8V742HB426detail11FloatTraitsIdLm8EE25positiveBinaryPowersOfTenEv: 32| 23.7k| static pgm_array positiveBinaryPowersOfTen() { 33| 23.7k| ARDUINOJSON_DEFINE_PROGMEM_ARRAY( // ------------------ | | 45| 23.7k| static type const name[] = __VA_ARGS__; ------------------ 34| 23.7k| uint64_t, factors, 35| 23.7k| { 36| 23.7k| 0x4024000000000000, // 1e1 37| 23.7k| 0x4059000000000000, // 1e2 38| 23.7k| 0x40C3880000000000, // 1e4 39| 23.7k| 0x4197D78400000000, // 1e8 40| 23.7k| 0x4341C37937E08000, // 1e16 41| 23.7k| 0x4693B8B5B5056E17, // 1e32 42| 23.7k| 0x4D384F03E93FF9F5, // 1e64 43| 23.7k| 0x5A827748F9301D32, // 1e128 44| 23.7k| 0x75154FDD7F73BF3C, // 1e256 45| 23.7k| }); 46| 23.7k| return pgm_array(reinterpret_cast(factors)); 47| 23.7k| } _ZN11ArduinoJson8V742HB426detail11FloatTraitsIdLm8EE25negativeBinaryPowersOfTenEv: 49| 11.7k| static pgm_array negativeBinaryPowersOfTen() { 50| 11.7k| ARDUINOJSON_DEFINE_PROGMEM_ARRAY( // ------------------ | | 45| 11.7k| static type const name[] = __VA_ARGS__; ------------------ 51| 11.7k| uint64_t, factors, 52| 11.7k| { 53| 11.7k| 0x3FB999999999999A, // 1e-1 54| 11.7k| 0x3F847AE147AE147B, // 1e-2 55| 11.7k| 0x3F1A36E2EB1C432D, // 1e-4 56| 11.7k| 0x3E45798EE2308C3A, // 1e-8 57| 11.7k| 0x3C9CD2B297D889BC, // 1e-16 58| 11.7k| 0x3949F623D5A8A733, // 1e-32 59| 11.7k| 0x32A50FFD44F4A73D, // 1e-64 60| 11.7k| 0x255BBA08CF8C979D, // 1e-128 61| 11.7k| 0x0AC8062864AC6F43 // 1e-256 62| 11.7k| }); 63| 11.7k| return pgm_array(reinterpret_cast(factors)); 64| 11.7k| } _ZN11ArduinoJson8V742HB426detail11FloatTraitsIdLm8EE3infEv: 70| 394| static T inf() { 71| 394| return forge(0x7ff0000000000000); 72| 394| } _ZN11ArduinoJson8V742HB426detail11FloatTraitsIdLm8EE5forgeEm: 101| 394| static T forge(uint64_t bits) { 102| 394| return alias_cast(bits); 103| 394| } _ZN11ArduinoJson8V742HB426detail20multiplyByPowerOfTenIdiEET_S3_T0_: 197| 9.39k|inline TFloat multiplyByPowerOfTen(TFloat m, TExponent e) { 198| 9.39k| using traits = FloatTraits; 199| | 200| 9.39k| auto powersOfTen = e > 0 ? traits::positiveBinaryPowersOfTen() ------------------ | Branch (200:22): [True: 8.66k, False: 736] ------------------ 201| 9.39k| : traits::negativeBinaryPowersOfTen(); 202| | 203| 9.39k| if (e <= 0) ------------------ | Branch (203:7): [True: 736, False: 8.66k] ------------------ 204| 736| e = TExponent(-e); 205| | 206| 61.6k| for (uint8_t index = 0; e != 0; index++) { ------------------ | Branch (206:27): [True: 52.2k, False: 9.39k] ------------------ 207| 52.2k| if (index >= powersOfTen.size()) ------------------ | Branch (207:9): [True: 0, False: 52.2k] ------------------ 208| 0| return traits::nan(); 209| 52.2k| if (e & 1) ------------------ | Branch (209:9): [True: 36.0k, False: 16.2k] ------------------ 210| 36.0k| m *= powersOfTen[index]; 211| 52.2k| e >>= 1; 212| 52.2k| } 213| 9.39k| return m; 214| 9.39k|} _ZN11ArduinoJson8V742HB426detail20multiplyByPowerOfTenIfiEET_S3_T0_: 197| 48.3k|inline TFloat multiplyByPowerOfTen(TFloat m, TExponent e) { 198| 48.3k| using traits = FloatTraits; 199| | 200| 48.3k| auto powersOfTen = e > 0 ? traits::positiveBinaryPowersOfTen() ------------------ | Branch (200:22): [True: 853, False: 47.4k] ------------------ 201| 48.3k| : traits::negativeBinaryPowersOfTen(); 202| | 203| 48.3k| if (e <= 0) ------------------ | Branch (203:7): [True: 47.4k, False: 853] ------------------ 204| 47.4k| e = TExponent(-e); 205| | 206| 54.0k| for (uint8_t index = 0; e != 0; index++) { ------------------ | Branch (206:27): [True: 5.74k, False: 48.3k] ------------------ 207| 5.74k| if (index >= powersOfTen.size()) ------------------ | Branch (207:9): [True: 0, False: 5.74k] ------------------ 208| 0| return traits::nan(); 209| 5.74k| if (e & 1) ------------------ | Branch (209:9): [True: 2.64k, False: 3.10k] ------------------ 210| 2.64k| m *= powersOfTen[index]; 211| 5.74k| e >>= 1; 212| 5.74k| } 213| 48.3k| return m; 214| 48.3k|} _ZN11ArduinoJson8V742HB426detail11FloatTraitsIfLm4EE25positiveBinaryPowersOfTenEv: 116| 853| static pgm_array positiveBinaryPowersOfTen() { 117| 853| ARDUINOJSON_DEFINE_PROGMEM_ARRAY(uint32_t, factors, ------------------ | | 45| 853| static type const name[] = __VA_ARGS__; ------------------ 118| 853| { 119| 853| 0x41200000, // 1e1f 120| 853| 0x42c80000, // 1e2f 121| 853| 0x461c4000, // 1e4f 122| 853| 0x4cbebc20, // 1e8f 123| 853| 0x5a0e1bca, // 1e16f 124| 853| 0x749dc5ae // 1e32f 125| 853| }); 126| 853| return pgm_array(reinterpret_cast(factors)); 127| 853| } _ZN11ArduinoJson8V742HB426detail11FloatTraitsIfLm4EE25negativeBinaryPowersOfTenEv: 129| 47.4k| static pgm_array negativeBinaryPowersOfTen() { 130| 47.4k| ARDUINOJSON_DEFINE_PROGMEM_ARRAY(uint32_t, factors, ------------------ | | 45| 47.4k| static type const name[] = __VA_ARGS__; ------------------ 131| 47.4k| { 132| 47.4k| 0x3dcccccd, // 1e-1f 133| 47.4k| 0x3c23d70a, // 1e-2f 134| 47.4k| 0x38d1b717, // 1e-4f 135| 47.4k| 0x322bcc77, // 1e-8f 136| 47.4k| 0x24e69595, // 1e-16f 137| 47.4k| 0x0a4fb11f // 1e-32f 138| 47.4k| }); 139| 47.4k| return pgm_array(reinterpret_cast(factors)); 140| 47.4k| } _ZN11ArduinoJson8V742HB426detail16canConvertNumberIjmEENS1_9enable_ifIXaaaaaasr11is_integralIT0_EE5valuesr11is_unsignedIS4_EE5valuesr11is_integralIT_EE5valuelestS5_stS4_EbE4typeES4_: 28| 10.7k|canConvertNumber(TIn value) { 29| 10.7k| return value <= TIn(numeric_limits::highest()); 30| 10.7k|} _ZN11ArduinoJson8V742HB426detail16canConvertNumberIilEENS1_9enable_ifIXaaaaaaaasr11is_integralIT0_EE5valuesr9is_signedIS4_EE5valuesr11is_integralIT_EE5valuesr9is_signedIS5_EE5valueltstS5_stS4_EbE4typeES4_: 55| 1.27k|canConvertNumber(TIn value) { 56| 1.27k| return value >= TIn(numeric_limits::lowest()) && ------------------ | Branch (56:10): [True: 745, False: 534] ------------------ 57| 745| value <= TIn(numeric_limits::highest()); ------------------ | Branch (57:10): [True: 745, False: 0] ------------------ 58| 1.27k|} _ZN11ArduinoJson8V742HB426detail11parseNumberEPKc: 105| 70.5k|inline Number parseNumber(const char* s) { 106| 70.5k| using traits = FloatTraits; 107| 70.5k| using mantissa_t = largest_type; 108| 70.5k| using exponent_t = traits::exponent_type; 109| | 110| 70.5k| ARDUINOJSON_ASSERT(s != 0); ------------------ | | 11| 70.5k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ | Branch (110:3): [True: 70.5k, False: 0] ------------------ 111| | 112| 70.5k| bool is_negative = false; 113| 70.5k| switch (*s) { ------------------ | Branch (113:11): [True: 2.47k, False: 68.0k] ------------------ 114| 2.27k| case '-': ------------------ | Branch (114:5): [True: 2.27k, False: 68.2k] ------------------ 115| 2.27k| is_negative = true; 116| 2.27k| s++; 117| 2.27k| break; 118| 203| case '+': ------------------ | Branch (118:5): [True: 203, False: 70.3k] ------------------ 119| 203| s++; 120| 203| break; 121| 70.5k| } 122| | 123| |#if ARDUINOJSON_ENABLE_NAN 124| | if (*s == 'n' || *s == 'N') { 125| | return Number(traits::nan()); 126| | } 127| |#endif 128| | 129| |#if ARDUINOJSON_ENABLE_INFINITY 130| | if (*s == 'i' || *s == 'I') { 131| | return Number(is_negative ? -traits::inf() : traits::inf()); 132| | } 133| |#endif 134| | 135| 70.5k| if (!isdigit(*s) && *s != '.') ------------------ | Branch (135:7): [True: 46.0k, False: 24.5k] | Branch (135:23): [True: 135, False: 45.8k] ------------------ 136| 135| return Number(); 137| | 138| 70.4k| mantissa_t mantissa = 0; 139| 70.4k| exponent_t exponent_offset = 0; 140| 70.4k| const mantissa_t maxUint = JsonUInt(-1); 141| | 142| 127k| while (isdigit(*s)) { ------------------ | Branch (142:10): [True: 57.8k, False: 69.9k] ------------------ 143| 57.8k| uint8_t digit = uint8_t(*s - '0'); 144| 57.8k| if (mantissa > maxUint / 10) ------------------ | Branch (144:9): [True: 283, False: 57.5k] ------------------ 145| 283| break; 146| 57.5k| mantissa *= 10; 147| 57.5k| if (mantissa > maxUint - digit) ------------------ | Branch (147:9): [True: 194, False: 57.3k] ------------------ 148| 194| break; 149| 57.3k| mantissa += digit; 150| 57.3k| s++; 151| 57.3k| } 152| | 153| 70.4k| if (*s == '\0') { ------------------ | Branch (153:7): [True: 12.2k, False: 58.1k] ------------------ 154| 12.2k| if (is_negative) { ------------------ | Branch (154:9): [True: 1.47k, False: 10.7k] ------------------ 155| 1.47k| const mantissa_t sintMantissaMax = mantissa_t(1) 156| 1.47k| << (sizeof(JsonInteger) * 8 - 1); 157| 1.47k| if (mantissa <= sintMantissaMax) { ------------------ | Branch (157:11): [True: 1.27k, False: 195] ------------------ 158| 1.27k| return Number(JsonInteger(~mantissa + 1)); 159| 1.27k| } 160| 10.7k| } else { 161| 10.7k| return Number(JsonUInt(mantissa)); 162| 10.7k| } 163| 12.2k| } 164| | 165| | // avoid mantissa overflow 166| 61.2k| while (mantissa > traits::mantissa_max) { ------------------ | Branch (166:10): [True: 2.91k, False: 58.3k] ------------------ 167| 2.91k| mantissa /= 10; 168| 2.91k| exponent_offset++; 169| 2.91k| } 170| | 171| | // remaing digits can't fit in the mantissa 172| 59.0k| while (isdigit(*s)) { ------------------ | Branch (172:10): [True: 737, False: 58.3k] ------------------ 173| 737| exponent_offset++; 174| 737| s++; 175| 737| } 176| | 177| 58.3k| if (*s == '.') { ------------------ | Branch (177:7): [True: 46.3k, False: 11.9k] ------------------ 178| 46.3k| s++; 179| 47.4k| while (isdigit(*s)) { ------------------ | Branch (179:12): [True: 1.10k, False: 46.3k] ------------------ 180| 1.10k| if (mantissa < traits::mantissa_max / 10) { ------------------ | Branch (180:11): [True: 912, False: 194] ------------------ 181| 912| mantissa = mantissa * 10 + uint8_t(*s - '0'); 182| 912| exponent_offset--; 183| 912| } 184| 1.10k| s++; 185| 1.10k| } 186| 46.3k| } 187| | 188| 58.3k| int exponent = 0; 189| 58.3k| if (*s == 'e' || *s == 'E') { ------------------ | Branch (189:7): [True: 1.41k, False: 56.9k] | Branch (189:20): [True: 9.91k, False: 47.0k] ------------------ 190| 11.3k| s++; 191| 11.3k| bool negative_exponent = false; 192| 11.3k| if (*s == '-') { ------------------ | Branch (192:9): [True: 1.12k, False: 10.2k] ------------------ 193| 1.12k| negative_exponent = true; 194| 1.12k| s++; 195| 10.2k| } else if (*s == '+') { ------------------ | Branch (195:16): [True: 194, False: 10.0k] ------------------ 196| 194| s++; 197| 194| } 198| | 199| 30.5k| while (isdigit(*s)) { ------------------ | Branch (199:12): [True: 19.8k, False: 10.7k] ------------------ 200| 19.8k| exponent = exponent * 10 + (*s - '0'); 201| 19.8k| if (exponent + exponent_offset > traits::exponent_max) { ------------------ | Branch (201:11): [True: 590, False: 19.2k] ------------------ 202| 590| if (negative_exponent) ------------------ | Branch (202:13): [True: 196, False: 394] ------------------ 203| 196| return Number(is_negative ? -0.0f : 0.0f); ------------------ | Branch (203:25): [True: 2, False: 194] ------------------ 204| 394| else 205| 394| return Number(is_negative ? -traits::inf() : traits::inf()); ------------------ | Branch (205:25): [True: 194, False: 200] ------------------ 206| 590| } 207| 19.2k| s++; 208| 19.2k| } 209| 10.7k| if (negative_exponent) ------------------ | Branch (209:9): [True: 933, False: 9.80k] ------------------ 210| 933| exponent = -exponent; 211| 10.7k| } 212| 57.7k| exponent += exponent_offset; 213| | 214| | // we should be at the end of the string, otherwise it's an error 215| 57.7k| if (*s != '\0') ------------------ | Branch (215:7): [True: 42, False: 57.7k] ------------------ 216| 42| return Number(); 217| | 218| 57.7k|#if ARDUINOJSON_USE_DOUBLE 219| 57.7k| bool isDouble = exponent < -FloatTraits::exponent_max || ------------------ | Branch (219:19): [True: 239, False: 57.4k] ------------------ 220| 57.4k| exponent > FloatTraits::exponent_max || ------------------ | Branch (220:19): [True: 7.78k, False: 49.6k] ------------------ 221| 49.6k| mantissa > FloatTraits::mantissa_max; ------------------ | Branch (221:19): [True: 1.37k, False: 48.3k] ------------------ 222| 57.7k| if (isDouble) { ------------------ | Branch (222:7): [True: 9.39k, False: 48.3k] ------------------ 223| 9.39k| auto final_result = multiplyByPowerOfTen(double(mantissa), exponent); 224| 9.39k| return Number(is_negative ? -final_result : final_result); ------------------ | Branch (224:19): [True: 392, False: 9.00k] ------------------ 225| 9.39k| } else 226| 48.3k|#endif 227| 48.3k| { 228| 48.3k| auto final_result = multiplyByPowerOfTen(float(mantissa), exponent); 229| 48.3k| return Number(is_negative ? -final_result : final_result); ------------------ | Branch (229:19): [True: 388, False: 47.9k] ------------------ 230| 48.3k| } 231| 57.7k|} _ZN11ArduinoJson8V742HB426detail6NumberC2Ev: 52| 177| Number() : type_(NumberType::Invalid) {} _ZN11ArduinoJson8V742HB426detail11NumberValueC2Ev: 31| 177| NumberValue() {} _ZN11ArduinoJson8V742HB426detail6NumberC2El: 54| 1.27k| Number(JsonInteger value) : type_(NumberType::SignedInteger), value_(value) {} _ZN11ArduinoJson8V742HB426detail11NumberValueC2El: 33| 1.27k| NumberValue(JsonInteger x) : asSignedInteger(x) {} _ZN11ArduinoJson8V742HB426detail6NumberC2Em: 55| 10.7k| Number(JsonUInt value) : type_(NumberType::UnsignedInteger), value_(value) {} _ZN11ArduinoJson8V742HB426detail11NumberValueC2Em: 34| 10.7k| NumberValue(JsonUInt x) : asUnsignedInteger(x) {} _ZN11ArduinoJson8V742HB426detail6NumberC2Ef: 53| 48.5k| Number(float value) : type_(NumberType::Float), value_(value) {} _ZN11ArduinoJson8V742HB426detail11NumberValueC2Ef: 32| 48.5k| NumberValue(float x) : asFloat(x) {} _ZN11ArduinoJson8V742HB426detail6NumberC2Ed: 57| 9.79k| Number(double value) : type_(NumberType::Double), value_(value) {} _ZN11ArduinoJson8V742HB426detail11NumberValueC2Ed: 36| 9.79k| NumberValue(double x) : asDouble(x) {} _ZNK11ArduinoJson8V742HB426detail6Number4typeEv: 78| 70.5k| NumberType type() const { 79| 70.5k| return type_; 80| 70.5k| } _ZNK11ArduinoJson8V742HB426detail6Number17asUnsignedIntegerEv: 87| 10.7k| JsonUInt asUnsignedInteger() const { 88| 10.7k| ARDUINOJSON_ASSERT(type_ == NumberType::UnsignedInteger); ------------------ | | 11| 10.7k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ | Branch (88:5): [True: 10.7k, False: 0] ------------------ 89| 10.7k| return value_.asUnsignedInteger; 90| 10.7k| } _ZNK11ArduinoJson8V742HB426detail6Number15asSignedIntegerEv: 82| 1.27k| JsonInteger asSignedInteger() const { 83| 1.27k| ARDUINOJSON_ASSERT(type_ == NumberType::SignedInteger); ------------------ | | 11| 1.27k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ | Branch (83:5): [True: 1.27k, False: 0] ------------------ 84| 1.27k| return value_.asSignedInteger; 85| 1.27k| } _ZNK11ArduinoJson8V742HB426detail6Number7asFloatEv: 92| 48.5k| float asFloat() const { 93| 48.5k| ARDUINOJSON_ASSERT(type_ == NumberType::Float); ------------------ | | 11| 48.5k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ | Branch (93:5): [True: 48.5k, False: 0] ------------------ 94| 48.5k| return value_.asFloat; 95| 48.5k| } _ZNK11ArduinoJson8V742HB426detail6Number8asDoubleEv: 98| 9.79k| double asDouble() const { 99| 9.79k| ARDUINOJSON_ASSERT(type_ == NumberType::Double); ------------------ | | 11| 9.79k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ | Branch (99:5): [True: 9.79k, False: 0] ------------------ 100| 9.79k| return value_.asDouble; 101| 9.79k| } _ZN11ArduinoJson8V742HB426detail11VariantImpl9getMemberINS1_9RamStringEEEPNS1_11VariantDataET_S6_PNS1_15ResourceManagerE: 15| 6.33k| ResourceManager* resources) { 16| 6.33k| auto it = findKey(key, data, resources); 17| 6.33k| if (it.done()) ------------------ | Branch (17:7): [True: 4.66k, False: 1.67k] ------------------ 18| 4.66k| return nullptr; 19| 1.67k| it.move(resources); 20| 1.67k| return it.data(); 21| 6.33k|} _ZN11ArduinoJson8V742HB426detail11VariantImpl7findKeyINS1_9RamStringEEENS1_18CollectionIteratorET_PNS1_11VariantDataEPNS1_15ResourceManagerE: 39| 6.33k| ResourceManager* resources) { 40| 6.33k| ARDUINOJSON_ASSERT(data != nullptr); ------------------ | | 11| 6.33k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ | Branch (40:3): [True: 6.33k, False: 0] ------------------ 41| 6.33k| ARDUINOJSON_ASSERT(data->isObject()); ------------------ | | 11| 6.33k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ | Branch (41:3): [True: 6.33k, False: 0] ------------------ 42| 6.33k| ARDUINOJSON_ASSERT(resources != nullptr); ------------------ | | 11| 6.33k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ | Branch (42:3): [True: 6.33k, False: 0] ------------------ 43| | 44| 6.33k| if (key.isNull()) ------------------ | Branch (44:7): [True: 0, False: 6.33k] ------------------ 45| 0| return iterator(); 46| 6.33k| bool isKey = true; 47| 23.9k| for (auto it = createIterator(data, resources); !it.done(); ------------------ | Branch (47:51): [True: 19.3k, False: 4.66k] ------------------ 48| 19.3k| it.move(resources)) { 49| 19.3k| if (isKey && stringEquals(key, adaptString(it->asString()))) ------------------ | Branch (49:9): [True: 10.4k, False: 8.82k] | Branch (49:9): [True: 1.67k, False: 17.6k] | Branch (49:18): [True: 1.67k, False: 8.82k] ------------------ 50| 1.67k| return it; 51| 17.6k| isKey = !isKey; 52| 17.6k| } 53| 4.66k| return iterator(); 54| 6.33k|} _ZN11ArduinoJson8V742HB426detail11VariantImpl7addPairEPPNS1_11VariantDataES4_PNS1_15ResourceManagerE: 84| 4.66k| ResourceManager* resources) { 85| 4.66k| ARDUINOJSON_ASSERT(value != nullptr); ------------------ | | 11| 4.66k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ | Branch (85:3): [True: 4.66k, False: 0] ------------------ 86| 4.66k| ARDUINOJSON_ASSERT(data != nullptr); ------------------ | | 11| 4.66k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ | Branch (86:3): [True: 4.66k, False: 0] ------------------ 87| 4.66k| ARDUINOJSON_ASSERT(data->isObject()); ------------------ | | 11| 4.66k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ | Branch (87:3): [True: 4.66k, False: 0] ------------------ 88| 4.66k| ARDUINOJSON_ASSERT(resources != nullptr); ------------------ | | 11| 4.66k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ | Branch (88:3): [True: 4.66k, False: 0] ------------------ 89| | 90| 4.66k| auto keySlot = resources->allocVariant(); 91| 4.66k| if (!keySlot) ------------------ | Branch (91:7): [True: 0, False: 4.66k] ------------------ 92| 0| return nullptr; 93| | 94| 4.66k| auto valueSlot = resources->allocVariant(); 95| 4.66k| if (!valueSlot) ------------------ | Branch (95:7): [True: 0, False: 4.66k] ------------------ 96| 0| return nullptr; 97| 4.66k| *value = valueSlot.ptr(); 98| | 99| 4.66k| appendPair(keySlot, valueSlot, data, resources); 100| | 101| 4.66k| return keySlot.ptr(); 102| 4.66k|} _ZN11ArduinoJson8V742HB426detail10alias_castIdmEET_T0_: 24| 394|T alias_cast(F raw_data) { 25| 394| alias_cast_t ac; 26| 394| ac.raw = raw_data; 27| 394| return ac.data; 28| 394|} _ZN11ArduinoJson8V742HB426detail7isdigitEc: 12| 335k|inline bool isdigit(char c) { 13| 335k| return '0' <= c && c <= '9'; ------------------ | Branch (13:10): [True: 126k, False: 208k] | Branch (13:22): [True: 104k, False: 22.6k] ------------------ 14| 335k|} _ZN11ArduinoJson8V742HB426detail14numeric_limitsIjvE7highestEv: 25| 10.7k| static constexpr T highest() { 26| 10.7k| return T(-1); 27| 10.7k| } _ZN11ArduinoJson8V742HB426detail14numeric_limitsIivE6lowestEv: 33| 2.02k| static constexpr T lowest() { 34| 2.02k| return T(T(1) << (sizeof(T) * 8 - 1)); 35| 2.02k| } _ZN11ArduinoJson8V742HB426detail14numeric_limitsIivE7highestEv: 36| 745| static constexpr T highest() { 37| 745| return T(~lowest()); 38| 745| } _ZN11ArduinoJson8V742HB426detail5isnanIdEEbT_: 16| 5.88k|bool isnan(T x) { 17| 5.88k| return x != x; 18| 5.88k|} _ZN11ArduinoJson8V742HB426detail5isinfIdEEbT_: 23| 5.88k|bool isinf(T x) { 24| 5.88k| return x != 0.0 && x * 2 == x; ------------------ | Branch (24:10): [True: 3.23k, False: 2.65k] | Branch (24:22): [True: 196, False: 3.04k] ------------------ 25| 5.88k|} _ZN11ArduinoJson8V742HB426detail9pgm_arrayIdLm9EEC2EPKd: 71| 35.4k| explicit pgm_array(const T* ptr) : ptr_(ptr) {} _ZN11ArduinoJson8V742HB426detail7pgm_ptrIdEC2EPKd: 58| 35.4k| explicit pgm_ptr(const T* ptr) : ptr_(ptr) {} _ZNK11ArduinoJson8V742HB426detail9pgm_arrayIdLm9EEixEm: 73| 62.1k| T operator[](size_t index) const { 74| 62.1k| ARDUINOJSON_ASSERT(index < N); ------------------ | | 11| 62.1k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ | Branch (74:5): [True: 62.1k, False: 0] ------------------ 75| 62.1k| return ptr_[intptr_t(index)]; 76| 62.1k| } _ZNK11ArduinoJson8V742HB426detail7pgm_ptrIdEixEl: 60| 62.1k| T operator[](intptr_t index) const { 61| 62.1k| return pgm_read(ptr_ + index); 62| 62.1k| } _ZN11ArduinoJson8V742HB426detail8pgm_readIdEET_PKS3_: 49| 62.1k|inline T pgm_read(const T* p) { 50| 62.1k| return *p; 51| 62.1k|} _ZNK11ArduinoJson8V742HB426detail9pgm_arrayIdLm9EE4sizeEv: 78| 52.2k| size_t size() const { 79| 52.2k| return N; 80| 52.2k| } _ZN11ArduinoJson8V742HB426detail9pgm_arrayIfLm6EEC2EPKf: 71| 48.3k| explicit pgm_array(const T* ptr) : ptr_(ptr) {} _ZN11ArduinoJson8V742HB426detail7pgm_ptrIfEC2EPKf: 58| 48.3k| explicit pgm_ptr(const T* ptr) : ptr_(ptr) {} _ZNK11ArduinoJson8V742HB426detail9pgm_arrayIfLm6EE4sizeEv: 78| 5.74k| size_t size() const { 79| 5.74k| return N; 80| 5.74k| } _ZNK11ArduinoJson8V742HB426detail9pgm_arrayIfLm6EEixEm: 73| 2.64k| T operator[](size_t index) const { 74| 2.64k| ARDUINOJSON_ASSERT(index < N); ------------------ | | 11| 2.64k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ | Branch (74:5): [True: 2.64k, False: 0] ------------------ 75| 2.64k| return ptr_[intptr_t(index)]; 76| 2.64k| } _ZNK11ArduinoJson8V742HB426detail7pgm_ptrIfEixEl: 60| 2.64k| T operator[](intptr_t index) const { 61| 2.64k| return pgm_read(ptr_ + index); 62| 2.64k| } _ZN11ArduinoJson8V742HB426detail8pgm_readIfEET_PKS3_: 49| 2.64k|inline T pgm_read(const T* p) { 50| 2.64k| return *p; 51| 2.64k|} _ZN11ArduinoJson8V742HB426detail7forwardINS0_10JsonStringEEEOT_RNS1_16remove_referenceIS4_E4typeE: 14| 10.4k|T&& forward(remove_reference_t& t) noexcept { 15| 10.4k| return static_cast(t); 16| 10.4k|} _ZN11ArduinoJson8V742HB426detail7forwardIRNS0_10JsonStringEEEOT_RNS1_16remove_referenceIS5_E4typeE: 14| 6.33k|T&& forward(remove_reference_t& t) noexcept { 15| 6.33k| return static_cast(t); 16| 6.33k|} _ZN11ArduinoJson8V742HB426detail7forwardIRNS0_12JsonDocumentEEEOT_RNS1_16remove_referenceIS5_E4typeE: 14| 3.09k|T&& forward(remove_reference_t& t) noexcept { 15| 3.09k| return static_cast(t); 16| 3.09k|} _ZN11ArduinoJson8V742HB426detail7forwardIRmEEOT_RNS1_16remove_referenceIS4_E4typeE: 14| 3.09k|T&& forward(remove_reference_t& t) noexcept { 15| 3.09k| return static_cast(t); 16| 3.09k|} _ZN11ArduinoJson8V742HB426detail17CountingDecoratorINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEEC2ERSB_: 14| 1.21k| explicit CountingDecorator(TWriter& writer) : writer_(writer), count_(0) {} _ZN11ArduinoJson8V742HB426detail17CountingDecoratorINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE5writeEPKhm: 20| 17.6k| void write(const uint8_t* s, size_t n) { 21| 17.6k| count_ += writer_.write(s, n); 22| 17.6k| } _ZNK11ArduinoJson8V742HB426detail17CountingDecoratorINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE5countEv: 24| 18.0k| size_t count() const { 25| 18.0k| return count_; 26| 18.0k| } _ZN11ArduinoJson8V742HB426detail17CountingDecoratorINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE5writeEh: 16| 40.7k| void write(uint8_t c) { 17| 40.7k| count_ += writer_.write(c); 18| 40.7k| } _ZN11ArduinoJson8V742HB426detail6WriterINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEvEC2ERS9_: 24| 1.21k| Writer(TDestination& str) : str_(&str) { 25| 1.21k| str.clear(); 26| 1.21k| } _ZN11ArduinoJson8V742HB426detail6WriterINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEvE5writeEPKhm: 33| 17.6k| size_t write(const uint8_t* s, size_t n) { 34| 17.6k| str_->append(reinterpret_cast(s), n); 35| 17.6k| return n; 36| 17.6k| } _ZN11ArduinoJson8V742HB426detail6WriterINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEvE5writeEh: 28| 40.7k| size_t write(uint8_t c) { 29| 40.7k| str_->push_back(static_cast(c)); 30| 40.7k| return 1; 31| 40.7k| } _ZN11ArduinoJson8V742HB426detail9serializeINS1_14JsonSerializerENSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEmNS0_16JsonVariantConstERT0_: 21| 1.21k| TDestination& destination) { 22| 1.21k| Writer writer(destination); 23| 1.21k| return doSerialize(source, writer); 24| 1.21k|} _ZN11ArduinoJson8V742HB426detail11doSerializeINS1_14JsonSerializerENS1_6WriterINSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEvEEEEmNS0_16JsonVariantConstET0_: 12| 1.21k|size_t doSerialize(ArduinoJson::JsonVariantConst source, TWriter writer) { 13| 1.21k| auto data = VariantAttorney::getData(source); 14| 1.21k| auto resources = VariantAttorney::getResourceManager(source); 15| 1.21k| TSerializer serializer(writer, resources); 16| 1.21k| return VariantImpl::accept(serializer, data, resources); 17| 1.21k|} _ZNK11ArduinoJson8V742HB426detail9RamString4dataEv: 42| 1.25k| const char* data() const { 43| 1.25k| return str_; 44| 1.25k| } _ZNK11ArduinoJson8V742HB426detail9RamString4sizeEv: 32| 195k| size_t size() const { 33| 195k| return size_; 34| 195k| } _ZN11ArduinoJson8V742HB426detail9RamStringC2EPKcm: 24| 54.4k| RamString(const char* str, size_t sz) : str_(str), size_(sz) { 25| | ARDUINOJSON_ASSERT(size_ == sz); ------------------ | | 11| 54.4k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ | Branch (25:5): [True: 54.4k, False: 0] ------------------ 26| 54.4k| } _ZNK11ArduinoJson8V742HB426detail9RamString6isNullEv: 28| 85.7k| bool isNull() const { 29| 85.7k| return !str_; 30| 85.7k| } _ZNK11ArduinoJson8V742HB426detail9RamStringixEm: 36| 105k| char operator[](size_t i) const { 37| 105k| ARDUINOJSON_ASSERT(str_ != 0); ------------------ | | 11| 105k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ | Branch (37:5): [True: 105k, False: 0] ------------------ 38| 105k| ARDUINOJSON_ASSERT(i <= size()); ------------------ | | 11| 105k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ | Branch (38:5): [True: 105k, False: 0] ------------------ 39| 105k| return str_[i]; 40| 105k| } _ZN11ArduinoJson8V742HB426detail18SizedStringAdapterIPcvE5adaptEPKcm: 65| 36.3k| static AdaptedString adapt(const TChar* p, size_t n) { 66| 36.3k| return AdaptedString(reinterpret_cast(p), n); 67| 36.3k| } _ZNK11ArduinoJson8V742HB4210JsonString5c_strEv: 43| 1.25k| const char* c_str() const { 44| 1.25k| return str_.data(); 45| 1.25k| } _ZNK11ArduinoJson8V742HB4210JsonString4sizeEv: 59| 1.25k| size_t size() const { 60| 1.25k| return str_.size(); 61| 1.25k| } _ZN11ArduinoJson8V742HB4210JsonStringC2EPKc: 24| 7.21k| JsonString(const char* data) : str_(data, data ? ::strlen(data) : 0) {} ------------------ | Branch (24:45): [True: 7.21k, False: 0] ------------------ _ZN11ArduinoJson8V742HB4210JsonStringC2ItTnNS0_6detail9enable_ifIXaasr6detail11is_integralIT_EE5valuentsr6detail7is_sameIS5_bEE5valueEiE4typeELi0EEEPKcS5_: 35| 4.53k| JsonString(const char* data, TSize sz) : str_(data, size_t(sz)) {} _ZN11ArduinoJson8V742HB4210JsonStringC2ImTnNS0_6detail9enable_ifIXaasr6detail11is_integralIT_EE5valuentsr6detail7is_sameIS5_bEE5valueEiE4typeELi0EEEPKcS5_: 35| 6.33k| JsonString(const char* data, TSize sz) : str_(data, size_t(sz)) {} _ZN11ArduinoJson8V742HB426detail13StringAdapterINS0_10JsonStringEvE5adaptERKS3_: 102| 16.8k| static const AdaptedString& adapt(const JsonString& s) { 103| 16.8k| return s.str_; 104| 16.8k| } _ZN11ArduinoJson8V742HB426detail11adaptStringINS0_10JsonStringEEENS1_13StringAdapterINS1_5decayIT_E4typeEvE13AdaptedStringEOS6_: 24| 10.4k|AdaptedString adaptString(TString&& s) { 25| 10.4k| return StringAdapterFor::adapt(detail::forward(s)); 26| 10.4k|} _ZN11ArduinoJson8V742HB426detail11adaptStringIRNS0_10JsonStringEEENS1_13StringAdapterINS1_5decayIT_E4typeEvE13AdaptedStringEOS7_: 24| 6.33k|AdaptedString adaptString(TString&& s) { 25| 6.33k| return StringAdapterFor::adapt(detail::forward(s)); 26| 6.33k|} _ZN11ArduinoJson8V742HB426detail11adaptStringIcEENS1_13StringAdapterINS1_5decayIPT_E4typeEvE13AdaptedStringES6_m: 34| 36.3k|AdaptedString adaptString(TChar* p, size_t n) { 35| 36.3k| return SizedStringAdapter::adapt(p, n); 36| 36.3k|} _ZN11ArduinoJson8V742HB426detail12stringEqualsINS1_9RamStringES3_EENS1_9enable_ifIXlesrT_11typeSortKeysrT0_11typeSortKeyEbE4typeES5_S6_: 44| 39.6k|stringEquals(TAdaptedString1 s1, TAdaptedString2 s2) { 45| 39.6k| ARDUINOJSON_ASSERT(!s1.isNull()); ------------------ | | 11| 39.6k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ | Branch (45:3): [True: 39.6k, False: 0] ------------------ 46| 39.6k| ARDUINOJSON_ASSERT(!s2.isNull()); ------------------ | | 11| 39.6k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ | Branch (46:3): [True: 39.6k, False: 0] ------------------ 47| 39.6k| size_t size1 = s1.size(); 48| 39.6k| size_t size2 = s2.size(); 49| 39.6k| if (size1 != size2) ------------------ | Branch (49:7): [True: 2.88k, False: 36.7k] ------------------ 50| 2.88k| return false; 51| 52.6k| for (size_t i = 0; i < size1; i++) { ------------------ | Branch (51:22): [True: 50.6k, False: 2.01k] ------------------ 52| 50.6k| if (s1[i] != s2[i]) ------------------ | Branch (52:9): [True: 34.7k, False: 15.8k] ------------------ 53| 34.7k| return false; 54| 50.6k| } 55| 2.01k| return true; 56| 36.7k|} _ZN11ArduinoJson8V742HB4216JsonVariantConstC2EPNS0_6detail11VariantDataEPNS2_15ResourceManagerE: 43| 1.21k| : impl_(data, resources) {} _ZNK11ArduinoJson8V742HB4216JsonVariantConst7getDataEv: 174| 1.21k| detail::VariantData* getData() const { 175| 1.21k| return impl_.data(); 176| 1.21k| } _ZNK11ArduinoJson8V742HB4216JsonVariantConst18getResourceManagerEv: 178| 1.21k| detail::ResourceManager* getResourceManager() const { 179| 1.21k| return impl_.resources(); 180| 1.21k| } _ZN11ArduinoJson8V742HB426detail15VariantAttorney7getDataINS0_16JsonVariantConstEEEDTcldtfp_7getDataEERT_: 24| 1.21k| static auto getData(TClient& client) -> decltype(client.getData()) { 25| 1.21k| return client.getData(); 26| 1.21k| } _ZN11ArduinoJson8V742HB426detail15VariantAttorney18getResourceManagerINS0_16JsonVariantConstEEEDTcldtfp_18getResourceManagerEERT_: 19| 1.21k| -> decltype(client.getResourceManager()) { 20| 1.21k| return client.getResourceManager(); 21| 1.21k| } _ZN11ArduinoJson8V742HB426detail15VariantAttorney15getOrCreateDataINS0_12JsonDocumentEEEPNS1_11VariantDataERT_: 39| 3.09k| static VariantData* getOrCreateData(TClient& client) { 40| 3.09k| return client.getOrCreateData(); 41| 3.09k| } _ZN11ArduinoJson8V742HB426detail15VariantAttorney18getResourceManagerINS0_12JsonDocumentEEEDTcldtfp_18getResourceManagerEERT_: 19| 3.09k| -> decltype(client.getResourceManager()) { 20| 3.09k| return client.getResourceManager(); 21| 3.09k| } _ZN11ArduinoJson8V742HB426detail14VariantContentC2Ev: 62| 86.9k| VariantContent() {} _ZN11ArduinoJson8V742HB426detailanENS1_11VariantTypeENS1_15VariantTypeBitsE: 43| 119k|inline bool operator&(VariantType type, VariantTypeBits bit) { 44| 119k| return (uint8_t(type) & uint8_t(bit)) != 0; 45| 119k|} _ZN11ArduinoJson8V742HB426detail14CollectionDatanwEmPv: 52| 8.98k| static void* operator new(size_t, void* p) noexcept { 53| 8.98k| return p; 54| 8.98k| } _ZNK11ArduinoJson8V742HB426detail11VariantData7isArrayEv: 60| 75.8k| bool isArray() const { 61| 75.8k| return type == VariantType::Array; 62| 75.8k| } _ZNK11ArduinoJson8V742HB426detail11VariantData8isObjectEv: 80| 11.6k| bool isObject() const { 81| 11.6k| return type == VariantType::Object; 82| 11.6k| } _ZN11ArduinoJson8V742HB426detail11VariantData7toArrayEv: 125| 5.66k| CollectionData* toArray() { 126| 5.66k| ARDUINOJSON_ASSERT(type == VariantType::Null); ------------------ | | 11| 5.66k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ | Branch (126:5): [True: 5.66k, False: 0] ------------------ 127| 5.66k| type = VariantType::Array; 128| 5.66k| return new (&content.asCollection) CollectionData(); 129| 5.66k| } _ZN11ArduinoJson8V742HB426detail11VariantDatanwEmPv: 32| 83.8k| static void* operator new(size_t, void* p) noexcept { 33| 83.8k| return p; 34| 83.8k| } _ZNK11ArduinoJson8V742HB426detail11VariantData12isCollectionEv: 68| 81.6k| bool isCollection() const { 69| 81.6k| return type & VariantTypeBits::CollectionMask; 70| 81.6k| } _ZN11ArduinoJson8V742HB426detail11VariantData8toObjectEv: 131| 3.32k| CollectionData* toObject() { 132| 3.32k| ARDUINOJSON_ASSERT(type == VariantType::Null); ------------------ | | 11| 3.32k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ | Branch (132:5): [True: 3.32k, False: 0] ------------------ 133| 3.32k| type = VariantType::Object; 134| 3.32k| return new (&content.asCollection) CollectionData(); 135| 3.32k| } _ZNK11ArduinoJson8V742HB426detail11VariantData8asStringEv: 48| 10.4k| JsonString asString() const { 49| 10.4k| switch (type) { 50| 6.20k| case VariantType::TinyString: ------------------ | Branch (50:7): [True: 6.20k, False: 4.29k] ------------------ 51| 6.20k| return JsonString(content.asTinyString); 52| 4.29k| case VariantType::LongString: ------------------ | Branch (52:7): [True: 4.29k, False: 6.20k] ------------------ 53| 4.29k| return JsonString(content.asStringNode->data, 54| 4.29k| content.asStringNode->length); 55| 0| default: ------------------ | Branch (55:7): [True: 0, False: 10.4k] ------------------ 56| 0| return JsonString(); 57| 10.4k| } 58| 10.4k| } json_fuzzer.cpp:_ZN11ArduinoJson8V742HB426detailL12isTinyStringIPcEEbRKT_m: 17| 7.17k|static bool isTinyString(const T& s, size_t n) { 18| 7.17k| if (n > tinyStringMaxLength) ------------------ | Branch (18:7): [True: 2.25k, False: 4.91k] ------------------ 19| 2.25k| return false; 20| 4.91k| bool containsNul = false; 21| 9.07k| for (uint8_t i = 0; i < uint8_t(n); i++) ------------------ | Branch (21:23): [True: 4.15k, False: 4.91k] ------------------ 22| 4.15k| containsNul |= !s[i]; 23| 4.91k| return !containsNul; 24| 7.17k|} _ZN11ArduinoJson8V742HB426detail11VariantData13setTinyStringINS1_9RamStringEEEvRKT_: 102| 4.91k| void setTinyString(const TAdaptedString& s) { 103| 4.91k| ARDUINOJSON_ASSERT(type == VariantType::Null); ------------------ | | 11| 4.91k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ | Branch (103:5): [True: 4.91k, False: 0] ------------------ 104| 4.91k| ARDUINOJSON_ASSERT(s.size() <= tinyStringMaxLength); ------------------ | | 11| 4.91k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ | Branch (104:5): [True: 4.91k, False: 0] ------------------ 105| | 106| 4.91k| type = VariantType::TinyString; 107| | 108| 4.91k| auto n = uint8_t(s.size()); 109| 9.05k| for (uint8_t i = 0; i < n; i++) { ------------------ | Branch (109:25): [True: 4.14k, False: 4.91k] ------------------ 110| 4.14k| char c = s[i]; 111| 4.14k| ARDUINOJSON_ASSERT(c != 0); // no NUL in tiny string ------------------ | | 11| 4.14k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ | Branch (111:7): [True: 4.14k, False: 0] ------------------ 112| 4.14k| content.asTinyString[i] = c; 113| 4.14k| } 114| | 115| 4.91k| content.asTinyString[n] = 0; 116| 4.91k| } _ZN11ArduinoJson8V742HB426detail11VariantData13setLongStringEPNS1_10StringNodeE: 118| 2.26k| void setLongString(StringNode* s) { 119| 2.26k| ARDUINOJSON_ASSERT(type == VariantType::Null); ------------------ | | 11| 2.26k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ | Branch (119:5): [True: 2.26k, False: 0] ------------------ 120| 2.26k| ARDUINOJSON_ASSERT(s); ------------------ | | 11| 2.26k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ | Branch (120:5): [True: 2.26k, False: 0] ------------------ 121| 2.26k| type = VariantType::LongString; 122| 2.26k| content.asStringNode = s; 123| 2.26k| } _ZN11ArduinoJson8V742HB426detail11VariantData10setBooleanEb: 88| 806| void setBoolean(bool value) { 89| 806| ARDUINOJSON_ASSERT(type == VariantType::Null); ------------------ | | 11| 806|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ | Branch (89:5): [True: 806, False: 0] ------------------ 90| 806| type = VariantType::Boolean; 91| 806| content.asBoolean = value; 92| 806| } _ZNK11ArduinoJson8V742HB426detail11VariantData7isFloatEv: 72| 372| bool isFloat() const { 73| 372| return type & VariantTypeBits::NumberBit; 74| 372| } _ZN11ArduinoJson8V742HB426detail11VariantImplC2EPNS1_11VariantDataEPNS1_15ResourceManagerE: 26| 1.21k| : data_(data), resources_(resources) {} _ZNK11ArduinoJson8V742HB426detail11VariantImpl4dataEv: 28| 1.21k| VariantData* data() const { 29| 1.21k| return data_; 30| 1.21k| } _ZNK11ArduinoJson8V742HB426detail11VariantImpl9resourcesEv: 32| 1.21k| ResourceManager* resources() const { 33| 1.21k| return resources_; 34| 1.21k| } _ZN11ArduinoJson8V742HB426detail11VariantImpl6acceptINS1_14JsonSerializerINS1_6WriterINSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEvEEEEEENT_11result_typeERSF_PNS1_11VariantDataEPNS1_15ResourceManagerE: 44| 18.0k| ResourceManager* resources) { 45| 18.0k| if (!data) ------------------ | Branch (45:9): [True: 0, False: 18.0k] ------------------ 46| 0| return visit.visit(nullptr); 47| | 48| 18.0k|#if ARDUINOJSON_USE_8_BYTE_POOL 49| 18.0k| auto eightByteValue = getEightByte(data, resources); 50| 18.0k|#endif 51| 18.0k| switch (data->type) { 52| 4.52k| case VariantType::Float: ------------------ | Branch (52:7): [True: 4.52k, False: 13.5k] ------------------ 53| 4.52k| return visit.visit(data->content.asFloat); 54| | 55| 0|#if ARDUINOJSON_USE_DOUBLE 56| 1.36k| case VariantType::Double: ------------------ | Branch (56:7): [True: 1.36k, False: 16.7k] ------------------ 57| 1.36k| return visit.visit(eightByteValue->asDouble); 58| 0|#endif 59| | 60| 1.30k| case VariantType::Array: ------------------ | Branch (60:7): [True: 1.30k, False: 16.7k] ------------------ 61| 1.30k| return visit.visitArray(data); 62| | 63| 615| case VariantType::Object: ------------------ | Branch (63:7): [True: 615, False: 17.4k] ------------------ 64| 615| return visit.visitObject(data); 65| | 66| 1.01k| case VariantType::TinyString: ------------------ | Branch (66:7): [True: 1.01k, False: 17.0k] ------------------ 67| 1.01k| return visit.visit(JsonString(data->content.asTinyString)); 68| | 69| 238| case VariantType::LongString: ------------------ | Branch (69:7): [True: 238, False: 17.8k] ------------------ 70| 238| return visit.visit(JsonString(data->content.asStringNode->data, 71| 238| data->content.asStringNode->length)); 72| | 73| 0| case VariantType::RawString: ------------------ | Branch (73:7): [True: 0, False: 18.0k] ------------------ 74| 0| return visit.visit(RawString(data->content.asStringNode->data, 75| 0| data->content.asStringNode->length)); 76| | 77| 619| case VariantType::Int32: ------------------ | Branch (77:7): [True: 619, False: 17.4k] ------------------ 78| 619| return visit.visit(static_cast(data->content.asInt32)); 79| | 80| 6.95k| case VariantType::Uint32: ------------------ | Branch (80:7): [True: 6.95k, False: 11.1k] ------------------ 81| 6.95k| return visit.visit(static_cast(data->content.asUint32)); 82| | 83| 0|#if ARDUINOJSON_USE_LONG_LONG 84| 468| case VariantType::Int64: ------------------ | Branch (84:7): [True: 468, False: 17.6k] ------------------ 85| 468| return visit.visit(eightByteValue->asInt64); 86| | 87| 405| case VariantType::Uint64: ------------------ | Branch (87:7): [True: 405, False: 17.6k] ------------------ 88| 405| return visit.visit(eightByteValue->asUint64); 89| 0|#endif 90| | 91| 388| case VariantType::Boolean: ------------------ | Branch (91:7): [True: 388, False: 17.6k] ------------------ 92| 388| return visit.visit(data->content.asBoolean != 0); 93| | 94| 194| default: ------------------ | Branch (94:7): [True: 194, False: 17.8k] ------------------ 95| 194| return visit.visit(nullptr); 96| 18.0k| } 97| 18.0k| } _ZN11ArduinoJson8V742HB426detail11VariantImpl12getEightByteEPNS1_11VariantDataEPNS1_15ResourceManagerE: 273| 18.0k| ResourceManager* resources) { 274| 18.0k| ARDUINOJSON_ASSERT(data != nullptr); ------------------ | | 11| 18.0k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ | Branch (274:5): [True: 18.0k, False: 0] ------------------ 275| 18.0k| ARDUINOJSON_ASSERT(resources != nullptr); ------------------ | | 11| 18.0k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ | Branch (275:5): [True: 18.0k, False: 0] ------------------ 276| 18.0k| return data->type & VariantTypeBits::EightByteBit ------------------ | Branch (276:12): [True: 2.23k, False: 15.8k] ------------------ 277| 18.0k| ? resources->getEightByte(data->content.asSlotId) 278| 18.0k| : 0; 279| 18.0k| } _ZN11ArduinoJson8V742HB426detail11VariantImpl5clearEPNS1_11VariantDataEPNS1_15ResourceManagerE: 587| 6.30k| static void clear(VariantData* data, ResourceManager* resources) { 588| 6.30k| ARDUINOJSON_ASSERT(data != nullptr); ------------------ | | 11| 6.30k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ | Branch (588:5): [True: 6.30k, False: 0] ------------------ 589| 6.30k| ARDUINOJSON_ASSERT(resources != nullptr); ------------------ | | 11| 6.30k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ | Branch (589:5): [True: 6.30k, False: 0] ------------------ 590| | 591| 6.30k| if (data->type & VariantTypeBits::OwnedStringBit) ------------------ | Branch (591:9): [True: 1.01k, False: 5.29k] ------------------ 592| 1.01k| resources->dereferenceString(data->content.asStringNode->data); 593| | 594| 6.30k|#if ARDUINOJSON_USE_8_BYTE_POOL 595| 6.30k| if (data->type & VariantTypeBits::EightByteBit) ------------------ | Branch (595:9): [True: 2.23k, False: 4.07k] ------------------ 596| 2.23k| resources->freeEightByte(data->content.asSlotId); 597| 6.30k|#endif 598| | 599| 6.30k| if (data->type & VariantTypeBits::CollectionMask) ------------------ | Branch (599:9): [True: 776, False: 5.52k] ------------------ 600| 776| empty(data, resources); 601| | 602| 6.30k| data->type = VariantType::Null; 603| 6.30k| } _ZN11ArduinoJson8V742HB426detail11VariantImpl11freeVariantENS1_4SlotINS1_11VariantDataEEEPNS1_15ResourceManagerE: 613| 4.63k| static void freeVariant(Slot slot, ResourceManager* resources) { 614| 4.63k| clear(slot.ptr(), resources); 615| 4.63k| resources->freeVariant(slot); 616| 4.63k| } _ZN11ArduinoJson8V742HB426detail11VariantImpl10setIntegerImEENS1_9enable_ifIXsr11is_unsignedIT_EE5valueEbE4typeES5_PNS1_11VariantDataEPNS1_15ResourceManagerE: 466| 10.7k| T value, VariantData* data, ResourceManager* resources) { 467| 10.7k| ARDUINOJSON_ASSERT(data != nullptr); ------------------ | | 11| 10.7k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ | Branch (467:5): [True: 10.7k, False: 0] ------------------ 468| 10.7k| ARDUINOJSON_ASSERT(data->type == VariantType::Null); ------------------ | | 11| 10.7k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ | Branch (468:5): [True: 10.7k, False: 0] ------------------ 469| 10.7k| ARDUINOJSON_ASSERT(resources != nullptr); ------------------ | | 11| 10.7k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ | Branch (469:5): [True: 10.7k, False: 0] ------------------ 470| | 471| 10.7k| if (canConvertNumber(value)) { ------------------ | Branch (471:9): [True: 10.3k, False: 440] ------------------ 472| 10.3k| data->type = VariantType::Uint32; 473| 10.3k| data->content.asUint32 = static_cast(value); 474| 10.3k| } 475| 440|#if ARDUINOJSON_USE_LONG_LONG 476| 440| else { 477| 440| auto slot = resources->allocEightByte(); 478| 440| if (!slot) ------------------ | Branch (478:11): [True: 0, False: 440] ------------------ 479| 0| return false; 480| 440| data->type = VariantType::Uint64; 481| 440| data->content.asSlotId = slot.id(); 482| 440| slot->asUint64 = value; 483| 440| } 484| |#else 485| | (void)resources; 486| |#endif 487| 10.7k| return true; 488| 10.7k| } _ZN11ArduinoJson8V742HB426detail11VariantImpl10setIntegerIlEENS1_9enable_ifIXsr9is_signedIT_EE5valueEbE4typeES5_PNS1_11VariantDataEPNS1_15ResourceManagerE: 440| 1.27k| T value, VariantData* data, ResourceManager* resources) { 441| 1.27k| ARDUINOJSON_ASSERT(data != nullptr); ------------------ | | 11| 1.27k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ | Branch (441:5): [True: 1.27k, False: 0] ------------------ 442| 1.27k| ARDUINOJSON_ASSERT(data->type == VariantType::Null); ------------------ | | 11| 1.27k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ | Branch (442:5): [True: 1.27k, False: 0] ------------------ 443| 1.27k| ARDUINOJSON_ASSERT(resources != nullptr); ------------------ | | 11| 1.27k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ | Branch (443:5): [True: 1.27k, False: 0] ------------------ 444| | 445| 1.27k| if (canConvertNumber(value)) { ------------------ | Branch (445:9): [True: 745, False: 534] ------------------ 446| 745| data->type = VariantType::Int32; 447| 745| data->content.asInt32 = static_cast(value); 448| 745| } 449| 534|#if ARDUINOJSON_USE_LONG_LONG 450| 534| else { 451| 534| auto slot = resources->allocEightByte(); 452| 534| if (!slot) ------------------ | Branch (452:11): [True: 0, False: 534] ------------------ 453| 0| return false; 454| 534| data->type = VariantType::Int64; 455| 534| data->content.asSlotId = slot.id(); 456| 534| slot->asInt64 = value; 457| 534| } 458| |#else 459| | (void)resources; 460| |#endif 461| 1.27k| return true; 462| 1.27k| } _ZN11ArduinoJson8V742HB426detail11VariantImpl8setFloatIfEENS1_9enable_ifIXeqstT_Li4EEbE4typeES5_PNS1_11VariantDataEPNS1_15ResourceManagerE: 394| 48.5k| ResourceManager*) { 395| 48.5k| ARDUINOJSON_ASSERT(data != nullptr); ------------------ | | 11| 48.5k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ | Branch (395:5): [True: 48.5k, False: 0] ------------------ 396| 48.5k| ARDUINOJSON_ASSERT(data->type == VariantType::Null); ------------------ | | 11| 48.5k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ | Branch (396:5): [True: 48.5k, False: 0] ------------------ 397| 48.5k| data->type = VariantType::Float; 398| 48.5k| data->content.asFloat = value; 399| 48.5k| return true; 400| 48.5k| } _ZN11ArduinoJson8V742HB426detail11VariantImpl8setFloatIdEENS1_9enable_ifIXeqstT_Li8EEbE4typeES5_PNS1_11VariantDataEPNS1_15ResourceManagerE: 404| 9.79k| T value, VariantData* data, ResourceManager* resources) { 405| 9.79k| ARDUINOJSON_ASSERT(data != nullptr); ------------------ | | 11| 9.79k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ | Branch (405:5): [True: 9.79k, False: 0] ------------------ 406| 9.79k| ARDUINOJSON_ASSERT(data->type == VariantType::Null); ------------------ | | 11| 9.79k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ | Branch (406:5): [True: 9.79k, False: 0] ------------------ 407| 9.79k| ARDUINOJSON_ASSERT(resources != nullptr); ------------------ | | 11| 9.79k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ | Branch (407:5): [True: 9.79k, False: 0] ------------------ 408| | 409| 9.79k| float valueAsFloat = static_cast(value); 410| | 411| 9.79k|#if ARDUINOJSON_USE_DOUBLE 412| 9.79k| if (value == valueAsFloat) { ------------------ | Branch (412:9): [True: 1.19k, False: 8.59k] ------------------ 413| 1.19k| data->type = VariantType::Float; 414| 1.19k| data->content.asFloat = valueAsFloat; 415| 8.59k| } else { 416| 8.59k| auto slot = resources->allocEightByte(); 417| 8.59k| if (!slot) ------------------ | Branch (417:11): [True: 0, False: 8.59k] ------------------ 418| 0| return false; 419| 8.59k| data->type = VariantType::Double; 420| 8.59k| data->content.asSlotId = slot.id(); 421| 8.59k| slot->asDouble = value; 422| 8.59k| } 423| |#else 424| | data->type = VariantType::Float; 425| | data->content.asFloat = valueAsFloat; 426| |#endif 427| 9.79k| return true; 428| 9.79k| }