LLVMFuzzerTestOneInput: 11| 39|{ 12| 39| std::string s(reinterpret_cast(data), size); 13| 39| std::istringstream is(s); 14| | 15| 39| default_json_visitor visitor; 16| | 17| 39| ubjson_stream_reader reader(is, visitor); 18| 39| std::error_code ec; 19| 39| reader.read(ec); 20| | 21| 39| return 0; 22| 39|} _ZNK8jsoncons6detail4spanIKhLm18446744073709551615EE4sizeEv: 116| 1.44M| { 117| 1.44M| return size_; 118| 1.44M| } _ZN8jsoncons6detail4spanIKhLm18446744073709551615EEC2Ev: 58| 390k| { 59| 390k| } _ZN8jsoncons6detail4spanIKhLm18446744073709551615EEC2EPS2_m: 61| 91.9k| : data_(data), size_(size) 62| 91.9k| { 63| 91.9k| } _ZNK8jsoncons6detail4spanIKhLm18446744073709551615EE4dataEv: 111| 965k| { 112| 965k| return data_; 113| 965k| } _ZN8jsoncons26basic_default_json_visitorIcEC2Ev: 811| 39| basic_default_json_visitor() = default; _ZN8jsoncons18basic_json_visitorIcEC2Ev: 103| 39| basic_json_visitor() = default; _ZN8jsoncons19typed_array_visitorD2Ev: 33| 39| virtual ~typed_array_visitor() = default; _ZN8jsoncons18basic_json_visitorIcE17visit_begin_arrayEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE: 560| 3.33k| { 561| 3.33k| visit_begin_array(tag, context, ec); 562| 3.33k| JSONCONS_VISITOR_RETURN; ------------------ | | 276| 3.33k|#define JSONCONS_VISITOR_RETURN return true ------------------ 563| 3.33k| } _ZN8jsoncons26basic_default_json_visitorIcE15visit_end_arrayERKNS_11ser_contextERNSt3__110error_codeE: 833| 1.18M| { 834| 1.18M| JSONCONS_VISITOR_RETURN; ------------------ | | 276| 1.18M|#define JSONCONS_VISITOR_RETURN return true ------------------ 835| 1.18M| } _ZN8jsoncons26basic_default_json_visitorIcE12visit_uint64EmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE: 858| 294| { 859| 294| JSONCONS_VISITOR_RETURN; ------------------ | | 276| 294|#define JSONCONS_VISITOR_RETURN return true ------------------ 860| 294| } _ZN8jsoncons26basic_default_json_visitorIcE11visit_int64ElNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE: 863| 1.60M| { 864| 1.60M| JSONCONS_VISITOR_RETURN; ------------------ | | 276| 1.60M|#define JSONCONS_VISITOR_RETURN return true ------------------ 865| 1.60M| } _ZN8jsoncons26basic_default_json_visitorIcE12visit_doubleEdNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE: 873| 51| { 874| 51| JSONCONS_VISITOR_RETURN; ------------------ | | 276| 51|#define JSONCONS_VISITOR_RETURN return true ------------------ 875| 51| } _ZN8jsoncons26basic_default_json_visitorIcE11visit_flushEv: 814| 2| { 815| 2| } _ZN8jsoncons26basic_default_json_visitorIcE18visit_begin_objectENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE: 818| 1.55M| { 819| 1.55M| JSONCONS_VISITOR_RETURN; ------------------ | | 276| 1.55M|#define JSONCONS_VISITOR_RETURN return true ------------------ 820| 1.55M| } _ZN8jsoncons18basic_json_visitorIcE18visit_begin_objectEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE: 544| 3.33k| { 545| 3.33k| visit_begin_object(tag, context, ec); 546| 3.33k| JSONCONS_VISITOR_RETURN; ------------------ | | 276| 3.33k|#define JSONCONS_VISITOR_RETURN return true ------------------ 547| 3.33k| } _ZN8jsoncons26basic_default_json_visitorIcE16visit_end_objectERKNS_11ser_contextERNSt3__110error_codeE: 823| 1.55M| { 824| 1.55M| JSONCONS_VISITOR_RETURN; ------------------ | | 276| 1.55M|#define JSONCONS_VISITOR_RETURN return true ------------------ 825| 1.55M| } _ZN8jsoncons26basic_default_json_visitorIcE17visit_begin_arrayENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE: 828| 1.18M| { 829| 1.18M| JSONCONS_VISITOR_RETURN; ------------------ | | 276| 1.18M|#define JSONCONS_VISITOR_RETURN return true ------------------ 830| 1.18M| } _ZN8jsoncons26basic_default_json_visitorIcE9visit_keyERKNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEERKNS_11ser_contextERNS2_10error_codeE: 838| 464k| { 839| 464k| JSONCONS_VISITOR_RETURN; ------------------ | | 276| 464k|#define JSONCONS_VISITOR_RETURN return true ------------------ 840| 464k| } _ZN8jsoncons26basic_default_json_visitorIcE10visit_nullENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE: 843| 3.71M| { 844| 3.71M| JSONCONS_VISITOR_RETURN; ------------------ | | 276| 3.71M|#define JSONCONS_VISITOR_RETURN return true ------------------ 845| 3.71M| } _ZN8jsoncons26basic_default_json_visitorIcE10visit_boolEbNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE: 878| 440k| { 879| 440k| JSONCONS_VISITOR_RETURN; ------------------ | | 276| 440k|#define JSONCONS_VISITOR_RETURN return true ------------------ 880| 440k| } _ZN8jsoncons26basic_default_json_visitorIcE12visit_stringERKNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEENS_12semantic_tagERKNS_11ser_contextERNS2_10error_codeE: 848| 18.7k| { 849| 18.7k| JSONCONS_VISITOR_RETURN; ------------------ | | 276| 18.7k|#define JSONCONS_VISITOR_RETURN return true ------------------ 850| 18.7k| } _ZN8jsoncons18basic_json_visitorIcE11begin_arrayEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE: 345| 3.33k| { 346| 3.33k| visit_begin_array(length, tag, context, ec); 347| 3.33k| JSONCONS_VISITOR_RETURN; ------------------ | | 276| 3.33k|#define JSONCONS_VISITOR_RETURN return true ------------------ 348| 3.33k| } _ZN8jsoncons18basic_json_visitorIcE12uint64_valueEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE: 414| 294| { 415| 294| visit_uint64(value, tag, context, ec); 416| 294| JSONCONS_VISITOR_RETURN; ------------------ | | 276| 294|#define JSONCONS_VISITOR_RETURN return true ------------------ 417| 294| } _ZN8jsoncons18basic_json_visitorIcE9end_arrayERKNS_11ser_contextERNSt3__110error_codeE: 351| 1.18M| { 352| 1.18M| visit_end_array(context, ec); 353| 1.18M| JSONCONS_VISITOR_RETURN; ------------------ | | 276| 1.18M|#define JSONCONS_VISITOR_RETURN return true ------------------ 354| 1.18M| } _ZN8jsoncons18basic_json_visitorIcE11int64_valueElNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE: 423| 1.60M| { 424| 1.60M| visit_int64(value, tag, context, ec); 425| 1.60M| JSONCONS_VISITOR_RETURN; ------------------ | | 276| 1.60M|#define JSONCONS_VISITOR_RETURN return true ------------------ 426| 1.60M| } _ZN8jsoncons18basic_json_visitorIcE12double_valueEdNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE: 441| 51| { 442| 51| visit_double(value, tag, context, ec); 443| 51| JSONCONS_VISITOR_RETURN; ------------------ | | 276| 51|#define JSONCONS_VISITOR_RETURN return true ------------------ 444| 51| } _ZN8jsoncons18basic_json_visitorIcE10null_valueENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE: 365| 3.71M| { 366| 3.71M| visit_null(tag, context, ec); 367| 3.71M| JSONCONS_VISITOR_RETURN; ------------------ | | 276| 3.71M|#define JSONCONS_VISITOR_RETURN return true ------------------ 368| 3.71M| } _ZN8jsoncons18basic_json_visitorIcE10bool_valueEbNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE: 374| 440k| { 375| 440k| visit_bool(value, tag, context, ec); 376| 440k| JSONCONS_VISITOR_RETURN; ------------------ | | 276| 440k|#define JSONCONS_VISITOR_RETURN return true ------------------ 377| 440k| } _ZN8jsoncons18basic_json_visitorIcE12string_valueERKNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEENS_12semantic_tagERKNS_11ser_contextERNS2_10error_codeE: 383| 18.7k| { 384| 18.7k| visit_string(value, tag, context, ec); 385| 18.7k| JSONCONS_VISITOR_RETURN; ------------------ | | 276| 18.7k|#define JSONCONS_VISITOR_RETURN return true ------------------ 386| 18.7k| } _ZN8jsoncons18basic_json_visitorIcE11begin_arrayENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE: 339| 1.17M| { 340| 1.17M| visit_begin_array(tag, context, ec); 341| 1.17M| JSONCONS_VISITOR_RETURN; ------------------ | | 276| 1.17M|#define JSONCONS_VISITOR_RETURN return true ------------------ 342| 1.17M| } _ZN8jsoncons18basic_json_visitorIcE12begin_objectEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE: 327| 3.33k| { 328| 3.33k| visit_begin_object(length, tag, context, ec); 329| 3.33k| JSONCONS_VISITOR_RETURN; ------------------ | | 276| 3.33k|#define JSONCONS_VISITOR_RETURN return true ------------------ 330| 3.33k| } _ZN8jsoncons18basic_json_visitorIcE12begin_objectENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE: 318| 1.55M| { 319| 1.55M| visit_begin_object(tag, context, ec); 320| 1.55M| JSONCONS_VISITOR_RETURN; ------------------ | | 276| 1.55M|#define JSONCONS_VISITOR_RETURN return true ------------------ 321| 1.55M| } _ZN8jsoncons18basic_json_visitorIcE3keyERKNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEERKNS_11ser_contextERNS2_10error_codeE: 357| 464k| { 358| 464k| visit_key(name, context, ec); 359| 464k| JSONCONS_VISITOR_RETURN; ------------------ | | 276| 464k|#define JSONCONS_VISITOR_RETURN return true ------------------ 360| 464k| } _ZN8jsoncons18basic_json_visitorIcE10end_objectERKNS_11ser_contextERNSt3__110error_codeE: 333| 1.55M| { 334| 1.55M| visit_end_object(context, ec); 335| 1.55M| JSONCONS_VISITOR_RETURN; ------------------ | | 276| 1.55M|#define JSONCONS_VISITOR_RETURN return true ------------------ 336| 1.55M| } _ZN8jsoncons18basic_json_visitorIcE5flushEv: 108| 2| { 109| 2| visit_flush(); 110| 2| } _ZN8jsoncons11ser_contextD2Ev: 21| 39| virtual ~ser_context() = default; _ZN8jsoncons13stream_sourceIhNSt3__19allocatorIhEEED2Ev: 193| 39| { 194| 39| if (chunk_) ------------------ | Branch (194:13): [True: 39, False: 0] ------------------ 195| 39| { 196| 39| std::allocator_traits::deallocate(alloc_, chunk_, chunk_size_); 197| 39| } 198| 39| } _ZN8jsoncons13stream_sourceIhNSt3__19allocatorIhEEEC2ERNS1_13basic_istreamIcNS1_11char_traitsIcEEEERKS3_: 176| 39| : alloc_(alloc), stream_ptr_(std::addressof(is)), sbuf_(is.rdbuf()), 177| 39| chunk_size_(default_max_chunk_size) 178| 39| { 179| 39| chunk_ = std::allocator_traits::allocate(alloc_, chunk_size_); 180| 39| data_end_ = chunk_; 181| 39| } _ZN8jsoncons18basic_null_istreamIcEC1Ev: 57| 39| : std::basic_istream(&nb_) 58| 39| { 59| 39| } _ZN8jsoncons18basic_null_istreamIcE11null_bufferC2Ev: 43| 39| null_buffer() = default; _ZNK8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE8is_errorEv: 276| 4.74M| { 277| 4.74M| return stream_ptr_->bad(); 278| 4.74M| } _ZN8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE4readEPhm: 377| 7.33M| { 378| 7.33M| std::size_t len = 0; 379| 7.33M| if (remaining_ > 0) ------------------ | Branch (379:13): [True: 7.33M, False: 180] ------------------ 380| 7.33M| { 381| 7.33M| len = (std::min)(remaining_, length); 382| 7.33M| std::memcpy(p, data_end_, len*sizeof(value_type)); 383| 7.33M| data_end_ += len; 384| 7.33M| remaining_ -= len; 385| 7.33M| position_ += len; 386| 7.33M| } 387| 7.33M| if (length - len == 0) ------------------ | Branch (387:13): [True: 7.33M, False: 657] ------------------ 388| 7.33M| { 389| 7.33M| return len; 390| 7.33M| } 391| 657| else if (length - len < chunk_size_) ------------------ | Branch (391:18): [True: 657, False: 0] ------------------ 392| 657| { 393| 657| data_end_ = chunk_; 394| 657| remaining_ = fill_buffer(chunk_, chunk_size_); 395| 657| if (remaining_ > 0) ------------------ | Branch (395:17): [True: 647, False: 10] ------------------ 396| 647| { 397| 647| std::size_t len2 = (std::min)(remaining_, length-len); 398| 647| std::memcpy(p+len, data_end_, len2*sizeof(value_type)); 399| 647| data_end_ += len2; 400| 647| remaining_ -= len2; 401| 647| position_ += len2; 402| 647| len += len2; 403| 647| } 404| 657| return len; 405| 657| } 406| 0| else 407| 0| { 408| 0| if (stream_ptr_->eof()) ------------------ | Branch (408:17): [True: 0, False: 0] ------------------ 409| 0| { 410| 0| remaining_ = 0; 411| 0| return 0; 412| 0| } 413| 0| JSONCONS_TRY ------------------ | | 37| 0| #define JSONCONS_TRY try ------------------ 414| 0| { 415| 0| std::streamsize count = sbuf_->sgetn(reinterpret_cast(p+len), length-len); 416| 0| std::size_t len2 = static_cast(count); 417| 0| if (len2 < length-len) ------------------ | Branch (417:21): [True: 0, False: 0] ------------------ 418| 0| { 419| 0| stream_ptr_->clear(stream_ptr_->rdstate() | std::ios::eofbit); 420| 0| } 421| 0| len += len2; 422| 0| position_ += len2; 423| 0| return len; 424| 0| } 425| 0| JSONCONS_CATCH(const std::exception&) 426| 0| { 427| 0| stream_ptr_->clear(stream_ptr_->rdstate() | std::ios::badbit | std::ios::eofbit); 428| 0| return 0; 429| 0| } 430| 0| } 431| 7.33M| } _ZN8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE11fill_bufferEPhm: 442| 1.35k| { 443| 1.35k| if (stream_ptr_->eof()) ------------------ | Branch (443:13): [True: 11, False: 1.34k] ------------------ 444| 11| { 445| 11| return 0; 446| 11| } 447| | 448| 1.34k| JSONCONS_TRY ------------------ | | 37| 1.34k| #define JSONCONS_TRY try ------------------ 449| 1.34k| { 450| 1.34k| std::streamsize count = sbuf_->sgetn(reinterpret_cast(chunk), chunk_size); 451| 1.34k| std::size_t length = static_cast(count); 452| | 453| 1.34k| if (length < chunk_size) ------------------ | Branch (453:17): [True: 29, False: 1.31k] ------------------ 454| 29| { 455| 29| stream_ptr_->clear(stream_ptr_->rdstate() | std::ios::eofbit); 456| 29| } 457| 1.34k| return length; 458| 1.34k| } 459| 1.34k| JSONCONS_CATCH(const std::exception&) 460| 1.34k| { 461| 0| stream_ptr_->clear(stream_ptr_->rdstate() | std::ios::badbit | std::ios::eofbit); 462| 0| return 0; 463| 0| } 464| 1.34k| } _ZN8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE9read_spanIRNS1_12basic_stringIcNS1_11char_traitsIcEENS2_IcEEEEEENS_6detail4spanIKhLm18446744073709551615EEEmOT_: 352| 482k| { 353| 482k| if (JSONCONS_UNLIKELY(length == 0)) ------------------ | | 78| 482k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 390k, False: 91.9k] | | ------------------ ------------------ 354| 390k| { 355| 390k| return span{}; 356| 390k| } 357| 91.9k| if (remaining_ == 0 && length <= chunk_size_) ------------------ | Branch (357:13): [True: 5, False: 91.9k] | Branch (357:32): [True: 0, False: 5] ------------------ 358| 0| { 359| 0| remaining_ = fill_buffer(chunk_, chunk_size_); 360| 0| data_end_ = chunk_; 361| 0| } 362| 91.9k| if (length > remaining_) ------------------ | Branch (362:13): [True: 166, False: 91.8k] ------------------ 363| 166| { 364| 166| buffer.clear(); 365| 166| source_reader::read(*this, std::forward(buffer), length); 366| 166| return span(reinterpret_cast(buffer.data()), buffer.size()); 367| 166| } 368| | 369| 91.8k| const value_type* data = data_end_; 370| 91.8k| data_end_ += length; 371| 91.8k| remaining_ -= length; 372| 91.8k| position_ += length; 373| 91.8k| return span(data, length); 374| 91.9k| } _ZN8jsoncons13source_readerINS_13stream_sourceIhNSt3__19allocatorIhEEEEE4readINS2_12basic_stringIcNS2_11char_traitsIcEENS3_IcEEEEEENS2_9enable_ifIXaaL_ZNS2_17integral_constantIbLb1EE5valueEEsr10ext_traits7is_byteINT_10value_typeEEE5valueEmE4typeERS5_RSG_m: 746| 166| { 747| 166| std::size_t unread = length; 748| | 749| 915| while (unread > 0 && !source.eof()) ------------------ | Branch (749:16): [True: 761, False: 154] | Branch (749:30): [True: 749, False: 12] ------------------ 750| 749| { 751| 749| if (source.remaining() == 0 && unread >= source.chunk_size()) ------------------ | Branch (751:17): [True: 223, False: 526] | Branch (751:44): [True: 223, False: 0] ------------------ 752| 223| { 753| 223| std::size_t n = source.chunk_size(); 754| 223| std::size_t offset = buffer.size(); 755| 223| buffer.resize(offset+n); 756| 223| std::size_t actual = source.read_buffer(reinterpret_cast(&buffer[0]) + offset, n); 757| 223| if (JSONCONS_UNLIKELY(actual != n)) ------------------ | | 78| 223|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 5, False: 218] | | ------------------ ------------------ 758| 5| { 759| 5| buffer.resize(offset+actual); 760| 5| } 761| 223| unread -= actual; 762| 223| } 763| 526| else 764| 526| { 765| 526| std::size_t n = (std::min)(source.chunk_size(), unread); 766| 526| std::size_t offset = buffer.size(); 767| 526| buffer.resize(offset+n); 768| 526| std::size_t actual = source.read(reinterpret_cast(&buffer[0]) + offset, n); 769| 526| if (JSONCONS_UNLIKELY(actual != n)) ------------------ | | 78| 526|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 7, False: 519] | | ------------------ ------------------ 770| 7| { 771| 7| buffer.resize(offset + actual); 772| 7| } 773| 526| unread -= actual; 774| 526| } 775| 749| } 776| 166| return length - unread; 777| 166| } _ZNK8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE3eofEv: 271| 761| { 272| 761| return remaining_ == 0 && stream_ptr_->eof(); ------------------ | Branch (272:16): [True: 235, False: 526] | Branch (272:35): [True: 12, False: 223] ------------------ 273| 761| } _ZNK8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE9remainingEv: 346| 749| { 347| 749| return remaining_; 348| 749| } _ZNK8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE10chunk_sizeEv: 261| 972| { 262| 972| return chunk_size_; 263| 972| } _ZN8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE11read_bufferEPhm: 435| 223| { 436| 223| auto len = fill_buffer(chunk, chunk_size); 437| 223| position_ += len; 438| 223| return len; 439| 223| } _ZN8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE4peekEv: 312| 11.7M| { 313| 11.7M| if (remaining_ == 0) ------------------ | Branch (313:13): [True: 475, False: 11.7M] ------------------ 314| 475| { 315| 475| data_end_ = chunk_; 316| 475| remaining_ = fill_buffer(chunk_, chunk_size_); 317| 475| } 318| 11.7M| if (remaining_ > 0) ------------------ | Branch (318:13): [True: 11.7M, False: 9] ------------------ 319| 11.7M| { 320| 11.7M| value_type c = *data_end_; 321| 11.7M| return char_result{c, false}; 322| 11.7M| } 323| 9| else 324| 9| { 325| 9| return char_result{0, true}; 326| 9| } 327| 11.7M| } _ZN8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE6ignoreEm: 286| 2.74M| { 287| 2.74M| std::size_t len = 0; 288| 2.74M| if (remaining_ > 0) ------------------ | Branch (288:13): [True: 2.74M, False: 0] ------------------ 289| 2.74M| { 290| 2.74M| len = (std::min)(remaining_, length); 291| 2.74M| position_ += len; 292| 2.74M| data_end_ += len; 293| 2.74M| remaining_ -= len; 294| 2.74M| } 295| 2.74M| while (len < length) ------------------ | Branch (295:16): [True: 0, False: 2.74M] ------------------ 296| 0| { 297| 0| data_end_ = chunk_; 298| 0| remaining_ = fill_buffer(chunk_, chunk_size_); 299| 0| if (remaining_ == 0) ------------------ | Branch (299:17): [True: 0, False: 0] ------------------ 300| 0| { 301| 0| break; 302| 0| } 303| 0| std::size_t len2 = (std::min)(remaining_, length-len); 304| 0| position_ += len2; 305| 0| data_end_ += len2; 306| 0| remaining_ -= len2; 307| 0| len += len2; 308| 0| } 309| 2.74M| } _ZN8jsoncons6binary13big_to_nativeIaNS_6detail6endianEEENSt3__19enable_ifIXeqsrT0_6nativesrS6_6littleET_E4typeEPKhm: 182| 2.07M| { 183| 2.07M| if (sizeof(T) > count) ------------------ | Branch (183:13): [True: 0, False: 2.07M] ------------------ 184| 0| { 185| 0| return T{}; 186| 0| } 187| 2.07M| T val; 188| 2.07M| std::memcpy(&val,first,sizeof(T)); 189| 2.07M| return byte_swap(val); 190| 2.07M| } _ZN8jsoncons6binary9byte_swapIaEENSt3__19enable_ifIXaasr3std11is_integralIT_EE5valueeqstS4_Lm1EES4_E4typeES4_: 21| 2.07M| { 22| 2.07M| return val; 23| 2.07M| } _ZN8jsoncons6binary13big_to_nativeIsNS_6detail6endianEEENSt3__19enable_ifIXeqsrT0_6nativesrS6_6littleET_E4typeEPKhm: 182| 1.64k| { 183| 1.64k| if (sizeof(T) > count) ------------------ | Branch (183:13): [True: 0, False: 1.64k] ------------------ 184| 0| { 185| 0| return T{}; 186| 0| } 187| 1.64k| T val; 188| 1.64k| std::memcpy(&val,first,sizeof(T)); 189| 1.64k| return byte_swap(val); 190| 1.64k| } _ZN8jsoncons6binary9byte_swapIsEENSt3__19enable_ifIXaasr3std11is_integralIT_EE5valueeqstS4_Lm2EES4_E4typeES4_: 28| 1.64k| { 29| 1.64k| #if defined(JSONCONS_BYTE_SWAP_16) 30| 1.64k| return JSONCONS_BYTE_SWAP_16(val); ------------------ | | 466| 1.64k|# define JSONCONS_BYTE_SWAP_16 __builtin_bswap16 ------------------ 31| | #else 32| | return (static_cast(val) >> 8) | (static_cast(val) << 8); 33| | #endif 34| 1.64k| } _ZN8jsoncons6binary13big_to_nativeIiNS_6detail6endianEEENSt3__19enable_ifIXeqsrT0_6nativesrS6_6littleET_E4typeEPKhm: 182| 21| { 183| 21| if (sizeof(T) > count) ------------------ | Branch (183:13): [True: 0, False: 21] ------------------ 184| 0| { 185| 0| return T{}; 186| 0| } 187| 21| T val; 188| 21| std::memcpy(&val,first,sizeof(T)); 189| 21| return byte_swap(val); 190| 21| } _ZN8jsoncons6binary9byte_swapIiEENSt3__19enable_ifIXaasr3std11is_integralIT_EE5valueeqstS4_Lm4EES4_E4typeES4_: 39| 21| { 40| 21| #if defined(JSONCONS_BYTE_SWAP_32) 41| 21| return JSONCONS_BYTE_SWAP_32(val); ------------------ | | 462| 21|# define JSONCONS_BYTE_SWAP_32 __builtin_bswap32 ------------------ 42| | #else 43| | uint32_t tmp = ((static_cast(val) << 8) & 0xff00ff00) | ((static_cast(val) >> 8) & 0xff00ff); 44| | return (tmp << 16) | (tmp >> 16); 45| | #endif 46| 21| } _ZN8jsoncons6binary13big_to_nativeIlNS_6detail6endianEEENSt3__19enable_ifIXeqsrT0_6nativesrS6_6littleET_E4typeEPKhm: 182| 88| { 183| 88| if (sizeof(T) > count) ------------------ | Branch (183:13): [True: 0, False: 88] ------------------ 184| 0| { 185| 0| return T{}; 186| 0| } 187| 88| T val; 188| 88| std::memcpy(&val,first,sizeof(T)); 189| 88| return byte_swap(val); 190| 88| } _ZN8jsoncons6binary9byte_swapIlEENSt3__19enable_ifIXaasr3std11is_integralIT_EE5valueeqstS4_Lm8EES4_E4typeES4_: 51| 88| { 52| 88| #if defined(JSONCONS_BYTE_SWAP_64) 53| 88| return JSONCONS_BYTE_SWAP_64(val); ------------------ | | 461| 88|# define JSONCONS_BYTE_SWAP_64 __builtin_bswap64 ------------------ 54| | #else 55| | uint64_t tmp = ((static_cast(val) & 0x00000000ffffffffull) << 32) | ((static_cast(val) & 0xffffffff00000000ull) >> 32); 56| | tmp = ((tmp & 0x0000ffff0000ffffull) << 16) | ((tmp & 0xffff0000ffff0000ull) >> 16); 57| | return ((tmp & 0x00ff00ff00ff00ffull) << 8) | ((tmp & 0xff00ff00ff00ff00ull) >> 8); 58| | #endif 59| 88| } _ZN8jsoncons6binary13big_to_nativeIfNS_6detail6endianEEENSt3__19enable_ifIXeqsrT0_6nativesrS6_6littleET_E4typeEPKhm: 182| 3| { 183| 3| if (sizeof(T) > count) ------------------ | Branch (183:13): [True: 0, False: 3] ------------------ 184| 0| { 185| 0| return T{}; 186| 0| } 187| 3| T val; 188| 3| std::memcpy(&val,first,sizeof(T)); 189| 3| return byte_swap(val); 190| 3| } _ZN8jsoncons6binary9byte_swapIfEENSt3__19enable_ifIXaasr3std17is_floating_pointIT_EE5valueeqstS4_Lm4EES4_E4typeES4_: 64| 3| { 65| 3| uint32_t x; 66| 3| std::memcpy(&x,&val,sizeof(uint32_t)); 67| 3| uint32_t y = byte_swap(x); 68| 3| T val2; 69| 3| std::memcpy(&val2,&y,sizeof(uint32_t)); 70| 3| return val2; 71| 3| } _ZN8jsoncons6binary9byte_swapIjEENSt3__19enable_ifIXaasr3std11is_integralIT_EE5valueeqstS4_Lm4EES4_E4typeES4_: 39| 3| { 40| 3| #if defined(JSONCONS_BYTE_SWAP_32) 41| 3| return JSONCONS_BYTE_SWAP_32(val); ------------------ | | 462| 3|# define JSONCONS_BYTE_SWAP_32 __builtin_bswap32 ------------------ 42| | #else 43| | uint32_t tmp = ((static_cast(val) << 8) & 0xff00ff00) | ((static_cast(val) >> 8) & 0xff00ff); 44| | return (tmp << 16) | (tmp >> 16); 45| | #endif 46| 3| } _ZN8jsoncons6binary13big_to_nativeIdNS_6detail6endianEEENSt3__19enable_ifIXeqsrT0_6nativesrS6_6littleET_E4typeEPKhm: 182| 48| { 183| 48| if (sizeof(T) > count) ------------------ | Branch (183:13): [True: 0, False: 48] ------------------ 184| 0| { 185| 0| return T{}; 186| 0| } 187| 48| T val; 188| 48| std::memcpy(&val,first,sizeof(T)); 189| 48| return byte_swap(val); 190| 48| } _ZN8jsoncons6binary9byte_swapIdEENSt3__19enable_ifIXaasr3std17is_floating_pointIT_EE5valueeqstS4_Lm8EES4_E4typeES4_: 76| 48| { 77| 48| uint64_t x; 78| 48| std::memcpy(&x,&val,sizeof(uint64_t)); 79| 48| uint64_t y = byte_swap(x); 80| 48| T val2; 81| 48| std::memcpy(&val2,&y,sizeof(uint64_t)); 82| 48| return val2; 83| 48| } _ZN8jsoncons6binary9byte_swapImEENSt3__19enable_ifIXaasr3std11is_integralIT_EE5valueeqstS4_Lm8EES4_E4typeES4_: 51| 48| { 52| 48| #if defined(JSONCONS_BYTE_SWAP_64) 53| 48| return JSONCONS_BYTE_SWAP_64(val); ------------------ | | 461| 48|# define JSONCONS_BYTE_SWAP_64 __builtin_bswap64 ------------------ 54| | #else 55| | uint64_t tmp = ((static_cast(val) & 0x00000000ffffffffull) << 32) | ((static_cast(val) & 0xffffffff00000000ull) >> 32); 56| | tmp = ((tmp & 0x0000ffff0000ffffull) << 16) | ((tmp & 0xffff0000ffff0000ull) >> 16); 57| | return ((tmp & 0x00ff00ff00ff00ffull) << 8) | ((tmp & 0xff00ff00ff00ff00ull) >> 8); 58| | #endif 59| 48| } _ZN8jsoncons9is_base10IhEEbPKT_m: 164| 172|{ 165| 172| integer_chars_state state = integer_chars_state::initial; 166| | 167| 172| const CharT* end = s + length; 168| 325| for (;s < end; ++s) ------------------ | Branch (168:11): [True: 257, False: 68] ------------------ 169| 257| { 170| 257| switch(state) 171| 257| { 172| 172| case integer_chars_state::initial: ------------------ | Branch (172:13): [True: 172, False: 85] ------------------ 173| 172| { 174| 172| switch(*s) 175| 172| { 176| 3| case '0':case '1':case '2':case '3':case '4':case '5':case '6':case '7':case '8': case '9': ------------------ | Branch (176:21): [True: 1, False: 171] | Branch (176:30): [True: 1, False: 171] | Branch (176:39): [True: 0, False: 172] | Branch (176:48): [True: 0, False: 172] | Branch (176:57): [True: 0, False: 172] | Branch (176:66): [True: 0, False: 172] | Branch (176:75): [True: 1, False: 171] | Branch (176:84): [True: 0, False: 172] | Branch (176:93): [True: 0, False: 172] | Branch (176:103): [True: 0, False: 172] ------------------ 177| 3| state = integer_chars_state::decimal; 178| 3| break; 179| 82| case '-': ------------------ | Branch (179:21): [True: 82, False: 90] ------------------ 180| 82| state = integer_chars_state::minus; 181| 82| break; 182| 87| default: ------------------ | Branch (182:21): [True: 87, False: 85] ------------------ 183| 87| return false; 184| 172| } 185| 85| break; 186| 172| } 187| 85| case integer_chars_state::minus: ------------------ | Branch (187:13): [True: 17, False: 240] ------------------ 188| 17| { 189| 17| switch(*s) 190| 17| { 191| 17| case '0':case '1':case '2':case '3':case '4':case '5':case '6':case '7':case '8': case '9': ------------------ | Branch (191:21): [True: 17, False: 0] | Branch (191:30): [True: 0, False: 17] | Branch (191:39): [True: 0, False: 17] | Branch (191:48): [True: 0, False: 17] | Branch (191:57): [True: 0, False: 17] | Branch (191:66): [True: 0, False: 17] | Branch (191:75): [True: 0, False: 17] | Branch (191:84): [True: 0, False: 17] | Branch (191:93): [True: 0, False: 17] | Branch (191:103): [True: 0, False: 17] ------------------ 192| 17| state = integer_chars_state::decimal; 193| 17| break; 194| 0| default: ------------------ | Branch (194:21): [True: 0, False: 17] ------------------ 195| 0| return false; 196| 17| } 197| 17| break; 198| 17| } 199| 68| case integer_chars_state::decimal: ------------------ | Branch (199:13): [True: 68, False: 189] ------------------ 200| 68| { 201| 68| switch(*s) 202| 68| { 203| 51| case '0':case '1':case '2':case '3':case '4':case '5':case '6':case '7':case '8': case '9': ------------------ | Branch (203:21): [True: 0, False: 68] | Branch (203:30): [True: 4, False: 64] | Branch (203:39): [True: 13, False: 55] | Branch (203:48): [True: 0, False: 68] | Branch (203:57): [True: 17, False: 51] | Branch (203:66): [True: 0, False: 68] | Branch (203:75): [True: 0, False: 68] | Branch (203:84): [True: 17, False: 51] | Branch (203:93): [True: 0, False: 68] | Branch (203:103): [True: 0, False: 68] ------------------ 204| 51| break; 205| 17| default: ------------------ | Branch (205:21): [True: 17, False: 51] ------------------ 206| 17| return false; 207| 68| } 208| 51| break; 209| 68| } 210| 51| default: ------------------ | Branch (210:13): [True: 0, False: 257] ------------------ 211| 0| break; 212| 257| } 213| 257| } 214| 68| return state == integer_chars_state::decimal ? true : false; ------------------ | Branch (214:12): [True: 3, False: 65] ------------------ 215| 172|} _ZN8jsoncons14unicode_traits8validateIhEENSt3__19enable_ifIXsr10ext_traits8is_char8IT_EE5valueENS0_14unicode_resultIS4_EEE4typeEPKS4_m: 1147| 482k| { 1148| 482k| const uint8_t* it = reinterpret_cast(data); 1149| 482k| const uint8_t* end = it + length; 1150| | 1151| 482k| unicode_errc result{}; 1152| 818k| while (it != end) ------------------ | Branch (1152:16): [True: 336k, False: 482k] ------------------ 1153| 336k| { 1154| 336k| if ((end - it) >= 8) ------------------ | Branch (1154:17): [True: 166k, False: 169k] ------------------ 1155| 166k| { 1156| 1.15M| JSONCONS_REPEAT8({if (JSONCONS_LIKELY((*it & 0x80) == 0)) ++it; else goto non_ascii;}) ------------------ | | 281| 333k|#define JSONCONS_REPEAT8(x) { x x x x x x x x } | | ------------------ | | | Branch (281:32): [True: 166k, False: 55] | | | Branch (281:34): [True: 166k, False: 64] | | | Branch (281:36): [True: 166k, False: 4] | | | Branch (281:38): [True: 166k, False: 46] | | | Branch (281:40): [True: 166k, False: 217] | | | Branch (281:42): [True: 165k, False: 263] | | | Branch (281:44): [True: 160k, False: 5.07k] | | | Branch (281:46): [True: 145k, False: 15.4k] | | ------------------ ------------------ 1157| 145k| continue; 1158| 1.15M| } 1159| 190k| non_ascii: 1160| 190k| const std::size_t len = static_cast(trailing_bytes_for_utf8[*it]) + 1; 1161| 190k| if (len > (std::size_t)(end - it)) ------------------ | Branch (1161:17): [True: 0, False: 190k] ------------------ 1162| 0| { 1163| 0| return unicode_result{reinterpret_cast(it), unicode_errc::source_exhausted}; 1164| 0| } 1165| 190k| if ((result=is_legal_utf8(it, len)) != unicode_errc()) ------------------ | Branch (1165:17): [True: 3, False: 190k] ------------------ 1166| 3| { 1167| 3| return unicode_result{reinterpret_cast(it),result} ; 1168| 3| } 1169| 190k| it += len; 1170| 190k| } 1171| 482k| return unicode_result{reinterpret_cast(it),result} ; 1172| 482k| } _ZN8jsoncons14unicode_traits13is_legal_utf8EPKhm: 305| 190k| { 306| 190k| const uint8_t* it = reinterpret_cast(bytes); 307| 190k| const uint8_t* end = it+length; 308| | 309| 190k| uint8_t byte; 310| 190k| switch (length) { 311| 3| default: ------------------ | Branch (311:9): [True: 3, False: 190k] ------------------ 312| 3| return unicode_errc::over_long_utf8_sequence; 313| 2| case 4: ------------------ | Branch (313:9): [True: 2, False: 190k] ------------------ 314| 2| if (((byte = (*--end))& 0xC0) != 0x80) ------------------ | Branch (314:17): [True: 0, False: 2] ------------------ 315| 0| return unicode_errc::bad_continuation_byte; 316| 2| JSONCONS_FALLTHROUGH; ------------------ | | 564| 2|# define JSONCONS_FALLTHROUGH [[fallthrough]] ------------------ 317| 2| case 3: ------------------ | Branch (317:9): [True: 0, False: 190k] ------------------ 318| 2| if (((byte = (*--end))& 0xC0) != 0x80) ------------------ | Branch (318:17): [True: 0, False: 2] ------------------ 319| 0| return unicode_errc::bad_continuation_byte; 320| 2| JSONCONS_FALLTHROUGH; ------------------ | | 564| 2|# define JSONCONS_FALLTHROUGH [[fallthrough]] ------------------ 321| 21.2k| case 2: ------------------ | Branch (321:9): [True: 21.2k, False: 169k] ------------------ 322| 21.2k| if (((byte = (*--end))& 0xC0) != 0x80) ------------------ | Branch (322:17): [True: 0, False: 21.2k] ------------------ 323| 0| return unicode_errc::bad_continuation_byte; 324| | 325| 21.2k| switch (*it) 326| 21.2k| { 327| | // no fall-through in this inner switch 328| 0| case 0xE0: if (byte < 0xA0) return unicode_errc::source_illegal; break; ------------------ | Branch (328:17): [True: 0, False: 21.2k] | Branch (328:32): [True: 0, False: 0] ------------------ 329| 0| case 0xED: if (byte > 0x9F) return unicode_errc::source_illegal; break; ------------------ | Branch (329:17): [True: 0, False: 21.2k] | Branch (329:32): [True: 0, False: 0] ------------------ 330| 0| case 0xF0: if (byte < 0x90) return unicode_errc::source_illegal; break; ------------------ | Branch (330:17): [True: 0, False: 21.2k] | Branch (330:32): [True: 0, False: 0] ------------------ 331| 0| case 0xF4: if (byte > 0x8F) return unicode_errc::source_illegal; break; ------------------ | Branch (331:17): [True: 0, False: 21.2k] | Branch (331:32): [True: 0, False: 0] ------------------ 332| 21.2k| default: if (byte < 0x80) return unicode_errc::source_illegal; ------------------ | Branch (332:17): [True: 21.2k, False: 0] | Branch (332:32): [True: 0, False: 21.2k] ------------------ 333| 21.2k| } 334| | 335| 21.2k| JSONCONS_FALLTHROUGH; ------------------ | | 564| 21.2k|# define JSONCONS_FALLTHROUGH [[fallthrough]] ------------------ 336| 190k| case 1: ------------------ | Branch (336:9): [True: 169k, False: 21.2k] ------------------ 337| 190k| if (*it >= 0x80 && *it < 0xC2) ------------------ | Branch (337:17): [True: 21.2k, False: 169k] | Branch (337:32): [True: 0, False: 21.2k] ------------------ 338| 0| return unicode_errc::source_illegal; 339| 190k| break; 340| 190k| } 341| 190k| if (*it > 0xF4) ------------------ | Branch (341:13): [True: 0, False: 190k] ------------------ 342| 0| return unicode_errc::source_illegal; 343| | 344| 190k| return unicode_errc(); 345| 190k| } _ZN8jsoncons6ubjson15make_error_codeENS0_11ubjson_errcE: 90| 38|{ 91| 38| return std::error_code(static_cast(e),ubjson_error_category()); 92| 38|} _ZN8jsoncons6ubjson21ubjson_error_categoryEv: 83| 38|{ 84| 38| static ubjson_error_category_impl instance; 85| 38| return instance; 86| 38|} _ZN8jsoncons6ubjson21ubjson_decode_optionsC1Ev: 38| 39| ubjson_decode_options() = default; _ZN8jsoncons6ubjson21ubjson_options_commonC2Ev: 23| 39| ubjson_options_common() = default; _ZN8jsoncons6ubjson21ubjson_options_commonD2Ev: 25| 39| virtual ~ubjson_options_common() = default; _ZNK8jsoncons6ubjson21ubjson_options_common17max_nesting_depthEv: 28| 39| { 29| 39| return max_nesting_depth_; 30| 39| } _ZNK8jsoncons6ubjson21ubjson_decode_options9max_itemsEv: 44| 39| { 45| 39| return max_items_; 46| 39| } _ZN8jsoncons6ubjson19basic_ubjson_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEEC2IRNS3_19basic_istringstreamIcNS3_11char_traitsIcEES7_EEEEOT_RKNS0_21ubjson_decode_optionsERKS7_: 79| 39| : source_(std::forward(source)), 80| 39| max_nesting_depth_(options.max_nesting_depth()), 81| 39| max_items_(options.max_items()), 82| 39| text_buffer_(alloc), 83| 39| state_stack_(alloc) 84| 39| { 85| 39| state_stack_.emplace_back(parse_mode::root,0); 86| 39| } _ZN8jsoncons6ubjson11parse_stateC2ENS0_10parse_modeEmh: 45| 2.74M| : mode(mode), length(length), type(type) 46| 2.74M| { 47| 2.74M| } _ZN8jsoncons6ubjson19basic_ubjson_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE5resetEv: 94| 39| { 95| 39| more_ = true; 96| 39| done_ = false; 97| 39| text_buffer_.clear(); 98| 39| state_stack_.clear(); 99| 39| state_stack_.emplace_back(parse_mode::root,0,uint8_t(0)); 100| 39| nesting_depth_ = 0; 101| 39| } _ZN8jsoncons6ubjson19basic_ubjson_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE5parseERNS_18basic_json_visitorIcEERNS3_10error_codeE: 151| 39| { 152| 12.1M| while (!done_ && more_) ------------------ | Branch (152:16): [True: 12.1M, False: 2] | Branch (152:26): [True: 12.1M, False: 0] ------------------ 153| 12.1M| { 154| 12.1M| switch (state_stack_.back().mode) ------------------ | Branch (154:21): [True: 12.1M, False: 0] ------------------ 155| 12.1M| { 156| 3.88k| case parse_mode::array: ------------------ | Branch (156:17): [True: 3.88k, False: 12.1M] ------------------ 157| 3.88k| { 158| 3.88k| if (state_stack_.back().index < state_stack_.back().length) ------------------ | Branch (158:25): [True: 2.19k, False: 1.68k] ------------------ 159| 2.19k| { 160| 2.19k| ++state_stack_.back().index; 161| 2.19k| read_type_and_value(visitor, ec); 162| 2.19k| if (JSONCONS_UNLIKELY(ec)) ------------------ | | 78| 2.19k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 0, False: 2.19k] | | ------------------ ------------------ 163| 0| { 164| 0| return; 165| 0| } 166| 2.19k| } 167| 1.68k| else 168| 1.68k| { 169| 1.68k| end_array(visitor, ec); 170| 1.68k| } 171| 3.88k| break; 172| 3.88k| } 173| 4.20M| case parse_mode::strongly_typed_array: ------------------ | Branch (173:17): [True: 4.20M, False: 7.94M] ------------------ 174| 4.20M| { 175| 4.20M| if (state_stack_.back().index < state_stack_.back().length) ------------------ | Branch (175:25): [True: 4.20M, False: 812] ------------------ 176| 4.20M| { 177| 4.20M| ++state_stack_.back().index; 178| 4.20M| read_value(visitor, state_stack_.back().type, ec); 179| 4.20M| if (JSONCONS_UNLIKELY(ec)) ------------------ | | 78| 4.20M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 6, False: 4.20M] | | ------------------ ------------------ 180| 6| { 181| 6| return; 182| 6| } 183| 4.20M| } 184| 812| else 185| 812| { 186| 812| end_array(visitor, ec); 187| 812| } 188| 4.20M| break; 189| 4.20M| } 190| 5.45M| case parse_mode::indefinite_array: ------------------ | Branch (190:17): [True: 5.45M, False: 6.69M] ------------------ 191| 5.45M| { 192| 5.45M| auto c = source_.peek(); 193| 5.45M| if (JSONCONS_UNLIKELY(c.eof)) ------------------ | | 78| 5.45M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 5, False: 5.45M] | | ------------------ ------------------ 194| 5| { 195| 5| ec = ubjson_errc::unexpected_eof; 196| 5| more_ = false; 197| 5| return; 198| 5| } 199| 5.45M| if (c.value == jsoncons::ubjson::ubjson_type::end_array_marker) ------------------ | Branch (199:25): [True: 1.17M, False: 4.27M] ------------------ 200| 1.17M| { 201| 1.17M| source_.ignore(1); 202| 1.17M| end_array(visitor, ec); 203| 1.17M| if (JSONCONS_UNLIKELY(ec)) ------------------ | | 78| 1.17M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 0, False: 1.17M] | | ------------------ ------------------ 204| 0| { 205| 0| return; 206| 0| } 207| 1.17M| } 208| 4.27M| else 209| 4.27M| { 210| 4.27M| if (++state_stack_.back().index > max_items_) ------------------ | Branch (210:29): [True: 0, False: 4.27M] ------------------ 211| 0| { 212| 0| ec = ubjson_errc::max_items_exceeded; 213| 0| more_ = false; 214| 0| return; 215| 0| } 216| 4.27M| read_type_and_value(visitor, ec); 217| 4.27M| if (JSONCONS_UNLIKELY(ec)) ------------------ | | 78| 4.27M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 7, False: 4.27M] | | ------------------ ------------------ 218| 7| { 219| 7| return; 220| 7| } 221| 4.27M| } 222| 5.45M| break; 223| 5.45M| } 224| 5.45M| case parse_mode::map_key: ------------------ | Branch (224:17): [True: 17, False: 12.1M] ------------------ 225| 17| { 226| 17| if (state_stack_.back().index < state_stack_.back().length) ------------------ | Branch (226:25): [True: 5, False: 12] ------------------ 227| 5| { 228| 5| ++state_stack_.back().index; 229| 5| read_key(visitor, ec); 230| 5| if (JSONCONS_UNLIKELY(ec)) ------------------ | | 78| 5|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 0, False: 5] | | ------------------ ------------------ 231| 0| { 232| 0| return; 233| 0| } 234| 5| state_stack_.back().mode = parse_mode::map_value; 235| 5| } 236| 12| else 237| 12| { 238| 12| end_object(visitor, ec); 239| 12| } 240| 17| break; 241| 17| } 242| 17| case parse_mode::map_value: ------------------ | Branch (242:17): [True: 5, False: 12.1M] ------------------ 243| 5| { 244| 5| state_stack_.back().mode = parse_mode::map_key; 245| 5| read_type_and_value(visitor, ec); 246| 5| if (JSONCONS_UNLIKELY(ec)) ------------------ | | 78| 5|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 0, False: 5] | | ------------------ ------------------ 247| 0| { 248| 0| return; 249| 0| } 250| 5| break; 251| 5| } 252| 3.31k| case parse_mode::strongly_typed_map_key: ------------------ | Branch (252:17): [True: 3.31k, False: 12.1M] ------------------ 253| 3.31k| { 254| 3.31k| if (state_stack_.back().index < state_stack_.back().length) ------------------ | Branch (254:25): [True: 0, False: 3.31k] ------------------ 255| 0| { 256| 0| ++state_stack_.back().index; 257| 0| read_key(visitor, ec); 258| 0| if (JSONCONS_UNLIKELY(ec)) ------------------ | | 78| 0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 0, False: 0] | | ------------------ ------------------ 259| 0| { 260| 0| return; 261| 0| } 262| 0| state_stack_.back().mode = parse_mode::strongly_typed_map_value; 263| 0| } 264| 3.31k| else 265| 3.31k| { 266| 3.31k| end_object(visitor, ec); 267| 3.31k| } 268| 3.31k| break; 269| 3.31k| } 270| 3.31k| case parse_mode::strongly_typed_map_value: ------------------ | Branch (270:17): [True: 0, False: 12.1M] ------------------ 271| 0| { 272| 0| state_stack_.back().mode = parse_mode::strongly_typed_map_key; 273| 0| read_value(visitor, state_stack_.back().type, ec); 274| 0| if (JSONCONS_UNLIKELY(ec)) ------------------ | | 78| 0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 0, False: 0] | | ------------------ ------------------ 275| 0| { 276| 0| return; 277| 0| } 278| 0| break; 279| 0| } 280| 2.02M| case parse_mode::indefinite_map_key: ------------------ | Branch (280:17): [True: 2.02M, False: 10.1M] ------------------ 281| 2.02M| { 282| 2.02M| auto c = source_.peek(); 283| 2.02M| if (JSONCONS_UNLIKELY(c.eof)) ------------------ | | 78| 2.02M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 1, False: 2.02M] | | ------------------ ------------------ 284| 1| { 285| 1| ec = ubjson_errc::unexpected_eof; 286| 1| more_ = false; 287| 1| return; 288| 1| } 289| 2.02M| if (c.value == jsoncons::ubjson::ubjson_type::end_object_marker) ------------------ | Branch (289:25): [True: 1.55M, False: 464k] ------------------ 290| 1.55M| { 291| 1.55M| source_.ignore(1); 292| 1.55M| end_object(visitor, ec); 293| 1.55M| if (JSONCONS_UNLIKELY(ec)) ------------------ | | 78| 1.55M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 0, False: 1.55M] | | ------------------ ------------------ 294| 0| { 295| 0| return; 296| 0| } 297| 1.55M| } 298| 464k| else 299| 464k| { 300| 464k| if (++state_stack_.back().index > max_items_) ------------------ | Branch (300:29): [True: 0, False: 464k] ------------------ 301| 0| { 302| 0| ec = ubjson_errc::max_items_exceeded; 303| 0| more_ = false; 304| 0| return; 305| 0| } 306| 464k| read_key(visitor, ec); 307| 464k| if (JSONCONS_UNLIKELY(ec)) ------------------ | | 78| 464k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 6, False: 464k] | | ------------------ ------------------ 308| 6| { 309| 6| return; 310| 6| } 311| 464k| state_stack_.back().mode = parse_mode::indefinite_map_value; 312| 464k| } 313| 2.02M| break; 314| 2.02M| } 315| 2.02M| case parse_mode::indefinite_map_value: ------------------ | Branch (315:17): [True: 464k, False: 11.6M] ------------------ 316| 464k| { 317| 464k| state_stack_.back().mode = parse_mode::indefinite_map_key; 318| 464k| read_type_and_value(visitor, ec); 319| 464k| if (JSONCONS_UNLIKELY(ec)) ------------------ | | 78| 464k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 2, False: 464k] | | ------------------ ------------------ 320| 2| { 321| 2| return; 322| 2| } 323| 464k| break; 324| 464k| } 325| 464k| case parse_mode::root: ------------------ | Branch (325:17): [True: 39, False: 12.1M] ------------------ 326| 39| { 327| 39| state_stack_.back().mode = parse_mode::accept; 328| 39| read_type_and_value(visitor, ec); 329| 39| if (JSONCONS_UNLIKELY(ec)) ------------------ | | 78| 39|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 10, False: 29] | | ------------------ ------------------ 330| 10| { 331| 10| return; 332| 10| } 333| 29| break; 334| 39| } 335| 29| case parse_mode::accept: ------------------ | Branch (335:17): [True: 2, False: 12.1M] ------------------ 336| 2| { 337| 2| JSONCONS_ASSERT(state_stack_.size() == 1); ------------------ | | 49| 2|#define JSONCONS_ASSERT(x) if (!(x)) { \ | | ------------------ | | | Branch (49:32): [True: 0, False: 2] | | ------------------ | | 50| 0| JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at <> :" \ | | ------------------ | | | | 35| 0| #define JSONCONS_THROW(exception) throw exception | | ------------------ | | 51| 0| JSONCONS_STR( 0 ))); } ------------------ 338| 2| state_stack_.clear(); 339| 2| more_ = false; 340| 2| done_ = true; 341| 2| visitor.flush(); 342| 2| break; 343| 2| } 344| 12.1M| } 345| 12.1M| } 346| 39| } _ZN8jsoncons6ubjson19basic_ubjson_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE19read_type_and_valueERNS_18basic_json_visitorIcEERNS3_10error_codeE: 349| 4.74M| { 350| 4.74M| if (source_.is_error()) ------------------ | Branch (350:13): [True: 0, False: 4.74M] ------------------ 351| 0| { 352| 0| ec = ubjson_errc::source_error; 353| 0| more_ = false; 354| 0| return; 355| 0| } 356| | 357| 4.74M| uint8_t b; 358| 4.74M| if (source_.read(&b, 1) == 0) ------------------ | Branch (358:13): [True: 1, False: 4.74M] ------------------ 359| 1| { 360| 1| ec = ubjson_errc::unexpected_eof; 361| 1| more_ = false; 362| 1| return; 363| 1| } 364| 4.74M| read_value(visitor, b, ec); 365| 4.74M| } _ZN8jsoncons6ubjson19basic_ubjson_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE9end_arrayERNS_18basic_json_visitorIcEERNS3_10error_codeE: 671| 1.18M| { 672| 1.18M| --nesting_depth_; 673| | 674| 1.18M| visitor.end_array(*this, ec); 675| 1.18M| more_ = !cursor_mode_; 676| 1.18M| if (level() == mark_level_) ------------------ | Branch (676:13): [True: 0, False: 1.18M] ------------------ 677| 0| { 678| 0| more_ = false; 679| 0| } 680| 1.18M| state_stack_.pop_back(); 681| 1.18M| } _ZNK8jsoncons6ubjson19basic_ubjson_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE5levelEv: 116| 2.74M| { 117| 2.74M| return static_cast(state_stack_.size()); 118| 2.74M| } _ZN8jsoncons6ubjson19basic_ubjson_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE10read_valueERNS_18basic_json_visitorIcEEhRNS3_10error_codeE: 368| 8.94M| { 369| 8.94M| switch (type) 370| 8.94M| { 371| 3.71M| case jsoncons::ubjson::ubjson_type::null_type: ------------------ | Branch (371:13): [True: 3.71M, False: 5.22M] ------------------ 372| 3.71M| { 373| 3.71M| visitor.null_value(semantic_tag::none, *this, ec); 374| 3.71M| more_ = !cursor_mode_; 375| 3.71M| break; 376| 0| } 377| 424k| case jsoncons::ubjson::ubjson_type::no_op_type: ------------------ | Branch (377:13): [True: 424k, False: 8.52M] ------------------ 378| 424k| { 379| 424k| break; 380| 0| } 381| 437k| case jsoncons::ubjson::ubjson_type::true_type: ------------------ | Branch (381:13): [True: 437k, False: 8.51M] ------------------ 382| 437k| { 383| 437k| visitor.bool_value(true, semantic_tag::none, *this, ec); 384| 437k| more_ = !cursor_mode_; 385| 437k| break; 386| 0| } 387| 3.47k| case jsoncons::ubjson::ubjson_type::false_type: ------------------ | Branch (387:13): [True: 3.47k, False: 8.94M] ------------------ 388| 3.47k| { 389| 3.47k| visitor.bool_value(false, semantic_tag::none, *this, ec); 390| 3.47k| more_ = !cursor_mode_; 391| 3.47k| break; 392| 0| } 393| 1.60M| case jsoncons::ubjson::ubjson_type::int8_type: ------------------ | Branch (393:13): [True: 1.60M, False: 7.34M] ------------------ 394| 1.60M| { 395| 1.60M| uint8_t buf[sizeof(int8_t)]; 396| 1.60M| if (source_.read(buf, sizeof(int8_t)) != sizeof(int8_t)) ------------------ | Branch (396:21): [True: 2, False: 1.60M] ------------------ 397| 2| { 398| 2| ec = ubjson_errc::unexpected_eof; 399| 2| more_ = false; 400| 2| return; 401| 2| } 402| 1.60M| int8_t val = binary::big_to_native(buf, sizeof(buf)); 403| 1.60M| visitor.int64_value(val, semantic_tag::none, *this, ec); 404| 1.60M| more_ = !cursor_mode_; 405| 1.60M| break; 406| 1.60M| } 407| 294| case jsoncons::ubjson::ubjson_type::uint8_type: ------------------ | Branch (407:13): [True: 294, False: 8.94M] ------------------ 408| 294| { 409| 294| uint8_t b; 410| 294| if (source_.read(&b, 1) == 0) ------------------ | Branch (410:21): [True: 0, False: 294] ------------------ 411| 0| { 412| 0| ec = ubjson_errc::unexpected_eof; 413| 0| more_ = false; 414| 0| return; 415| 0| } 416| 294| visitor.uint64_value(b, semantic_tag::none, *this, ec); 417| 294| more_ = !cursor_mode_; 418| 294| break; 419| 294| } 420| 837| case jsoncons::ubjson::ubjson_type::int16_type: ------------------ | Branch (420:13): [True: 837, False: 8.94M] ------------------ 421| 837| { 422| 837| uint8_t buf[sizeof(int16_t)]; 423| 837| if (source_.read(buf, sizeof(int16_t)) != sizeof(int16_t)) ------------------ | Branch (423:21): [True: 0, False: 837] ------------------ 424| 0| { 425| 0| ec = ubjson_errc::unexpected_eof; 426| 0| more_ = false; 427| 0| return; 428| 0| } 429| 837| int16_t val = binary::big_to_native(buf, sizeof(buf)); 430| 837| visitor.int64_value(val, semantic_tag::none, *this, ec); 431| 837| more_ = !cursor_mode_; 432| 837| break; 433| 837| } 434| 7| case jsoncons::ubjson::ubjson_type::int32_type: ------------------ | Branch (434:13): [True: 7, False: 8.94M] ------------------ 435| 7| { 436| 7| uint8_t buf[sizeof(int32_t)]; 437| 7| if (source_.read(buf, sizeof(int32_t)) != sizeof(int32_t)) ------------------ | Branch (437:21): [True: 0, False: 7] ------------------ 438| 0| { 439| 0| ec = ubjson_errc::unexpected_eof; 440| 0| more_ = false; 441| 0| return; 442| 0| } 443| 7| int32_t val = binary::big_to_native(buf, sizeof(buf)); 444| 7| visitor.int64_value(val, semantic_tag::none, *this, ec); 445| 7| more_ = !cursor_mode_; 446| 7| break; 447| 7| } 448| 81| case jsoncons::ubjson::ubjson_type::int64_type: ------------------ | Branch (448:13): [True: 81, False: 8.94M] ------------------ 449| 81| { 450| 81| uint8_t buf[sizeof(int64_t)]; 451| 81| if (source_.read(buf, sizeof(int64_t)) != sizeof(int64_t)) ------------------ | Branch (451:21): [True: 0, False: 81] ------------------ 452| 0| { 453| 0| ec = ubjson_errc::unexpected_eof; 454| 0| more_ = false; 455| 0| return; 456| 0| } 457| 81| int64_t val = binary::big_to_native(buf, sizeof(buf)); 458| 81| visitor.int64_value(val, semantic_tag::none, *this, ec); 459| 81| more_ = !cursor_mode_; 460| 81| break; 461| 81| } 462| 3| case jsoncons::ubjson::ubjson_type::float32_type: ------------------ | Branch (462:13): [True: 3, False: 8.94M] ------------------ 463| 3| { 464| 3| uint8_t buf[sizeof(float)]; 465| 3| if (source_.read(buf, sizeof(float)) != sizeof(float)) ------------------ | Branch (465:21): [True: 0, False: 3] ------------------ 466| 0| { 467| 0| ec = ubjson_errc::unexpected_eof; 468| 0| more_ = false; 469| 0| return; 470| 0| } 471| 3| float val = binary::big_to_native(buf, sizeof(buf)); 472| 3| visitor.double_value(val, semantic_tag::none, *this, ec); 473| 3| more_ = !cursor_mode_; 474| 3| break; 475| 3| } 476| 48| case jsoncons::ubjson::ubjson_type::float64_type: ------------------ | Branch (476:13): [True: 48, False: 8.94M] ------------------ 477| 48| { 478| 48| uint8_t buf[sizeof(double)]; 479| 48| if (source_.read(buf, sizeof(double)) != sizeof(double)) ------------------ | Branch (479:21): [True: 0, False: 48] ------------------ 480| 0| { 481| 0| ec = ubjson_errc::unexpected_eof; 482| 0| more_ = false; 483| 0| return; 484| 0| } 485| 48| double val = binary::big_to_native(buf, sizeof(buf)); 486| 48| visitor.double_value(val, semantic_tag::none, *this, ec); 487| 48| more_ = !cursor_mode_; 488| 48| break; 489| 48| } 490| 24| case jsoncons::ubjson::ubjson_type::char_type: ------------------ | Branch (490:13): [True: 24, False: 8.94M] ------------------ 491| 24| { 492| 24| uint8_t ch{}; 493| 24| if (source_.read(&ch, 1) != 1) ------------------ | Branch (493:21): [True: 0, False: 24] ------------------ 494| 0| { 495| 0| ec = ubjson_errc::unexpected_eof; 496| 0| more_ = false; 497| 0| return; 498| 0| } 499| 24| auto result = unicode_traits::validate(&ch, 1); 500| 24| if (result.ec != unicode_traits::unicode_errc()) ------------------ | Branch (500:21): [True: 0, False: 24] ------------------ 501| 0| { 502| 0| ec = ubjson_errc::invalid_utf8_text_string; 503| 0| more_ = false; 504| 0| return; 505| 0| } 506| 24| visitor.string_value(string_view(reinterpret_cast(&ch), 1), semantic_tag::none, *this, ec); 507| 24| more_ = !cursor_mode_; 508| 24| break; 509| 24| } 510| 18.5k| case jsoncons::ubjson::ubjson_type::string_type: ------------------ | Branch (510:13): [True: 18.5k, False: 8.93M] ------------------ 511| 18.5k| { 512| 18.5k| std::size_t length = get_length(ec); 513| 18.5k| if (JSONCONS_UNLIKELY(ec)) ------------------ | | 78| 18.5k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 0, False: 18.5k] | | ------------------ ------------------ 514| 0| { 515| 0| return; 516| 0| } 517| 18.5k| auto data = source_.read_span(length, text_buffer_); 518| 18.5k| if (data.size() != length) ------------------ | Branch (518:21): [True: 1, False: 18.5k] ------------------ 519| 1| { 520| 1| ec = ubjson_errc::unexpected_eof; 521| 1| more_ = false; 522| 1| return; 523| 1| } 524| 18.5k| auto result = unicode_traits::validate(data.data(), data.size()); 525| 18.5k| if (result.ec != unicode_traits::unicode_errc()) ------------------ | Branch (525:21): [True: 2, False: 18.5k] ------------------ 526| 2| { 527| 2| ec = ubjson_errc::invalid_utf8_text_string; 528| 2| more_ = false; 529| 2| return; 530| 2| } 531| 18.5k| visitor.string_value(jsoncons::string_view(reinterpret_cast(data.data()),data.size()), 532| 18.5k| semantic_tag::none, *this, ec); 533| 18.5k| more_ = !cursor_mode_; 534| 18.5k| break; 535| 18.5k| } 536| 179| case jsoncons::ubjson::ubjson_type::high_precision_number_type: ------------------ | Branch (536:13): [True: 179, False: 8.94M] ------------------ 537| 179| { 538| 179| std::size_t length = get_length(ec); 539| 179| if (JSONCONS_UNLIKELY(ec)) ------------------ | | 78| 179|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 0, False: 179] | | ------------------ ------------------ 540| 0| { 541| 0| return; 542| 0| } 543| 179| auto data = source_.read_span(length, text_buffer_); 544| 179| if (data.size() != length) ------------------ | Branch (544:21): [True: 7, False: 172] ------------------ 545| 7| { 546| 7| ec = ubjson_errc::unexpected_eof; 547| 7| more_ = false; 548| 7| return; 549| 7| } 550| 172| if (jsoncons::is_base10(data.data(), data.size())) ------------------ | Branch (550:21): [True: 3, False: 169] ------------------ 551| 3| { 552| 3| visitor.string_value(jsoncons::string_view(reinterpret_cast(data.data()), data.size()), 553| 3| semantic_tag::bigint, *this, ec); 554| 3| more_ = !cursor_mode_; 555| 3| } 556| 169| else 557| 169| { 558| 169| visitor.string_value(jsoncons::string_view(reinterpret_cast(data.data()), data.size()), 559| 169| semantic_tag::bigdec, *this, ec); 560| 169| more_ = !cursor_mode_; 561| 169| } 562| 172| break; 563| 179| } 564| 1.18M| case jsoncons::ubjson::ubjson_type::start_array_marker: ------------------ | Branch (564:13): [True: 1.18M, False: 7.76M] ------------------ 565| 1.18M| { 566| 1.18M| begin_array(visitor,ec); 567| 1.18M| break; 568| 179| } 569| 1.55M| case jsoncons::ubjson::ubjson_type::start_object_marker: ------------------ | Branch (569:13): [True: 1.55M, False: 7.38M] ------------------ 570| 1.55M| { 571| 1.55M| begin_object(visitor, ec); 572| 1.55M| break; 573| 179| } 574| 8| default: ------------------ | Branch (574:13): [True: 8, False: 8.94M] ------------------ 575| 8| { 576| 8| ec = ubjson_errc::unknown_type; 577| 8| break; 578| 179| } 579| 8.94M| } 580| 8.94M| if (JSONCONS_UNLIKELY(ec)) ------------------ | | 78| 8.94M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 12, False: 8.94M] | | ------------------ ------------------ 581| 12| { 582| 12| more_ = false; 583| 12| } 584| 8.94M| } _ZN8jsoncons6ubjson19basic_ubjson_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE10get_lengthERNS3_10error_codeE: 790| 489k| { 791| 489k| std::size_t length = 0; 792| 489k| uint8_t type; 793| 489k| if (source_.read(&type, 1) == 0) ------------------ | Branch (793:13): [True: 0, False: 489k] ------------------ 794| 0| { 795| 0| ec = ubjson_errc::unexpected_eof; 796| 0| more_ = false; 797| 0| return length; 798| 0| } 799| 489k| switch (type) 800| 489k| { 801| 470k| case jsoncons::ubjson::ubjson_type::int8_type: ------------------ | Branch (801:13): [True: 470k, False: 19.3k] ------------------ 802| 470k| { 803| 470k| uint8_t buf[sizeof(int8_t)]; 804| 470k| if (source_.read(buf, sizeof(int8_t)) != sizeof(int8_t)) ------------------ | Branch (804:21): [True: 0, False: 470k] ------------------ 805| 0| { 806| 0| ec = ubjson_errc::unexpected_eof; 807| 0| more_ = false; 808| 0| return length; 809| 0| } 810| 470k| int8_t val = binary::big_to_native(buf, sizeof(buf)); 811| 470k| if (val >= 0) ------------------ | Branch (811:21): [True: 470k, False: 0] ------------------ 812| 470k| { 813| 470k| length = val; 814| 470k| } 815| 0| else 816| 0| { 817| 0| ec = ubjson_errc::length_is_negative; 818| 0| more_ = false; 819| 0| return length; 820| 0| } 821| 470k| break; 822| 470k| } 823| 470k| case jsoncons::ubjson::ubjson_type::uint8_type: ------------------ | Branch (823:13): [True: 18.5k, False: 470k] ------------------ 824| 18.5k| { 825| 18.5k| uint8_t b; 826| 18.5k| if (source_.read(&b, 1) == 0) ------------------ | Branch (826:21): [True: 0, False: 18.5k] ------------------ 827| 0| { 828| 0| ec = ubjson_errc::unexpected_eof; 829| 0| more_ = false; 830| 0| return length; 831| 0| } 832| 18.5k| length = b; 833| 18.5k| break; 834| 18.5k| } 835| 807| case jsoncons::ubjson::ubjson_type::int16_type: ------------------ | Branch (835:13): [True: 807, False: 488k] ------------------ 836| 807| { 837| 807| uint8_t buf[sizeof(int16_t)]; 838| 807| if (source_.read(buf, sizeof(int16_t)) != sizeof(int16_t)) ------------------ | Branch (838:21): [True: 0, False: 807] ------------------ 839| 0| { 840| 0| ec = ubjson_errc::unexpected_eof; 841| 0| more_ = false; 842| 0| return length; 843| 0| } 844| 807| int16_t val = binary::big_to_native(buf, sizeof(buf)); 845| 807| if (val >= 0) ------------------ | Branch (845:21): [True: 807, False: 0] ------------------ 846| 807| { 847| 807| length = val; 848| 807| } 849| 0| else 850| 0| { 851| 0| ec = ubjson_errc::length_is_negative; 852| 0| more_ = false; 853| 0| return length; 854| 0| } 855| 807| break; 856| 807| } 857| 807| case jsoncons::ubjson::ubjson_type::int32_type: ------------------ | Branch (857:13): [True: 14, False: 489k] ------------------ 858| 14| { 859| 14| uint8_t buf[sizeof(int32_t)]; 860| 14| if (source_.read(buf, sizeof(int32_t)) != sizeof(int32_t)) ------------------ | Branch (860:21): [True: 0, False: 14] ------------------ 861| 0| { 862| 0| ec = ubjson_errc::unexpected_eof; 863| 0| more_ = false; 864| 0| return length; 865| 0| } 866| 14| int32_t val = binary::big_to_native(buf, sizeof(buf)); 867| 14| if (val >= 0) ------------------ | Branch (867:21): [True: 14, False: 0] ------------------ 868| 14| { 869| 14| length = static_cast(val); 870| 14| } 871| 0| else 872| 0| { 873| 0| ec = ubjson_errc::length_is_negative; 874| 0| more_ = false; 875| 0| return length; 876| 0| } 877| 14| break; 878| 14| } 879| 14| case jsoncons::ubjson::ubjson_type::int64_type: ------------------ | Branch (879:13): [True: 7, False: 489k] ------------------ 880| 7| { 881| 7| uint8_t buf[sizeof(int64_t)]; 882| 7| if (source_.read(buf, sizeof(int64_t)) != sizeof(int64_t)) ------------------ | Branch (882:21): [True: 0, False: 7] ------------------ 883| 0| { 884| 0| ec = ubjson_errc::unexpected_eof; 885| 0| more_ = false; 886| 0| return length; 887| 0| } 888| 7| int64_t val = binary::big_to_native(buf, sizeof(buf)); 889| 7| if (val >= 0) ------------------ | Branch (889:21): [True: 7, False: 0] ------------------ 890| 7| { 891| 7| length = (std::size_t)val; 892| 7| if (length != (uint64_t)val) ------------------ | Branch (892:25): [True: 0, False: 7] ------------------ 893| 0| { 894| 0| ec = ubjson_errc::number_too_large; 895| 0| more_ = false; 896| 0| return length; 897| 0| } 898| 7| } 899| 0| else 900| 0| { 901| 0| ec = ubjson_errc::length_is_negative; 902| 0| more_ = false; 903| 0| return length; 904| 0| } 905| 7| break; 906| 7| } 907| 7| default: ------------------ | Branch (907:13): [True: 1, False: 489k] ------------------ 908| 1| { 909| 1| ec = ubjson_errc::length_must_be_integer; 910| 1| more_ = false; 911| 1| return length; 912| 7| } 913| 489k| } 914| 489k| return length; 915| 489k| } _ZN8jsoncons6ubjson19basic_ubjson_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE11begin_arrayERNS_18basic_json_visitorIcEERNS3_10error_codeE: 587| 1.18M| { 588| 1.18M| if (JSONCONS_UNLIKELY(++nesting_depth_ > max_nesting_depth_)) ------------------ | | 78| 1.18M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 0, False: 1.18M] | | ------------------ ------------------ 589| 0| { 590| 0| ec = ubjson_errc::max_nesting_depth_exceeded; 591| 0| more_ = false; 592| 0| return; 593| 0| } 594| | 595| 1.18M| auto c = source_.peek(); 596| 1.18M| if (JSONCONS_UNLIKELY(c.eof)) ------------------ | | 78| 1.18M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 1, False: 1.18M] | | ------------------ ------------------ 597| 1| { 598| 1| ec = ubjson_errc::unexpected_eof; 599| 1| more_ = false; 600| 1| return; 601| 1| } 602| 1.18M| if (c.value == jsoncons::ubjson::ubjson_type::type_marker) ------------------ | Branch (602:13): [True: 1.54k, False: 1.18M] ------------------ 603| 1.54k| { 604| 1.54k| source_.ignore(1); 605| 1.54k| uint8_t b; 606| 1.54k| if (source_.read(&b, 1) == 0) ------------------ | Branch (606:17): [True: 0, False: 1.54k] ------------------ 607| 0| { 608| 0| ec = ubjson_errc::unexpected_eof; 609| 0| more_ = false; 610| 0| return; 611| 0| } 612| 1.54k| c = source_.peek(); 613| 1.54k| if (JSONCONS_UNLIKELY(c.eof)) ------------------ | | 78| 1.54k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 0, False: 1.54k] | | ------------------ ------------------ 614| 0| { 615| 0| ec = ubjson_errc::unexpected_eof; 616| 0| more_ = false; 617| 0| return; 618| 0| } 619| 1.54k| if (c.value == jsoncons::ubjson::ubjson_type::count_marker) ------------------ | Branch (619:17): [True: 1.54k, False: 1] ------------------ 620| 1.54k| { 621| 1.54k| source_.ignore(1); 622| 1.54k| std::size_t length = get_length(ec); 623| 1.54k| if (JSONCONS_UNLIKELY(ec)) ------------------ | | 78| 1.54k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 0, False: 1.54k] | | ------------------ ------------------ 624| 0| { 625| 0| return; 626| 0| } 627| 1.54k| if (length > max_items_) ------------------ | Branch (627:21): [True: 0, False: 1.54k] ------------------ 628| 0| { 629| 0| ec = ubjson_errc::max_items_exceeded; 630| 0| more_ = false; 631| 0| return; 632| 0| } 633| 1.54k| state_stack_.emplace_back(parse_mode::strongly_typed_array,length,b); 634| 1.54k| visitor.begin_array(length, semantic_tag::none, *this, ec); 635| 1.54k| more_ = !cursor_mode_; 636| 1.54k| } 637| 1| else 638| 1| { 639| 1| ec = ubjson_errc::count_required_after_type; 640| 1| more_ = false; 641| 1| return; 642| 1| } 643| 1.54k| } 644| 1.18M| else if (c.value == jsoncons::ubjson::ubjson_type::count_marker) ------------------ | Branch (644:18): [True: 1.79k, False: 1.17M] ------------------ 645| 1.79k| { 646| 1.79k| source_.ignore(1); 647| 1.79k| std::size_t length = get_length(ec); 648| 1.79k| if (JSONCONS_UNLIKELY(ec)) ------------------ | | 78| 1.79k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 0, False: 1.79k] | | ------------------ ------------------ 649| 0| { 650| 0| return; 651| 0| } 652| 1.79k| if (length > max_items_) ------------------ | Branch (652:17): [True: 0, False: 1.79k] ------------------ 653| 0| { 654| 0| ec = ubjson_errc::max_items_exceeded; 655| 0| more_ = false; 656| 0| return; 657| 0| } 658| 1.79k| state_stack_.emplace_back(parse_mode::array,length); 659| 1.79k| visitor.begin_array(length, semantic_tag::none, *this, ec); 660| 1.79k| more_ = !cursor_mode_; 661| 1.79k| } 662| 1.17M| else 663| 1.17M| { 664| 1.17M| state_stack_.emplace_back(parse_mode::indefinite_array,0); 665| 1.17M| visitor.begin_array(semantic_tag::none, *this, ec); 666| 1.17M| more_ = !cursor_mode_; 667| 1.17M| } 668| 1.18M| } _ZN8jsoncons6ubjson19basic_ubjson_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE12begin_objectERNS_18basic_json_visitorIcEERNS3_10error_codeE: 684| 1.55M| { 685| 1.55M| if (JSONCONS_UNLIKELY(++nesting_depth_ > max_nesting_depth_)) ------------------ | | 78| 1.55M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 0, False: 1.55M] | | ------------------ ------------------ 686| 0| { 687| 0| ec = ubjson_errc::max_nesting_depth_exceeded; 688| 0| more_ = false; 689| 0| return; 690| 0| } 691| | 692| 1.55M| auto c = source_.peek(); 693| 1.55M| if (JSONCONS_UNLIKELY(c.eof)) ------------------ | | 78| 1.55M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 2, False: 1.55M] | | ------------------ ------------------ 694| 2| { 695| 2| ec = ubjson_errc::unexpected_eof; 696| 2| more_ = false; 697| 2| return; 698| 2| } 699| 1.55M| if (c.value == jsoncons::ubjson::ubjson_type::type_marker) ------------------ | Branch (699:13): [True: 3.31k, False: 1.55M] ------------------ 700| 3.31k| { 701| 3.31k| source_.ignore(1); 702| 3.31k| uint8_t b; 703| 3.31k| if (source_.read(&b, 1) == 0) ------------------ | Branch (703:17): [True: 0, False: 3.31k] ------------------ 704| 0| { 705| 0| ec = ubjson_errc::unexpected_eof; 706| 0| more_ = false; 707| 0| return; 708| 0| } 709| 3.31k| c = source_.peek(); 710| 3.31k| if (JSONCONS_UNLIKELY(c.eof)) ------------------ | | 78| 3.31k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 0, False: 3.31k] | | ------------------ ------------------ 711| 0| { 712| 0| ec = ubjson_errc::unexpected_eof; 713| 0| more_ = false; 714| 0| return; 715| 0| } 716| 3.31k| if (c.value == jsoncons::ubjson::ubjson_type::count_marker) ------------------ | Branch (716:17): [True: 3.31k, False: 0] ------------------ 717| 3.31k| { 718| 3.31k| source_.ignore(1); 719| 3.31k| std::size_t length = get_length(ec); 720| 3.31k| if (JSONCONS_UNLIKELY(ec)) ------------------ | | 78| 3.31k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 0, False: 3.31k] | | ------------------ ------------------ 721| 0| { 722| 0| return; 723| 0| } 724| 3.31k| if (length > max_items_) ------------------ | Branch (724:21): [True: 0, False: 3.31k] ------------------ 725| 0| { 726| 0| ec = ubjson_errc::max_items_exceeded; 727| 0| more_ = false; 728| 0| return; 729| 0| } 730| 3.31k| state_stack_.emplace_back(parse_mode::strongly_typed_map_key,length,b); 731| 3.31k| visitor.begin_object(length, semantic_tag::none, *this, ec); 732| 3.31k| more_ = !cursor_mode_; 733| 3.31k| } 734| 0| else 735| 0| { 736| 0| ec = ubjson_errc::count_required_after_type; 737| 0| more_ = false; 738| 0| return; 739| 0| } 740| 3.31k| } 741| 1.55M| else 742| 1.55M| { 743| 1.55M| c = source_.peek(); 744| 1.55M| if (JSONCONS_UNLIKELY(c.eof)) ------------------ | | 78| 1.55M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 0, False: 1.55M] | | ------------------ ------------------ 745| 0| { 746| 0| ec = ubjson_errc::unexpected_eof; 747| 0| more_ = false; 748| 0| return; 749| 0| } 750| 1.55M| if (c.value == jsoncons::ubjson::ubjson_type::count_marker) ------------------ | Branch (750:17): [True: 17, False: 1.55M] ------------------ 751| 17| { 752| 17| source_.ignore(1); 753| 17| std::size_t length = get_length(ec); 754| 17| if (JSONCONS_UNLIKELY(ec)) ------------------ | | 78| 17|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 0, False: 17] | | ------------------ ------------------ 755| 0| { 756| 0| return; 757| 0| } 758| 17| if (length > max_items_) ------------------ | Branch (758:21): [True: 0, False: 17] ------------------ 759| 0| { 760| 0| ec = ubjson_errc::max_items_exceeded; 761| 0| more_ = false; 762| 0| return; 763| 0| } 764| 17| state_stack_.emplace_back(parse_mode::map_key,length); 765| 17| visitor.begin_object(length, semantic_tag::none, *this, ec); 766| 17| more_ = !cursor_mode_; 767| 17| } 768| 1.55M| else 769| 1.55M| { 770| 1.55M| state_stack_.emplace_back(parse_mode::indefinite_map_key,0); 771| 1.55M| visitor.begin_object(semantic_tag::none, *this, ec); 772| 1.55M| more_ = !cursor_mode_; 773| 1.55M| } 774| 1.55M| } 775| 1.55M| } _ZN8jsoncons6ubjson19basic_ubjson_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE8read_keyERNS_18basic_json_visitorIcEERNS3_10error_codeE: 918| 464k| { 919| 464k| std::size_t length = get_length(ec); 920| 464k| if (JSONCONS_UNLIKELY(ec)) ------------------ | | 78| 464k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 1, False: 464k] | | ------------------ ------------------ 921| 1| { 922| 1| ec = ubjson_errc::key_expected; 923| 1| more_ = false; 924| 1| return; 925| 1| } 926| 464k| auto data = source_.read_span(length, text_buffer_); 927| 464k| if (data.size() != length) ------------------ | Branch (927:13): [True: 4, False: 464k] ------------------ 928| 4| { 929| 4| ec = ubjson_errc::unexpected_eof; 930| 4| more_ = false; 931| 4| return; 932| 4| } 933| | 934| 464k| auto result = unicode_traits::validate(data.data(), data.size()); 935| 464k| if (result.ec != unicode_traits::unicode_errc()) ------------------ | Branch (935:13): [True: 1, False: 464k] ------------------ 936| 1| { 937| 1| ec = ubjson_errc::invalid_utf8_text_string; 938| 1| more_ = false; 939| 1| return; 940| 1| } 941| 464k| visitor.key(jsoncons::string_view(reinterpret_cast(data.data()),data.size()), 942| 464k| *this, ec); 943| 464k| more_ = !cursor_mode_; 944| 464k| } _ZN8jsoncons6ubjson19basic_ubjson_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE10end_objectERNS_18basic_json_visitorIcEERNS3_10error_codeE: 778| 1.55M| { 779| 1.55M| --nesting_depth_; 780| 1.55M| visitor.end_object(*this, ec); 781| 1.55M| more_ = !cursor_mode_; 782| 1.55M| if (level() == mark_level_) ------------------ | Branch (782:13): [True: 0, False: 1.55M] ------------------ 783| 0| { 784| 0| more_ = false; 785| 0| } 786| 1.55M| state_stack_.pop_back(); 787| 1.55M| } _ZN8jsoncons6ubjson19basic_ubjson_readerINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEEC2IRNS3_19basic_istringstreamIcNS3_11char_traitsIcEES7_EEEEOT_RNS_18basic_json_visitorIcEERKNS0_21ubjson_decode_optionsERKS7_: 48| 39| : parser_(std::forward(source), options, alloc), 49| 39| visitor_(visitor) 50| 39| { 51| 39| } _ZN8jsoncons6ubjson19basic_ubjson_readerINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE4readERNS3_10error_codeE: 64| 39| { 65| 39| parser_.reset(); 66| 39| parser_.parse(visitor_, ec); 67| 39| if (JSONCONS_UNLIKELY(ec)) ------------------ | | 78| 39|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 37, False: 2] | | ------------------ ------------------ 68| 37| { 69| 37| return; 70| 37| } 71| 39| }