LLVMFuzzerTestOneInput: 11| 42|{ 12| 42| std::string s(reinterpret_cast(data), size); 13| 42| std::istringstream is(s); 14| | 15| 42| default_json_visitor visitor; 16| | 17| 42| ubjson_stream_reader reader(is, visitor); 18| 42| std::error_code ec; 19| 42| reader.read(ec); 20| | 21| 42| return 0; 22| 42|} _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| 42| basic_default_json_visitor() = default; _ZN8jsoncons18basic_json_visitorIcEC2Ev: 103| 42| basic_json_visitor() = default; _ZN8jsoncons19typed_array_visitorD2Ev: 33| 42| virtual ~typed_array_visitor() = default; _ZN8jsoncons18basic_json_visitorIcE17visit_begin_arrayEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE: 560| 3.22k| { 561| 3.22k| visit_begin_array(tag, context, ec); 562| 3.22k| JSONCONS_VISITOR_RETURN; ------------------ | | 276| 3.22k|#define JSONCONS_VISITOR_RETURN return true ------------------ 563| 3.22k| } _ZN8jsoncons26basic_default_json_visitorIcE15visit_end_arrayERKNS_11ser_contextERNSt3__110error_codeE: 833| 638k| { 834| 638k| JSONCONS_VISITOR_RETURN; ------------------ | | 276| 638k|#define JSONCONS_VISITOR_RETURN return true ------------------ 835| 638k| } _ZN8jsoncons26basic_default_json_visitorIcE12visit_uint64EmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE: 858| 279| { 859| 279| JSONCONS_VISITOR_RETURN; ------------------ | | 276| 279|#define JSONCONS_VISITOR_RETURN return true ------------------ 860| 279| } _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| 59| { 874| 59| JSONCONS_VISITOR_RETURN; ------------------ | | 276| 59|#define JSONCONS_VISITOR_RETURN return true ------------------ 875| 59| } _ZN8jsoncons26basic_default_json_visitorIcE11visit_flushEv: 814| 2| { 815| 2| } _ZN8jsoncons26basic_default_json_visitorIcE18visit_begin_objectENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE: 818| 2.60M| { 819| 2.60M| JSONCONS_VISITOR_RETURN; ------------------ | | 276| 2.60M|#define JSONCONS_VISITOR_RETURN return true ------------------ 820| 2.60M| } _ZN8jsoncons18basic_json_visitorIcE18visit_begin_objectEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE: 544| 3.20k| { 545| 3.20k| visit_begin_object(tag, context, ec); 546| 3.20k| JSONCONS_VISITOR_RETURN; ------------------ | | 276| 3.20k|#define JSONCONS_VISITOR_RETURN return true ------------------ 547| 3.20k| } _ZN8jsoncons26basic_default_json_visitorIcE16visit_end_objectERKNS_11ser_contextERNSt3__110error_codeE: 823| 2.60M| { 824| 2.60M| JSONCONS_VISITOR_RETURN; ------------------ | | 276| 2.60M|#define JSONCONS_VISITOR_RETURN return true ------------------ 825| 2.60M| } _ZN8jsoncons26basic_default_json_visitorIcE17visit_begin_arrayENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE: 828| 640k| { 829| 640k| JSONCONS_VISITOR_RETURN; ------------------ | | 276| 640k|#define JSONCONS_VISITOR_RETURN return true ------------------ 830| 640k| } _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.72M| { 844| 3.72M| JSONCONS_VISITOR_RETURN; ------------------ | | 276| 3.72M|#define JSONCONS_VISITOR_RETURN return true ------------------ 845| 3.72M| } _ZN8jsoncons26basic_default_json_visitorIcE10visit_boolEbNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE: 878| 439k| { 879| 439k| JSONCONS_VISITOR_RETURN; ------------------ | | 276| 439k|#define JSONCONS_VISITOR_RETURN return true ------------------ 880| 439k| } _ZN8jsoncons26basic_default_json_visitorIcE12visit_stringERKNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEENS_12semantic_tagERKNS_11ser_contextERNS2_10error_codeE: 848| 18.6k| { 849| 18.6k| JSONCONS_VISITOR_RETURN; ------------------ | | 276| 18.6k|#define JSONCONS_VISITOR_RETURN return true ------------------ 850| 18.6k| } _ZN8jsoncons18basic_json_visitorIcE11begin_arrayEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE: 345| 3.22k| { 346| 3.22k| visit_begin_array(length, tag, context, ec); 347| 3.22k| JSONCONS_VISITOR_RETURN; ------------------ | | 276| 3.22k|#define JSONCONS_VISITOR_RETURN return true ------------------ 348| 3.22k| } _ZN8jsoncons18basic_json_visitorIcE12uint64_valueEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE: 414| 279| { 415| 279| visit_uint64(value, tag, context, ec); 416| 279| JSONCONS_VISITOR_RETURN; ------------------ | | 276| 279|#define JSONCONS_VISITOR_RETURN return true ------------------ 417| 279| } _ZN8jsoncons18basic_json_visitorIcE9end_arrayERKNS_11ser_contextERNSt3__110error_codeE: 351| 638k| { 352| 638k| visit_end_array(context, ec); 353| 638k| JSONCONS_VISITOR_RETURN; ------------------ | | 276| 638k|#define JSONCONS_VISITOR_RETURN return true ------------------ 354| 638k| } _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| 59| { 442| 59| visit_double(value, tag, context, ec); 443| 59| JSONCONS_VISITOR_RETURN; ------------------ | | 276| 59|#define JSONCONS_VISITOR_RETURN return true ------------------ 444| 59| } _ZN8jsoncons18basic_json_visitorIcE10null_valueENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE: 365| 3.72M| { 366| 3.72M| visit_null(tag, context, ec); 367| 3.72M| JSONCONS_VISITOR_RETURN; ------------------ | | 276| 3.72M|#define JSONCONS_VISITOR_RETURN return true ------------------ 368| 3.72M| } _ZN8jsoncons18basic_json_visitorIcE10bool_valueEbNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE: 374| 439k| { 375| 439k| visit_bool(value, tag, context, ec); 376| 439k| JSONCONS_VISITOR_RETURN; ------------------ | | 276| 439k|#define JSONCONS_VISITOR_RETURN return true ------------------ 377| 439k| } _ZN8jsoncons18basic_json_visitorIcE12string_valueERKNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEENS_12semantic_tagERKNS_11ser_contextERNS2_10error_codeE: 383| 18.6k| { 384| 18.6k| visit_string(value, tag, context, ec); 385| 18.6k| JSONCONS_VISITOR_RETURN; ------------------ | | 276| 18.6k|#define JSONCONS_VISITOR_RETURN return true ------------------ 386| 18.6k| } _ZN8jsoncons18basic_json_visitorIcE11begin_arrayENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE: 339| 637k| { 340| 637k| visit_begin_array(tag, context, ec); 341| 637k| JSONCONS_VISITOR_RETURN; ------------------ | | 276| 637k|#define JSONCONS_VISITOR_RETURN return true ------------------ 342| 637k| } _ZN8jsoncons18basic_json_visitorIcE12begin_objectEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE: 327| 3.20k| { 328| 3.20k| visit_begin_object(length, tag, context, ec); 329| 3.20k| JSONCONS_VISITOR_RETURN; ------------------ | | 276| 3.20k|#define JSONCONS_VISITOR_RETURN return true ------------------ 330| 3.20k| } _ZN8jsoncons18basic_json_visitorIcE12begin_objectENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE: 318| 2.60M| { 319| 2.60M| visit_begin_object(tag, context, ec); 320| 2.60M| JSONCONS_VISITOR_RETURN; ------------------ | | 276| 2.60M|#define JSONCONS_VISITOR_RETURN return true ------------------ 321| 2.60M| } _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| 2.60M| { 334| 2.60M| visit_end_object(context, ec); 335| 2.60M| JSONCONS_VISITOR_RETURN; ------------------ | | 276| 2.60M|#define JSONCONS_VISITOR_RETURN return true ------------------ 336| 2.60M| } _ZN8jsoncons18basic_json_visitorIcE5flushEv: 108| 2| { 109| 2| visit_flush(); 110| 2| } _ZN8jsoncons11ser_contextD2Ev: 21| 42| virtual ~ser_context() = default; _ZN8jsoncons13stream_sourceIhNSt3__19allocatorIhEEED2Ev: 193| 42| { 194| 42| if (chunk_) ------------------ | Branch (194:13): [True: 42, False: 0] ------------------ 195| 42| { 196| 42| std::allocator_traits::deallocate(alloc_, chunk_, chunk_size_); 197| 42| } 198| 42| } _ZN8jsoncons13stream_sourceIhNSt3__19allocatorIhEEEC2ERNS1_13basic_istreamIcNS1_11char_traitsIcEEEERKS3_: 176| 42| : alloc_(alloc), stream_ptr_(std::addressof(is)), sbuf_(is.rdbuf()), 177| 42| chunk_size_(default_max_chunk_size) 178| 42| { 179| 42| chunk_ = std::allocator_traits::allocate(alloc_, chunk_size_); 180| 42| data_end_ = chunk_; 181| 42| } _ZN8jsoncons18basic_null_istreamIcEC1Ev: 57| 42| : std::basic_istream(&nb_) 58| 42| { 59| 42| } _ZN8jsoncons18basic_null_istreamIcE11null_bufferC2Ev: 43| 42| 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: 183] ------------------ 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: 723] ------------------ 388| 7.33M| { 389| 7.33M| return len; 390| 7.33M| } 391| 723| else if (length - len < chunk_size_) ------------------ | Branch (391:18): [True: 723, False: 0] ------------------ 392| 723| { 393| 723| data_end_ = chunk_; 394| 723| remaining_ = fill_buffer(chunk_, chunk_size_); 395| 723| if (remaining_ > 0) ------------------ | Branch (395:17): [True: 711, False: 12] ------------------ 396| 711| { 397| 711| std::size_t len2 = (std::min)(remaining_, length-len); 398| 711| std::memcpy(p+len, data_end_, len2*sizeof(value_type)); 399| 711| data_end_ += len2; 400| 711| remaining_ -= len2; 401| 711| position_ += len2; 402| 711| len += len2; 403| 711| } 404| 723| return len; 405| 723| } 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.48k| { 443| 1.48k| if (stream_ptr_->eof()) ------------------ | Branch (443:13): [True: 12, False: 1.47k] ------------------ 444| 12| { 445| 12| return 0; 446| 12| } 447| | 448| 1.47k| JSONCONS_TRY ------------------ | | 37| 1.47k| #define JSONCONS_TRY try ------------------ 449| 1.47k| { 450| 1.47k| std::streamsize count = sbuf_->sgetn(reinterpret_cast(chunk), chunk_size); 451| 1.47k| std::size_t length = static_cast(count); 452| | 453| 1.47k| if (length < chunk_size) ------------------ | Branch (453:17): [True: 33, False: 1.43k] ------------------ 454| 33| { 455| 33| stream_ptr_->clear(stream_ptr_->rdstate() | std::ios::eofbit); 456| 33| } 457| 1.47k| return length; 458| 1.47k| } 459| 1.47k| JSONCONS_CATCH(const std::exception&) 460| 1.47k| { 461| 0| stream_ptr_->clear(stream_ptr_->rdstate() | std::ios::badbit | std::ios::eofbit); 462| 0| return 0; 463| 0| } 464| 1.47k| } _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: 6, False: 91.9k] | Branch (357:32): [True: 0, False: 6] ------------------ 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: 169, False: 91.7k] ------------------ 363| 169| { 364| 169| buffer.clear(); 365| 169| source_reader::read(*this, std::forward(buffer), length); 366| 169| return span(reinterpret_cast(buffer.data()), buffer.size()); 367| 169| } 368| | 369| 91.7k| const value_type* data = data_end_; 370| 91.7k| data_end_ += length; 371| 91.7k| remaining_ -= length; 372| 91.7k| position_ += length; 373| 91.7k| 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| 169| { 747| 169| std::size_t unread = length; 748| | 749| 1.01k| while (unread > 0 && !source.eof()) ------------------ | Branch (749:16): [True: 858, False: 154] | Branch (749:30): [True: 843, False: 15] ------------------ 750| 843| { 751| 843| if (source.remaining() == 0 && unread >= source.chunk_size()) ------------------ | Branch (751:17): [True: 254, False: 589] | Branch (751:44): [True: 254, False: 0] ------------------ 752| 254| { 753| 254| std::size_t n = source.chunk_size(); 754| 254| std::size_t offset = buffer.size(); 755| 254| buffer.resize(offset+n); 756| 254| std::size_t actual = source.read_buffer(reinterpret_cast(&buffer[0]) + offset, n); 757| 254| if (JSONCONS_UNLIKELY(actual != n)) ------------------ | | 78| 254|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 6, False: 248] | | ------------------ ------------------ 758| 6| { 759| 6| buffer.resize(offset+actual); 760| 6| } 761| 254| unread -= actual; 762| 254| } 763| 589| else 764| 589| { 765| 589| std::size_t n = (std::min)(source.chunk_size(), unread); 766| 589| std::size_t offset = buffer.size(); 767| 589| buffer.resize(offset+n); 768| 589| std::size_t actual = source.read(reinterpret_cast(&buffer[0]) + offset, n); 769| 589| if (JSONCONS_UNLIKELY(actual != n)) ------------------ | | 78| 589|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 9, False: 580] | | ------------------ ------------------ 770| 9| { 771| 9| buffer.resize(offset + actual); 772| 9| } 773| 589| unread -= actual; 774| 589| } 775| 843| } 776| 169| return length - unread; 777| 169| } _ZNK8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE3eofEv: 271| 858| { 272| 858| return remaining_ == 0 && stream_ptr_->eof(); ------------------ | Branch (272:16): [True: 269, False: 589] | Branch (272:35): [True: 15, False: 254] ------------------ 273| 858| } _ZNK8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE9remainingEv: 346| 843| { 347| 843| return remaining_; 348| 843| } _ZNK8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE10chunk_sizeEv: 261| 1.09k| { 262| 1.09k| return chunk_size_; 263| 1.09k| } _ZN8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE11read_bufferEPhm: 435| 254| { 436| 254| auto len = fill_buffer(chunk, chunk_size); 437| 254| position_ += len; 438| 254| return len; 439| 254| } _ZN8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE4peekEv: 312| 13.8M| { 313| 13.8M| if (remaining_ == 0) ------------------ | Branch (313:13): [True: 506, False: 13.8M] ------------------ 314| 506| { 315| 506| data_end_ = chunk_; 316| 506| remaining_ = fill_buffer(chunk_, chunk_size_); 317| 506| } 318| 13.8M| if (remaining_ > 0) ------------------ | Branch (318:13): [True: 13.8M, False: 10] ------------------ 319| 13.8M| { 320| 13.8M| value_type c = *data_end_; 321| 13.8M| return char_result{c, false}; 322| 13.8M| } 323| 10| else 324| 10| { 325| 10| return char_result{0, true}; 326| 10| } 327| 13.8M| } _ZN8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE6ignoreEm: 286| 3.25M| { 287| 3.25M| std::size_t len = 0; 288| 3.25M| if (remaining_ > 0) ------------------ | Branch (288:13): [True: 3.25M, False: 0] ------------------ 289| 3.25M| { 290| 3.25M| len = (std::min)(remaining_, length); 291| 3.25M| position_ += len; 292| 3.25M| data_end_ += len; 293| 3.25M| remaining_ -= len; 294| 3.25M| } 295| 3.25M| while (len < length) ------------------ | Branch (295:16): [True: 0, False: 3.25M] ------------------ 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| 3.25M| } _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.61k| { 183| 1.61k| if (sizeof(T) > count) ------------------ | Branch (183:13): [True: 0, False: 1.61k] ------------------ 184| 0| { 185| 0| return T{}; 186| 0| } 187| 1.61k| T val; 188| 1.61k| std::memcpy(&val,first,sizeof(T)); 189| 1.61k| return byte_swap(val); 190| 1.61k| } _ZN8jsoncons6binary9byte_swapIsEENSt3__19enable_ifIXaasr3std11is_integralIT_EE5valueeqstS4_Lm2EES4_E4typeES4_: 28| 1.61k| { 29| 1.61k| #if defined(JSONCONS_BYTE_SWAP_16) 30| 1.61k| return JSONCONS_BYTE_SWAP_16(val); ------------------ | | 466| 1.61k|# define JSONCONS_BYTE_SWAP_16 __builtin_bswap16 ------------------ 31| | #else 32| | return (static_cast(val) >> 8) | (static_cast(val) << 8); 33| | #endif 34| 1.61k| } _ZN8jsoncons6binary13big_to_nativeIiNS_6detail6endianEEENSt3__19enable_ifIXeqsrT0_6nativesrS6_6littleET_E4typeEPKhm: 182| 25| { 183| 25| if (sizeof(T) > count) ------------------ | Branch (183:13): [True: 0, False: 25] ------------------ 184| 0| { 185| 0| return T{}; 186| 0| } 187| 25| T val; 188| 25| std::memcpy(&val,first,sizeof(T)); 189| 25| return byte_swap(val); 190| 25| } _ZN8jsoncons6binary9byte_swapIiEENSt3__19enable_ifIXaasr3std11is_integralIT_EE5valueeqstS4_Lm4EES4_E4typeES4_: 39| 25| { 40| 25| #if defined(JSONCONS_BYTE_SWAP_32) 41| 25| return JSONCONS_BYTE_SWAP_32(val); ------------------ | | 462| 25|# 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| 25| } _ZN8jsoncons6binary13big_to_nativeIlNS_6detail6endianEEENSt3__19enable_ifIXeqsrT0_6nativesrS6_6littleET_E4typeEPKhm: 182| 92| { 183| 92| if (sizeof(T) > count) ------------------ | Branch (183:13): [True: 0, False: 92] ------------------ 184| 0| { 185| 0| return T{}; 186| 0| } 187| 92| T val; 188| 92| std::memcpy(&val,first,sizeof(T)); 189| 92| return byte_swap(val); 190| 92| } _ZN8jsoncons6binary9byte_swapIlEENSt3__19enable_ifIXaasr3std11is_integralIT_EE5valueeqstS4_Lm8EES4_E4typeES4_: 51| 92| { 52| 92| #if defined(JSONCONS_BYTE_SWAP_64) 53| 92| return JSONCONS_BYTE_SWAP_64(val); ------------------ | | 461| 92|# 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| 92| } _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| 56| { 183| 56| if (sizeof(T) > count) ------------------ | Branch (183:13): [True: 0, False: 56] ------------------ 184| 0| { 185| 0| return T{}; 186| 0| } 187| 56| T val; 188| 56| std::memcpy(&val,first,sizeof(T)); 189| 56| return byte_swap(val); 190| 56| } _ZN8jsoncons6binary9byte_swapIdEENSt3__19enable_ifIXaasr3std17is_floating_pointIT_EE5valueeqstS4_Lm8EES4_E4typeES4_: 76| 56| { 77| 56| uint64_t x; 78| 56| std::memcpy(&x,&val,sizeof(uint64_t)); 79| 56| uint64_t y = byte_swap(x); 80| 56| T val2; 81| 56| std::memcpy(&val2,&y,sizeof(uint64_t)); 82| 56| return val2; 83| 56| } _ZN8jsoncons6binary9byte_swapImEENSt3__19enable_ifIXaasr3std11is_integralIT_EE5valueeqstS4_Lm8EES4_E4typeES4_: 51| 56| { 52| 56| #if defined(JSONCONS_BYTE_SWAP_64) 53| 56| return JSONCONS_BYTE_SWAP_64(val); ------------------ | | 461| 56|# 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| 56| } _ZN8jsoncons9is_base10IhEEbPKT_m: 164| 118|{ 165| 118| integer_chars_state state = integer_chars_state::initial; 166| | 167| 118| const CharT* end = s + length; 168| 226| for (;s < end; ++s) ------------------ | Branch (168:11): [True: 223, False: 3] ------------------ 169| 223| { 170| 223| switch(state) 171| 223| { 172| 118| case integer_chars_state::initial: ------------------ | Branch (172:13): [True: 118, False: 105] ------------------ 173| 118| { 174| 118| switch(*s) 175| 118| { 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: 117] | Branch (176:30): [True: 1, False: 117] | Branch (176:39): [True: 0, False: 118] | Branch (176:48): [True: 0, False: 118] | Branch (176:57): [True: 0, False: 118] | Branch (176:66): [True: 0, False: 118] | Branch (176:75): [True: 1, False: 117] | Branch (176:84): [True: 0, False: 118] | Branch (176:93): [True: 0, False: 118] | Branch (176:103): [True: 0, False: 118] ------------------ 177| 3| state = integer_chars_state::decimal; 178| 3| break; 179| 21| case '-': ------------------ | Branch (179:21): [True: 21, False: 97] ------------------ 180| 21| state = integer_chars_state::minus; 181| 21| break; 182| 94| default: ------------------ | Branch (182:21): [True: 94, False: 24] ------------------ 183| 94| return false; 184| 118| } 185| 24| break; 186| 118| } 187| 24| case integer_chars_state::minus: ------------------ | Branch (187:13): [True: 21, False: 202] ------------------ 188| 21| { 189| 21| switch(*s) 190| 21| { 191| 21| case '0':case '1':case '2':case '3':case '4':case '5':case '6':case '7':case '8': case '9': ------------------ | Branch (191:21): [True: 21, False: 0] | Branch (191:30): [True: 0, False: 21] | Branch (191:39): [True: 0, False: 21] | Branch (191:48): [True: 0, False: 21] | Branch (191:57): [True: 0, False: 21] | Branch (191:66): [True: 0, False: 21] | Branch (191:75): [True: 0, False: 21] | Branch (191:84): [True: 0, False: 21] | Branch (191:93): [True: 0, False: 21] | Branch (191:103): [True: 0, False: 21] ------------------ 192| 21| state = integer_chars_state::decimal; 193| 21| break; 194| 0| default: ------------------ | Branch (194:21): [True: 0, False: 21] ------------------ 195| 0| return false; 196| 21| } 197| 21| break; 198| 21| } 199| 84| case integer_chars_state::decimal: ------------------ | Branch (199:13): [True: 84, False: 139] ------------------ 200| 84| { 201| 84| switch(*s) 202| 84| { 203| 63| 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: 84] | Branch (203:30): [True: 5, False: 79] | Branch (203:39): [True: 16, False: 68] | Branch (203:48): [True: 0, False: 84] | Branch (203:57): [True: 21, False: 63] | Branch (203:66): [True: 0, False: 84] | Branch (203:75): [True: 0, False: 84] | Branch (203:84): [True: 21, False: 63] | Branch (203:93): [True: 0, False: 84] | Branch (203:103): [True: 0, False: 84] ------------------ 204| 63| break; 205| 21| default: ------------------ | Branch (205:21): [True: 21, False: 63] ------------------ 206| 21| return false; 207| 84| } 208| 63| break; 209| 84| } 210| 63| default: ------------------ | Branch (210:13): [True: 0, False: 223] ------------------ 211| 0| break; 212| 223| } 213| 223| } 214| 3| return state == integer_chars_state::decimal ? true : false; ------------------ | Branch (214:12): [True: 3, False: 0] ------------------ 215| 118|} _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.16M| 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: 215] | | | Branch (281:42): [True: 166k, False: 263] | | | Branch (281:44): [True: 161k, False: 5.07k] | | | Branch (281:46): [True: 145k, False: 15.4k] | | ------------------ ------------------ 1157| 145k| continue; 1158| 1.16M| } 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| 0| case 4: ------------------ | Branch (313:9): [True: 0, False: 190k] ------------------ 314| 0| if (((byte = (*--end))& 0xC0) != 0x80) ------------------ | Branch (314:17): [True: 0, False: 0] ------------------ 315| 0| return unicode_errc::bad_continuation_byte; 316| 0| JSONCONS_FALLTHROUGH; ------------------ | | 564| 0|# define JSONCONS_FALLTHROUGH [[fallthrough]] ------------------ 317| 0| case 3: ------------------ | Branch (317:9): [True: 0, False: 190k] ------------------ 318| 0| if (((byte = (*--end))& 0xC0) != 0x80) ------------------ | Branch (318:17): [True: 0, False: 0] ------------------ 319| 0| return unicode_errc::bad_continuation_byte; 320| 0| JSONCONS_FALLTHROUGH; ------------------ | | 564| 0|# 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| 41|{ 91| 41| return std::error_code(static_cast(e),ubjson_error_category()); 92| 41|} _ZN8jsoncons6ubjson21ubjson_error_categoryEv: 83| 41|{ 84| 41| static ubjson_error_category_impl instance; 85| 41| return instance; 86| 41|} _ZN8jsoncons6ubjson21ubjson_decode_optionsC1Ev: 38| 42| ubjson_decode_options() = default; _ZN8jsoncons6ubjson21ubjson_options_commonC2Ev: 23| 42| ubjson_options_common() = default; _ZN8jsoncons6ubjson21ubjson_options_commonD2Ev: 25| 42| virtual ~ubjson_options_common() = default; _ZNK8jsoncons6ubjson21ubjson_options_common17max_nesting_depthEv: 28| 42| { 29| 42| return max_nesting_depth_; 30| 42| } _ZNK8jsoncons6ubjson21ubjson_decode_options9max_itemsEv: 44| 42| { 45| 42| return max_items_; 46| 42| } _ZN8jsoncons6ubjson19basic_ubjson_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEEC2IRNS3_19basic_istringstreamIcNS3_11char_traitsIcEES7_EEEEOT_RKNS0_21ubjson_decode_optionsERKS7_: 79| 42| : source_(std::forward(source)), 80| 42| max_nesting_depth_(options.max_nesting_depth()), 81| 42| max_items_(options.max_items()), 82| 42| text_buffer_(alloc), 83| 42| state_stack_(alloc) 84| 42| { 85| 42| state_stack_.emplace_back(parse_mode::root,0); 86| 42| } _ZN8jsoncons6ubjson11parse_stateC2ENS0_10parse_modeEmh: 45| 3.24M| : mode(mode), length(length), type(type) 46| 3.24M| { 47| 3.24M| } _ZN8jsoncons6ubjson19basic_ubjson_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE5resetEv: 94| 42| { 95| 42| more_ = true; 96| 42| done_ = false; 97| 42| text_buffer_.clear(); 98| 42| state_stack_.clear(); 99| 42| state_stack_.emplace_back(parse_mode::root,0,uint8_t(0)); 100| 42| nesting_depth_ = 0; 101| 42| } _ZN8jsoncons6ubjson19basic_ubjson_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE5parseERNS_18basic_json_visitorIcEERNS3_10error_codeE: 151| 42| { 152| 13.1M| while (!done_ && more_) ------------------ | Branch (152:16): [True: 13.1M, False: 2] | Branch (152:26): [True: 13.1M, False: 0] ------------------ 153| 13.1M| { 154| 13.1M| switch (state_stack_.back().mode) ------------------ | Branch (154:21): [True: 13.1M, False: 0] ------------------ 155| 13.1M| { 156| 4.19k| case parse_mode::array: ------------------ | Branch (156:17): [True: 4.19k, False: 13.1M] ------------------ 157| 4.19k| { 158| 4.19k| if (state_stack_.back().index < state_stack_.back().length) ------------------ | Branch (158:25): [True: 2.56k, False: 1.63k] ------------------ 159| 2.56k| { 160| 2.56k| ++state_stack_.back().index; 161| 2.56k| read_type_and_value(visitor, ec); 162| 2.56k| if (JSONCONS_UNLIKELY(ec)) ------------------ | | 78| 2.56k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 0, False: 2.56k] | | ------------------ ------------------ 163| 0| { 164| 0| return; 165| 0| } 166| 2.56k| } 167| 1.63k| else 168| 1.63k| { 169| 1.63k| end_array(visitor, ec); 170| 1.63k| } 171| 4.19k| break; 172| 4.19k| } 173| 4.71M| case parse_mode::strongly_typed_array: ------------------ | Branch (173:17): [True: 4.71M, False: 8.45M] ------------------ 174| 4.71M| { 175| 4.71M| if (state_stack_.back().index < state_stack_.back().length) ------------------ | Branch (175:25): [True: 4.70M, False: 743] ------------------ 176| 4.70M| { 177| 4.70M| ++state_stack_.back().index; 178| 4.70M| read_value(visitor, state_stack_.back().type, ec); 179| 4.70M| if (JSONCONS_UNLIKELY(ec)) ------------------ | | 78| 4.70M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 7, False: 4.70M] | | ------------------ ------------------ 180| 7| { 181| 7| return; 182| 7| } 183| 4.70M| } 184| 743| else 185| 743| { 186| 743| end_array(visitor, ec); 187| 743| } 188| 4.71M| break; 189| 4.71M| } 190| 4.91M| case parse_mode::indefinite_array: ------------------ | Branch (190:17): [True: 4.91M, False: 8.25M] ------------------ 191| 4.91M| { 192| 4.91M| auto c = source_.peek(); 193| 4.91M| if (JSONCONS_UNLIKELY(c.eof)) ------------------ | | 78| 4.91M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 5, False: 4.91M] | | ------------------ ------------------ 194| 5| { 195| 5| ec = ubjson_errc::unexpected_eof; 196| 5| more_ = false; 197| 5| return; 198| 5| } 199| 4.91M| if (c.value == jsoncons::ubjson::ubjson_type::end_array_marker) ------------------ | Branch (199:25): [True: 636k, False: 4.27M] ------------------ 200| 636k| { 201| 636k| source_.ignore(1); 202| 636k| end_array(visitor, ec); 203| 636k| if (JSONCONS_UNLIKELY(ec)) ------------------ | | 78| 636k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 0, False: 636k] | | ------------------ ------------------ 204| 0| { 205| 0| return; 206| 0| } 207| 636k| } 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| 4.91M| break; 223| 4.91M| } 224| 4.91M| case parse_mode::map_key: ------------------ | Branch (224:17): [True: 20, False: 13.1M] ------------------ 225| 20| { 226| 20| if (state_stack_.back().index < state_stack_.back().length) ------------------ | Branch (226:25): [True: 6, False: 14] ------------------ 227| 6| { 228| 6| ++state_stack_.back().index; 229| 6| read_key(visitor, ec); 230| 6| if (JSONCONS_UNLIKELY(ec)) ------------------ | | 78| 6|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 0, False: 6] | | ------------------ ------------------ 231| 0| { 232| 0| return; 233| 0| } 234| 6| state_stack_.back().mode = parse_mode::map_value; 235| 6| } 236| 14| else 237| 14| { 238| 14| end_object(visitor, ec); 239| 14| } 240| 20| break; 241| 20| } 242| 20| case parse_mode::map_value: ------------------ | Branch (242:17): [True: 6, False: 13.1M] ------------------ 243| 6| { 244| 6| state_stack_.back().mode = parse_mode::map_key; 245| 6| read_type_and_value(visitor, ec); 246| 6| if (JSONCONS_UNLIKELY(ec)) ------------------ | | 78| 6|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 0, False: 6] | | ------------------ ------------------ 247| 0| { 248| 0| return; 249| 0| } 250| 6| break; 251| 6| } 252| 3.18k| case parse_mode::strongly_typed_map_key: ------------------ | Branch (252:17): [True: 3.18k, False: 13.1M] ------------------ 253| 3.18k| { 254| 3.18k| if (state_stack_.back().index < state_stack_.back().length) ------------------ | Branch (254:25): [True: 0, False: 3.18k] ------------------ 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.18k| else 265| 3.18k| { 266| 3.18k| end_object(visitor, ec); 267| 3.18k| } 268| 3.18k| break; 269| 3.18k| } 270| 3.18k| case parse_mode::strongly_typed_map_value: ------------------ | Branch (270:17): [True: 0, False: 13.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| 3.06M| case parse_mode::indefinite_map_key: ------------------ | Branch (280:17): [True: 3.06M, False: 10.0M] ------------------ 281| 3.06M| { 282| 3.06M| auto c = source_.peek(); 283| 3.06M| if (JSONCONS_UNLIKELY(c.eof)) ------------------ | | 78| 3.06M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 1, False: 3.06M] | | ------------------ ------------------ 284| 1| { 285| 1| ec = ubjson_errc::unexpected_eof; 286| 1| more_ = false; 287| 1| return; 288| 1| } 289| 3.06M| if (c.value == jsoncons::ubjson::ubjson_type::end_object_marker) ------------------ | Branch (289:25): [True: 2.60M, False: 464k] ------------------ 290| 2.60M| { 291| 2.60M| source_.ignore(1); 292| 2.60M| end_object(visitor, ec); 293| 2.60M| if (JSONCONS_UNLIKELY(ec)) ------------------ | | 78| 2.60M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 0, False: 2.60M] | | ------------------ ------------------ 294| 0| { 295| 0| return; 296| 0| } 297| 2.60M| } 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| 3.06M| break; 314| 3.06M| } 315| 3.06M| case parse_mode::indefinite_map_value: ------------------ | Branch (315:17): [True: 464k, False: 12.7M] ------------------ 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: 42, False: 13.1M] ------------------ 326| 42| { 327| 42| state_stack_.back().mode = parse_mode::accept; 328| 42| read_type_and_value(visitor, ec); 329| 42| if (JSONCONS_UNLIKELY(ec)) ------------------ | | 78| 42|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 12, False: 30] | | ------------------ ------------------ 330| 12| { 331| 12| return; 332| 12| } 333| 30| break; 334| 42| } 335| 30| case parse_mode::accept: ------------------ | Branch (335:17): [True: 2, False: 13.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| 13.1M| } 345| 13.1M| } 346| 42| } _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| 638k| { 672| 638k| --nesting_depth_; 673| | 674| 638k| visitor.end_array(*this, ec); 675| 638k| more_ = !cursor_mode_; 676| 638k| if (level() == mark_level_) ------------------ | Branch (676:13): [True: 0, False: 638k] ------------------ 677| 0| { 678| 0| more_ = false; 679| 0| } 680| 638k| state_stack_.pop_back(); 681| 638k| } _ZNK8jsoncons6ubjson19basic_ubjson_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE5levelEv: 116| 3.24M| { 117| 3.24M| return static_cast(state_stack_.size()); 118| 3.24M| } _ZN8jsoncons6ubjson19basic_ubjson_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE10read_valueERNS_18basic_json_visitorIcEEhRNS3_10error_codeE: 368| 9.45M| { 369| 9.45M| switch (type) 370| 9.45M| { 371| 3.72M| case jsoncons::ubjson::ubjson_type::null_type: ------------------ | Branch (371:13): [True: 3.72M, False: 5.73M] ------------------ 372| 3.72M| { 373| 3.72M| visitor.null_value(semantic_tag::none, *this, ec); 374| 3.72M| more_ = !cursor_mode_; 375| 3.72M| break; 376| 0| } 377| 424k| case jsoncons::ubjson::ubjson_type::no_op_type: ------------------ | Branch (377:13): [True: 424k, False: 9.03M] ------------------ 378| 424k| { 379| 424k| break; 380| 0| } 381| 436k| case jsoncons::ubjson::ubjson_type::true_type: ------------------ | Branch (381:13): [True: 436k, False: 9.01M] ------------------ 382| 436k| { 383| 436k| visitor.bool_value(true, semantic_tag::none, *this, ec); 384| 436k| more_ = !cursor_mode_; 385| 436k| break; 386| 0| } 387| 3.47k| case jsoncons::ubjson::ubjson_type::false_type: ------------------ | Branch (387:13): [True: 3.47k, False: 9.45M] ------------------ 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.85M] ------------------ 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| 279| case jsoncons::ubjson::ubjson_type::uint8_type: ------------------ | Branch (407:13): [True: 279, False: 9.45M] ------------------ 408| 279| { 409| 279| uint8_t b; 410| 279| if (source_.read(&b, 1) == 0) ------------------ | Branch (410:21): [True: 0, False: 279] ------------------ 411| 0| { 412| 0| ec = ubjson_errc::unexpected_eof; 413| 0| more_ = false; 414| 0| return; 415| 0| } 416| 279| visitor.uint64_value(b, semantic_tag::none, *this, ec); 417| 279| more_ = !cursor_mode_; 418| 279| break; 419| 279| } 420| 837| case jsoncons::ubjson::ubjson_type::int16_type: ------------------ | Branch (420:13): [True: 837, False: 9.45M] ------------------ 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: 9.45M] ------------------ 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| 84| case jsoncons::ubjson::ubjson_type::int64_type: ------------------ | Branch (448:13): [True: 84, False: 9.45M] ------------------ 449| 84| { 450| 84| uint8_t buf[sizeof(int64_t)]; 451| 84| if (source_.read(buf, sizeof(int64_t)) != sizeof(int64_t)) ------------------ | Branch (451:21): [True: 0, False: 84] ------------------ 452| 0| { 453| 0| ec = ubjson_errc::unexpected_eof; 454| 0| more_ = false; 455| 0| return; 456| 0| } 457| 84| int64_t val = binary::big_to_native(buf, sizeof(buf)); 458| 84| visitor.int64_value(val, semantic_tag::none, *this, ec); 459| 84| more_ = !cursor_mode_; 460| 84| break; 461| 84| } 462| 3| case jsoncons::ubjson::ubjson_type::float32_type: ------------------ | Branch (462:13): [True: 3, False: 9.45M] ------------------ 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| 56| case jsoncons::ubjson::ubjson_type::float64_type: ------------------ | Branch (476:13): [True: 56, False: 9.45M] ------------------ 477| 56| { 478| 56| uint8_t buf[sizeof(double)]; 479| 56| if (source_.read(buf, sizeof(double)) != sizeof(double)) ------------------ | Branch (479:21): [True: 0, False: 56] ------------------ 480| 0| { 481| 0| ec = ubjson_errc::unexpected_eof; 482| 0| more_ = false; 483| 0| return; 484| 0| } 485| 56| double val = binary::big_to_native(buf, sizeof(buf)); 486| 56| visitor.double_value(val, semantic_tag::none, *this, ec); 487| 56| more_ = !cursor_mode_; 488| 56| break; 489| 56| } 490| 29| case jsoncons::ubjson::ubjson_type::char_type: ------------------ | Branch (490:13): [True: 29, False: 9.45M] ------------------ 491| 29| { 492| 29| uint8_t ch{}; 493| 29| if (source_.read(&ch, 1) != 1) ------------------ | Branch (493:21): [True: 0, False: 29] ------------------ 494| 0| { 495| 0| ec = ubjson_errc::unexpected_eof; 496| 0| more_ = false; 497| 0| return; 498| 0| } 499| 29| auto result = unicode_traits::validate(&ch, 1); 500| 29| if (result.ec != unicode_traits::unicode_errc()) ------------------ | Branch (500:21): [True: 0, False: 29] ------------------ 501| 0| { 502| 0| ec = ubjson_errc::invalid_utf8_text_string; 503| 0| more_ = false; 504| 0| return; 505| 0| } 506| 29| visitor.string_value(string_view(reinterpret_cast(&ch), 1), semantic_tag::none, *this, ec); 507| 29| more_ = !cursor_mode_; 508| 29| break; 509| 29| } 510| 18.5k| case jsoncons::ubjson::ubjson_type::string_type: ------------------ | Branch (510:13): [True: 18.5k, False: 9.43M] ------------------ 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: 2, False: 18.5k] ------------------ 519| 2| { 520| 2| ec = ubjson_errc::unexpected_eof; 521| 2| more_ = false; 522| 2| return; 523| 2| } 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| 127| case jsoncons::ubjson::ubjson_type::high_precision_number_type: ------------------ | Branch (536:13): [True: 127, False: 9.45M] ------------------ 537| 127| { 538| 127| std::size_t length = get_length(ec); 539| 127| if (JSONCONS_UNLIKELY(ec)) ------------------ | | 78| 127|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 0, False: 127] | | ------------------ ------------------ 540| 0| { 541| 0| return; 542| 0| } 543| 127| auto data = source_.read_span(length, text_buffer_); 544| 127| if (data.size() != length) ------------------ | Branch (544:21): [True: 9, False: 118] ------------------ 545| 9| { 546| 9| ec = ubjson_errc::unexpected_eof; 547| 9| more_ = false; 548| 9| return; 549| 9| } 550| 118| if (jsoncons::is_base10(data.data(), data.size())) ------------------ | Branch (550:21): [True: 3, False: 115] ------------------ 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| 115| else 557| 115| { 558| 115| visitor.string_value(jsoncons::string_view(reinterpret_cast(data.data()), data.size()), 559| 115| semantic_tag::bigdec, *this, ec); 560| 115| more_ = !cursor_mode_; 561| 115| } 562| 118| break; 563| 127| } 564| 640k| case jsoncons::ubjson::ubjson_type::start_array_marker: ------------------ | Branch (564:13): [True: 640k, False: 8.81M] ------------------ 565| 640k| { 566| 640k| begin_array(visitor,ec); 567| 640k| break; 568| 127| } 569| 2.60M| case jsoncons::ubjson::ubjson_type::start_object_marker: ------------------ | Branch (569:13): [True: 2.60M, False: 6.84M] ------------------ 570| 2.60M| { 571| 2.60M| begin_object(visitor, ec); 572| 2.60M| break; 573| 127| } 574| 7| default: ------------------ | Branch (574:13): [True: 7, False: 9.45M] ------------------ 575| 7| { 576| 7| ec = ubjson_errc::unknown_type; 577| 7| break; 578| 127| } 579| 9.45M| } 580| 9.45M| if (JSONCONS_UNLIKELY(ec)) ------------------ | | 78| 9.45M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 12, False: 9.45M] | | ------------------ ------------------ 581| 12| { 582| 12| more_ = false; 583| 12| } 584| 9.45M| } _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| 469k| case jsoncons::ubjson::ubjson_type::int8_type: ------------------ | Branch (801:13): [True: 469k, False: 19.3k] ------------------ 802| 469k| { 803| 469k| uint8_t buf[sizeof(int8_t)]; 804| 469k| if (source_.read(buf, sizeof(int8_t)) != sizeof(int8_t)) ------------------ | Branch (804:21): [True: 0, False: 469k] ------------------ 805| 0| { 806| 0| ec = ubjson_errc::unexpected_eof; 807| 0| more_ = false; 808| 0| return length; 809| 0| } 810| 469k| int8_t val = binary::big_to_native(buf, sizeof(buf)); 811| 469k| if (val >= 0) ------------------ | Branch (811:21): [True: 469k, False: 0] ------------------ 812| 469k| { 813| 469k| length = val; 814| 469k| } 815| 0| else 816| 0| { 817| 0| ec = ubjson_errc::length_is_negative; 818| 0| more_ = false; 819| 0| return length; 820| 0| } 821| 469k| break; 822| 469k| } 823| 469k| 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| 777| case jsoncons::ubjson::ubjson_type::int16_type: ------------------ | Branch (835:13): [True: 777, False: 488k] ------------------ 836| 777| { 837| 777| uint8_t buf[sizeof(int16_t)]; 838| 777| if (source_.read(buf, sizeof(int16_t)) != sizeof(int16_t)) ------------------ | Branch (838:21): [True: 0, False: 777] ------------------ 839| 0| { 840| 0| ec = ubjson_errc::unexpected_eof; 841| 0| more_ = false; 842| 0| return length; 843| 0| } 844| 777| int16_t val = binary::big_to_native(buf, sizeof(buf)); 845| 777| if (val >= 0) ------------------ | Branch (845:21): [True: 777, False: 0] ------------------ 846| 777| { 847| 777| length = val; 848| 777| } 849| 0| else 850| 0| { 851| 0| ec = ubjson_errc::length_is_negative; 852| 0| more_ = false; 853| 0| return length; 854| 0| } 855| 777| break; 856| 777| } 857| 777| case jsoncons::ubjson::ubjson_type::int32_type: ------------------ | Branch (857:13): [True: 18, False: 489k] ------------------ 858| 18| { 859| 18| uint8_t buf[sizeof(int32_t)]; 860| 18| if (source_.read(buf, sizeof(int32_t)) != sizeof(int32_t)) ------------------ | Branch (860:21): [True: 0, False: 18] ------------------ 861| 0| { 862| 0| ec = ubjson_errc::unexpected_eof; 863| 0| more_ = false; 864| 0| return length; 865| 0| } 866| 18| int32_t val = binary::big_to_native(buf, sizeof(buf)); 867| 18| if (val >= 0) ------------------ | Branch (867:21): [True: 18, False: 0] ------------------ 868| 18| { 869| 18| length = static_cast(val); 870| 18| } 871| 0| else 872| 0| { 873| 0| ec = ubjson_errc::length_is_negative; 874| 0| more_ = false; 875| 0| return length; 876| 0| } 877| 18| break; 878| 18| } 879| 18| case jsoncons::ubjson::ubjson_type::int64_type: ------------------ | Branch (879:13): [True: 8, False: 489k] ------------------ 880| 8| { 881| 8| uint8_t buf[sizeof(int64_t)]; 882| 8| if (source_.read(buf, sizeof(int64_t)) != sizeof(int64_t)) ------------------ | Branch (882:21): [True: 0, False: 8] ------------------ 883| 0| { 884| 0| ec = ubjson_errc::unexpected_eof; 885| 0| more_ = false; 886| 0| return length; 887| 0| } 888| 8| int64_t val = binary::big_to_native(buf, sizeof(buf)); 889| 8| if (val >= 0) ------------------ | Branch (889:21): [True: 8, False: 0] ------------------ 890| 8| { 891| 8| length = (std::size_t)val; 892| 8| if (length != (uint64_t)val) ------------------ | Branch (892:25): [True: 0, False: 8] ------------------ 893| 0| { 894| 0| ec = ubjson_errc::number_too_large; 895| 0| more_ = false; 896| 0| return length; 897| 0| } 898| 8| } 899| 0| else 900| 0| { 901| 0| ec = ubjson_errc::length_is_negative; 902| 0| more_ = false; 903| 0| return length; 904| 0| } 905| 8| break; 906| 8| } 907| 8| 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| 8| } 913| 489k| } 914| 489k| return length; 915| 489k| } _ZN8jsoncons6ubjson19basic_ubjson_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE11begin_arrayERNS_18basic_json_visitorIcEERNS3_10error_codeE: 587| 640k| { 588| 640k| if (JSONCONS_UNLIKELY(++nesting_depth_ > max_nesting_depth_)) ------------------ | | 78| 640k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 0, False: 640k] | | ------------------ ------------------ 589| 0| { 590| 0| ec = ubjson_errc::max_nesting_depth_exceeded; 591| 0| more_ = false; 592| 0| return; 593| 0| } 594| | 595| 640k| auto c = source_.peek(); 596| 640k| if (JSONCONS_UNLIKELY(c.eof)) ------------------ | | 78| 640k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 1, False: 640k] | | ------------------ ------------------ 597| 1| { 598| 1| ec = ubjson_errc::unexpected_eof; 599| 1| more_ = false; 600| 1| return; 601| 1| } 602| 640k| if (c.value == jsoncons::ubjson::ubjson_type::type_marker) ------------------ | Branch (602:13): [True: 1.46k, False: 638k] ------------------ 603| 1.46k| { 604| 1.46k| source_.ignore(1); 605| 1.46k| uint8_t b; 606| 1.46k| if (source_.read(&b, 1) == 0) ------------------ | Branch (606:17): [True: 0, False: 1.46k] ------------------ 607| 0| { 608| 0| ec = ubjson_errc::unexpected_eof; 609| 0| more_ = false; 610| 0| return; 611| 0| } 612| 1.46k| c = source_.peek(); 613| 1.46k| if (JSONCONS_UNLIKELY(c.eof)) ------------------ | | 78| 1.46k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 0, False: 1.46k] | | ------------------ ------------------ 614| 0| { 615| 0| ec = ubjson_errc::unexpected_eof; 616| 0| more_ = false; 617| 0| return; 618| 0| } 619| 1.46k| if (c.value == jsoncons::ubjson::ubjson_type::count_marker) ------------------ | Branch (619:17): [True: 1.46k, False: 1] ------------------ 620| 1.46k| { 621| 1.46k| source_.ignore(1); 622| 1.46k| std::size_t length = get_length(ec); 623| 1.46k| if (JSONCONS_UNLIKELY(ec)) ------------------ | | 78| 1.46k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 0, False: 1.46k] | | ------------------ ------------------ 624| 0| { 625| 0| return; 626| 0| } 627| 1.46k| if (length > max_items_) ------------------ | Branch (627:21): [True: 0, False: 1.46k] ------------------ 628| 0| { 629| 0| ec = ubjson_errc::max_items_exceeded; 630| 0| more_ = false; 631| 0| return; 632| 0| } 633| 1.46k| state_stack_.emplace_back(parse_mode::strongly_typed_array,length,b); 634| 1.46k| visitor.begin_array(length, semantic_tag::none, *this, ec); 635| 1.46k| more_ = !cursor_mode_; 636| 1.46k| } 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.46k| } 644| 638k| else if (c.value == jsoncons::ubjson::ubjson_type::count_marker) ------------------ | Branch (644:18): [True: 1.75k, False: 637k] ------------------ 645| 1.75k| { 646| 1.75k| source_.ignore(1); 647| 1.75k| std::size_t length = get_length(ec); 648| 1.75k| if (JSONCONS_UNLIKELY(ec)) ------------------ | | 78| 1.75k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 0, False: 1.75k] | | ------------------ ------------------ 649| 0| { 650| 0| return; 651| 0| } 652| 1.75k| if (length > max_items_) ------------------ | Branch (652:17): [True: 0, False: 1.75k] ------------------ 653| 0| { 654| 0| ec = ubjson_errc::max_items_exceeded; 655| 0| more_ = false; 656| 0| return; 657| 0| } 658| 1.75k| state_stack_.emplace_back(parse_mode::array,length); 659| 1.75k| visitor.begin_array(length, semantic_tag::none, *this, ec); 660| 1.75k| more_ = !cursor_mode_; 661| 1.75k| } 662| 637k| else 663| 637k| { 664| 637k| state_stack_.emplace_back(parse_mode::indefinite_array,0); 665| 637k| visitor.begin_array(semantic_tag::none, *this, ec); 666| 637k| more_ = !cursor_mode_; 667| 637k| } 668| 640k| } _ZN8jsoncons6ubjson19basic_ubjson_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE12begin_objectERNS_18basic_json_visitorIcEERNS3_10error_codeE: 684| 2.60M| { 685| 2.60M| if (JSONCONS_UNLIKELY(++nesting_depth_ > max_nesting_depth_)) ------------------ | | 78| 2.60M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 0, False: 2.60M] | | ------------------ ------------------ 686| 0| { 687| 0| ec = ubjson_errc::max_nesting_depth_exceeded; 688| 0| more_ = false; 689| 0| return; 690| 0| } 691| | 692| 2.60M| auto c = source_.peek(); 693| 2.60M| if (JSONCONS_UNLIKELY(c.eof)) ------------------ | | 78| 2.60M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 3, False: 2.60M] | | ------------------ ------------------ 694| 3| { 695| 3| ec = ubjson_errc::unexpected_eof; 696| 3| more_ = false; 697| 3| return; 698| 3| } 699| 2.60M| if (c.value == jsoncons::ubjson::ubjson_type::type_marker) ------------------ | Branch (699:13): [True: 3.18k, False: 2.60M] ------------------ 700| 3.18k| { 701| 3.18k| source_.ignore(1); 702| 3.18k| uint8_t b; 703| 3.18k| if (source_.read(&b, 1) == 0) ------------------ | Branch (703:17): [True: 0, False: 3.18k] ------------------ 704| 0| { 705| 0| ec = ubjson_errc::unexpected_eof; 706| 0| more_ = false; 707| 0| return; 708| 0| } 709| 3.18k| c = source_.peek(); 710| 3.18k| if (JSONCONS_UNLIKELY(c.eof)) ------------------ | | 78| 3.18k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 0, False: 3.18k] | | ------------------ ------------------ 711| 0| { 712| 0| ec = ubjson_errc::unexpected_eof; 713| 0| more_ = false; 714| 0| return; 715| 0| } 716| 3.18k| if (c.value == jsoncons::ubjson::ubjson_type::count_marker) ------------------ | Branch (716:17): [True: 3.18k, False: 0] ------------------ 717| 3.18k| { 718| 3.18k| source_.ignore(1); 719| 3.18k| std::size_t length = get_length(ec); 720| 3.18k| if (JSONCONS_UNLIKELY(ec)) ------------------ | | 78| 3.18k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 0, False: 3.18k] | | ------------------ ------------------ 721| 0| { 722| 0| return; 723| 0| } 724| 3.18k| if (length > max_items_) ------------------ | Branch (724:21): [True: 0, False: 3.18k] ------------------ 725| 0| { 726| 0| ec = ubjson_errc::max_items_exceeded; 727| 0| more_ = false; 728| 0| return; 729| 0| } 730| 3.18k| state_stack_.emplace_back(parse_mode::strongly_typed_map_key,length,b); 731| 3.18k| visitor.begin_object(length, semantic_tag::none, *this, ec); 732| 3.18k| more_ = !cursor_mode_; 733| 3.18k| } 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.18k| } 741| 2.60M| else 742| 2.60M| { 743| 2.60M| c = source_.peek(); 744| 2.60M| if (JSONCONS_UNLIKELY(c.eof)) ------------------ | | 78| 2.60M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 0, False: 2.60M] | | ------------------ ------------------ 745| 0| { 746| 0| ec = ubjson_errc::unexpected_eof; 747| 0| more_ = false; 748| 0| return; 749| 0| } 750| 2.60M| if (c.value == jsoncons::ubjson::ubjson_type::count_marker) ------------------ | Branch (750:17): [True: 20, False: 2.60M] ------------------ 751| 20| { 752| 20| source_.ignore(1); 753| 20| std::size_t length = get_length(ec); 754| 20| if (JSONCONS_UNLIKELY(ec)) ------------------ | | 78| 20|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 0, False: 20] | | ------------------ ------------------ 755| 0| { 756| 0| return; 757| 0| } 758| 20| if (length > max_items_) ------------------ | Branch (758:21): [True: 0, False: 20] ------------------ 759| 0| { 760| 0| ec = ubjson_errc::max_items_exceeded; 761| 0| more_ = false; 762| 0| return; 763| 0| } 764| 20| state_stack_.emplace_back(parse_mode::map_key,length); 765| 20| visitor.begin_object(length, semantic_tag::none, *this, ec); 766| 20| more_ = !cursor_mode_; 767| 20| } 768| 2.60M| else 769| 2.60M| { 770| 2.60M| state_stack_.emplace_back(parse_mode::indefinite_map_key,0); 771| 2.60M| visitor.begin_object(semantic_tag::none, *this, ec); 772| 2.60M| more_ = !cursor_mode_; 773| 2.60M| } 774| 2.60M| } 775| 2.60M| } _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| 2.60M| { 779| 2.60M| --nesting_depth_; 780| 2.60M| visitor.end_object(*this, ec); 781| 2.60M| more_ = !cursor_mode_; 782| 2.60M| if (level() == mark_level_) ------------------ | Branch (782:13): [True: 0, False: 2.60M] ------------------ 783| 0| { 784| 0| more_ = false; 785| 0| } 786| 2.60M| state_stack_.pop_back(); 787| 2.60M| } _ZN8jsoncons6ubjson19basic_ubjson_readerINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEEC2IRNS3_19basic_istringstreamIcNS3_11char_traitsIcEES7_EEEEOT_RNS_18basic_json_visitorIcEERKNS0_21ubjson_decode_optionsERKS7_: 48| 42| : parser_(std::forward(source), options, alloc), 49| 42| visitor_(visitor) 50| 42| { 51| 42| } _ZN8jsoncons6ubjson19basic_ubjson_readerINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE4readERNS3_10error_codeE: 64| 42| { 65| 42| parser_.reset(); 66| 42| parser_.parse(visitor_, ec); 67| 42| if (JSONCONS_UNLIKELY(ec)) ------------------ | | 78| 42|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 40, False: 2] | | ------------------ ------------------ 68| 40| { 69| 40| return; 70| 40| } 71| 42| }